Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Manuell response_format

Lektion 5 av 12 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Mer kontroll med response_format
  2. Arbetsflöde
  3. Komplett exempel
  4. Skillnader från parse()
  5. Parsning utan Pydantic
  6. När ska du välja response_format
  7. Felhantering
  8. Viktiga punkter

Mer kontroll med response_format

Den manuella metoden via response_format ger dig full kontroll över parsningen. Till skillnad från parse(), som returnerar ett typat objekt, returnerar denna approach en JSON-sträng som du parserar själv – Pydantic-modellen tillhandahåller endast schemat (model_json_schema()) och validerar i efterhand. Välj denna metod när du behöver flexibilitet eller när du arbetar i en miljö utan Pydantic.

Arbetsflöde

Med response_format sker processen i två steg:

  1. API:et returnerar JSON:en som en sträng i response.choices[0].message.content
  2. Du parserar denna sträng med valfri metod

Komplett exempel

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

# Innehållet är en JSON-sträng
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Manuell parsning med Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Skillnader från parse()

Aspektparse()response_format
Returvärde(Response, ParsedModel)Endast Response
ParsningAutomatiskManuell
Dataåtkomstparsed.fältjson.loads() eller model_validate_json()
FlexibilitetStandardMaximal
FelhanteringInbyggdDitt ansvar

Parsning utan Pydantic

Du behöver inte använda Pydantic för att parsera resultatet. Standardmodulen json fungerar också:

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

När ska du välja response_format

response_format glänser närhelst du behöver se eller inspektera JSON:en innan den blir ett objekt. Det vanligaste fallet är loggning: i produktion är det ofta ett krav för revision eller felsökning att behålla rå-JSON:en före transformation, och parse() ger dig inte den möjligheten att interceptera datan. Därefter kommer frågan om schema: om ditt gränssnittskontrakt är ett rått JSON-schema – som delas med andra team, genereras av ett verktyg eller versioneras oberoende av Python-koden – är det mer troget att tillämpa det direkt än att återskapa det som en Pydantic-modell. Slutligen opererar inte alla projekt inom Pydantic-ekosystemet: om din validering sker via ett annat ramverk, eller genom ett mellanliggande bearbetningssteg specifikt för din pipeline, levererar response_format JSON:en exakt som den är och låter dig ha kontrollen över vad som händer härnäst.

Felhantering

Med den manuella metoden måste du hantera parsningsfel själv:

import json

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

I praktiken bör detta fel aldrig inträffa eftersom API:et garanterar giltig JSON. Men defensiv hantering är ändå en bästa praxis i produktion.

Viktiga punkter

  • response_format returnerar en JSON-sträng i response.choices[0].message.content
  • Parsningen är ditt ansvar: json.loads(), model_validate_json() eller annan metod
  • Du kan använda ett rått JSON-schema istället för en Pydantic-modell
  • Mer flexibilitet än parse(), men mer kod att skriva
  • Den returnerade JSON:en är garanterat giltig – parsningsfel bör inte inträffa