Strukturierte Ausgaben für Anthropic Claude Modelle auf Amazon Bedrock

Amazon Bedrock unterstützt jetzt strukturierte Ausgaben für alle Anthropic Claude Modelle, sowohl auf dem bedrock-runtime- als auch auf dem bedrock-mantle-Endpunkt, wo das Modell verfügbar ist.

Ob Sie Claude über Boto3 und die bedrock-runtime-APIs oder über die Messages API und den bedrock-mantle-Endpunkt aufrufen – Sie können jetzt schema-konforme JSON-Antworten erhalten, die einer definierten Struktur entsprechen. Benutzerdefiniertes Parsing, Retry-Logik oder Nachverarbeitung sind nicht mehr erforderlich.

Praktische Anwendungen

Mit strukturierten Ausgaben für Claude auf Amazon Bedrock können Sie zuverlässige, schema-konforme Aufgaben branchenübergreifend automatisieren. Beispiele hierfür sind das Extrahieren aller erforderlichen Felder aus Finanzberichten und Compliance-Dokumenten, das Parsen klinischer Notizen in elektronische Patientenakten (Electronic Health Records, EHR) und die Anreicherung von Produktkatalogen mit konsistenten, validierten Ergebnissen. Sie können auch Verträge auf zentrale Begriffe, Parteien und Verpflichtungen analysieren oder intelligentes Support-Ticket-Routing ermöglichen, bei dem Absichten, Stimmungen und Entitäten stets dem Datenmodell Ihrer Anwendung entsprechen.

Was sich durch strukturierte Ausgaben auf Amazon Bedrock ändert

Strukturierte Ausgaben verwenden constrained decoding, um Ihr JSON-Schema während der Token-Generierung durchzusetzen – nicht nachträglich. Das Modell erzeugt keine Tokens, die Ihr Schema verletzen würden. Dadurch wird die Ausgabeformatierung von probabilistisch zu deterministisch.

Zwei komplementäre Mechanismen sind jetzt auf beiden Amazon Bedrock-Endpunkten verfügbar:

Was das für Sie bedeutet

Jede Antwort ist ein gültiges JSON, sodass Sie nicht mehr auf JSON.parse() Fehler oder Parsing-Ausnahmen stoßen. Antworten sind zudem typsicher: Feldtypen werden durchgesetzt, und erforderliche Felder sind immer vorhanden. Da die Ausgaben stets Ihrem Schema entsprechen, benötigen Sie keine Wiederholungsversuche zur Behandlung von Schemaverletzungen, was Ihre Integration zuverlässiger macht. Strukturierte Ausgaben beschränken Antworten außerdem nur auf die Felder, die Ihr Schema definiert, was die Anzahl der Ausgabe-Tokens reduziert und die Inferenzkosten bei Workloads mit hohem Volumen senken kann. Diese Eigenschaften machen strukturierte Ausgaben produktionsreif, sodass Sie im großen Maßstab bereitstellen können, ohne zusätzlichen Code zur Schemavalidierung.

Unterstützte Modelle und Verfügbarkeit

Strukturierte Ausgaben funktionieren mit Batch-Inferenz, sodass Sie große Mengen von Anfragen asynchron verarbeiten können und dennoch schema-konforme Ausgaben erhalten. Auf dem bedrock-runtime-Endpunkt funktioniert es auch mit Cross-Region-Inferenz, sodass Sie es ohne zusätzliche Einrichtung regionsübergreifend in AWS-Regionen nutzen können. Wenn Sie Antworten in Echtzeit benötigen, können Sie strukturierte Antworten als typisierte Ereignisse streamen.

Funktionsweise

Wenn Sie eine Anfrage mit einem JSON-Schema stellen, geschieht Folgendes im Hintergrund:

1. Schemavalidierung – Amazon Bedrock validiert Ihr JSON-Schema anhand der unterstützten Teilmenge von JSON Schema Draft 2020-12.
2. Grammatikkompilierung – Für neue Schemata kompiliert Amazon Bedrock ein Grammatik-Artefakt (die erste Anfrage kann etwas länger dauern).
3. Caching – Kompilierte Grammatiken werden 24 Stunden lang zwischengespeichert, wodurch nachfolgende Anfragen schneller ausgeführt werden.
4. Constrained Generation – Das Modell generiert Tokens, die gültiges JSON entsprechend Ihrem Schema erzeugen.

