Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Ruční response_format

Lekce 5 z 12 Aktualizováno 30. července 2026 Vývojář
Na této stránce
  1. Větší kontrola díky response_format
  2. Pracovní postup
  3. Kompletní příklad
  4. Rozdíly oproti parse()
  5. Parsování bez Pydantic
  6. Kdy zvolit response_format
  7. Zpracování chyb
  8. Klíčové poznatky

Větší kontrola díky response_format

Ruční metoda přes response_format ti dává plnou kontrolu nad parsováním. Na rozdíl od parse(), která vrací typizovaný objekt, tento přístup vrací JSON řetězec, který si parsuješ sám – model Pydantic zde slouží pouze k definici schématu (model_json_schema()) a následné validaci. Tuto metodu zvol, když potřebuješ flexibilitu nebo pracuješ v prostředí bez knihovny Pydantic.

Pracovní postup

Při použití response_format probíhá proces ve dvou krocích:

  1. API vrátí JSON jako řetězec v response.choices[0].message.content
  2. Tento řetězec parsuješ zvolenou metodou

Kompletní příklad

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

# Obsah je JSON řetězec
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Ruční parsování s Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Rozdíly oproti parse()

Aspektparse()response_format
Návratová hodnota(Response, ParsedModel)Pouze Response
ParsováníAutomatickéRuční
Přístup k datůmparsed.fieldjson.loads() nebo model_validate_json()
FlexibilitaStandardníMaximální
Zpracování chybVestavěnéTvá zodpovědnost

Parsování bez Pydantic

K parsování výsledku nemusíš používat Pydantic. Funguje i standardní modul json:

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

Kdy zvolit response_format

response_format se hodí vždy, když potřebuješ JSON vidět nebo zkontrolovat ještě před jeho převodem na objekt. Nejčastějším případem je logování: v produkčním prostředí je často požadavkem na audit nebo ladění uchování surového JSON před transformací a parse() ti tento bod odposlechu neposkytuje. Dalším aspektem je otázka schématu: pokud je tvůj kontraktní interface surové JSON schéma – sdílené s jinými týmy, generované nástrojem nebo verzované nezávisle na Python kódu – je jeho přímé vynucení věrnější než jeho rekonstrukce jako modelu Pydantic. Nakonec, ne každý projekt funguje v ekosystému Pydantic: pokud tvá validace probíhá přes jiný framework nebo přes mezilehlý zpracovatelský krok specifický pro tvůj pipeline, response_format ti předá JSON tak, jak je, a nechá tě rozhodnout, co bude dál.

Zpracování chyb

Při ruční metodě musíš chyby parsování ošetřit sám:

import json

try:
    data = json.loads(response.choices[0].message.content)
except json.JSONDecodeError as e:
    print(f"Chyba parsování: {e}")

V praxi by tato chyba neměla nikdy nastat, protože API garantuje platný JSON. Obranné programování však zůstává v produkčním prostředí osvědčeným postupem.

Klíčové poznatky

  • response_format vrací JSON řetězec v response.choices[0].message.content
  • Parsování je na tobě: json.loads(), model_validate_json() nebo jiná metoda
  • Můžeš použít surové JSON schéma místo modelu Pydantic
  • Větší flexibilita než u parse(), ale více kódu k napsání
  • Vrácený JSON je garantovaně platný – chyby parsování by neměly nastat