Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Validering med JSON Schema och Zod

Lektion 11 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Validering med JSON Schema och Zod
  2. Varför validera efter mottagandet
  3. Python-validering med jsonschema
  4. Validering med Pydantic
  5. Validering med Zod (TypeScript/Node.js)
  6. Mönster: försök igen med korrigering
  7. En testbänk för kalenderinbjudningar
  8. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAI-dokumentation: temperature och top_p accepteras 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 specificera reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.

Validering med JSON Schema och Zod

Strukturerad utmatning garanterar svarstrukturen, men inte data semantiska giltighet. Ett fält för “e-post” kan innehålla en sträng som inte är en giltig e-postadress. Validering på klientsidan med JSON Schema eller Zod är det nödvändiga komplementet för en robust pipeline.

Varför validera efter mottagandet

Gör en inventering av vad API:t garanterar, så blir arbetsfördelningen tydlig. OpenAI:s Strukturerade Utmatning säkerställer att JSON:en är syntaktiskt giltig, att deklarerade typer respekteras – en sträng förblir en sträng, ett heltal förblir ett heltal – att alla obligatoriska fält finns med och att värden begränsade av en enum tillhör listan. På dessa fyra punkter kan du skriva din kod med tillförsikt.

Allt annat ligger på dig och omfattar fyra familjer av problem. Formatbegränsningar undgår det strikta schemat: inget hindrar modellen från att returnera jean.dupont(at)example.fr i ett email-fält, eller ett datum i formatet 15/03/2026 när du förväntar dig ISO. Gränser kontrolleras inte heller, varken för stränglängd eller talintervall: en ålder på 350 passerar utan att blinka. Konsistens mellan fält ligger utom räckhåll – ett end_date tidigare än start_date är perfekt giltig JSON. Och affärsmässig giltighet har ingen anledning att bekymra API:t: ett SIRET-nummer (franskt företags-ID) måste vara fjorton siffror, men det är din domäns kunskap, inte avkodarens.

Dessa fyra familjer delar en skrämmande egenskap: de orsakar inga synliga fel. En felformad e-postadress som sparas i databasen visar sig inte förrän e-postkampanjen studsar veckor senare. Därför gäller regeln: validera innan du sparar, aldrig efteråt.

Python-validering med jsonschema

Den praktiska konsekvensen är att du behöver två scheman för samma data. Det första skickas till API:t, avsiktligt sparsamt, begränsat till vad strikt läge accepterar. Det andra stannar hos dig och bär de finmaskiga begränsningarna – format, pattern, minimum, maximum. Denna skenbara duplicering är en separation av ansvarsområden: det ena ramar in genereringen, det andra försvarar din lagring. I exemplet nedan förekommer endast roll-enum i båda, eftersom det är den enda begränsning båda nivåerna kan uttrycka.

import json
from jsonschema import validate, ValidationError

# Schema för OpenAI API (strikt, inget format/mönster)
api_schema = {
    "type": "object",
    "properties": {
        "email": {"type": "string"},
        "age": {"type": "integer"},
        "role": {"type": "string", "enum": ["admin", "user", "viewer"]}
    },
    "required": ["email", "age", "role"],
    "additionalProperties": False
}

# Utökat schema för validering på klientsidan
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]:
    """Validerar LLM-svaret mot det utökade schemat."""
    try:
        validate(instance=data, schema=validation_schema)
        return True, "Valid"
    except ValidationError as e:
        return False, f"Error: {e.message}"

Validering med Pydantic

Pydantic är ofta bekvämare än jsonschema för validering i Python, och skillnaden ligger i vad du får ut. jsonschema berättar ja eller nej och lämnar dig med en ordbok, manipulerad via data["email"] utan hjälp från editorn. Pydantic returnerar ett typat objekt: autokomplettering fungerar, ett stavfel i ett attributnamn fångas vid skrivtid, och data cirkulerar därefter utan konvertering.

