Automatische parse()-Methode

Aktualisiert am 3. November 2026. Basierend auf der Dokumentation zu Structured Outputs von xAI und dem openai SDK 3.42.1: Wenn das OpenAI SDK auf xAI gerichtet ist, lautet die Methode client.chat.completions.parse. Diese gibt eine Completion zurück, bei der das typisierte Objekt aus choices[0].message.parsed gelesen wird. Die Methode client.chat.parse existiert nicht (das xAI SDK bietet zwar chat.parse(Schema) für einen Chatverlauf an, was ein Antwort-Objekt-Paar zurückgibt). Quelle: Structured Outputs.

Der schnelle Weg: parse()

Die parse()-Methode ist der einfachste Weg, um strukturierte Ausgaben mit der Grok-API zu verwenden. Sie nimmt ein Pydantic-Modell als Eingabe und gibt ein typisiertes Objekt direkt zurück – kein JSON zum Parsen, keine manuelle Validierung.

Vollständiges Beispiel

So extrahieren Sie eine strukturierte Filmkritik:

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 ist ein typisiertes MovieReview-Objekt
print(parsed.title)      # "Inception"
print(parsed.rating)     # 9.2
print(parsed.recommend)  # True
print(type(parsed))      # <class 'MovieReview'>

Was parse() zurückgibt

Die parse()-Methode gibt ein Tupel mit zwei Elementen zurück:

1. response: Das vollständige API-Antwortobjekt (mit Metadaten, verbrauchten Tokens usw.)
2. parsed: Ihr Pydantic-Modell, instanziiert mit den extrahierten Daten

Sie können beide nach Bedarf zugreifen:

completion = client.chat.completions.parse(...)
parsed = completion.choices[0].message.parsed

# Metadaten zugreifen
print(completion.usage.total_tokens)
print(completion.model)

# Strukturierte Daten zugreifen
print(parsed.title)
print(parsed.rating)

Verschachtelte Modelle

parse() bewältigt komplexe Strukturen mühelos. Sie können Pydantic-Modelle verschachteln:

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} spielt {actor.role}")

Wann parse() verwenden

parse() ist der kürzeste Weg zwischen einer Modellantwort und einem nutzbaren Python-Objekt: Wenn Sie mit Pydantic arbeiten, ist dies die Standardwahl. Die Methode kapselt alles ein – das Senden des Schemas, die Validierung der Antwort, die Instanziierung des Objekts – und übergibt Ihnen eine typisierte Instanz direkt, ohne json.loads oder manuelle Prüfungen. Es ist der möglichste knappe Code, und für die überwiegende Mehrheit der Fälle kostet diese Einfachheit nichts: Sie verzichten nur auf eine feingranulare Parsing-Kontrolle, falls Sie diese tatsächlich benötigt hätten, was selten ist. Die nächste Lektion behandelt genau jene Fälle, in denen manuelle Kontrolle gerechtfertigt ist.

Kernaussagen

• parse() gibt ein Tupel (Response, ParsedModel) zurück – automatisches Parsen
• Das zurückgegebene Objekt ist eine typisierte und validierte Pydantic-Instanz
• Verschachtelte Modelle und Listen von Objekten funktionieren nativ
• Dies ist die empfohlene Methode für die meisten Anwendungsfälle in Python
• Kein Bedarf für json.loads() oder manuelle Validierung