Manuel response_format
På denne side
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:
- API’et returnerer JSON’en som en streng i
response.choices[0].message.content - 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()
| Aspekt | parse() | response_format |
|---|---|---|
| Returværdi | (Response, ParsedModel) | Kun Response |
| Parsing | Automatisk | Manuel |
| Dataadgang | parsed.field | json.loads() eller model_validate_json() |
| Fleksibilitet | Standard | Maksimal |
| Fejlhåndtering | Indbygget | Dit 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_formatreturnerer en JSON-streng iresponse.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å