JSON Toolkit

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.

Mittel~8 Min. LesezeitVeröffentlicht 2026-11-19Aktualisiert 2026-11-19
Diagramm der Umschreibregeln für JSON Schema im Strict-Mode von LLMs

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:

  1. 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.
  2. 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.
  3. 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 refusal in der Antwort ist wahr — JSON zu lesen ist da sinnlos; an einen Menschen übergeben oder den Request umformulieren.
  • Abschnitt: finish_reason ist length — 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.

Quellen

Verwandte Artikel

JSON-Schema-Vertragstests: Validierungsregeln in die CI schweißen

Ein Schema hört beim Schreiben nicht auf — dort beginnt der Verfall. Ein Tippfehler lockert die Validierung still, ein Refactoring bricht alle Fixtures. Dieser Leitfaden zeigt eine praktikable Vertragstest-Architektur: positive, negative und Snapshot-Fixtures, Lint des Schemas selbst, einmalige kompilierte Wiederverwendung und vier CI-Tore, die einen Vertragsbruch in einen roten Build verwandeln.

Mittel~8 Min. LesezeitAktualisiert 2026-11-05

Das JSON eines LLM ist abgeschnitten: erst den Stoppgrund prüfen, dann über Reparatur reden

Das Modell liefert JSON, das mitten im Wert endet, und der Parser nennt nur eine Spaltennummer. Klammern schließen macht es wieder parsebar, aber jedes fehlende Feld verschwindet in den Daten. Der Artikel zieht die Grenze zwischen dem, was eine Reparatur bei Abschneiden ehrlich retten kann, und dem, was erneut angefragt werden muss: stop_reason, Token-Budget, Feldreihenfolge.

Praxis~5 Min. LesezeitAktualisiert 2026-11-14

Ohne additionalProperties validiert das Schema nichts

Eine bestandene Validierung bedeutet keine sauberen Daten. Pydantic ignoriert unbekannte Felder standardmäßig, Zod entfernt sie, Ajv lässt sie durch — erfundene Parameter und Tippfehler-Schlüssel rutschen lautlos durch. Dieser Artikel zeigt die drei Formen stiller Akzeptanz und liefert vollständige Rezepte: Objekte schließen, Typos-Konvertierung kontrollieren, jede Verschachtelungsebene festziehen.

Intermediate~8 Min. LesezeitAktualisiert 2026-11-02