Manuell response_format
På denna sida
Mer kontroll med response_format
Den manuella metoden via response_format ger dig full kontroll över parsningen. Till skillnad från parse(), som returnerar ett typat objekt, returnerar denna approach en JSON-sträng som du parserar själv – Pydantic-modellen tillhandahåller endast schemat (model_json_schema()) och validerar i efterhand. Välj denna metod när du behöver flexibilitet eller när du arbetar i en miljö utan Pydantic.
Arbetsflöde
Med response_format sker processen i två steg:
- API:et returnerar JSON:en som en sträng i
response.choices[0].message.content - Du parserar denna sträng med valfri metod
Komplett exempel
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()
}
}
)
# Innehållet är en JSON-sträng
json_string = response.choices[0].message.content
print(type(json_string)) # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}
# Manuell parsning med Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title) # "Inception"
Skillnader från parse()
| Aspekt | parse() | response_format |
|---|---|---|
| Returvärde | (Response, ParsedModel) | Endast Response |
| Parsning | Automatisk | Manuell |
| Dataåtkomst | parsed.fält | json.loads() eller model_validate_json() |
| Flexibilitet | Standard | Maximal |
| Felhantering | Inbyggd | Ditt ansvar |
Parsning utan Pydantic
Du behöver inte använda Pydantic för att parsera resultatet. Standardmodulen json fungerar också:
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"]
När ska du välja response_format
response_format glänser närhelst du behöver se eller inspektera JSON:en innan den blir ett objekt. Det vanligaste fallet är loggning: i produktion är det ofta ett krav för revision eller felsökning att behålla rå-JSON:en före transformation, och parse() ger dig inte den möjligheten att interceptera datan. Därefter kommer frågan om schema: om ditt gränssnittskontrakt är ett rått JSON-schema – som delas med andra team, genereras av ett verktyg eller versioneras oberoende av Python-koden – är det mer troget att tillämpa det direkt än att återskapa det som en Pydantic-modell. Slutligen opererar inte alla projekt inom Pydantic-ekosystemet: om din validering sker via ett annat ramverk, eller genom ett mellanliggande bearbetningssteg specifikt för din pipeline, levererar response_format JSON:en exakt som den är och låter dig ha kontrollen över vad som händer härnäst.
Felhantering
Med den manuella metoden måste du hantera parsningsfel själv:
import json
try:
data = json.loads(response.choices[0].message.content)
except json.JSONDecodeError as e:
print(f"Parsningsfel: {e}")
I praktiken bör detta fel aldrig inträffa eftersom API:et garanterar giltig JSON. Men defensiv hantering är ändå en bästa praxis i produktion.
Viktiga punkter
response_formatreturnerar en JSON-sträng iresponse.choices[0].message.content- Parsningen är ditt ansvar:
json.loads(),model_validate_json()eller annan metod - Du kan använda ett rått JSON-schema istället för en Pydantic-modell
- Mer flexibilitet än
parse(), men mer kod att skriva - Den returnerade JSON:en är garanterat giltig – parsningsfel bör inte inträffa