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

Manuális response_format

5. lecke 12 közül Frissítve 2026. július 30. Fejlesztő
Ezen az oldalon
  1. Több kontroll a response_format segítségével
  2. Munkafolyamat
  3. Teljes példa
  4. Különbségek a parse()-hoz képest
  5. Elemzés Pydantic nélkül
  6. Mikor válaszd a response_format-ot?
  7. Hibakezelés
  8. Főbb megállapítások

Több kontroll a response_format segítségével

A response_format-on keresztüli manuális módszer teljes kontrollt biztosít a feldolgozás felett. A parse()-szel ellentétben, amely egy típusos objektumot ad vissza, ez a megközelítés egy JSON-sztringet szolgáltat, amelyet neked kell elemezned – a Pydantic modell csupán a sémát (model_json_schema()) biztosítja, és utólag végez validálást. Akkor válaszd ezt a módszert, ha rugalmasságra van szükséged, vagy olyan környezetben dolgozol, ahol nincs jelen a Pydantic.

Munkafolyamat

A response_format használatakor a folyamat két lépésben zajlik:

  1. Az API a JSON-t sztringként adja vissza a response.choices[0].message.content mezőben
  2. Ezt a sztringet a saját módszereddel elemzed

Teljes példa

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

# A tartalom egy JSON-sztring
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Manuális elemzés Pydantic segítségével
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Különbségek a parse()-hoz képest

Szempontparse()response_format
Visszatérési érték(Response, ParsedModel)Csak Response
ElemzésAutomatikusManuális
Adathozzáférésparsed.fieldjson.loads() vagy model_validate_json()
RugalmasságSzabványosMaximális
HibakezelésBeépítettA te felelősséged

Elemzés Pydantic nélkül

Nem kötelező a Pydanticet használnod az eredmény elemzéséhez. A szabványos json modul is működik:

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"]

Mikor válaszd a response_format-ot?

A response_format akkor ragyog, amikor látnod vagy megvizsgálnod kell a JSON-t, mielőtt az objektummá alakul. A leggyakoribb eset a naplózás: éles környezetben gyakran auditálási vagy hibakeresési követelmény a nyers JSON megőrzése a transzformáció előtt, és a parse() nem biztosítja ezt a beavatkozási pontot. A következő szempont a séma kérdése: ha az interfész-szerződésed egy nyers JSON-séma – amelyet más csapatokkal osztasz meg, egy eszköz generál, vagy a Python kódtól függetlenül verziókezeltek –, akkor annak közvetlen érvényesítése hűségesebb, mint egy Pydantic modellként történő újraalkotása. Végül pedig nem minden projekt a Pydantic ökoszisztémájában működik: ha a validációd egy másik keretrendszeren keresztül fut, vagy a pipeline-odra jellemző közbenső feldolgozási lépésen megy át, a response_format változatlanul a kezedbe adja a JSON-t, és rád bízza a továbbiak irányítását.

Hibakezelés

A manuális módszerrel neked kell kezelned az elemzési hibákat:

import json

try:
    data = json.loads(response.choices[0].message.content)
except json.JSONDecodeError as e:
    print(f"Parsing error: {e}")

Gyakorlati szempontból ez a hiba soha nem fordulhat elő, mivel az API garantálja az érvényes JSON-t. Ugyanakkor a védekező hibakezelés továbbra is bevált gyakorlat éles környezetben.

Főbb megállapítások

  • A response_format egy JSON-sztringet ad vissza a response.choices[0].message.content mezőben
  • Az elemzés a te felelősséged: json.loads(), model_validate_json() vagy más módszer
  • Használhatsz nyers JSON-sémát is Pydantic modell helyett
  • Rugalmasabb, mint a parse(), de több kódot igényel
  • A visszakapott JSON garantáltan érvényes – elemzési hibák nem fordulhatnak elő