Automatisk parse()-metod
På denna sida
Uppdaterad 3 november 2026. Baserat på dokumentationen för Structured Outputs från xAI och
openaiSDK 3.42.1: när OpenAI SDK pekar mot xAI är metodenclient.chat.completions.parse, vilket returnerar ett svar där det typade objektet läses frånchoices[0].message.parsed;client.chat.parsefinns inte (xAI SDK erbjuder dockchat.parse(Schema)på en konversation, vilket returnerar ett par av svarsobjekt). Källa: Structured Outputs.
Snabbspåret: parse()
Metoden parse() är det enklaste sättet att använda strukturerade utdata med Grok API. Den tar en Pydantic-modell som indata och returnerar direkt ett typat objekt – ingen JSON att parsa, ingen manuell validering.
Definiera Pydantic-modellen
Du skapar en Python-klass som beskriver den förväntade strukturen.
Anropa client.chat.completions.parse()
Du skickar Pydantic-modellen som response_format.
Ta emot tuplen (Response, ParsedModel)
Det typade objektet är redo att användas i din kod.
Fullständigt exempel
Så här extraherar du en strukturerad filmanalys:
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
completion = client.chat.completions.parse(
model="grok-4.20-0309-reasoning",
messages=[{
"role": "user",
"content": "Write a review of the movie Inception"
}],
response_format=MovieReview
)
parsed = completion.choices[0].message.parsed
# parsed är ett typat MovieReview-objekt
print(parsed.title) # "Inception"
print(parsed.rating) # 9.2
print(parsed.recommend) # True
print(type(parsed)) # <class 'MovieReview'>
Vad parse() returnerar
Metoden parse() returnerar en tupel med två element:
response: Det fullständiga API-svarsobjektet (med metadata, använda tokens, etc.)parsed: Din Pydantic-modell instansierad med den extraherade datan
Du kan komma åt båda efter behov:
completion = client.chat.completions.parse(...)
parsed = completion.choices[0].message.parsed
# Kom åt metadata
print(completion.usage.total_tokens)
print(completion.model)
# Kom åt strukturerad data
print(parsed.title)
print(parsed.rating)
Nästlade modeller
parse() hanterar komplexa strukturer utan ansträngning. Du kan nästla Pydantic-modeller:
class Actor(BaseModel):
name: str
role: str
class Review(BaseModel):
title: str
director: str
year: int
rating: float
main_actors: list[Actor]
genres: list[str]
strengths: list[str]
weaknesses: list[str]
completion = client.chat.completions.parse(
model="grok-4.20-0309-reasoning",
messages=[{
"role": "user",
"content": "Complete analysis of the movie Interstellar"
}],
response_format=Review
)
parsed = completion.choices[0].message.parsed
for actor in parsed.main_actors:
print(f"{actor.name} plays {actor.role}")
När ska du använda parse()?
parse() är den kortaste vägen mellan ett modelsvar och ett användbart Python-objekt: om du arbetar med Pydantic är detta ditt förstahandsval. Metoden kapslar in allt – skickar schemat, validerar svaret, instansierar objektet – och ger dig direkt en typad instans utan behov av json.loads eller manuella kontroller. Det är den mest koncisa koden möjlig, och för de allra flesta fall kommer denna enkelhet utan kostnad: du ger bara upp finjusterad parsning om du faktiskt behöver det, vilket är sällsynt. Nästa lektion täcker precis de fall där manuell kontroll är motiverad.
Viktiga punkter
parse()returnerar en tupel(Response, ParsedModel)– automatisk parsning- Det returnerade objektet är en typad och validerad Pydantic-instans
- Nästlade modeller och listor med objekt fungerar inbyggt
- Detta är den rekommenderade metoden för de flesta användningsfall i Python
- Inget behov av
json.loads()eller manuell validering