Validering med JSON Schema og Zod
På denne side
Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres 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 specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Validering med JSON Schema og Zod
Struktureret output garanterer svarstrukturen, men ikke dataenes semantiske gyldighed. Et felt til “email” kan indeholde en streng, der ikke er en gyldig e-mailadresse. Validering på klientsiden ved hjælp af JSON Schema eller Zod er det essentielle supplement til en robust pipeline.
Hvorfor validere efter modtagelse
Gør status over, hvad API’en garanterer, så bliver arbejdsfordelingen klar. OpenAIs strukturerede output sikrer, at JSON’en er syntaktisk gyldig, at deklarerede typer overholdes – en streng forbliver en streng, et heltal forbliver et heltal – at alle påkrævede felter er til stede, og at værdier begrænset af en enum tilhører listen. På disse fire punkter kan du skrive din kode med tillid.
Alt andet påhviler dig og dækker fire familier af problemer. Formatbegrænsninger undgår det strikse skema: Intet forhindrer modellen i at returnere jean.dupont(at)example.fr i et email-felt eller en dato i formatet 15/03/2026, når du forventer ISO. Grænser kontrolleres heller ikke, hverken for strenglængde eller talområde: En alder på 350 vil passere uden at blinke. Konsistens på tværs af felter forbliver uden for rækkevidde – en end_date tidligere end start_date er perfekt gyldig JSON. Og forretningsmæssig gyldighed har ingen grund til at bekymre API’en: Et SIRET-nummer (fransk virksomheds-ID) skal være på fjorten cifre, men det er din domæneviden, ikke decoderens.
Disse fire familier deler en skræmmende egenskab: De forårsager ingen synlige fejl. En forkert formateret e-mail, der gemmes i databasen, viser sig først, når e-mail-kampagnen fejler uger senere. Derfor gælder reglen: Valider før persistens, aldrig efter.
Python-validering med jsonschema
Den praktiske konsekvens er, at du har brug for to skemaer til de samme data. Det første sendes til API’en, bevidst slankt og begrænset til, hvad streng tilstand accepterer. Det andet bliver hos dig og bærer de finmaskede begrænsninger – format, pattern, minimum, maximum. Denne tilsyneladende duplikering er en adskillelse af ansvar: Det ene rammer genereringen, det andet forsvarer din lagring. I eksemplet nedenfor optræder kun rolle-enum’et i begge, fordi det er den eneste begrænsning, begge niveauer kan udtrykke.
import json
from jsonschema import validate, ValidationError
# Skema til OpenAI API (strengt, uden format/pattern)
api_schema = {
"type": "object",
"properties": {
"email": {"type": "string"},
"age": {"type": "integer"},
"role": {"type": "string", "enum": ["admin", "user", "viewer"]}
},
"required": ["email", "age", "role"],
"additionalProperties": False
}
# Udvidet skema til validering på klientsiden
validation_schema = {
"type": "object",
"properties": {
"email": {
"type": "string",
"format": "email",
"pattern": r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z]{2,}$"
},
"age": {
"type": "integer",
"minimum": 0,
"maximum": 150
},
"role": {"type": "string", "enum": ["admin", "user", "viewer"]}
},
"required": ["email", "age", "role"]
}
def validate_response(data: dict) -> tuple[bool, str]:
"""Validerer LLM-svaret mod det udvidede skema."""
try:
validate(instance=data, schema=validation_schema)
return True, "Valid"
except ValidationError as e:
return False, f"Error: {e.message}"
Validering med Pydantic
Pydantic er ofte mere bekvemt end jsonschema til validering i Python, og forskellen ligger i, hvad du får ved output. jsonschema fortæller dig ja eller nej og efterlader dig med et ordbogsobjekt, som manipuleres via data["email"] uden editorhjælp. Pydantic returnerer et typet objekt: Autoudfyldning fungerer, en stavefejl i et attributnavn fanges på skrifttidspunktet, og dataene cirkulerer derefter uden konvertering.
Modellen ContactExtraction udtrykker grænser direkte i feltdeklarationerne. field_validator på date_extraction dækker det tilfælde, som ingen typeannotering kan fange: Strengen er ganske rigtigt en streng, men den skal repræsentere en reel dato – 2026-02-31 opfylder ethvert rimeligt pattern, men eksisterer ikke. Ekstraktionsfunktionen viser hele kæden, fra det slanke skema sendt til API’en til den validerede instansiering.
from pydantic import BaseModel, Field, field_validator
from pydantic import EmailStr
from datetime import date
class ContactExtraction(BaseModel):
"""Valideringsskema for kontaktudtrækning."""
last_name: str = Field(min_length=2, max_length=100)
first_name: str = Field(min_length=2, max_length=100)
email: EmailStr
phone: str = Field(pattern=r"^\+?[0-9\s\-\.]{10,15}$")
company: str
title: str
extraction_date: str
@field_validator("extraction_date")
@classmethod
def validate_date(cls, v):
try:
date.fromisoformat(v)
return v
except ValueError:
raise ValueError(f"Invalid date: {v}")
def extract_and_validate(text: str) -> ContactExtraction:
"""Udtrækker en kontakt og validerer dataene."""
# Skema til API (uden finmaskede begrænsninger)
api_schema = {
"type": "object",
"properties": {
"last_name": {"type": "string"},
"first_name": {"type": "string"},
"email": {"type": "string"},
"phone": {"type": "string"},
"company": {"type": "string"},
"title": {"type": "string"},
"extraction_date": {"type": "string"}
},
"required": ["last_name", "first_name", "email", "phone",
"company", "title", "extraction_date"],
"additionalProperties": False
}
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Extract contact information. "
"Date format: YYYY-MM-DD.",
input=text,
text={
"format": {
"type": "json_schema",
"name": "contact",
"schema": api_schema,
"strict": True
}
}
)
data = json.loads(response.output_text)
# Pydantic-validering med finmaskede begrænsninger
return ContactExtraction(**data)
Validering med Zod (TypeScript/Node.js)
Hvis din backend er skrevet i TypeScript, er Zod referenceværktøjet, og det bringer en fordel, som Pydantic ikke behøver at levere: z.infer udleder TypeScript-typen direkte fra valideringsskemaet. Du beskriver formen én gang, og compileren kender derefter strukturen af Invoice, uden at du skal vedligeholde et parallelt interface, så der er ingen risiko for divergens.
Faktura-skemaet nedenfor illustrerer arbejdsfordelingen: På API-siden er siret blot en streng; på Zod-siden skal det være præcis fjorten tegn og kun indeholde cifre. Det endelige parse udløser en undtagelse, hvis dataene ikke passer, og det er den ønskede adfærd – en højlydt fejl, der afbryder dokumentbehandlingen, er bedre end en faktura med et fantasifuldt SIRET-nummer gemt i databasen blandt ti tusind andre.
import { z } from "zod";
import OpenAI from "openai";
const client = new OpenAI();
// Zod-skema med finmaskede valideringer
const InvoiceSchema = z.object({
number: z.string().regex(/^[A-Z]{2}-\d{4}-\d{4}$/),
date: z.string().date(),
amount_excl_tax: z.number().positive(),
vat_rate: z.number().min(0).max(100),
amount_incl_tax: z.number().positive(),
supplier: z.object({
name: z.string().min(2),
siret: z.string().length(14).regex(/^\d+$/),
}),
});
type Invoice = z.infer<typeof InvoiceSchema>;
async function extractInvoice(text: string): Promise<Invoice> {
const response = await client.responses.create({
model: "gpt-5.6-terra",
instructions: "Extract invoice data.",
input: text,
text: {
format: {
type: "json_schema",
name: "invoice",
schema: {
type: "object",
properties: {
number: { type: "string" },
date: { type: "string" },
amount_excl_tax: { type: "number" },
vat_rate: { type: "number" },
amount_incl_tax: { type: "number" },
supplier: {
type: "object",
properties: {
name: { type: "string" },
siret: { type: "string" },
},
required: ["name", "siret"],
additionalProperties: false,
},
},
required: ["number", "date", "amount_excl_tax",
"vat_rate", "amount_incl_tax", "supplier"],
additionalProperties: false,
},
strict: true,
},
},
});
const data = JSON.parse(response.output_text);
// Zod-validering med finmaskede begrænsninger
return InvoiceSchema.parse(data);
}
Mønster: Genforsøg med korrektion
Når valideringen fejler, sender du fejlen tilbage til modellen til korrektion. Denne refleks ændrer fejlens natur: En dato i forkert format er ikke længere en undtagelse, der bobler op til brugeren, men en ekstra rundtur på få hundrede millisekunder, som ingen lægger mærke til. Mekanismen er simpel – vi genindsætter valideringsbeskeden i prompten til næste forsøg, så modellen ved præcis, hvad der gik galt, i stedet for at gætte blindt anden gang.
Denne komfort kræver dog grænser. Sæt en grænse for antallet af forsøg, ellers vil en umulig begrænsning – f.eks. et pattern, der er for strengt for udenlandske numre – koste dig opkald i en løkke. Og overvåg genforsøgsraten: Hvis en fjerdedel af dine udtrækninger går gennem et genforsøg, ligger problemet i den oprindelige prompt eller skemaet, ikke i modellen.
def extract_with_retry(prompt: str, schema: dict,
validator, max_retries: int = 3) -> dict:
"""Udtrækker og validerer med automatisk genforsøg."""
last_error = None
for attempt in range(max_retries):
input_text = prompt
if last_error:
input_text += (f"\n\nWARNING: Your previous response had "
f"this validation error: {last_error}\n"
f"Correct and try again.")
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=input_text,
text={"format": {"type": "json_schema",
"name": "data",
"schema": schema,
"strict": True}},
temperature=0.1
)
data = json.loads(response.output_text)
is_valid, error = validator(data)
if is_valid:
return data
last_error = error
raise ValueError(f"Failed after {max_retries} attempts: {last_error}")
En testbænk for kalenderinvitationer
Byg et Pydantic-skema til at udtrække begivenheder – titel, dato, tid, sted, deltagere – og tilslut det bag et kald til struktureret output. Test på fem e-mails, der indeholder invitationer, og sørg for at inkludere mindst én, hvor tiden er skrevet ud („torsdag sent på formiddagen”), og én, hvor stedet er implicit („som sædvanligt i bestyrelseslokalet”). Det er disse tilfælde, der bryder valideringen, og de dominerer i en rigtig indbakke.
Tilføj derefter automatisk genforsøg og mål to tal: Succesraten ved første forsøg og raten efter genforsøg. Det andet tal fortæller dig, hvad korrektionen køber dig, det første fortæller dig, om du bør revidere dine instrukser frem for at stole på en anden chance.
Vigtige pointer
- Struktureret output garanterer struktur, ikke semantisk gyldighed
- Brug to skemaer: ét til API’en (strengt), ét til validering på klientsiden
- Pydantic (Python) og Zod (TypeScript) er referenceværktøjerne
- Mønsteret med genforsøg og feedback korrigerer de fleste valideringsfejl
- Valider altid på klientsiden, før du gemmer data