Spring til hovedindhold
Dansk— Vælg et sprog
Menu

JSON-tilstand og skemahåndhævelse

Lektion 10 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. JSON-tilstand og skemahåndhævelse
  2. JSON-tilstand kontra struktureret output
  3. Struktureret output med JSON-skema
  4. Regler for strengt struktureret output
  5. Hjælper til opbygning af skemaer
  6. Eksempel: Struktureret dataudtrækning
  7. Måling af hvad begrænsningen bringer
  8. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonneringsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

JSON-tilstand og skemahåndhævelse

OpenAIs strukturerede output garanterer, at modellens svar er gyldig JSON, der overholder et skema, du definerer. Farvel til skrøbelig parsing med regex eller formatfejl – begrænsningen anvendes direkte på generationsniveau.

Denne nuance er afgørende, og den ændrer alt for en udvikler. At bede om „svar i JSON” i prompten er en bøn: Modellen adlyder oftest, men en dag præfikserer den svaret med „Her er den ønskede JSON:”, tilføjer Markdown-backticks eller glemmer et komma, og din json.loads kaster en undtagelse i produktionen kl. 3 om natten under ugens største batchkørsel. Med struktureret output gælder begrænsningen under afkodning: Tokens, der ville producere ugyldig eller ikke-overholdende JSON, kan slet ikke vælges. Du holder op med at tigge og begynder at håndhæve.

JSON-tilstand kontra struktureret output

OpenAI tilbyder to niveauer af begrænsning, og forskellen hviler på et enkelt ord. JSON-tilstand garanterer gyldig JSON uden strukturelle begrænsninger; struktureret output garanterer JSON, der overholder et JSON-skema, du har skrevet.

JSON-tilstand løser halvdelen af problemet. Du er sikker på, at du kan parse svaret, men ikke sikker på, hvad det indeholder: Modellen kan navngive et felt annee i den ene anmodning og year i den næste eller pakke sin liste ind i et resultats-objekt, som den ikke brugte dagen før. Til en prototype eller rå visning beregnet til et menneske er dette tilstrækkeligt; så snart outputtet fodrer kode, der tilgår felter ved navn, får du brug for det andet niveau.

from openai import OpenAI

client = OpenAI()

# Simpel JSON-tilstand (gyldig 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)

Struktureret output med JSON-skema

Dette er den mest kraftfulde funktion. Du definerer et JSON-skema, og API’en garanterer, at outputtet overholder det. Eksemplet nedenfor analyserer stemningen i en kundeanmeldelse og illustrerer tre komplementære anvendelser af skemaet.

enum på sentiment forhindrer modellen i at opfinde en mellemkategori som „ganske positiv”: Den skal vælge mellem de fire angivne værdier, hvilket gør outputtet direkte brugbart i et filter eller dashboard. description af feltet score fungerer som en lokal mini-prompt, der angiver den forventede skala uden at kræve, at du forklarer det i de generelle instrukser, og det forbliver knyttet til feltet, selvom prompten udvikler sig. Endelig tillader aspects-arrayet dig at dekonstruere en modstridende anmeldelse – her et produkt, der kunne lide, men hvor leveringen fejlede – i stedet for at knuse den nuance ned til en enkelt score, der ikke hjælper nogen.

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)
# Garanteret: result har præcis de definerede felter
print(f"Sentiment: {result['sentiment']}")
print(f"Score: {result['score']}")
for aspect in result["aspects"]:
    print(f"  - {aspect['aspect']}: {aspect['sentiment']}")

Regler for strengt struktureret output

strict: true-tilstanden pålægger sine egne begrænsninger på skemaet. Alle felter skal forekomme i required, og additionalProperties skal være false på hvert objekt. Tilladte typer er string, number, integer, boolean, array, object og null samt enum til at begrænse værdier. Hverken pattern eller minLength/maxLength accepteres dog: finmasket validering sker på klientsiden.

Disse regler kan være overraskende ved første forsøg, fordi de forbyder det valgfrie felt, som det normalt skrives i JSON-skema. Afvejningen er behagelig: Din kode behøver aldrig at teste, om en nøgle eksisterer; den er altid der. For et felt, der legitimt kan være tomt – et telefonnummer, der mangler i et dokument, en slutdato for en igangværende kontrakt – er svaret ikke at fjerne det fra required, men at tillade, at det er null. Hvad angår fraværet af pattern og længdebegrænsninger, signalerer det næste lektion: Skemaet garanterer formen, men forretningsvalidering forbliver dit job, når svaret er modtaget.

Hjælper til opbygning af skemaer

Manuelt at skrive text.format-blokken for hvert kald bliver hurtigt kedeligt og udsat for taste fejl – en manglende name-nøgle, en fejlplaceret strict, og fejlen kommer tilbage fra API’en uden at angive, hvor man skal kigge. Et par linjer wrapper-kode centraliserer strukturen, anvender en lav temperatur som standard (da variabilitet ikke tilføjer noget til udtrækning) og gør kaldstedet læsbart.

def structured_query(prompt: str, schema: dict,
                     schema_name: str = "response",
                     model: str = "gpt-5.6-terra",
                     system: str = "") -> dict:
    """Wrapper til anmodninger om struktureret output."""
    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)

Eksempel: Struktureret dataudtrækning

Her er use casen, der alene retfærdiggør at lære denne teknik: at transformere en faktura modtaget som ren tekst til et objekt, der kan bruges af dit regnskabssystem. Skemaet beskriver tre niveauer – fakturaens hoved, et indlejret vendor-objekt og et lines-array, hvor hvert element har samme form. Modellen skal derfor både lokalisere information spredt gennem dokumentet og placere det på det rigtige sted, også for en linje udtrykt i timer frem for enheder, hvor stykprisen forstås som en timesats.

Bemærk, at totaler fremstår i skemaet som felter, der skal udtrækkes, ikke genberegnes. Vi beder modellen om at læse; kontrol af aritmetik sker bagefter i din kode, hvor en simpel sammenligning mellem summen af linjerne og den udtrukne total_ht vil flagge dokumenter til menneskelig gennemgang.

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åling af hvad begrænsningen bringer

Anvend dette princip på et dokument, du kender godt: Definer et JSON-skema til at udtrække nøgleinformation fra et CV – navn, erfaring, færdigheder, uddannelse – og test det på tre CV’er i ren tekst, der bevidst er valgt for deres heterogene layouts. Verificér, at outputtet overholder skemaet, selv når et afsnit mangler helt.

Gentag derefter den samme udtrækning uden struktureret output, blot ved at bede om JSON i prompten, og behold de seks output side om side. Sammenligning af de to serier viser, hvad begrænsningen bringer: Forskellen ligger sjældent i det udtrukne indhold, næsten altid i stabiliteten af feltnavne og tilstedeværelsen af forventede nøgler.

Vigtige pointer

  • Struktureret output garanterer JSON, der overholder skemaet på generationsniveau
  • Brug strict: true for maksimal overholdelse
  • Alle felter skal være required med additionalProperties: false
  • Ideel til dataudtrækning, klassificering og behandlingspipelines
  • Finmasket validering (længde, mønster) sker på klientsiden efter modtagelse