JSON-läge och schemaframtvingande
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAIs dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.
JSON-läge och schemaframtvingande
OpenAIs strukturerade utmatning garanterar att modellens svar är giltig JSON som följer ett schema du definierar. Inget mer ömtåligt parsande med regex eller formatfel – begränsningen tillämpas direkt på genereringsnivå.
Denna nyans är avgörande och förändrar allt för en utvecklare. Att be «svara i JSON» i prompten är en vädjan: modellen lyder oftast, men en dag prefixar den sitt svar med «Här är den begärda JSON:», lägger till Markdown-backticks eller glömmer ett kommatecken, och din json.loads kastar ett undantag i produktion klockan 03.00 under veckans största batch. Med strukturerad utmatning tillämpas begränsningen under avkodningen: token som skulle producera ogiltig eller icke-konform JSON kan helt enkelt inte väljas. Du slutar be och börjar framtvinga.
JSON-läge kontra strukturerad utmatning
OpenAI erbjuder två nivåer av begränsning, och skillnaden hänger på ett enda ord. JSON-läge garanterar giltig JSON utan strukturella begränsningar; strukturerad utmatning garanterar JSON som följer ett JSON-schema du har skrivit.
JSON-läge löser halva problemet. Du är säker på att du kan parsa svaret, men inte säker på vad det innehåller: modellen kan namnge ett fält annee i en förfrågan och year i nästa, eller packa in sin lista i ett resultats-objekt den inte använde dagen innan. För en prototyp eller rå visning avsedd för en människa räcker detta; så snart utmatningen matar kod som kommer åt fält efter namn behöver du den andra nivån.
from openai import OpenAI
client = OpenAI()
# Enkelt JSON-läge (giltig JSON, fri struktur)
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Always respond in JSON.",
input="List 3 programming languages with their year of creation.",
text={"format": {"type": "json_object"}}
)
import json
data = json.loads(response.output_text)
print(data)
Strukturerad utmatning med JSON-schema
Detta är den kraftfullaste funktionen. Du definierar ett JSON-schema och API:t garanterar att utmatningen följer det. Exemplet nedan analyserar sentimentet i en kundrecension och illustrerar tre kompletterande användningsområden för schemat.
enum på sentiment hindrar modellen från att hitta på en mellanliggande kategori som «ganska positiv»: den måste välja mellan de fyra angivna värdena, vilket gör utmatningen direkt användbar i ett filter eller en instrumentpanel. description för fältet score fungerar som en lokal miniprompt som anger den förväntade skalan utan att du behöver förklara den i de generella instruktionerna, och den förblir kopplad till fältet även om prompten utvecklas. Slutligen låter arrayen aspects dig bryta ner en motsägelsefull recension – här en produkt som gillades men där leveransen misslyckades – istället för att krossa den nyansen till en enda poäng som inte hjälper någon.
response = client.responses.create(
model="gpt-5.6-terra",
input="Analyze the sentiment of: 'The product is excellent "
"but the delivery was catastrophic.'",
text={
"format": {
"type": "json_schema",
"name": "sentiment_analysis",
"schema": {
"type": "object",
"properties": {
"sentiment": {
"type": "string",
"enum": ["positive", "negative", "mixed", "neutral"]
},
"score": {
"type": "number",
"description": "Score from -1.0 (very negative) to 1.0 (very positive)"
},
"aspects": {
"type": "array",
"items": {
"type": "object",
"properties": {
"aspect": {"type": "string"},
"sentiment": {
"type": "string",
"enum": ["positive", "negative", "neutral"]
}
},
"required": ["aspect", "sentiment"],
"additionalProperties": False
}
},
"summary": {"type": "string"}
},
"required": ["sentiment", "score", "aspects", "summary"],
"additionalProperties": False
},
"strict": True
}
}
)
result = json.loads(response.output_text)
# Garanterat: result har exakt de definierade fälten
print(f"Sentiment: {result['sentiment']}")
print(f"Score: {result['score']}")
for aspect in result["aspects"]:
print(f" - {aspect['aspect']}: {aspect['sentiment']}")
Regler för strikt strukturerad utmatning
Läget strict: true ställer sina egna krav på schemat. Alla fält måste finnas med i required, och additionalProperties måste vara false på varje objekt. Tillåtna typer är string, number, integer, boolean, array, object och null, plus enum för att begränsa värden. Däremot accepteras varken pattern eller minLength/maxLength: finmaskig validering sker på klientsidan.
Dessa regler kan vara överraskande vid första försöket eftersom de förbjuder valfria fält såsom de vanligtvis skrivs i JSON-schema. Avvägningen är bekväm: din kod behöver aldrig testa om en nyckel finns; den finns alltid där. För ett fält som legitimt kan vara tomt – ett telefonnummer som saknas i ett dokument, ett slutdatum för ett pågående kontrakt – är svaret inte att ta bort det från required utan att tillåta att det är null. Vad gäller frånvaron av pattern och längdbegränsningar signalerar det nästa lektion: schemat garanterar formen, men affärsvalideringen är ditt jobb när svaret väl har mottagits.
Hjälpfunktion för att bygga scheman
Att manuellt skriva blocket text.format för varje anrop blir snabbt tröttsamt och benäget för slarvfel – en saknad nyckel name, en felplacerad strict, och felet kommer tillbaka från API:t utan att ange var man ska leta. Några rader wrapper-kod centraliserar strukturen, tillämpar en låg temperatur som standard (eftersom variabilitet inte tillför något till extrahering) och gör anropsstället läsbart.
def structured_query(prompt: str, schema: dict,
schema_name: str = "response",
model: str = "gpt-5.6-terra",
system: str = "") -> dict:
"""Wrapper för förfrågningar om strukturerad utmatning."""
response = client.responses.create(
model=model,
reasoning={"effort": "none"}, # temperature kräver effort none
instructions=system or "Respond in JSON according to the provided schema.",
input=prompt,
text={
"format": {
"type": "json_schema",
"name": schema_name,
"schema": schema,
"strict": True
}
},
temperature=0.1
)
return json.loads(response.output_text)
Exempel: Strukturerad dataextrahering
Här är användningsfallet som ensamt motiverar att lära sig denna teknik: att omvandla en faktura mottagen som vanlig text till ett objekt som ditt redovisningssystem kan använda. Schemat beskriver tre nivåer – fakturarubriken, ett nästlat vendor-objekt och en lines-array där varje element har samma form. Modellen måste därför både lokalisera information som är spridd genom hela dokumentet och placera den på rätt ställe, även för en rad uttryckt i timmar snarare än enheter, där enhetspriset förstås som en timtaxa.
Observera att summor förekommer i schemat som fält att extrahera, inte att beräkna om. Vi ber modellen att läsa; kontrollen av aritmetiken sker efteråt i din kod, där en enkel jämförelse mellan summan av raderna och den extraherade total_ht kommer att flagga dokument för mänsklig granskning.
invoice_schema = {
"type": "object",
"properties": {
"invoice_number": {"type": "string"},
"date": {"type": "string"},
"vendor": {
"type": "object",
"properties": {
"name": {"type": "string"},
"siret": {"type": "string"},
"address": {"type": "string"}
},
"required": ["name", "siret", "address"],
"additionalProperties": False
},
"lines": {
"type": "array",
"items": {
"type": "object",
"properties": {
"description": {"type": "string"},
"quantity": {"type": "integer"},
"unit_price_excl_tax": {"type": "number"},
"vat_percent": {"type": "number"}
},
"required": ["description", "quantity",
"unit_price_excl_tax", "vat_percent"],
"additionalProperties": False
}
},
"total_excl_tax": {"type": "number"},
"total_incl_tax": {"type": "number"}
},
"required": ["invoice_number", "date", "vendor",
"lines", "total_excl_tax", "total_incl_tax"],
"additionalProperties": False
}
invoice_text = """
Invoice No. 2026-0042
Date: 15/03/2026
Vendor: TechServ SARL, SIRET 123 456 789 00012
12 rue de la Paix, 75002 Paris
- REST API Development x1: 3500.00 EUR excl. tax (VAT 20%)
- Cloud hosting (3 months) x1: 450.00 EUR excl. tax (VAT 20%)
- Technical support x10h: 150.00 EUR excl. tax/h (VAT 20%)
Total excl. tax: 5450.00 EUR
Total incl. tax: 6540.00 EUR
"""
result = structured_query(
invoice_text,
invoice_schema,
schema_name="invoice",
system="Extract the data from this invoice."
)
Mäta vad begränsningen tillför
Tillämpa denna princip på ett dokument du känner väl: definiera ett JSON-schema för att extrahera nyckelinformation från ett CV – namn, erfarenhet, färdigheter, utbildning – och testa det på tre CV:n i vanlig text som medvetet valts för sina heterogena layouter. Verifiera att utmatningen följer schemat även när en sektion saknas helt.
Upprepa sedan samma extrahering utan strukturerad utmatning, genom att helt enkelt be om JSON i prompten, och lägg de sex utmatningarna sida vid sida. Att jämföra de två serierna visar vad begränsningen tillför: skillnaden ligger sällan i det extraherade innehållet, nästan alltid i stabiliteten hos fältnamn och förekomsten av förväntade nycklar.
Viktiga punkter
- Strukturerad utmatning garanterar JSON som följer schemat på genereringsnivå
- Använd
strict: trueför maximal efterlevnad - Alla fält måste vara
requiredmedadditionalProperties: false - Idealiskt för dataextrahering, klassificering och bearbetningspipelines
- Finmaskig validering (längd, mönster) sker på klientsidan efter mottagandet