Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Begrænsninger og fejlhåndtering i JSON-tilstand

Lektion 6 af 12 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Gyldig betyder ikke korrekt
  2. Ingen skemagarantier
  3. Obligatorisk validering på klientsiden
  4. Tre fejl, du vil støde på
  5. Genforsøg med feedback
  6. Signalet om at ændre tilgang
  7. Vigtige pointer

Gyldig betyder ikke korrekt

JSON-tilstand garanterer syntaktisk gyldig JSON, ikke semantisk korrekt JSON. Denne forskel kan virke subtil under udvikling, men bliver afgørende i produktion. JSON, der parses uden fejl, men indeholder uventede nøgler, skaber præcis den type bug, der tager dage at opspore, fordi ingen undtagelse udløses, når problemet faktisk opstår.

Ingen skemagarantier

Mekanismen ved intet om dit skema: den har aldrig set den struktur, din kode forventer. Modellen kan udelade et felt, du har brug for, tilføje et, du ikke har bedt om, omdøbe en nøgle – firstName i stedet for first_name – eller ændre en type ved at returnere "42" som en streng, når du forventede tallet 42. Intet af dette er ugyldig JSON.

# Du forventer dette:
# {"name": "Alice", "age": 30, "city": "Paris"}

# Men du kan modtage:
# {"nom": "Alice", "âge": "trente ans", "ville": "Paris", "pays": "France"}

JSON’en er gyldig, men strukturen matcher ikke det, din kode forventer. Dette er den fundamentale forskel fra tilpassede strukturerede output.

Obligatorisk validering på klientsiden

Da skemaet ikke er garanteret, påhviler valideringen dig. Det minimale mønster gør tre ting i rækkefølge: det forsøger at parse, verificerer, at roden er et objekt (ikke en liste eller skalar), og tjekker derefter for påkrævede nøgler. Hver fejl udløser en ValueError med en besked, du kan bruge i dine logs.

import json
from typing import Optional

def parse_and_validate(raw_content: str, required_keys: list[str]) -> dict:
    """Parse JSON og verificér påkrævede nøgler."""
    try:
        data = json.loads(raw_content)
    except json.JSONDecodeError as e:
        raise ValueError(f"Ugyldig JSON: {e}")

    if not isinstance(data, dict):
        raise ValueError(f"Forventede JSON-objekt, modtog {type(data).__name__}")

    missing = [k for k in required_keys if k not in data]
    if missing:
        raise ValueError(f"Manglende nøgler: {missing}")

    return data

# Brug
try:
    result = parse_and_validate(
        response.choices[0].message.content,
        required_keys=["name", "category", "priority"]
    )
    process_ticket(result)
except ValueError as e:
    log_error(f"Ugyldigt output: {e}")
    fallback_processing(raw_content)

TypeScript-versionen går et skridt videre ved at verificere, udover nøglernes eksistens, at den returnerede kategori tilhører den tilladte liste. Dette er den tjek, der oftest mangler, og den, der forhindrer, at en billet klassificeret som "urgent_billing" sniger sig ubemærket gennem din routing.

interface TicketClassification {
  category: string;
  priority: string;
  sentiment: string;
  summary: string;
}

function validateTicket(raw: string): TicketClassification {
  const data = JSON.parse(raw);

  const requiredKeys = ["category", "priority", "sentiment", "summary"];
  const missing = requiredKeys.filter((k) => !(k in data));

  if (missing.length > 0) {
    throw new Error(`Manglende nøgler: ${missing.join(", ")}`);
  }

  const validCategories = ["billing", "account", "technical", "feature_request", "other"];
  if (!validCategories.includes(data.category)) {
    throw new Error(`Ugyldig kategori: ${data.category}`);
  }

  return data as TicketClassification;
}

Tre fejl, du vil støde på

Den første er trunkeret JSON. Hvis svaret rammer max_tokens-grænsen, bliver det afskåret midt i strømmen og bliver ugyldigt – den afsluttende kramme ankommer aldrig. Du kan spotte symptomet før selv parsing: finish_reason er lig med "length" i stedet for "stop".

response = client.chat.complete(
    model="mistral-small-latest",
    messages=messages,
    response_format={"type": "json_object"},
    max_tokens=50  # For lille til komplet JSON
)

