Vilka LLM-leverantörer stödjer strukturerad utdata?

OpenAI, Gemini och Mistral är LLM-leverantörer som stöder strukturerad utdata. Stödet i AWS Bedrock beror på modellen.

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

Något olika API:er kräver en särskild metod.

Sidinnehåll

Här är en jämförelse sida vid sida av stödet för strukturerad output (att få tillförlitlig JSON tillbaka) hos populära LLM-leverantörer, plus minimala Python-exempel

färgglada staplar stående

Vi har redan tittat på hur man begär strukturerad output från LLM:n som körs på Ollama. När JSON väl är tillbaka i strömmen, går validering av LLM-strukturerad output i Python som håller måttet igenom parsning, Pydantic-kontroller, återförsök och tester i din tjänst. Här tittar vi på hur man begär samma sak från andra leverantörer.

TL;DR-matris

Leverantör	Inbyggt “JSON-läge”	JSON-schema-tillämpning	Typisk inställning	Noteringar
OpenAI	Ja	Ja (first-class)	`response_format={"type":"json_schema", ...}`	Fungerar via Responses API eller Chat Completions; kan också använda function calling.
Google Gemini	Ja	Ja (first-class)	`response_schema=` + `response_mime_type="application/json"`	Returnerar strikt validerad JSON när schema är inställt.
Anthropic (Claude)	Indirekt	Ja (via Tool Use med JSON-schema)	`tools=[{input_schema=...}]` + `tool_choice`	Tvinga modellen att “anropa” ditt schema-definerade verktyg; ger arguments med schemans form.
Mistral	Ja	Delvis (endast JSON; inget serverbaserat schema)	`response_format={"type":"json_object"}`	Säkerställer JSON, men du validerar mot ditt schema på klientsidan.
AWS Bedrock (plattform)	Varierar per modell	Ja (via Tool/Converse schema)	`toolConfig.tools[].toolSpec.inputSchema`	Bedrocks Converse API validerar verktygsinput mot ett JSON-schema.

Strukturerad output från LLM: Allmän information

Strukturerad output från LLM:er avser förmågan hos stora språkmodeller (LLMs) att generera svar som strikt följer ett fördefinierat, specifikt format eller en struktur snarare än att producera fritt flytande text. Denna strukturerade output kan vara i format som JSON, XML, tabeller eller mallar, vilket gör data maskinläsbara, konsekventa och lätt att parsas av programvara för användning i olika applikationer.

Strukturerad output skiljer sig från traditionell LLM-output, som typiskt genererar öppen, naturlig språktext. Istället tvingar strukturerad output ett schema eller format, som JSON-objekt med definierade nycklar och värdestyper, eller specifika klasser i outputen (t.ex. flervals-svar, sentimentklasser eller databasradsformat). Detta ökar tillförlitligheten, minskar fel och hallucinationer, och förenklar integration i system som databaser, API:er eller arbetsflöden.

Genereringen av strukturerad output i LLM:er involverar ofta tekniker som:

Att specificera detaljerade promptinstruktioner för att guida modellen att producera output i önskat format.
Att använda validerings- och parsningsverktyg som Pydantic i Python för att säkerställa att outputen matchar schemat.
Ibland att tillämpa avkodningsbegränsningar baserade på grammatik eller ändliga automatiska maskiner för att säkerställa token-nivåens efterlevnad av formatet.

Fördelar med strukturerad LLM-output inkluderar:

Maskinläsbarhet och enkel integration.
Minskad variation och färre 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 nästlad data, och potentiella begränsningar i resonemangsförmåga jämfört med generering av fritt flytande text.

Sammanfattningsvis möjliggör strukturerad output att LLM:er blir mer användbara i applikationer som kräver precis, formaterad data snarare än enbart mänskligt läsbar text.

Exempel på strukturerad output i Python

Alla kodfragment extraherar event-info som JSON: {title, date, location}. Byt ut nycklar/modeller efter behov.

1) OpenAI — JSON Schema (strikt)

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": "Extract the event from: 'PyData Sydney is on 2025-11-03 at Darling Harbour.'"}
    ],
    response_format={"type": "json_schema", "json_schema": schema},
)

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

OpenAIs funktion för Structured Outputs tillämpar detta schema på 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="Extract the event from: 'PyData Sydney is on 2025-11-03 at Darling Harbour.'",
    generation_config=genai.GenerationConfig(
        response_mime_type="application/json",
        response_schema=schema,
    ),
)

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

Gemini kommer att returnera strikt JSON som följer response_schema.

3) Anthropic (Claude) — Tool Use med JSON-schema

from anthropic import Anthropic
import json

client = Anthropic()

tool = {
    "name": "extract_event",
    "description": "Return event details.",
    "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":
        "Extract the event from: 'PyData Sydney is on 2025-11-03 at Darling Harbour.'"}],
)

# Claude kommer att "anropa" verktyget; hämta argumentsen (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 inget generellt “JSON-läge”; istället ger Tool Use med ett input_schema dig validerade, schema-formade arguments (och du kan tvinga dess användning).

4) Mistral — JSON-läge (validering på klientsidan)

from mistralai import Mistral
import json

client = Mistral()

resp = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role":"user","content":
        "Return JSON with keys title, date (YYYY-MM-DD), location for: "
        "'PyData Sydney is on 2025-11-03 at Darling Harbour.'"}],
    response_format={"type": "json_object"}  # garanterar giltig JSON
)

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

Mistrals json_object tillämpar JSON-form (inte exakt ditt schema) — validera på klientsidan.

5) AWS Bedrock — Converse API Tool schema (modellagnostiskt)

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":
        "Extract the event from: 'PyData Sydney is on 2025-11-03 at Darling Harbour.'"}]}],
)

# Hämta toolUse-content
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 verktygsinput mot ditt JSON-schema och många hostade modeller (t.ex. Claude) stödjer detta via Converse.

Praktiska råd och validering

Om du vill ha starkast serversida-garanti: OpenAI structured outputs eller Gemini response schema.
Om du redan använder Claude/Bedrock: definiera ett Tool med ett JSON-schema och tvinga dess användning; läs verktygets arguments 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 vilken leverantör som helst
except ValidationError as e:
    # hantera / försök igen / be modellen fixa med e.errors()
    print(e)