Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Manuaalne response_format

Õppetund 5 / 12 Värskendatud 30. juuli 2026 Arendajatele
Sellel lehel
  1. Rohkem kontrolli response_format’iga
  2. Töövoog
  3. Täielik näide
  4. Erinevused parse()-st
  5. Parsimine ilma Pydanticuta
  6. Millal valida response_format
  7. Veakäsitlus
  8. Peamised punktid

Rohkem kontrolli response_format’iga

Manuaalne meetod response_format kaudu annab sulle täieliku kontrolli parsimise üle. Erinevalt parse()-ist, mis tagastab tüübitud objekti, tagastab see lähenemine JSON-stringi, mille sa ise parsid – Pydanticu mudel pakub vaid skeemi (model_json_schema()) ja teostab valideerimise hiljem. Vali see meetod, kui vajad paindlikkust või töötad keskkonnas, kus Pydanticut pole.

Töövoog

response_format kasutamisel toimub protsess kahe sammuna:

  1. API tagastab JSON-i **stringina** väljal response.choices[0].message.content`
  2. Sa parsid selle stringi enda valitud meetodil

Täielik näide

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

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

# Manuaalne parsimine Pydanticuga
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Erinevused parse()-st

Aspektparse()response_format
Tagastusväärtus(Response, ParsedModel)Ainult Response
ParsimineAutomaatneManuaalne
Andmete juurdepääsparsed.fieldjson.loads() või model_validate_json()
PaindlikkusStandardneMaksimaalne
VeakäsitlusSisseehitatudSinu vastutusel

Parsimine ilma Pydanticuta

Tulemuse parsimiseks ei pea sa tingimata Pydanticut kasutama. Sobib ka standardne json-moodul:

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

Millal valida response_format

response_format on eriti kasulik siis, kui soovid JSON-i enne objekti muutmist näha või uurida. Kõige levinum juhtum on logimine: tootmiskeskkonnas on toores JSON-i säilitamine enne teisendamist sageli auditi või silumise nõue ning parse() seda vahepealset punkti ei paku. Järgmiseks tuleb skeemi küsimus: kui sinu liidese leping on toores JSON-skeem – mida jagatakse teiste meeskondadega, genereeritakse tööriistaga või versioonitakse sõltumatult Pythoni koodist – on selle otsene jõustamine täpsem kui selle ümberkujundamine Pydanticu mudeliks. Lõpuks, mitte iga projekt ei tegutse Pydanticu ökosüsteemis: kui sinu valideerimine käib läbi mõne teise raamistiku või läbi sinu torustikule omase vaheetapi, annab response_format sulle JSON-i sellisena, nagu see on, ja jätab järgnevate sammude kontrolli sinu hooleks.

Veakäsitlus

Manuaalse meetodi puhul pead parsimisvead ise käsitlema:

import json

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

Praktikas ei tohiks see viga kunagi tekkida, kuna API garanteerib kehtiva JSON-i. Siiski on kaitsev käsitlemine tootmiskeskkonnas hea tava.

Peamised punktid

  • response_format tagastab JSON-stringi väljal response.choices[0].message.content
  • Parsimine on sinu vastutusel: json.loads(), model_validate_json() või mõni muu meetod
  • Saad kasutada toorest JSON-skeemi Pydanticu mudeli asemel
  • Suurem paindlikkus kui parse()-il, kuid rohkem kirjutatavat koodi
  • Tagastatud JSON on garanteeritult kehtiv – parsimisvigade tekkimine ei tohiks toimuda