Strukturierte Ausgaben
Erhalte validierte JSON-Ergebnisse aus Agenten-Workflows
„Structured outputs“ (strukturierte Ausgaben) beschränken Claudes Antworten auf ein bestimmtes Schema und stellen so eine gültige, parsebare Ausgabe für die nachgelagerte Verarbeitung sicher. Strukturierte Ausgaben bieten zwei sich ergänzende Funktionen:
- JSON-Ausgaben (
output_config.format): Erhalte Claudes Antwort in einem bestimmten JSON-Format, zum Beispiel um Daten aus Bildern oder Text zu extrahieren, strukturierte Berichte zu generieren oder API-Antworten zu formatieren. Diese Seite behandelt JSON-Ausgaben. - Strikte Tool-Nutzung (
strict: true): Garantiere die Schema-Validierung von Tool-Namen und -Eingaben. Siehe Strikte Tool-Nutzung.
Du kannst diese Funktionen unabhängig voneinander oder zusammen in derselben Anfrage verwenden.
Warum strukturierte Ausgaben verwenden
Ohne strukturierte Ausgaben kann Claude fehlerhafte JSON-Antworten oder ungültige Tool-Eingaben generieren, die deine Anwendungen zum Absturz bringen. Selbst mit sorgfältigem Prompting können folgende Probleme auftreten:
- Parsing-Fehler durch ungültige JSON-Syntax
- Fehlende Pflichtfelder
- Inkonsistente Datentypen
- Schema-Verletzungen, die Fehlerbehandlung und Wiederholungsversuche erfordern
Strukturierte Ausgaben garantieren schemakonforme Antworten durch „constrained decoding“ (eingeschränkte Dekodierung):
- Immer gültig: Keine JSON-Parsing-Fehler
- Typsicher: Garantierte Feldtypen und Pflichtfelder
- Zuverlässig: Keine Wiederholungsversuche wegen Schema-Verletzungen nötig
Funktionsweise
Definiere dein Schema
Beschreibe die gewünschte Struktur als JSON-Schema oder als Typ in deiner Sprache. Das Schema folgt JSON Schema, mit einigen Einschränkungen.
Sende es in output_config.format
Die Anfrage enthält das Schema in
output_config.formatmittype: "json_schema". SDK-Helfer setzen dies für dich.Lies die Antwort
Claude gibt gültiges JSON, das deinem Schema entspricht, im Text-Content-Block der Antwort zurück. SDK-Helfer parsen es in deinen Typ.
Verwendung
from pydantic import BaseModel
class ContactInfo(BaseModel):
name: str
email: str
plan_interest: str
demo_requested: bool
client = Anthropic()
response = client.messages.parse(
model="claude-opus-5-5",
max_tokens=1024,
messages=[
{
"role": "user",
"content": (
"Extract the key information from this email: "
"John Smith (john@example.com) is interested in our Enterprise plan "
"and wants to schedule a demo for next Tuesday at 2pm."
),
}
],
output_format=ContactInfo,
)
print(response.parsed_output)Übergib ein Pydantic-Modell als output_format an client.messages.parse(), die empfohlene Methode. Das SDK transformiert das Schema des Modells, sendet es als output_config.format, validiert die Antwort und gibt das geparste Modell in parsed_output zurück.
Das vorherige Beispiel gibt Folgendes aus:
name='John Smith' email='john@example.com' plan_interest='Enterprise' demo_requested=TrueWenn du die Schlüssel eines Feldes kennst, verwende ein verschachteltes Pydantic-Modell statt eines dict. Das SDK sendet ein dict-Feld als Objekt mit leeren properties, daher kann Claude dafür nur {} zurückgeben. Wenn du die Schlüssel nicht im Voraus kennst, siehe Objekte mit beliebigen Schlüsseln.
Wie die SDK-Transformation funktioniert
Die meisten SDK-Helfer transformieren Schemas, die nicht unterstützte Funktionen verwenden. Die Transformationsschritte:
- Nicht unterstützte Einschränkungen entfernen (zum Beispiel
minimum,maximum,minLength,maxLength) - Beschreibungen aktualisieren, indem jede nicht unterstützte Einschränkung zur Beschreibung des Feldes hinzugefügt wird (zum Beispiel
{minimum: 100}) additionalProperties: falsezu allen Objekten hinzufügen- String-Formate filtern, sodass nur die unterstützte Liste übrig bleibt
- Antworten validieren gegen dein ursprüngliches Schema und alle seine Einschränkungen, sofern der Helfer Antworten validiert
Claude erhält ein vereinfachtes Schema, aber ein Helfer, der Antworten validiert, setzt trotzdem jede Einschränkung in deinem Code durch.
Beispiel: Ein Feld mit minimum: 100 wird im gesendeten Schema zu einem einfachen Integer, und das SDK fügt {minimum: 100} zur Beschreibung des Feldes hinzu. Ein Helfer, der Antworten validiert, prüft die Antwort trotzdem gegen minimum: 100.
Ein rohes JSON-Schema verwenden
Um ein JSON-Schema aus einer Datei, einer OpenAPI-Spezifikation oder aus Code, der es zur Laufzeit erstellt, zu verwenden, übergib es in output_config.format.
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[
{
"role": "user",
"content": (
"Extract the key information from this email: "
"John Smith (john@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": {
"type": "object",
"properties": {
"name": {"type": "string"},
"email": {"type": "string"},
"plan_interest": {"type": "string"},
"demo_requested": {"type": "boolean"},
},
"required": ["name", "email", "plan_interest", "demo_requested"],
"additionalProperties": False,
},
}
},
)
text = next(block.text for block in response.content if block.type == "text")
contact = json.loads(text)
print(contact)Das vorherige Beispiel gibt Folgendes aus:
{'name': 'John Smith', 'email': 'john@example.com', 'plan_interest': 'Enterprise', 'demo_requested': True}Um von der API nicht unterstützte Einschränkungen in Feldbeschreibungen zu verschieben, leite das Schema vor dem Senden durch transform_schema() aus dem Paket anthropic und bearbeite das Ergebnis bei Bedarf. transform_schema() akzeptiert auch ein Pydantic-Modell. Im Gegensatz zu client.messages.parse() gibt es das transformierte Schema zurück, anstatt es zu senden.
Häufige Anwendungsfälle
Extrahiere strukturierte Daten aus unstrukturiertem Text:
from pydantic import BaseModel
class LineItem(BaseModel):
description: str
quantity: float
unit_price: float
class Invoice(BaseModel):
invoice_number: str
date: str
total_amount: float
line_items: list[LineItem]
customer_name: str
client = anthropic.Anthropic()
invoice_text = """
Invoice #12345
Date: 2024-01-15
Customer: Acme Corp
2 widgets at $150.00 each
1 setup fee at $200.00
Total: $500.00
"""
response = client.messages.parse(
model="claude-opus-5-5",
max_tokens=4096,
output_format=Invoice,
messages=[
{"role": "user", "content": f"Extract invoice data from: {invoice_text}"}
],
)
print(response.parsed_output)Klassifiziere Inhalte mit strukturierten Kategorien:
from pydantic import BaseModel
client = Anthropic()
class Classification(BaseModel):
category: str
confidence: float
tags: list[str]
sentiment: str
feedback_text = "Great product, but the delivery was slow."
response = client.messages.parse(
model="claude-opus-5-5",
max_tokens=1024,
output_format=Classification,
messages=[{"role": "user", "content": f"Classify this feedback: {feedback_text}"}],
)
print(response.parsed_output)Generiere API-fertige Antworten:
from pydantic import BaseModel
client = Anthropic()
class Payload(BaseModel):
message: str
class APIError(BaseModel):
code: str
detail: str
class Metadata(BaseModel):
request_id: str
class APIResponse(BaseModel):
status: str
data: Payload
errors: list[APIError] | None = None
metadata: Metadata
response = client.messages.parse(
model="claude-opus-5-5",
max_tokens=1024,
output_format=APIResponse,
messages=[
{
"role": "user",
"content": "Write an API response: request req_2abc3def has an invalid email.",
}
],
)
print(response.parsed_output)Strikte Tool-Nutzung
Um die JSON-Schema-Konformität von Tool-Eingaben mit grammatikbeschränktem Sampling durchzusetzen, siehe Strikte Tool-Nutzung.
Beide Funktionen zusammen verwenden
JSON-Ausgaben und strikte Tool-Nutzung lösen unterschiedliche Probleme und arbeiten zusammen:
- JSON-Ausgaben steuern Claudes Antwortformat (was Claude sagt).
- Strikte Tool-Nutzung validiert Tool-Parameter (wie Claude deine Funktionen aufruft).
In Kombination kann Claude Tools mit garantiert gültigen Parametern aufrufen UND strukturierte JSON-Antworten zurückgeben. Das ist nützlich für agentische Workflows, in denen du sowohl zuverlässige Tool-Aufrufe als auch strukturierte Endausgaben benötigst.
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[
{
"role": "user",
"content": "Help me plan a trip to Paris departing May 15, 2026",
}
],
# JSON-Ausgaben: strukturiertes Antwortformat
output_config={
"format": {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {
"summary": {"type": "string"},
"next_steps": {"type": "array", "items": {"type": "string"}},
},
"required": ["summary", "next_steps"],
"additionalProperties": False,
},
}
},
# Strikte Tool-Nutzung: garantierte Tool-Parameter
tools=[
{
"name": "search_flights",
"strict": True,
"input_schema": {
"type": "object",
"properties": {
"destination": {"type": "string"},
"date": {"type": "string", "format": "date"},
},
"required": ["destination", "date"],
"additionalProperties": False,
},
}
],
)
print(response)Wichtige Überlegungen
Grammatik-Kompilierung und Caching
Strukturierte Ausgaben verwenden eingeschränktes Sampling mit kompilierten Grammatik-Artefakten. Dadurch ergeben sich einige Leistungsmerkmale, die du beachten solltest:
- Latenz bei der ersten Anfrage: Wenn du ein bestimmtes Schema zum ersten Mal verwendest, entsteht zusätzliche „latency“ (Latenz), während die Grammatik kompiliert wird.
- Automatisches Caching: Kompilierte Grammatiken werden ab der letzten Verwendung 24 Stunden lang gecacht, wodurch nachfolgende Anfragen deutlich schneller werden.
- Cache-Invalidierung: Der Cache wird invalidiert, wenn du die Struktur des JSON-Schemas änderst oder – bei gleichzeitiger Verwendung von strukturierten Ausgaben und Tool-Nutzung – die Menge der Tools in deiner Anfrage. Das Ändern nur der Felder
nameoderdescriptioninvalidiert den Cache nicht.
Prompt-Änderung und Token-Kosten
Bei Verwendung strukturierter Ausgaben erhält Claude automatisch einen zusätzlichen „system prompt“ (System-Prompt), der das erwartete Ausgabeformat erklärt. Das bedeutet:
- Deine Anzahl an Eingabe-Token ist etwas höher.
- Der eingefügte Prompt kostet dich Token wie jeder andere System-Prompt.
- Eine Änderung des Parameters
output_config.formatinvalidiert jeden Prompt-Cache für diesen Konversationsverlauf.
Einschränkungen von JSON Schema
Strukturierte Ausgaben unterstützen Standard-JSON-Schema mit einigen Einschränkungen. Sowohl JSON-Ausgaben als auch strikte Tool-Nutzung teilen diese Einschränkungen.
- Alle Basistypen: object, array, string, integer, number, boolean, null
enumundconst(nur Strings, Zahlen, Booleans oder Nulls), mit einem Vorbehalt bei der Groß-/KleinschreibunganyOfundallOf, außer den unter „Nicht unterstützt“ aufgeführten Verwendungen$ref,$defsunddefinitionsdefault-Eigenschaft für alle unterstützten TypenrequiredundadditionalProperties(muss für Objekte auffalsegesetzt sein)- String-Formate:
date-time,time,date,duration,email,hostname,uri,ipv4,ipv6,uuid - Array-
minItems(nur die Werte 0 und 1 unterstützt)
- Rekursive Schemas
oneOf(verwende stattdessenanyOf)notanyOfim selben Schema-Objekt wie Schlüsselwörter wietypeoderproperties(Annotationen wietitleunddescriptionsind in Ordnung)allOfmit Schemas, die sich widersprechen (zum Beispiel unterschiedlichetype-Werte)allOfmit zwei oder mehr Schemas, wenn eines davon direkt$ref,anyOfoderallOfenthält- Komplexe Typen innerhalb von Enums
- Externes
$ref(zum Beispiel'$ref': 'http://...') - Numerische Constraints (wie
minimum,maximum,multipleOf) - String-Constraints (
minLength,maxLength) - Array-Constraints über
minItemsvon 0 oder 1 hinaus additionalPropertiesmit einem anderen Wert alsfalse(siehe Objekte mit beliebigen Schlüsseln)
Wenn du eine nicht unterstützte Funktion verwendest, erhältst du einen 400-Fehler mit Details.
Unterstützte Regex-Funktionen:
- Vollständige Übereinstimmung (
^...$) und teilweise Übereinstimmung - Quantifizierer:
*,+,?, einfache{n,m}-Fälle - Zeichenklassen:
[],.,\d,\w,\s - Gruppen:
(...)
Nicht unterstützt:
- Rückverweise auf Gruppen (zum Beispiel
\1,\2) - Lookahead-/Lookbehind-Assertions (zum Beispiel
(?=...),(?!...)) - Wortgrenzen:
\b,\B - Komplexe
{n,m}-Quantifizierer mit großen Bereichen
Einfache Regex-Muster funktionieren gut. Komplexe Muster können zu 400-Fehlern führen.
Objekte mit beliebigen Schlüsseln
Führe jeden Schlüssel eines Objekts auf, entweder in properties oder als Feld der Klasse bzw. des Schemas, die bzw. das du an das SDK übergibst. Da additionalProperties false sein muss, kann Claude nur die Schlüssel zurückgeben, die du aufführst.
Die API akzeptiert ein Objekt mit leeren oder fehlenden properties, aber Claude kann dafür nur {} zurückgeben. Ein Map-, Dictionary- oder Record-Typ führt keine Schlüssel auf, daher senden das Python- und das TypeScript-SDK ihn als Objekt mit leeren properties. Das Java- und das Ruby-SDK lösen stattdessen einen Fehler aus.
Wenn du die Schlüssel nicht im Voraus kennst, verwende stattdessen ein Array. Gib jedem Element einen key und einen value, wie in diesem Schema:
{
"type": "array",
"items": {
"type": "object",
"properties": {
"key": { "type": "string" },
"value": { "type": "string" }
},
"required": ["key", "value"],
"additionalProperties": false
}
}Reihenfolge der Eigenschaften
Bei Verwendung strukturierter Ausgaben behalten Eigenschaften in Objekten die in deinem Schema definierte Reihenfolge bei, mit einem wichtigen Vorbehalt: Erforderliche Eigenschaften erscheinen zuerst, gefolgt von optionalen Eigenschaften.
Zum Beispiel bei diesem Schema:
{
"type": "object",
"properties": {
"notes": { "type": "string" },
"name": { "type": "string" },
"email": { "type": "string" },
"age": { "type": "integer" }
},
"required": ["name", "email"],
"additionalProperties": false
}Die Ausgabe ordnet die Eigenschaften so an:
name(erforderlich, in Schema-Reihenfolge)email(erforderlich, in Schema-Reihenfolge)notes(optional, in Schema-Reihenfolge)age(optional, in Schema-Reihenfolge)
Das bedeutet, dass die Ausgabe so aussehen könnte:
{
"name": "John Smith",
"email": "john@example.com",
"notes": "Interested in enterprise plan",
"age": 35
}Wenn die Reihenfolge der Eigenschaften in der Ausgabe für deine Anwendung wichtig ist, markiere alle Eigenschaften als erforderlich oder berücksichtige diese Umordnung in deiner Parsing-Logik.
Ungültige Ausgaben
Obwohl strukturierte Ausgaben in den meisten Fällen Schema-Konformität garantieren, gibt es Szenarien, in denen die Ausgabe möglicherweise nicht deinem Schema entspricht:
Ablehnungen (stop_reason: "refusal")
Claude behält seine Sicherheits- und Hilfsbereitschaftseigenschaften auch bei Verwendung strukturierter Ausgaben bei. Wenn Claude eine Anfrage aus Sicherheitsgründen ablehnt:
- Die Antwort hat
stop_reason: "refusal". - Du erhältst einen 200-Statuscode.
- Dir werden die generierten Token in Rechnung gestellt.
- Die Ausgabe entspricht möglicherweise nicht deinem Schema, da die Ablehnungsnachricht Vorrang vor Schema-Constraints hat.
Eine Eigenschaft, die nach dem Nachdenken des Modells oder nach schrittweisem Denken fragt, kann zu einer reasoning_extraction-Ablehnung führen. Frage stattdessen nach einer kurzen Erklärung. Siehe Reasoning in Thinking-Blöcken belassen.
Token-Limit erreicht (stop_reason: "max_tokens")
Wenn die Antwort abgeschnitten wird, weil sie das max_tokens-Limit erreicht hat:
- Die Antwort hat
stop_reason: "max_tokens". - Die Ausgabe ist möglicherweise unvollständig und entspricht nicht deinem Schema.
- Versuche es erneut mit einem höheren
max_tokens-Wert, um die vollständige strukturierte Ausgabe zu erhalten.
Groß-/Kleinschreibung von Enum-Werten
Strukturierte Ausgaben garantieren nicht die Groß-/Kleinschreibung von String-Werten in enum und const: Claude könnte einen Wert zurückgeben, der sich von deinem Schema nur in der Groß-/Kleinschreibung unterscheidet, typischerweise beim ersten Buchstaben eines Wortes nach einem Leerzeichen. Zum Beispiel bei diesem Schema:
{
"type": "string",
"enum": ["Conversation Topic 1", "Conversation Topic 2", "Conversation topic 3"]
}Die Ausgabe könnte "Conversation Topic 3" (großes „T“) enthalten, obwohl genau dieser Wert nicht im Enum enthalten ist. Die Antwort wird normal abgeschlossen, ohne Fehler und ohne speziellen stop_reason. Das gilt sowohl für JSON-Ausgaben als auch für strikte Tool-Nutzung. Vergleiche Enum-Werte ohne Berücksichtigung der Groß-/Kleinschreibung und vermeide Enum-Werte, die sich nur in der Groß-/Kleinschreibung unterscheiden.
Grenzen der Schema-Komplexität
Strukturierte Ausgaben funktionieren, indem deine JSON-Schemas in eine Grammatik kompiliert werden, die Claudes Ausgabe einschränkt. Komplexere Schemas erzeugen größere Grammatiken, deren Kompilierung länger dauert. Zum Schutz vor übermäßigen Kompilierungszeiten setzt die API mehrere Komplexitätsgrenzen durch.
Explizite Grenzen
Die folgenden Grenzen gelten für alle Anfragen mit output_config.format oder strict: true:
| Grenze | Wert | Beschreibung |
|---|---|---|
| Strikte Tools pro Anfrage | 20 | Maximale Anzahl von Tools mit strict: true. Nicht-strikte Tools zählen nicht zu dieser Grenze. |
| Optionale Parameter | 24 | Gesamtzahl optionaler Parameter über alle strikten Tool-Schemas und JSON-Ausgabe-Schemas hinweg. Jeder Parameter, der nicht in required aufgeführt ist, zählt zu dieser Grenze. |
| Parameter mit Union-Typen | 16 | Gesamtzahl der Parameter, die anyOf oder Typ-Arrays (zum Beispiel "type": ["string", "null"]) verwenden, über alle strikten Schemas hinweg. Diese sind besonders aufwendig, da sie exponentielle Kompilierungskosten verursachen. |
Zusätzliche interne Grenzen
Über die expliziten Grenzen in der vorherigen Tabelle hinaus gibt es zusätzliche interne Grenzen für die Größe der kompilierten Grammatik. Diese Grenzen existieren, weil sich Schema-Komplexität nicht auf eine einzige Dimension reduzieren lässt: Funktionen wie optionale Parameter, Union-Typen, verschachtelte Objekte und die Anzahl der Tools wirken auf eine Weise zusammen, die die kompilierte Grammatik unverhältnismäßig groß machen kann.
Wenn diese Grenzen überschritten werden, erhältst du einen 400-Fehler mit der Meldung „Schema is too complex for compilation.“ Diese Fehler bedeuten, dass die kombinierte Komplexität deiner Schemas das übersteigt, was effizient kompiliert werden kann, selbst wenn jede einzelne Grenze in der vorherigen Tabelle eingehalten wird. Als letzte Absicherung setzt die API außerdem ein Kompilierungs-Timeout von 180 Sekunden durch. Schemas, die alle expliziten Prüfungen bestehen, aber sehr große kompilierte Grammatiken erzeugen, können dieses Timeout erreichen.
Tipps zur Reduzierung der Schema-Komplexität
Wenn du an Komplexitätsgrenzen stößt, probiere diese Strategien der Reihe nach aus:
-
Markiere nur kritische Tools als strikt. Wenn du viele Tools hast, reserviere strikte Tool-Nutzung für diejenigen, bei denen Schema-Verletzungen echte Probleme verursachen, und verlasse dich bei einfacheren Tools auf Claudes natürliche Einhaltung.
-
Reduziere optionale Parameter. Mache Parameter nach Möglichkeit
required. Jeder optionale Parameter verdoppelt ungefähr einen Teil des Zustandsraums der Grammatik. Wenn ein Parameter immer einen sinnvollen Standardwert hat, erwäge, ihn erforderlich zu machen und Claude diesen Standardwert explizit angeben zu lassen. -
Vereinfache verschachtelte Strukturen. Tief verschachtelte Objekte mit optionalen Feldern erhöhen die Komplexität zusätzlich. Flache Strukturen nach Möglichkeit ab.
-
Teile in mehrere Anfragen auf. Wenn du viele strikte Tools hast, erwäge, sie auf separate Anfragen oder Subagenten zu verteilen.
Bei anhaltenden Problemen mit gültigen Schemas kontaktiere den Support mit deiner Schema-Definition.
Migration von der Beta
Der Parameter output_format wurde nach output_config.format verschoben, und Beta-Header sind nicht mehr erforderlich. Der Parameter output_format ist abgekündigt. Um ihn dennoch zu verwenden, füge den Beta-Header structured-outputs-2025-11-13 hinzu. Ohne ihn gibt die API einen 400-Fehler zurück.
Im Python SDK (v1.0 und höher) löst ein als output_format={...} übergebenes Schema-Dictionary einen TypeError aus. Verwende stattdessen output_config. Ein als output_format=Model an parse() oder stream() übergebenes Pydantic-Modell funktioniert ohne Änderung und ohne Beta-Header, da das SDK es als output_config sendet. Siehe Ein rohes JSON-Schema verwenden für die aktualisierte API-Form.
Funktionskompatibilität
Funktioniert mit:
- Batch-Verarbeitung: Verarbeite strukturierte Ausgaben in großem Umfang mit 50 Prozent Rabatt
- Token-Zählung: Zähle Token ohne Kompilierung
- Streaming: Streame strukturierte Ausgaben wie normale Antworten
- Kombinierte Nutzung: Verwende JSON-Ausgaben (
output_config.format) und strikte Tool-Nutzung (strict: true) zusammen in derselben Anfrage
Inkompatibel mit:
- Zitate: Zitate erfordern das Verschachteln von Zitatblöcken mit Text, was mit strikten JSON-Schema-Constraints in Konflikt steht. Die API gibt einen 400-Fehler zurück, wenn Zitate zusammen mit
output_config.formataktiviert sind. Um strukturierte Daten mit einem Zitat für jeden Wert zu extrahieren, siehe Strukturierte Daten mit Citations erhalten. - Message-Prefilling: Prefilling ist mit JSON-Ausgaben inkompatibel.
Verfügbarkeit
Claude API
- APIs
- Messages API
- Managed Agents Nicht unterstützt
- Modelle
- Alle Modelle
Amazon Bedrock
- API
- Messages API
- Modelle
- Alle Modelle
Amazon Bedrock (bedrock-runtime)
- API
- Messages API
- Modelle
- Alle Modelle
Claude Platform on AWS
- APIs
- Messages API
- Managed Agents Nicht unterstützt
- Modelle
- Alle Modelle
Claude Models on Google Cloud (Anthropic managed)
- APIs
- Messages API
- Managed Agents Nicht unterstützt
- Modelle
- Alle Modelle
Claude Models on Google Cloud (Google managed)
- API
- Messages API
- Modelle
- Alle Modelle
Microsoft Foundry
- API
- Messages API
- Modelle
- Alle Modelle
Datenverarbeitung
Übersicht über die DatenverarbeitungZutreffende Endpunkte
/v1/messages
Ausgenommen: Abgedeckte Modelle
Deine Prompts und die Ausgaben von Claude werden nicht gespeichert. Nur das JSON Schema wird zwischengespeichert, bis zu 24 Stunden nach der letzten Verwendung. Dies gilt auch für strikte Tool-Nutzung (strict: true bei Tools), die dieselbe Grammatik-Pipeline verwendet. Mehr erfahren
PHI darf nicht in JSON-Schema-Definitionen enthalten sein; siehe die Richtlinien zum Umgang mit PHI. Mehr erfahren
Prompts und Antworten werden bei Verwendung strukturierter Ausgaben mit ZDR verarbeitet. Das JSON-Schema selbst wird jedoch zu Optimierungszwecken ab der letzten Verwendung bis zu 24 Stunden lang vorübergehend gecacht. Über die API-Antwort hinaus werden keine Prompt- oder Antwortdaten gespeichert.
Strukturierte Ausgaben sind HIPAA-berechtigt, aber PHI darf nicht in JSON-Schema-Definitionen enthalten sein. Die API kompiliert JSON-Schemas in Grammatiken, die getrennt vom Nachrichteninhalt gecacht werden, und diese gecachten Schemas erhalten nicht denselben PHI-Schutz wie Prompts und Antworten. Füge keine PHI in Schema-Eigenschaftsnamen, enum-Werte, const-Werte oder reguläre Ausdrücke in pattern ein. PHI sollten nur im Nachrichteninhalt (Prompts und Antworten) vorkommen, wo sie unter HIPAA-Schutzmaßnahmen geschützt sind.
Nächste Schritte
Lass Claude seine Quellen angeben, wenn es Fragen zu bereitgestellten Dokumenten beantwortet.
Setze die JSON-Schema-Konformität von Claudes Tool-Eingaben mit grammatikbeschränktem Sampling durch.
Verbinde Claude mit externen Tools und APIs. Erfahre, wo Tools ausgeführt werden und wie die agentische Schleife funktioniert.
Erfahre mehr über die Preisstruktur von Anthropic für Modelle und Funktionen.
War diese Seite hilfreich?