Jämförelse av strukturerad utdata hos populära LLM-leverantörer - OpenAI, Gemini, Anthropic, Mistral och AWS Bedrock

Lätt olika API:er kräver en särskild tillvägagångssätt.

Sidinnehåll

Här är en sida vid sida jämförelse av stöd för strukturerad utdata (att få tillförlitligt JSON tillbaka) över populära LLM-leverantörer (https://www.glukhov.org/sv/post/2025/10/structured-output-comparison-popular-llm-providers/ “strukturerad utdata över populära LLM-leverantörer”), plus minimala Python exempel

färgade staplar som står

Vi har redan tittat på hur man begär strukturerad utdata från LLM som värdas på Ollama. Här granskar vi hur man begär samma från andra leverantörer.

TL;DR-matris

Leverantör Naturligt “JSON-läge” JSON Schema-tvingande Typisk inställning Anmärkningar
OpenAI Ja Ja (förstaklass) response_format={"type":"json_schema", ...} Fungerar via Responses API eller Chat Completions; kan också göra funktioner.
Google Gemini Ja Ja (förstaklass) response_schema= + response_mime_type="application/json" Returnerar strikt validerat JSON när schema är inställt.
Anthropic (Claude) Indirekt Ja (via verktygsanvändning med JSON-schema) tools=[{input_schema=...}] + tool_choice Tvinga modellen att “ringa” ditt schema-definierade verktyg; ger schema-formade argument.
Mistral Ja Delvis (JSON-endast; ingen serversidig schema) response_format={"type":"json_object"} Garanterar JSON, men du validerar mot ditt schema klientsidan.
AWS Bedrock (plattform) Varierar efter modell Ja (via Tool/Converse schema) toolConfig.tools[].toolSpec.inputSchema Bedrock’s Converse API validerar verktygsinmatning mot ett JSON-schema.

LLM Strukturerad Utdata - Allmän Information

LLM strukturerad utdata refererar till förmågan hos stora språkmodeller (LLMs) att generera svar som strikt följer en fördefinierad, specifik format eller struktur istället för att producera fri text. Denna strukturerade utdata kan vara i format som JSON, XML, tabeller eller mallar, vilket gör datan maskinläsbar, konsekvent och enkelt parselbar av program för användning i olika applikationer.

Strukturerade utdata skiljer sig från traditionella LLM-utdata, som vanligtvis genererar öppen, naturlig text. Istället tvingar strukturerade utdata ett schema eller format, som JSON-objekt med definierade nycklar och värdetyper, eller specifika klasser i utdata (t.ex. flervalsfrågor, känsloanalysklasser eller databasradformat). Denna metod förbättrar tillförlitligheten, minskar fel och hallucinationer, och förenklar integration i system som databaser, API:er eller arbetsflöden.

Genereringen av strukturerade utdata i LLMs involverar ofta tekniker som:

  • Att specificera detaljerade prompt-instruktioner för att guida modellen att producera utdata i det önskade formatet.
  • Att använda validerings- och parsningsverktyg som Pydantic i Python för att säkerställa att utdata matchar schemat.
  • Ibland att tvinga fram avkodningsbegränsningar baserade på grammatik eller ändliga automatmaskiner för att säkerställa token-nivå överensstämmelse med formatet.

Fördelar med strukturerad LLM-utdata inkluderar:

  • Maskinläsbarhet och enkel integration.
  • Minskat variabilitet och fel.
  • Förbättrad förutsägbarhet och verifierbarhet för uppgifter som kräver konsekventa dataformat.

Utmaningar inkluderar att designa effektiva scheman, hantera komplexa inbäddade data och potentiella begränsningar i resonemangsförmåga jämfört med fri textgenerering.

Överlag möjliggör strukturerad utdata att LLMs blir mer användbara i applikationer som kräver exakt, formaterad data istället för endast mänskligt läsbar text.

Strukturerad Utdata Python-exempel

Alla kodavsnitt extraherar event info som JSON: {title, date, location}. Ersätt nycklar/modeller efter behag.

1) OpenAI — JSON Schema (strängt)

from openai import OpenAI
import json

client = OpenAI()

schema = {
    "name": "Event",
    "schema": {
        "type": "object",
        "properties": {
            "title": {"type": "string"},
            "date":  {"type": "string", "description": "YYYY-MM-DD"},
            "location": {"type": "string"}
        },
        "required": ["title", "date", "location"],
        "additionalProperties": False
    },
    "strict": True
}

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Extrahera evenemanget från: 'PyData Sydney är den 2025-11-03 vid Darling Harbour.'"}
    ],
    response_format={"type": "json_schema", "json_schema": schema},
)

data = json.loads(resp.choices[0].message.content)
print(data)

