Salt la conținutul principal
Română— Alege o limbă
Meniu

Formatul manual response_format

Lecția 5 din 12 Actualizată 30 iulie 2026 Dezvoltator
Pe această pagină
  1. Control sporit cu response_format
  2. Flux de lucru
  3. Exemplu complet
  4. Diferențe față de parse()
  5. Analizare fără Pydantic
  6. Când să alegeți response_format
  7. Gestionarea erorilor
  8. Puncte cheie

Control sporit cu response_format

Metoda manuală prin response_format vă oferă control total asupra analizării (parsing). Spre deosebire de parse(), care returnează un obiect tipizat, această abordare returnează un șir JSON pe care îl analizați dumneavoastră – modelul Pydantic furnizează doar schema (model_json_schema()) și validează ulterior. Alegeți această metodă când aveți nevoie de flexibilitate sau când lucrați într-un mediu fără Pydantic.

Flux de lucru

Cu response_format, procesul se desfășoară în doi pași:

  1. API-ul returnează JSON-ul ca un șir în response.choices[0].message.content
  2. Dumneavoastră analizați acest șir folosind metoda preferată

Exemplu complet

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

# Conținutul este un șir JSON
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Analizare manuală cu Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Diferențe față de parse()

Aspectparse()response_format
Returnare(Response, ParsedModel)Doar Response
Analizare (Parsing)AutomatăManuală
Acces la dateparsed.fieldjson.loads() sau model_validate_json()
FlexibilitateStandardMaximă
Gestionarea erorilorIntegratăResponsabilitatea dumneavoastră

Analizare fără Pydantic

Nu sunteți obligat să folosiți Pydantic pentru a analiza rezultatul. Modulul standard json funcționează de asemenea:

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

Când să alegeți response_format

response_format excelează ori de câte ori trebuie să vizualizați sau să inspectați JSON-ul înainte ca acesta să devină un obiect. Cel mai frecvent caz este jurnalizarea (logging): în producție, păstrarea JSON-ului brut înainte de transformare este adesea o cerință de audit sau depanare, iar parse() nu vă oferă acest punct de interceptare. Urmează apoi problema schemei: dacă contractul interfeței dumneavoastră este o schemă JSON brută – partajată cu alte echipe, generată de un instrument, versionată independent de codul Python – impunerea acesteia direct este mai fidelă decât reconstrucția sa ca model Pydantic. În final, nu fiecare proiect operează în ecosistemul Pydantic: dacă validarea trece printr-un alt framework sau printr-o etapă intermediară de procesare specifică pipeline-ului dumneavoastră, response_format vă livrează JSON-ul exact așa cum este și vă lasă controlul asupra pașilor următori.

Gestionarea erorilor

Cu metoda manuală, trebuie să gestionați singuri erorile de analizare:

import json

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

În practică, această eroare nu ar trebui să apară niciodată, deoarece API-ul garantează un JSON valid. Totuși, gestionarea defensivă rămâne o bună practică în producție.

Puncte cheie

  • response_format returnează un șir JSON în response.choices[0].message.content
  • Analizarea (parsing) este responsabilitatea dumneavoastră: json.loads(), model_validate_json() sau o altă metodă
  • Puteți folosi o schemă JSON brută în loc de un model Pydantic
  • Oferă mai multă flexibilitate decât parse(), dar necesită scrierea a mai mult cod
  • JSON-ul returnat este garantat valid – erorile de analizare nu ar trebui să apară