When working with LLMs, a particularly helpful use case is producing structured information because the output response of the AI immediate. Whether or not you’re constructing an app, prototyping an information pipeline, or performing information extraction or transformation, receiving structured outputs like JSON saves time and makes downstream processing seamless.
However there’s a problem: these fashions are optimized for pure language—not strict formatting. With out cautious prompting, you may get outputs that include JSON or occasion appear like JSON however finally fail to parse accurately. To keep away from that, you should information the mannequin and instruct it to the output you require.
This text walks you thru immediate engineering methods for writing AI prompts that reliably produce legitimate JSON responses, with examples and pattern code.
1. Be Express About JSON Output
Essentially the most primary and essential instruction you may give is:
Response with legitimate JSON solely. Don't embody any rationalization or further textual content.
Generative AI fashions are skilled to reply conversationally by default. This instruction helps shift the tone and format to strictly structured output. Preserve the immediate quick and direct to reduce danger of formatting drift.
2. Inform the LLM What You Need
Earlier than the LLM can output JSON information of what you’re on the lookout for, you will want to instruct the AI what you need it to do.
Right here’s a easy instance of a immediate that tells the LLM what we would like:
Generate an inventory of three fictional customers
3. Embody an Instance or Schema
You will have to inform the LLM what the output response ought to appear like and the way it must be formatted. Specifying JSON is nice, however you possible require a really particular schema. You’ll be able to both clarify the schema you require, or give the LLM an instance JSON to indicate it was you want.
Schema-style
Explaining the schema you require within the JSON output is one technique of telling the LLM find out how to format the info:
Every merchandise ought to have: title (string), age (quantity), signup_date (date)
Instance-style Immediate
A way that can possible enhance the accuracy and reliability of the LLM to output the JSON schema you want is to explicitly give it an instance of the JSON you need it to output:
Output utilizing the next JSON format:
[
{
"name": "Steve Johnson",
"age": 43
"signup_date": "2025-01-01"
}
]
Fashions are superb at copying construction—give it one thing to repeat.
4. Keep away from Overcomplication in Prompts
Sustaining readability is essential and being specific helps. Keep away from imprecise directions or further necessities that might result in inconsistencies.
Right here’s an instance of a immediate which may confuse the LLM:
Write an inventory of merchandise in JSON format. Every ought to have a reputation, age, and signup_date.
Additionally make sure that the costs are life like, and remember to incorporate not less than one out-of-stock merchandise.
As an alternative, you possibly can see the next immediate is far clearer:
Write an inventory of merchandise, every ought to have title (string), age (quantity), signup_date (date)
Easy, direct prompts will usually yield better-structured responses.
5. Use System Immediate Directions (If Obtainable)
If you happen to’re utilizing an API like OpenAI’s Chat API or instruments like LangChain, you’ll want to reap the benefits of the system immediate This can be utilized to instruct the LLM the way it ought to behave and reinforce the anticipated habits:
{"function": "system", "content material": "You're a JSON generator. At all times output legitimate JSON with out explanations."}
This reduces the danger of the mannequin slipping into pure language commentary within the response.
6. Put together for Errors
Even well-prompted fashions generally return further textual content, incorrect brackets, or malformed syntax. Construct safeguards into your workflow:
- Validate the output utilizing a parser like
json.masses()in Python - Use temperature=0 for constant and deterministic formatting
- Submit-process if essential to strip markdown artifacts or retry
A clean-up and validation step ensures your pipeline doesn’t break.
Full Instance: Prompting the LLM and Saving JSON with Python
Right here’s a working Python instance that:
- Sends a immediate to Azure OpenAI utilizing
langchain-openai - Retrieves a response
- Cleans and parses the JSON
- Saves it to a
.jsonfile
import os
import json
from dotenv import load_dotenv
from langchain_openai import AzureChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
# Load setting variables
load_dotenv()
# Arrange the Azure OpenAI chat mannequin
chat = AzureChatOpenAI(
azure_deployment=os.getenv("AZURE_OPENAI_DEPLOYMENT"),
azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
# System immediate to information the mannequin
system_prompt = """
You're a JSON generator. Your job is to generate legitimate JSON information based mostly on the supplied immediate.
"""
# Your JSON-focused immediate
user_prompt = """
Generate an inventory of three fictional customers.
Here is an instance of the JSON format you need to use:
[
{
"name": "string",
"age": number,
"email": "string",
"signup_date": "YYYY-MM-DD"
}
]
"""
# Name the chat mannequin instantly
response = chat.invoke([
SystemMessage(content=system_prompt),
HumanMessage(content=user_prompt)
])
# Invoke the chat mannequin
#response = chat.invoke(immediate)
# Get the response textual content
response_text = response.content material
print("nRaw Response:n", response_text)
# Clear up response (take away code block wrappers if current)
response_text = response_text.strip().change("```json", "").change("```", "").strip()
print("nnCleaned Response JSON:n", response_text)
# Parse and save JSON
information = json.masses(response_text)
# Save to file
os.makedirs("output", exist_ok=True)
with open("output/customers.json", "w") as f:
json.dump(information, f, indent=4)
print("Saved JSON to output/customers.json")
Rationalization
- System & Person Prompts: The mannequin is guided with each a system-level instruction to behave like a JSON generator, and a consumer immediate that features each directions and an instance.
- Instance Format: Together with a pattern JSON block within the consumer immediate helps the mannequin replicate the right construction.
- Message Format: This instance makes use of
SystemMessageandHumanMessagefrom LangChain to construction the interplay clearly. - Uncooked vs Cleaned Output: Prints the uncooked mannequin output earlier than and after eradicating markdown formatting which is often added by the LLM.
- Validation: Makes use of
json.masses()to make sure the cleaned string is legitimate JSON. - File Output: Saves the JSON to an
outputlisting, which is created if it doesn’t exist.
This strategy mirrors the way you’d use structured prompts and system steerage in manufacturing settings. It’s versatile, clear, and simple to develop for extra complicated workflows like multi-turn dialogs, pipelines, or analysis instruments.
Right here’s an instance of the JSON file that’s saved on the finish of this code:
[
{
"name": "Alice Evergreen",
"age": 28,
"email": "alice.evergreen@example.com",
"signup_date": "2023-02-15"
},
{
"name": "Michael Stone",
"age": 35,
"email": "michael.stone@example.com",
"signup_date": "2022-11-08"
},
{
"name": "Sofia Bright",
"age": 22,
"email": "sofia.bright@example.com",
"signup_date": "2023-08-21"
}
]
Conclusion
Immediate engineering strategies is essential when working with LLMs. That is very true when utilizing the LLM to provide predictable structured information that’s legitimate JSON. It is a highly effective method that unlocks automation, information processing, and power constructing automation capabilities utilizing LLMs. With well-structured prompts and some finest practices, you possibly can go from free-form textual content era to wash, parsable, and ready-to-use structured information.
Consider JSON prompting as a bridge between pure language creativity and structured logic—grasp it, and also you’ll get the very best of each worlds.
Unique Article Supply: Write AI Prompts That Output Legitimate JSON Knowledge written by Chris Pietschmann (If you happen to’re studying this someplace aside from Build5Nines.com, it was republished with out permission.)