Modellen ContactExtraction uttrycker gränser direkt i fältdeklarationerna. field_validator på date_extraction täcker fallet som ingen typannotering kan fånga: strängen är visserligen en sträng, men den måste representera ett verkligt datum – 2026-02-31 uppfyller vilket rimligt pattern som helst men existerar inte. Extraktionsfunktionen visar hela kedjan, från det sparsamma schemat som skickas till API:t till den validerade instansieringen.

from pydantic import BaseModel, Field, field_validator
from pydantic import EmailStr
from datetime import date

class ContactExtraction(BaseModel):
    """Valideringsschema för kontaktextrahering."""
    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:
    """Extraherar en kontakt och validerar data."""
    # Schema för API (utan finmaskiga begränsningar)
    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 finmaskiga begränsningar
    return ContactExtraction(**data)

Validering med Zod (TypeScript/Node.js)

Om din backend är skriven i TypeScript är Zod referensverktyget, och det för med sig en fördel som Pydantic inte behöver tillhandahålla: z.infer härleder TypeScript-typen direkt från valideringsschemat. Du beskriver formen en gång, och kompilatorn känner sedan till strukturen för Invoice utan att du behöver underhålla ett parallellt gränssnitt, så det finns ingen risk för divergens.

Fakturaschemat nedan illustrerar arbetsfördelningen: på API-sidan är siret bara en sträng; på Zod-sidan måste det vara exakt fjorton tecken och endast innehålla siffror. Den slutgiltiga parse kastar ett undantag om data inte passar, och det är önskvärt beteende – ett högljutt fel som avbryter dokumentbearbetningen är bättre än en fantasifull SIRET-faktura lagrad i databasen bland tiotusentals andra.

import { z } from "zod";
import OpenAI from "openai";

const client = new OpenAI();

// Zod-schema med finmaskiga valideringar
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 finmaskiga begränsningar
  return InvoiceSchema.parse(data);
}

Mönster: försök igen med korrigering

När valideringen misslyckas, skicka felet tillbaka till modellen för korrigering. Denna reflex förändrar misslyckandets natur: ett datum i fel format är inte längre ett undantag som bubblar upp till användaren, utan en extra omgång på några hundra millisekunder som ingen märker. Mekanismen är enkel – vi injicerar om valideringsmeddelandet i nästa försöks prompt, så att modellen vet exakt vad som gick fel istället för att gissa blindt en andra gång.

Denna bekvämlighet kräver dock gränser. Sätt ett tak för antalet försök, annars kommer en omöjlig begränsning – ett pattern som är för strikt för utländska nummer till exempel – att kosta dig anrop i en loop. Och övervaka frekvensen för nya försök: om en fjärdedel av dina extraheringar går genom ett nytt försök, ligger problemet i den ursprungliga prompten eller schemat, inte i modellen.

def extract_with_retry(prompt: str, schema: dict,
                       validator, max_retries: int = 3) -> dict:
    """Extraherar och validerar med automatiskt nytt försök."""
    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 för kalenderinbjudningar

Bygg ett Pydantic-schema för att extrahera händelser – titel, datum, tid, plats, deltagare – och koppla det sedan bakom ett anrop för Strukturerad Utmatning. Testa på fem e-postmeddelanden som innehåller inbjudningar, och se till att inkludera minst ett där tiden är utskriven (“torsdag sen förmiddag”) och ett där platsen är underförstådd (“som vanligt i konferensrummet”). Det är dessa fall som bryter valideringen, och de dominerar i en riktig inkorg.

Lägg sedan till automatiskt nytt försök och mät två siffror: framgångsfrekvensen vid första försöket och frekvensen efter nya försök. Den andra berättar vad korrigeringen ger dig, den första om du bör omarbeta dina instruktioner snarare än att lita på en andra chans.

Viktiga punkter

  • Strukturerad utmatning garanterar struktur, inte semantisk giltighet
  • Använd två scheman: ett för API:t (strikt), ett för validering på klientsidan
  • Pydantic (Python) och Zod (TypeScript) är referensverktygen
  • Mönstret med nytt försök och återkoppling korrigerar de flesta valideringsfel
  • Validera alltid på klientsidan innan du sparar data