Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Manuel response_format

Lektion 5 af 12 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Mere kontrol med response_format
  2. Arbejdsgang
  3. Komplet eksempel
  4. Forskelle fra parse()
  5. Parsing uden Pydantic
  6. Hvornår skal du vælge response_format
  7. Fejlhåndtering
  8. Vigtige pointer

Mere kontrol med response_format

Den manuelle metode via response_format giver dig fuld kontrol over parsningen. I modsætning til parse(), som returnerer et typet objekt, returnerer denne tilgang en JSON-streng, som du selv parser – Pydantic-modellen leverer kun skemaet (model_json_schema()) og validerer bagefter. Vælg denne metode, når du har brug for fleksibilitet, eller når du arbejder i et miljø uden Pydantic.

Arbejdsgang

Med response_format foregår processen i to trin:

  1. API’et returnerer JSON’en som en streng i response.choices[0].message.content
  2. Du parser denne streng ved hjælp af din foretrukne metode

Komplet eksempel

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI(
    api_key="your-xai-key",
    base_url="https://api.x.ai/v1"
)

class MovieReview(BaseModel):
    title: str
    rating: float
    summary: str
    recommend: bool

response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": "Review the movie Inception"
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "movie_review",
            "schema": MovieReview.model_json_schema()
        }
    }
)

# Indholdet er en JSON-streng
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Manuel parsing med Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Forskelle fra parse()

Aspektparse()response_format
Returværdi(Response, ParsedModel)Kun Response
ParsingAutomatiskManuel
Dataadgangparsed.fieldjson.loads() eller model_validate_json()
FleksibilitetStandardMaksimal
FejlhåndteringIndbyggetDit ansvar

Parsing uden Pydantic

Du behøver ikke bruge Pydantic til at parse resultatet. Standardmodulet json fungerer også:

import json

response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": "Analyze this text and extract entities"
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "entities",
            "schema": {
                "type": "object",
                "properties": {
                    "people": {
                        "type": "array",
                        "items": { "type": "string" }
                    },
                    "places": {
                        "type": "array",
                        "items": { "type": "string" }
                    }
                }
            }
        }
    }
)

data = json.loads(response.choices[0].message.content)
print(data["people"])  # ["Marie Curie", "Pierre Curie"]
print(data["places"])      # ["Paris", "Warsaw"]

Hvornår skal du vælge response_format

response_format skinner, når du har brug for at se eller inspicere JSON’en, før den bliver til et objekt. Det mest almindelige tilfælde er logning: i produktion er det ofte et krav til revision eller fejlfinding at beholde den rå JSON før transformation, og parse() giver dig ikke dette interceptionspunkt. Dernæst kommer spørgsmålet om skemaet: Hvis din grænsefladekontrakt er et rått JSON-skema – delt med andre teams, genereret af et værktøj, versioneret uafhængigt af Python-koden – er det mere trofast at håndhæve det direkte end at rekonstruere det som en Pydantic-model. Endelig opererer ikke alle projekter inden for Pydantic-økosystemet: Hvis din validering går gennem et andet framework eller gennem et mellemliggende behandlingstrin specifikt for din pipeline, giver response_format dig JSON’en, som den er, og lader dig have kontrollen over, hvad der sker derefter.

Fejlhåndtering

Med den manuelle metode skal du selv håndtere parseringsfejl:

import json

try:
    data = json.loads(response.choices[0].message.content)
except json.JSONDecodeError as e:
    print(f"Parsing error: {e}")

I praksis bør denne fejl aldrig opstå, da API’et garanterer gyldig JSON. Men defensiv håndtering forbliver en bedste praksis i produktion.

Vigtige pointer

  • response_format returnerer en JSON-streng i response.choices[0].message.content
  • Parsing er dit ansvar: json.loads(), model_validate_json() eller en anden metode
  • Du kan bruge et rått JSON-skema i stedet for en Pydantic-model
  • Mere fleksibilitet end parse(), men mere kode at skrive
  • Den returnerede JSON er garanteret gyldig – parseringsfejl bør ikke opstå