OpenAIs Strukturerade Utdata funktion tvingar detta schema serversidan.

2) Google Gemini — response schema + JSON MIME

import google.generativeai as genai
from google.genai import types

# Konfigurera med din API-nyckel
# genai.configure(api_key="your-api-key")

schema = types.Schema(
    type=types.Type.OBJECT,
    properties={
        "title": types.Schema(type=types.Type.STRING),
        "date": types.Schema(type=types.Type.STRING),
        "location": types.Schema(type=types.Type.STRING),
    },
    required=["title", "date", "location"],
    additional_properties=False,
)

resp = genai.generate_content(
    model="gemini-2.0-flash",
    contents="Extrahera evenemanget från: 'PyData Sydney är den 2025-11-03 vid Darling Harbour.'",
    generation_config=genai.GenerationConfig(
        response_mime_type="application/json",
        response_schema=schema,
    ),
)

print(resp.text)  # redan giltigt JSON enligt schema

Gemini kommer att returnera strängt JSON som överensstämmer med response_schema.

3) Anthropic (Claude) — Verktygsanvändning med JSON-schema

from anthropic import Anthropic
import json

client = Anthropic()

tool = {
    "name": "extract_event",
    "description": "Returnera evenemangsdetaljer.",
    "input_schema": {
        "type": "object",
        "properties": {
            "title": {"type": "string"},
            "date": {"type": "string"},
            "location": {"type": "string"}
        },
        "required": ["title", "date", "location"],
        "additionalProperties": False
    }
}

msg = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=256,
    tools=[tool],
    tool_choice={"type": "tool", "name": "extract_event"},  # tvinga schema
    messages=[{"role": "user", "content":
        "Extrahera evenemanget från: 'PyData Sydney är den 2025-11-03 vid Darling Harbour.'"}],
)

# Claude kommer att "ringa" verktyget; hämta argumenten (som matchar ditt schema)
tool_use = next(b for b in msg.content if b.type == "tool_use")
print(json.dumps(tool_use.input, indent=2))

Claude har ingen generisk “JSON-läge”-knapp; istället ger Verktygsanvändning med en input_schema dig validerade, schema-formade argument (och du kan tvinga dess användning).

4) Mistral — JSON-läge (klientsidig validering)

from mistralai import Mistral
import json

client = Mistral()

resp = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role":"user","content":
        "Returnera JSON med nycklar title, date (YYYY-MM-DD), location för: "
        "'PyData Sydney är den 2025-11-03 vid Darling Harbour.'"}],
    response_format={"type": "json_object"}  # garanterar giltigt JSON
)

data = json.loads(resp.choices[0].message.content)
print(data)
# Tips: validera `data` mot ditt Pydantic/JSON Schema lokalt.

Mistrals json_object tvingar JSON-form (inte ditt exakta schema) — validera klientsidan.

5) AWS Bedrock — Converse API Verktygsschema (modell-oberoende)

import boto3, json

bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
model_id = "anthropic.claude-3-5-sonnet-20240620-v1:0"

tools = [{
    "toolSpec": {
        "name": "extract_event",
        "inputSchema": {
            "json": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "date": {"type": "string"},
                    "location": {"type": "string"}
                },
                "required": ["title","date","location"],
                "additionalProperties": False
            }
        }
    }
}]

resp = bedrock.converse(
    modelId=model_id,
    toolConfig={"tools": tools},
    toolChoice={"tool": {"name": "extract_event"}},  # tvinga schema
    messages=[{"role":"user","content":[{"text":
        "Extrahera evenemanget från: 'PyData Sydney är den 2025-11-03 vid Darling Harbour.'"}]}],
)

# Hämta toolUse-innehåll
tool_use = next(
    c["toolUse"] for c in resp["output"]["message"]["content"] if "toolUse" in c
)
print(json.dumps(tool_use["input"], indent=2))

Bedrock validerar verktygsinmatning mot ditt JSON-schema och många värdade modeller (t.ex. Claude) stöder det genom Converse.

Praktisk vägledning och Validering

  • Om du vill ha starkast serversidiga garantier: OpenAI strukturerade utdata eller Gemini response schema.
  • Om du redan använder Claude/Bedrock: definiera ett Verktyg med ett JSON-schema och tvinga dess användning; läs verktygets argument som ditt typade objekt.
  • Om du använder Mistral: aktivera json_object och validera lokalt (t.ex. med Pydantic).

Valideringsmönster (fungerar för alla)

from pydantic import BaseModel, ValidationError

class Event(BaseModel):
    title: str
    date: str
    location: str

try:
    event = Event.model_validate(data)  # `data` från någon leverantör
except ValidationError as e:
    # hantera / återförsök / be modellen att rätta till med e.errors()
    print(e)

Användbara länkar