Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Automatisk parse()-metod

Lektion 4 av 12 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Snabbspåret: parse()
  2. Fullständigt exempel
  3. Vad parse() returnerar
  4. Nästlade modeller
  5. När ska du använda parse()?
  6. Viktiga punkter

Uppdaterad 3 november 2026. Baserat på dokumentationen för Structured Outputs från xAI och openai SDK 3.42.1: när OpenAI SDK pekar mot xAI är metoden client.chat.completions.parse, vilket returnerar ett svar där det typade objektet läses från choices[0].message.parsed; client.chat.parse finns inte (xAI SDK erbjuder dock chat.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.

1

Definiera Pydantic-modellen

Du skapar en Python-klass som beskriver den förväntade strukturen.

2

Anropa client.chat.completions.parse()

Du skickar Pydantic-modellen som response_format.

3

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:

  1. response: Det fullständiga API-svarsobjektet (med metadata, använda tokens, etc.)
  2. 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