Leistungshinweise

Aus Leistungsgründen kann die erste Anfrage mit einem neuen Schema länger dauern, da Amazon Bedrock vor Beginn der Generierung ein Grammatik-Artefakt kompiliert. Nach dieser anfänglichen Kompilierung laufen nachfolgende Anfragen mit demselben Schema mit minimalem Overhead, da die kompilierte Grammatik zwischengespeichert ist. Dieser Cache ist auf Ihr Konto beschränkt und gilt 24 Stunden ab dem ersten Zugriff. Eine Änderung der Struktur Ihres JSON-Schemas macht den Cache ungültig und löst eine neue Kompilierung aus, während eine Änderung nur der Felder name oder description die zwischengespeicherte Grammatik unberührt lässt.

Erste Schritte: Strukturierte Ausgaben mit der InvokeModel-API (bedrock-runtime)

Die InvokeModel-API übernimmt den Anthropic-nativen Request-Body, daher wird das Schema als output_config.format als JSON-Objekt statt als JSON-String übergeben. Das folgende Beispiel zeigt, wie man mit boto3 und einem Anthropic Claude Model die strukturierten Lead-Daten aus einer Kunden-E-Mail extrahiert:

Python

import boto3
import json

REGION = "us-east-1" # Choose your preferred region
bedrock_runtime = boto3.client(service_name="bedrock-runtime", region_name=REGION)

# Define the JSON schema for structured output
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "description": "Customer name"},
        "email": {"type": "string", "description": "Customer email address"},
        "plan_interest": {"type": "string", "description": "Product plan of interest"},
        "demo_requested": {"type": "boolean", "description": "Whether a demo was requested"}
    },
    "required": ["name", "email", "plan_interest", "demo_requested"],
    "additionalProperties": False
}

# Make a request with structured outputs via the InvokeModel API
# (reusing the schema defined for the Converse example)
response = bedrock_runtime.invoke_model(
    modelId="global.anthropic.claude-sonnet-5-5",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 512,
        "messages": [
            {"role": "user", "content": (
                "Paulo Santos (paulo@example.com) is interested in our Enterprise plan "
                "and wants to schedule a demo for next Tuesday at 2pm."
            )}
        ],
        "output_config": {"format": {"type": "json_schema", "schema": schema}}
    })
)

body = json.loads(response["body"].read())

# Check the stop reason before parsing
if body["stop_reason"] == "end_turn":
    result_text = next(b["text"] for b in body["content"] if b["type"] == "text")
    print(json.dumps(json.loads(result_text), indent=2))
elif body["stop_reason"] == "max_tokens":
    print("Response truncated: increase max_tokens and retry.")

JSON

{
    "name": "Paulo Santos",
    "email": "paulo@example.com",
    "plan_interest": "Enterprise",
    "demo_requested": true
}

Die Antwort entspricht Ihrem Schema. Eine zusätzliche Validierung ist nicht erforderlich.

Weitere API-Verwendungsbeispiele, einschließlich der Messages API, finden Sie im zugehörigen Sample-Notebook.

Strict Tool Use für agentische Workflows

Amazon Bedrock Mantle wurde für agentische Anwendungen mit serverseitigen Tools, Hintergrundinferenz und zustandsbehafteten Konversationen entwickelt. Mit Strict Tool Use auf dem bedrock-mantle-Endpunkt können Sie nun garantieren, dass Tool-Parameter exakt Ihrem Eingabeschema entsprechen. Das folgende Beispiel zeigt, wie man ein Tool mit strikter Schema-Durchsetzung definiert:

Import json
from anthropic import AnthropicBedrockMantle

# Reusing the client created in the Messages API example
client = AnthropicBedrockMantle(aws_region="us-east-1")

message = client.messages.create(
    model="anthropic.claude-sonnet-5",
    max_tokens=512,
    messages=[{"role": "user", "content": "What's the weather like in San Francisco?"}],
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather for a specified location",
            "strict": True,
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g., San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location", "unit"],
                "additionalProperties": False
            }
        }
    ]
)

#Tool inputs conform to the schema
for block in message.content:
    if block.type == "tool_use":
        print(f"Tool: {block.name}")
        print(f"Input: {json.dumps(block.input, indent=2)}")