# response.choices[0].finish_reason vil være "length" i stedet for "stop"
if response.choices[0].finish_reason == "length":
    print("Advarsel: Trunkeret svar, øg max_tokens")

Tjek altid finish_reason: hvis det er lig med "length", er svaret ufuldstændigt, uanset hvad resten af indholdet siger.

Den anden fejl vedrører typer. En alder kan ankomme som en streng, en pris som et heltal, når du forventer et flydende tal. I stedet for at stole på outputtet, skal du pakke adgangen ind i en hjælperfunktion, der forsøger konvertering og falder tilbage til en standardværdi, hvis det mislykkes.

def safe_get_int(data: dict, key: str, default: int = 0) -> int:
    """Udtræk et heltal, med konvertering hvis nødvendigt."""
    value = data.get(key)
    if value is None:
        return default
    if isinstance(value, int):
        return value
    if isinstance(value, float):
        return int(value)
    if isinstance(value, str):
        try:
            return int(value)
        except ValueError:
            return default
    return default

# Brug
age = safe_get_int(data, "age", default=0)

Den tredje er omdøbning af nøgler. Med en fransk prompt kan modellen nemt skifte phone til telephone eller name til nom. En synonymkortlægning absorberer disse variationer uden at kræve, at du gentager kaldet.

def normalize_keys(data: dict, key_mapping: dict) -> dict:
    """Normalisér nøgler ved hjælp af en synonymkortlægning."""
    normalized = {}
    for standard_key, aliases in key_mapping.items():
        for alias in aliases:
            if alias in data:
                normalized[standard_key] = data[alias]
                break
    return normalized

# Synonymkortlægning
mapping = {
    "name": ["name", "nom", "full_name", "fullName"],
    "email": ["email", "mail", "e-mail", "emailAddress"],
    "phone": ["phone", "telephone", "tel", "phoneNumber"],
}

normalized = normalize_keys(raw_data, mapping)

Genforsøg med feedback

Når valideringen mislykkes trods dine bedste bestræbelser, er det bedste svar ikke at gentage præcis samme kald: det er at fortælle modellen, hvad der gik galt. Ved at fodre dens eget svar tilbage i samtalen sammen med fejlmeddelelsen giver du den den kontekst, der er nødvendig for at selvkorrigerer, normalt allerede ved andet forsøg.

import json

def call_with_retry(client, messages, max_retries=3):
    """Kald med genforsøg og fejlfeedback."""
    for attempt in range(max_retries):
        response = client.chat.complete(
            model="mistral-large-latest",
            messages=messages,
            response_format={"type": "json_object"},
            temperature=0
        )

        raw = response.choices[0].message.content
        try:
            data = json.loads(raw)
            validate_schema(data)  # Din valideringsfunktion
            return data
        except (json.JSONDecodeError, ValueError) as e:
            if attempt < max_retries - 1:
                # Tilføj fejlfeedback til konteksten
                messages.append({"role": "assistant", "content": raw})
                messages.append({
                    "role": "user",
                    "content": f"Dit svar er ugyldigt: {e}. Ret det og returnér gyldig JSON."
                })
            else:
                raise RuntimeError(f"Mislykkedes efter {max_retries} forsøg: {e}")

Signalet om at ændre tilgang

Hvis du finder dig selv i at skrive omfattende valideringskode, er det et stærkt signal om, at det er tid til at migrere til tilpassede strukturerede output. Tre typiske tærskler bekræfter dette: ud over fem felter at validere, bliver kontrolfunktionen længere end selve kaldet; når typer bliver komplekse med nestede lister eller enums, bliver manuel validering uadskillelig fra de bugs, den introducerer; og for enhver kritisk produktionspipeline er det simpelthen sikrere at delegere begrænsninger til skemaet end at rekonstruere dem i hånden.

Vigtige pointer

  • JSON-tilstand garanterer gyldig JSON, ikke et gyldigt skema
  • Valider altid output på klientsiden: tjek for påkrævede nøgler, korrekte typer og værdier inden for grænser
  • Tjek finish_reason for at opdage trunkerede svar
  • Implementér en genforsøgsmekanisme med fejlfeedback
  • Hvis validering bliver kompleks, så migrér til tilpassede strukturerede output