Wenn strukturierte LLM-Ausgaben brechen: So schreibt man wirklich ein Strict-Mode-Schema
Fazit: Ein normales JSON Schema mit strict zu aktivieren endet meist in einem 400: alle Felder required, additionalProperties:false in jedem Objekt, $ref und allOf sofort abgelehnt. Dieser Leitfaden zeigt, wie man ein lockeres Schema stapelweise in eine strict-konforme Version umschreibt — mit nullable-Unions, harten Limits und einer Refusal-Triage-Checkliste.

Das Wichtigste: strict: true ist kein Schalter für „etwas ernster“, sondern ein Vertrag, der nur eine Teilmenge von JSON Schema akzeptiert. Alle Felder in required, additionalProperties: false in jedem Objekt, $ref und allOf sofort abgelehnt. Ein ungeschriebenes Schema im Strict-Mode abzuschicken ergibt eine 400 — nicht zuverlässigere Ausgaben.
Dasselbe Schema, das in Ihrem lokalen Validator glatt durchläuft, kommt sofort zurück, sobald Sie strict: true anhängen und es an die Modell-API senden. Das Modell ist nicht dümmer geworden — der Anbieter hat eine harte Grenze um die Schema-Teilmenge gezogen, die constrained decoding braucht, und Ihr Schema hat sie überschritten.
Was strict wirklich ändert: den Sampler in eine Grammatik einsperren
Im normalen Modus entspricht der JSON-Output des Modells Ihrer Schema nur „wahrscheinlich“, gestützt durch die Zeile „Antworte in JSON“ im Prompt. In den offiziellen Evals von OpenAI folgte gpt-4-0613 komplexen Schemata mit Prompt allein zu weniger als 40 %; mit aktiviertem strict erreichte gpt-4o-2024-08-06 in derselben Suite 100 %.
Der Mechanismus ist constrained decoding: Beim ersten Request kompiliert die API Ihr Schema in einen endlichen Automaten, und beim Decodieren muss jeder Token von diesem Automaten durchgelassen werden. Das Modell kann keinen Token emittieren, der das Schema verletzt. Das ist keine Erinnerung — das ist ein physisches Schloss. Der Preis fällt in zwei Raten: Die erste Kompilation eines neuen Schemas kostet zusätzliche Zeit (typisch unter 10 Sekunden, bis zu einer Minute bei komplexen Schemata) und erhöht die Latenz des ersten Tokens um etwa 5-8 %; die Kompilationsartefakte werden gecacht, spätere Requests zahlen nichts.
Seien Sie klar darüber, was garantiert wird und was nicht: Syntax und Form sind eingeschlossen, die Semantik nicht. Das Modell kann weiterhin estimate_hours zuversichtlich mit 400 füllen oder die falsche E-Mail-Adresse extrahieren. Form ist ein Fußboden, keine Decke — die semantische Qualität trägt weiter ein Eval-Set. Selbst Spitzenmodelle zeigen 2026 unter Last noch etwa 0,4 % Restfehlerrate bei der Form; eine Retry-Schleife bleibt Pflicht.
Drei harte Regeln: alles required, keine überzähligen Schlüssel, nullable statt optional
Der Strict-Mode stellt drei Umschreib-Anforderungen an das Schema, und jede läuft der gewohnten JSON-Schema-Intuition entgegen:
- Jedes Feld muss in required stehen. Der Strict-Mode kennt kein Konzept eines optionalen Feldes. Um „optional“ auszudrücken, lassen Sie das Feld in required, deklarieren aber den Typ als nullable-Union —
"type": ["string", "null"]— und lassen das Modell bei Abwesenheit null zurückgeben. Das ist genau das Gegenteil der üblichen Praxis, bei der required nur die wirklich nötigen Felder listet. - Jedes Objekt muss additionalProperties: false explizit deklarieren. In normalen Schemata lässt man das oft weg (siehe unseren Artikel zum Verhalten von additionalProperties in verschiedenen Runtimes), aber im Strict-Mode ist es eine Zulassungsbedingung: ohne ihn fällt der Request. Der Grund ist brutal — der Automat kann nur deklarierte Schlüssel generieren, jeder undoklarierte Schlüssel ist per Konstruktion unerreichbar.
- Die Python-Falle: Pydantic wirft Felder mit Defaults aus required. Ein
priority: str = "low"entfernt einen Eintrag aus dem required des generierten Schemas, und strict lehnt es ab. Entfernen Sie den Default oder stopfen Sie massenhaft mit dem Skript unten.
Alle drei Regeln müssen rekursiv auf jedes verschachtelte Objekt angewendet werden. Nur die oberste Ebene reparieren und Kindobjekte unberührt lassen ergibt trotzdem eine 400. Ein minimales konformes Beispiel:
{
"type": "object",
"properties": {
"intent": { "type": "string", "enum": ["book", "cancel", "question", "other"] },
"note": { "type": ["string", "null"] }
},
"required": ["intent", "note"],
"additionalProperties": false
}
Diese Konstrukte scheitern sofort: verbotene und wirkungslose Keywords
Der Strict-Mode unterstützt nur eine Teilmenge von JSON Schema. Teilen Sie die Keywords in zwei Eimer ein und behandeln Sie sie unterschiedlich:
| Eimer | Keywords | Verhalten im Strict-Mode |
|---|---|---|
| Sofort abgelehnt | $ref / $defs-Referenzen, allOf, not, dependentRequired, dependentSchemas, if/then/else |
Die API gibt einen Fehler zurück; der Request fällt |
| Still wirkungslos | pattern, minLength, maxLength, format, minimum, maximum, multipleOf (fine-tuned Modelle) |
Weder Fehler noch Durchsetzung — Regex-Beschränkungen selbst in der Anwendungsschicht prüfen |
Die Behandlung unterscheidet sich: Der erste Eimer muss umgeschrieben werden — $ref inline auflösen und allOf in properties verschmelzen. Der zweite Eimer darf bleiben (manche Konfigurationen akzeptieren sie), aber betrachten Sie ihn nie als Verteidigung. Sich auf "pattern": "^v\\d+\\.\\d+\\.\\d+$" für Versionsformate zu verlassen heißt unter strict nackt zu laufen; führen Sie auf jeder Antwort eine explizite Validierung aus. Noch eine Regel ganz oben: Die Wurzel des Schemas darf kein Array oder eine nackte Union sein — wickeln Sie sie in ein object.
Harte Limits: 5000 Eigenschaften, 10 Verschachtelungsebenen, 120 000 Zeichen
Auch mit allen Keywords konform scheitert man am Überschreiten der Größenlimits. Die offiziellen OpenAI-Zahlen:
- höchstens 5000 Objekteigenschaften im gesamten Schema, höchstens 10 Verschachtelungsebenen (bei Anthropic liegt die Grenze bei etwa 6 Ebenen);
- die Gesamtlänge der Strings aus Eigenschaftsnamen, Definitionsnamen, Enum-Werten und const-Werten ist auf 120 000 Zeichen gedeckelt;
- höchstens 1000 Enum-Werte insgesamt; ein String-Enum mit mehr als 250 Werten darf 15 000 Zeichen nicht überschreiten.
Man trifft diese Grenzen selten, aber „das gesamte Firmenwörterbuch als Enum nehmen“ und „einen dreistufigen Objektgraphen auf eine Ebene pressen“ sind zwei reale Unfallorte. Wenn Sie einen treffen: teilen. Zerlegen Sie das riesige Schema in mehrere Aufrufe oder plätten Sie die Struktur. Ein nützlicher Nebeneffekt: Ausgabeschlüssel folgen der Schlüsselreihenfolge des Schemas; Parser, die von einer festen Reihenfolge abhängen, können das als Feature nutzen.
Ein Skript, das ein lockeres Schema stapelweise in Strict-Form umschreibt
Handarbeit Schicht für Schicht lädt zu Auslassungen ein. Das rekursive Skript unten (das Muster aus dem 2026-Leitfaden von DevToolLab) ergänzt in einem Durchgang „jedes Objekt geschlossen, jeder Schlüssel required“:
def make_strict(schema: dict) -> dict:
"""additionalProperties:false + jeder Schlüssel required, auf jeder Ebene."""
if isinstance(schema, dict):
if schema.get("type") == "object" and "properties" in schema:
schema["additionalProperties"] = False
schema["required"] = list(schema["properties"].keys())
for value in schema["properties"].values():
make_strict(value)
elif isinstance(schema, dict):
for value in schema.values():
make_strict(value)
elif isinstance(schema, list):
for item in schema:
make_strict(item)
return schema
Der Begleit-Workflow: Zuerst aus einer Beispiel-JSON ein Schema-Skelett ableiten (die Tool-Seite /convert/schema auf dieser Website macht eine einseitige Ableitung von JSON zu Schema), das Skelett als Startpunkt nehmen, mit den drei Strict-Regeln straffen und am Ende make_strict als letzten Rückhalt durchlaufen lassen. Beachten Sie: Das Skript repariert nur die Form — nullable-Unions, Enums und semantische Felder bleiben Menschenentscheidungen; jedes Schema mit $ref muss erst inline aufgelöst werden.
Das Anthropic-Äquivalent: tool-as-schema
Anthropic hat keinen strict: true-Schalter. Das kanonische Muster 2026 ist, das Antwortschema als input_schema eines Tools anzuhängen und das Modell über tool_choice zu zwingen, es aufzurufen:
await anthropic.messages.create({
model: "claude-sonnet-4-6",
tools: [{ name: "emit", description: "Emit final summary", input_schema: schema }],
tool_choice: { type: "tool", name: "emit" },
messages,
});
Der Tool-Call-Kanal validiert das JSON selbst, der Effekt ist also äquivalent zum Strict-Mode. Die Unterschiede liegen im Detail: Anthropics Verschachtelungslimit liegt bei etwa 6 Ebenen, es unterstützt .nullable() statt .optional(); alle drei Anbieter (OpenAI, Anthropic, Gemini) akzeptieren leicht unterschiedliche Schema-Teilmengen. Ein Schema unverändert über Anbieter hinweg wiederzuverwenden ist unzuverlässig — bei jedem Modellwechsel neu verifizieren.
Refusal, Abschnitt und Timeouts sortieren, bevor Sie über Retries reden
Wenn der Strict-Mode Ihnen etwas Unzulässiges übergibt, gibt es nur drei Ursachen, und jede verlangt eine andere Reaktion:
- Refusal: Das Modell hat die Ausführung verweigert (unsicherer Request usw.). Das Feld
refusalin der Antwort ist wahr — JSON zu lesen ist da sinnlos; an einen Menschen übergeben oder den Request umformulieren. - Abschnitt:
finish_reasonistlength— max_tokens reichte nicht, die Ausgabe ist physisch unvollständig. Schema-Beschränkungen retten keinen abgeschnittenen Output; Budget erhöhen oder Struktur komprimieren. Identifikation und Teilwiederherstellung in unserem Artikel zur Diagnose und Reparatur von abgeschnittenem JSON. - Formverletzung: Wenn der Anbieter die Teilmenge nicht vollständig unterstützt, kann trotzdem schlechtes JSON ankommen. Wiederholen Sie nicht nur mit „versuch es nochmal“ — hängen Sie den genauen Validierungsfehlertext zurück an den Prompt: „severity muss low/medium/high/critical sein; du hast urgent ausgegeben; korrigiere und emittiere erneut.“ Retries mit Fehlerkontext senken die durchschnittliche Retry-Zahl von 3 auf etwa 1,5.
Setzen Sie eine harte Retry-Obergrenze (etwa zwei); danach degradieren Sie zu einem kleineren Korrekturmodell oder einer menschlichen Queue. Lassen Sie keinen einzigen schlechten Output die gesamte Pipeline strangulieren.
Checkliste vor dem Ausliefern
| Prüfung | Bestehenskriterium |
|---|---|
| required | Jedes Feld jedes Objekts steht in required |
| additionalProperties | Explizit false auf jedem Objekt, bis zur tiefsten Ebene |
| Optionale Semantik | Modelliert mit ["string", "null"]-Unions; kein nacktes optional |
| Verbotene Keywords | Kein $ref / allOf / if-then-else / dependentRequired |
| Wirkungslose Keywords | pattern und format in der Anwendungsschicht nachvalidiert |
| Größe | ≤5000 Eigenschaften, ≤10 Ebenen, ≤120 000 Zeichen Strings |
| Triage | refusal / length / Parse-Fehler auf getrennten Wegen behandelt |
| Retries | Mit Originalfehlertext, Obergrenze 2, dann Degradation |
| Semantik | Evals oder Feld-Assertions außerhalb des Schemas |
Nach dem Bestehen dieser Checkliste ist die Formzuverlässigkeit faktisch eingeschlossen. Für Semantik und Vertragsevolution — Schemata versionieren und ein kaputtes Schema zuerst in CI rot machen lassen — siehe Schema-Verträge ins CI schweißen.
FAQ
Garantiert der Strict-Mode korrekte Feldwerte?
Nein. Er sperrt nur Syntax und Form beim Decodieren: jeder Schlüssel vorhanden, Typen korrekt, Enums legal. Über semantische Korrektheit sagt er nichts — das Modell kann wohlgeformte, aber falsche Daten liefern. Die semantische Schicht trägt Eval-Sets oder Feld-Assertions.
Warum müssen optionale Felder auch in required?
Der Automat des Strict-Modes verlangt, dass jede deklarierte Eigenschaft erreichbar ist; ein fehlender required-Eintrag fällt bei der Validierung. Optionalität wird mit einer ["string", "null"]-Union simuliert: Das Feld erscheint immer, der Wert darf null sein, und der nachgelagerte Code behandelt null als Abwesenheit.
Sind pattern und minLength völlig nutzlos?
Unter fine-tuned Modellen und den meisten Strict-Konfigurationen werden sie nicht durchgesetzt. Sie werfen keinen Fehler — genau das macht sie gefährlich: Sie glauben eine Verteidigung zu haben, die es nicht gibt. Antworten, die von diesen Beschränkungen abhängen, nach Erhalt explizit mit ajv oder jsonschema validieren.
Verlangsamt der Strict-Mode die Antworten?
Nur der erste Request mit neuem Schema zahlt die Kompilation (typisch unter 10 Sekunden, bis zu einer Minute bei komplexen). Nach dem Cachen der Kompilationsartefakte sehen spätere Requests nur etwa 5-8 % Mehrlatenz am ersten Token. Im stationären Betrieb unmerklich; echte Kosten entstehen nur bei häufig wechselnden Schemata.
Was nach einem Modellversionswechsel nachtesten?
Drei Dinge: ob sich die unterstützte Schema-Teilmenge in dieser Version geändert hat, ob die Felder refusal und finish_reason noch da sind, ob die Limits für Verschachtelung und Größe sich verengt haben. Anbieter akzeptieren verschiedene Teilmengen — vor der Wiederverwendung eines Schemas über Modelle hinweg mit einem minimalen Request verifizieren.