Die Einstellung strict: true schränkt die Tool-Eingabe des Modells so ein, dass sie exakt Ihrem Schema entspricht. Das Feld location ist immer ein String, und das Feld unit ist immer entweder celsius oder fahrenheit. Das Modell kann keine Felder außerhalb Ihres Schemas hinzufügen, sodass die Tool-Eingabe nur das enthält, was Ihr Schema vorgibt.

Dies ist besonders wertvoll für agentische Anwendungsfälle auf Amazon Bedrock Mantle, bei denen Modelle mehrstufige Workflows mit serverseitigen Tools wie Web-Suche und Code-Interpreter orchestrieren.

Top-Anwendungsfälle für strukturierte Claude-Ausgaben

Strukturierte Ausgaben reduzieren die Komplexität der Fehlerbehandlung am stärksten bei drei gängigen Mustern:

• Datenextraktion: Extrahieren Sie Felder aus Rechnungen, Verträgen, E-Mails und Transkripten in JSON, das immer Ihrem Schema entspricht und bereit zum Laden in Datenbanken oder Customer-Relationship-Management-(CRM)-Systeme ist.
• Zuverlässige Agent-Tool-Aufrufe: Validieren Sie Tool-Argumente zur Generierungszeit gegen ihre Schemas, damit mehrstufige Agent-Workflows ohne Ausfälle durch fehlerhafte Eingaben laufen.
• Klassifizierung im großen Maßstab: Klassifizieren Sie Tickets, Leads oder Inhalte nach Absicht, Priorität und Stimmung für Routing, Moderation und Auswertung.

Claude Haiku 5.5 zuverlässig schnellere und sich wiederholende Workloads wie Zusammenfassungen, Kompaktierungen, Datenbankabfragen und Klassifizierungsanforderungen. Das folgende Beispiel zeigt, wie man eingehende Daten mit der Invoke API und Haiku 5.5 klassifiziert und weiterleitet:

import boto3
import json

REGION = "us-east-1" # Choose your preferred region
bedrock_runtime = boto3.client(service_name="bedrock-runtime", region_name=REGION)

# Classification schema: enums restrict output to a fixed set of labels
schema = {
    "type": "object",
    "properties": {
        "category": {
            "type": "string",
            "enum": ["billing", "technical", "account", "sales", "other"],
            "description": "Primary ticket category"
        },
        "priority": {
            "type": "string",
            "enum": ["low", "medium", "high", "urgent"],
            "description": "Urgency based on business impact"
        },
        "sentiment": {
            "type": "string",
            "enum": ["positive", "neutral", "negative"],
            "description": "Customer sentiment"
        },
        "escalate": {"type": "boolean", "description": "Whether a human should review immediately"},
        "reason": {"type": "string", "description": "One-sentence justification for the classification"}
    },
    "required": ["category", "priority", "sentiment", "escalate", "reason"],
    "additionalProperties": False
}

ticket = (
    "Our production API calls have been failing with 500 errors since this morning. "
    "We're losing orders every minute. This is the second outage this month!"
)

# Make a request with structured outputs via the InvokeModel API
response = bedrock_runtime.invoke_model(
    modelId="global.anthropic.claude-haiku-5-5",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 512,
        "system": "You are a support ticket classifier. Classify the ticket accurately.",
        "messages": [
            {"role": "user", "content": f"Classify this support ticket:\n\n{ticket}"}
        ],
        "output_config": {"format": {"type": "json_schema", "schema": schema}}
    })
)

body = json.loads(response["body"].read())

# Check the stop reason before parsing
if body["stop_reason"] == "end_turn":
    result_text = next(b["text"] for b in body["content"] if b["type"] == "text")
    result = json.loads(result_text)
    print(json.dumps(result, indent=2))
    # Route the ticket based on the guaranteed-valid labels
    if result["escalate"]:
        print(f"Escalating to on-call: {result['category']} / {result['priority']}")
elif body["stop_reason"] == "max_tokens":
    print("Response truncated: increase max_tokens and retry.")

Anforderungen und bewährte Methoden

Um strukturierte Ausgaben auf Amazon Bedrock effektiv zu nutzen, befolgen Sie diese Richtlinien:

1. Setzen Sie additionalProperties: false bei allen Objekten: Dies ist erforderlich, damit strukturierte Ausgaben funktionieren. Andernfalls wird Ihr Schema nicht akzeptiert.
2. Verwenden Sie aussagekräftige Feldnamen und Beschreibungen: Modelle nutzen Eigenschaftsnamen und Beschreibungen, um zu verstehen, welche Daten extrahiert werden sollen. Klare Namen wie customer_email schlagen generische Namen wie field1.
3. Verwenden Sie enum für eingeschränkte Werte: Wenn ein Feld nur eine begrenzte Menge gültiger Werte hat, verwenden Sie enum um die Optionen einzuschränken.
4. Grundlegend beginnen, dann Komplexität hinzufügen: Beginnen Sie mit den minimal erforderlichen Feldern und fügen Sie schrittweise Komplexität hinzu. Einfache Schemas lassen sich schneller kompilieren, sind einfacher zu debuggen und halten Ihre Request-Payload schlank, da das Schema zur Payload-Größe der Converse API beiträgt.
5. Schemas wiederverwenden, um vom Caching zu profitieren: Strukturieren Sie Ihre Anwendung so, dass Schemas über mehrere Requests hinweg wiederverwendet werden. Der 24-Stunden-Grammatik-Cache verbessert die Leistung bei wiederholten Abfragen.
6. Den Stop-Grund in jeder Antwort prüfen: Zwei Szenarien können zu nicht konformen Antworten führen: Verweigerungen (wenn das Modell aus Sicherheitsgründen ablehnt) und Token-Limits (wenn max_tokens erreicht wird, bevor die Ausgabe abgeschlossen ist). Behandeln Sie beide Fälle in Ihrem Code.
7. Vor dem Deployment mit realistischen Daten testen: Validieren Sie Ihre Schemas mit produktionsnahen Eingaben. Randfälle in echten Daten decken häufig Probleme beim Schema-Design auf.

Weitere Best Practices und Empfehlungen zum Schema-Design finden Sie unter Structured outputs im Amazon Bedrock User Guide.

Unterstützte JSON-Schema-Funktionen

1. Alle Basistypen: object, array, string, integer, number, boolean, null.
2. enum (nur Strings, Zahlen, Boolesche Werte oder null).
3. const, anyOf, allOf (mit Einschränkungen).
4. $ref, $defund definitions (nur interne Referenzen).
5. String-Formate: date-time, time, date, duration, email, hostname, uri, ipv4, ipv6, uuid.
6. Array minItems (nur die Werte 0 und 1).

Nicht unterstützt

Diese Schlüsselwörter werden von der API akzeptiert, werden jedoch während der Generierung nicht durchgesetzt. Eine Anfrage, die sie enthält, liefert eine erfolgreiche Antwort zurück, und das Modell kann weiterhin Werte zurückgeben, die gegen sie verstoßen. Validieren Sie diese Einschränkungen in Ihrer Anwendung, anstatt sich darauf zu verlassen, dass das Schema sie durchsetzt.

1. Rekursive Schemas.
2. Externe $ref Referenzen.
3. Numerische Einschränkungen (minimum, maximum, multipleOf).
4. Zeichenketten-Einschränkungen (minLength, maxLength).
5. additionalProperties auf einen anderen Wert als false gesetzt ist.

Fazit

Structured outputs für Anthropic Claude Modelle auf Amazon Bedrock bietet die Zuverlässigkeit, die produktive KI-Anwendungen benötigen. Es ist jetzt sowohl auf den Endpunkten bedrock-runtime als auch bedrock-mantle verfügbar. Durch die Kombination von JSON Schema-Ausgabeformat und strikter Tool-Nutzung können Sie Datenpipelines bauen, die keine zusätzliche Validierung benötigen. Sie können außerdem zuverlässige agentische Workflows und produktive KI-Anwendungen ohne benutzerdefinierte Parsing- oder Retry-Logik erstellen.

Structured outputs für Claude auf Amazon Bedrock ist jetzt allgemein verfügbar. Weitere Informationen finden Sie in der Amazon Bedrock-Dokumentation und erkunden Sie unser Beispiel-Notebook.

Welche Workflows könnten in Ihrer Organisation von validiertem, schema-konformem JSON profitieren? Teilen Sie Ihr Feedback und Ihre Fragen in den Kommentaren mit.

Über die Autoren