Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Rankinis response_format

Paskaita 5 iš 12 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Didesnė kontrolė naudojant response_format
  2. Darbo eiga
  3. Pilnas pavyzdys
  4. Skirtumai nuo parse()
  5. Analizavimas be Pydantic
  6. Kada rinktis response_format
  7. Klaidų valdymas
  8. Svarbiausi punktai

Didesnė kontrolė naudojant response_format

Rankinis metodas per response_format suteikia tau visišką kontrolę над analizavimu (parsing). Skirtingai nei parse(), kuris grąžina tipizuotą objektą, šis būdas grąžina JSON eilutę, kurią turi išanalizuoti pats – Pydantic modelis čia tik pateikia schemą (model_json_schema()) ir atlieka validavimą vėliau. Rinkis šį metodą, kai tau reikia lankstumo arba kai dirbi aplinkoje be Pydantic.

Darbo eiga

Naudojant response_format, procesas vyksta dviem žingsniais:

  1. API grąžina JSON kaip eilutę lauke response.choices[0].message.content
  2. Tu išanalizuoji šią eilutę pasirinktu būdu

Pilnas pavyzdys

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

# Turinys yra JSON eilutė
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Rankinis analizavimas su Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Skirtumai nuo parse()

Aspektasparse()response_format
Grąžinama reikšmė(Response, ParsedModel)Tik Response
AnalizavimasAutomatinisRankinis
Duomenų pasiekimasparsed.fieldjson.loads() arba model_validate_json()
LankstumasStandartinisMaksimalus
Klaidų valdymasIntegruotasTavo atsakomybė

Analizavimas be Pydantic

Tau nebūtina naudoti Pydantic rezultatui analizuoti. Tinka ir standartinis json modulis:

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

Kada rinktis response_format

response_format ypač praverčia, kai nori pamatyti arba patikrinti JSON prieš tai, kai jis tampa objektu. Dažniausias atvejis – žurnalų rašymas (logging): gamybinėje aplinkoje neapdoroto JSON saugojimas prieš transformaciją dažnai yra audito arba derinimo reikalavimas, o parse() tokio perėmimo taško nesuteikia. Kitas aspektas – schema: jei tavo sąsajos sutartis yra „žalia“ JSON schema – bendrinama su kitomis komandomis, sugeneruota įrankio arba versionuojama nepriklausomai nuo Python kodo – jos tiesioginis taikymas yra tikslesnis nei perkūrimas į Pydantic modelį. Galiausiai, ne kiekvienas projektas veikia Pydantic ekosistemoje: jei tavo validavimas eina per kitą sistemą arba tarpinį apdorojimo žingsnį, specifinį tavo konvejeriui, response_format atiduoda JSON tokį, koks jis yra, ir palieka tau kontrolę над tuo, kas vyksta toliau.

Klaidų valdymas

Naudojant rankinį metodą, analizavimo klaidas turi valdyti pats:

import json

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

Praktiškai ši klaida niekada neturėtų įvykti, nes API garantuoja tinkamą JSON formatą. Tačiau apsauginis klaidų valdymas išlieka gerąja praktika gamybinėje aplinkoje.

Svarbiausi punktai

  • response_format grąžina JSON eilutę lauke response.choices[0].message.content
  • Analizavimas yra tavo atsakomybė: json.loads(), model_validate_json() arba kitas būdas
  • Gali naudoti „žalią“ JSON schemą vietoj Pydantic modelio
  • Didesnis lankstumas nei naudojant parse(), bet reikia rašyti daugiau kodo
  • Grąžinamas JSON yra garantuotai tinkamas – analizavimo klaidos neturėtų kilti