Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Automatikus parse() metódus

4. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. A gyors út: parse()
  2. Teljes példa
  3. Mit ad vissza a parse()?
  4. Beágyazott modellek
  5. Mikor használd a parse() metódust?
  6. Főbb megállapítások

Frissítve: 2026. november 3. Az xAI Structured Outputs dokumentációja és az openai SDK 3.42.1 verziója alapján: ha az OpenAI SDK-t az xAI-ra irányítod, a használandó metódus a client.chat.completions.parse, amely egy olyan kiegészítést (completion) ad vissza, ahol a típusozott objektum a choices[0].message.parsed értékből olvasható ki; a client.chat.parse nem létezik (bár az xAI SDK kínál chat.parse(Schema) metódust beszélgetéshez, ami egy válasz-objektum párost ad vissza). Forrás: Structured Outputs.

A gyors út: parse()

A parse() metódus a legegyszerűbb módja a strukturált kimenetek használatának a Grok API-val. Egy Pydantic modellt vár bemenetként, és közvetlenül egy típusozott objektumot ad vissza – nincs szükség JSON elemzésre vagy kézi validálásra.

1

A Pydantic modell definiálása

Létrehozol egy Python osztályt, amely leírja a várt szerkezetet.

2

A client.chat.completions.parse() meghívása

A Pydantic modellt átadod response_format paraméterként.

3

A tuple (Válasz, ParsedModel) fogadása

A típusozott objektum azonnal használható a kódodban.

Teljes példa

Így néz ki egy strukturált filmkritika kinyerése:

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

# A parsed egy típusozott MovieReview objektum
print(parsed.title)      # "Inception"
print(parsed.rating)     # 9.2
print(parsed.recommend)  # True
print(type(parsed))      # <class 'MovieReview'>

Mit ad vissza a parse()?

A parse() metódus egy két elemű tuple-t ad vissza:

  1. response: A teljes API-válasz objektum (metaadatokkal, felhasznált tokenekkel stb.)
  2. parsed: A Pydantic modelled, amely a kinyert adatokkal példányosult

Mindkettőt elérheted szükség szerint:

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

# Metaadatok elérése
print(completion.usage.total_tokens)
print(completion.model)

# Strukturált adatok elérése
print(parsed.title)
print(parsed.rating)

Beágyazott modellek

A parse() effortlessly kezeli a komplex szerkezeteket. Beágyazhatsz Pydantic modelleket:

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}")

Mikor használd a parse() metódust?

A parse() a legrövidebb út egy modellválasz és egy használható Python objektum között: ha Pydanticcel dolgozol, ez az alapértelmezett választás. A metódus mindent encapsulál – a séma elküldésétől a válasz validálásán át az objektum példányosításáig –, és közvetlenül egy típusozott példányt ad át neked, json.loads vagy kézi ellenőrzések nélkül. Ez a lehető legtömörebb kód, és az esetek túlnyomó többségében ez az egyszerűség semmilyen hátránnyal nem jár: csak akkor mondasz le a finomhangolt elemzési kontrollról, ha arra tényleg szükséged lenne, ami ritka. A következő leckében pontosan azokat az eseteket tárgyaljuk, amikor a kézi kontroll indokolt.

Főbb megállapítások

  • A parse() egy (Response, ParsedModel) tuple-t ad vissza – automatikus elemzéssel
  • A visszaadott objektum egy típusozott és validált Pydantic példány
  • A beágyazott modellek és objektumlisták natívan működnek
  • Ez a javasolt módszer a legtöbb Python használati esethez
  • Nincs szükség json.loads()-ra vagy kézi validálásra