Zuverlässiges JSON von LLMs: Schema, Validierung, Retries
Gültiges JSON von einem LLM bekommst du nicht durch höfliches Bitten. Schemas, Structured-Output-Modi, Validierung und Retries und die häufigsten Fehlerquellen.
In diesem Artikel
- Warum zerstören Modelle überhaupt JSON?
- Schritt 1: Beschreibe die Ausgabe im Prompt genau
- Schritt 2: Nutze die Structured-Output-Funktion der API
- Schritt 3: Validiere alles, auch mit Erzwingung
- Schritt 4: Wiederhole mit dem Fehler, nicht blind
- Wohin gehört die Überlegung in einer JSON-Antwort?
- Häufige Designfehler bei Ausgabeschemas
- Reicht Prompting allein jemals aus?
Um zuverlässiges JSON von einem Sprachmodell zu bekommen, definierst du die Struktur als JSON Schema, nutzt die Structured-Output-Funktion des Anbieters, wo es sie gibt, validierst jede Antwort im Code und wiederholst die Anfrage mit der Fehlermeldung, wenn sie durchfällt. Die Formulierung des Prompts bringt dich ein gutes Stück weit, die letzten Prozentpunkte an Zuverlässigkeit kommen aus der API und deiner eigenen Validierung.
Der Unterschied ist wichtig, denn „ein gutes Stück weit“ reicht für Code nicht. Ein Parser, der bei 2 % der Antworten scheitert, bedeutet bei großem Volumen alle paar Minuten eine kaputte Funktion für jemanden.
Warum zerstören Modelle überhaupt JSON?
Bevor du es behebst, hilft es zu wissen, was eigentlich schiefgeht. In etwa in der Reihenfolge, in der du darauf stößt:
- Markdown-Zäune. Das Modell liefert
```json ... ```, weil Chat-Modelle darauf trainiert sind, Code schön darzustellen. - Geschwätzige Einleitungen. „Klar! Hier ist das gewünschte JSON:“ und danach das Objekt.
- Falsche oder erfundene Schlüssel.
customerNamestattcustomer_nameoder ein zusätzliches Feldnotes, das du nie verlangt hast. - Falsche Typen.
"price": "19.99"als String,"count": "three", ein einzelnes Objekt, wo du ein Array wolltest. - Abbruch. Die Antwort erreicht das Token-Limit und endet mitten im Objekt.
- Syntaktisch gültiger Unsinn. Perfektes JSON, falscher Inhalt: ein Datum im falschen Format, eine halluzinierte Telefonnummer,
null, obwohl der Wert direkt in der Eingabe stand.
Structured-Output-Funktionen beseitigen die ersten fünf weitgehend. Den sechsten beseitigt nichts außer gutem Prompting, Grounding und Prüfungen.
Schritt 1: Beschreibe die Ausgabe im Prompt genau
Auch mit erzwungenem Schema erklärst du im Prompt, was jedes Feld bedeutet. Ein Schema sagt, dass due_date ein String ist. Nur der Prompt kann sagen, dass es ISO 8601 sein soll und dass relative Angaben auf das Sendedatum der E-Mail bezogen werden sollen.
Ein schwacher Prompt:
Extrahiere die Rechnungsdetails aus dieser E-Mail als JSON.
Ein stärkerer:
Extrahiere die Rechnungsdetails aus der E-Mail unten.
Gib ein einzelnes JSON-Objekt mit genau diesen Schlüsseln zurück:
- "vendor": String, das Unternehmen, das die Rechnung ausgestellt hat
- "invoice_number": String, genau wie geschrieben (führende Nullen behalten)
- "total": Zahl, in der Rechnungswährung, ohne Währungssymbol
- "currency": String, ISO-4217-Code wie "USD" oder "EUR"
- "due_date": String im Format YYYY-MM-DD, oder null, wenn nicht angegeben
Steht ein Wert nicht in der E-Mail, verwende null. Rate nicht.
Gib nur das JSON-Objekt zurück, ohne Markdown und ohne Erklärung.
<email>
{{email_text}}
</email>
Zwei Details tragen hier viel. „Führende Nullen behalten“ verhindert, dass das Modell aus 00417 „hilfsbereit“ 417 macht. Und „verwende null, rate nicht“ gibt dem Modell einen legitimen Ausweg. Ohne eine ausdrückliche null-Option erfindet ein Modell bei einem Pflichtfeld lieber einen plausiblen Wert, als es leer zu lassen.
Schritt 2: Nutze die Structured-Output-Funktion der API
Die meisten großen Anbieter bieten inzwischen eine Möglichkeit, die Ausgabe auf ein Schema zu beschränken. Namen und Details unterscheiden sich und ändern sich mit der Zeit, schau also in die aktuelle Dokumentation. Die wichtigsten Optionen sehen so aus:
- OpenAI hat einen einfachen JSON Mode, der syntaktisch gültiges JSON garantiert, und Structured Outputs, bei denen du ein JSON Schema mit Strict Mode übergibst und die Ausgabe darauf beschränkt wird.
- Google Gemini erlaubt es, den Response-MIME-Type auf JSON zu setzen und ein Response-Schema mitzugeben.
- Anthropic lässt dich ein Tool mit einem Input-Schema definieren, das Claude aufruft, was Argumente in Schema-Form liefert. Die Dokumentation beschreibt auch native Unterstützung für Structured Output.
Der wichtige Unterschied ist JSON Mode vs. Schema-Erzwingung. Der JSON Mode verspricht nur, dass der Text sich parsen lässt. Deine Schlüssel können trotzdem falsch sein. Die Schema-Erzwingung (oft per Constrained Decoding, das einschränkt, welche Tokens das Modell als Nächstes erzeugen darf) verspricht die Form.
Ein Schema für das Rechnungsbeispiel:
{
"type": "object",
"properties": {
"vendor": { "type": ["string", "null"] },
"invoice_number": { "type": ["string", "null"] },
"total": { "type": ["number", "null"] },
"currency": { "type": ["string", "null"], "enum": ["USD", "EUR", "GBP", null] },
"due_date": { "type": ["string", "null"], "description": "YYYY-MM-DD" }
},
"required": ["vendor", "invoice_number", "total", "currency", "due_date"],
"additionalProperties": false
}
Beachte die Typen mit null. In strikten Modi ist in der Regel jedes Feld Pflicht, „optional“ muss also als „Pflicht, darf aber null sein“ ausgedrückt werden. Beachte auch additionalProperties: false, das überraschende Felder verhindert. Strikte Modi unterstützen meist nur eine Teilmenge von JSON Schema, prüfe also, welche Schlüsselwörter erlaubt sind, bevor du etwas Aufwendiges baust.
Wenn du Python oder TypeScript nutzt, definiere das Schema als Pydantic-Modell oder Zod-Schema und erzeuge daraus das JSON Schema. Dann validiert dieselbe Definition die Antwort, und beide können nicht auseinanderlaufen.
Schritt 3: Validiere alles, auch mit Erzwingung
Die Schema-Erzwingung garantiert die Struktur. Sie garantiert nicht:
- dass
due_dateein echtes Datum ist (der 30. Februar ist ein gültiger String), - dass
totalmit der Summe der Positionen übereinstimmt, - dass
vendorirgendwo in der Quell-E-Mail vorkommt, - dass das Modell nicht die dritte von fünf Positionen weggelassen hat.
Schreib die Prüfungen, die in deinem Bereich zählen. Parse Datumsangaben. Prüfe, dass Summen nicht negativ sind. Prüfe bei Extraktionsaufgaben, dass die extrahierten Strings tatsächlich in der Eingabe vorkommen. Dieser eine Test fängt erstaunlich viele Halluzinationen ab.
Schritt 4: Wiederhole mit dem Fehler, nicht blind
Schlägt die Validierung fehl, schick nicht einfach dieselbe Anfrage noch einmal und hoffe. Schick den Fehler zurück:
Deine vorherige Antwort hat die Validierung nicht bestanden:
- "due_date": "March 3rd" passt nicht zum Format YYYY-MM-DD
- "currency": "dollars" ist keiner der Werte USD, EUR, GBP
Gib nur das korrigierte JSON-Objekt zurück.
Modelle beheben konkrete, benannte Fehler gut. Begrenze die Wiederholungen auf ein oder zwei, protokolliere jeden Fehlschlag und sieh dir die Logs wöchentlich an. Wiederholte Fehler beim selben Feld bedeuten meist, dass Prompt oder Schema unklar sind, nicht dass das Modell unzuverlässig ist. Bibliotheken wie Instructor (Python) übernehmen diese Schleife aus Validieren und Wiederholen für dich, aber das Muster ist einfach genug, um es selbst zu schreiben.
Bei rein syntaktischen Fehlern bei Anbietern ohne Erzwingung deckt ein nachsichtiger Parser, der Zäune und nachgestellten Text vor JSON.parse entfernt, die häufigsten Fälle ab. Sieh ihn als Notlösung, nicht als Strategie.
Wohin gehört die Überlegung in einer JSON-Antwort?
Braucht die Aufgabe ein Urteil (eine Klassifikation mit Begründung, einen Risikowert), setz ein Feld für die Überlegung vor das Feld mit der Entscheidung:
{
"evidence": "Der Kunde erwähnt eine doppelte Abbuchung auf der Rechnung vom März.",
"category": "billing",
"confidence": "high"
}
Modelle erzeugen Felder der Reihe nach. Eine Entscheidung, die zuerst geschrieben wird, wird hinterher gerechtfertigt, statt von der Überlegung geprägt zu sein. Mehr dazu in Chain-of-Thought-Prompting erklärt.
Die Kehrseite: Felder für die Überlegung kosten bei jedem Aufruf Tokens. Lass sie bei einfacher Extraktion weg.
Häufige Designfehler bei Ausgabeschemas
Tiefe Verschachtelung ohne Grund. Drei Ebenen von Objekten, wo eine flache Liste reichen würde. Jede Ebene ist eine weitere Stelle, an der das Modell einen Wert falsch einsortieren kann.
Freitextfelder, die Enums sein sollten. Verzweigt nachgelagerter Code anhand von status, mach daraus ein Enum. Sonst bekommst du „Pending“, „pending“, „In progress“ und „awaiting review“ für dasselbe.
Mehrdeutige Feldnamen. date bei einer Rechnung kann das Ausstellungsdatum, das Fälligkeitsdatum oder das Zahlungsdatum sein. Nenne es due_date und beschreibe es.
Zu viel in einem Aufruf verlangen. Ein Schema mit vierzig Feldern, extrahiert aus einem zwanzigseitigen Vertrag, lädt zu Auslassungen ein. Teile es auf: ein Aufruf pro Abschnitt, oder ein Aufruf, der die relevanten Stellen findet, und ein weiterer, der daraus extrahiert.
Den leeren Fall vergessen. Was soll die Ausgabe sein, wenn die E-Mail gar keine Rechnung ist? Ergänze ein Boolean is_invoice oder erlaube ein leeres Ergebnis, sonst extrahiert das Modell eine Rechnung aus einer Einladung zum Mittagessen.
Reicht Prompting allein jemals aus?
Für Prototypen, Skripte, die du von Hand ausführst, oder Modelle ohne Structured-Output-Unterstützung: ja. Eine präzise Formatbeschreibung, ein Beispiel für die exakte Ausgabe und ein defensiver Parser bringen dich zu hoher Zuverlässigkeit. Für alles, was Nutzer sehen, nimm Erzwingung, wo verfügbar, und Validierung immer.
Die zugrunde liegende Fähigkeit ist in jedem Fall dieselbe: Beschreibe die Ausgabe so genau, dass es nur einen vernünftigen Weg gibt, sie auszufüllen. Das Thema Structured Output übt diese Entscheidungen, und ist das JSON, das du erzeugst, ein Tool-Aufruf statt einer endgültigen Antwort, knüpft Tool Calling und KI-Agents hier an. Für Extraktion auf Basis von Quelldokumenten siehe Was ist RAG?.
Häufige Fragen
Wie zwinge ich ein LLM, gültiges JSON zurückzugeben?
Nutze die Structured-Output-Funktion des Anbieters mit einem JSON Schema, sofern es sie gibt, denn sie beschränkt die Generierung auf das Schema. Validiere das Ergebnis trotzdem im Code und wiederhole die Anfrage oder repariere die Ausgabe, wenn die Validierung fehlschlägt.
Was ist der Unterschied zwischen JSON Mode und Structured Outputs?
Der JSON Mode sorgt dafür, dass das Modell syntaktisch gültiges JSON erzeugt, garantiert aber weder deine Schlüssel noch die Typen. Structured Outputs mit einem strikten Schema beschränken die Ausgabe darauf, zu dem Schema zu passen, das du vorgibst.
Warum verpackt mein LLM JSON in Markdown-Codeblöcke?
Auf Chat optimierte Modelle sind darauf trainiert, Code für Menschen schön zu formatieren. Sag dem Modell, dass es nur das reine JSON-Objekt zurückgeben soll, oder nutze einen Structured-Output-Modus, und entferne die Codeblock-Zäune sicherheitshalber in deinem Parser.
Soll ich JSON von einem LLM auch mit Schema validieren?
Ja. Ein Schema garantiert die Form, nicht die Wahrheit. Das JSON kann völlig gültig sein und trotzdem ein falsches Datum, einen erfundenen Wert oder ein leeres Feld enthalten, obwohl Daten vorhanden waren.
- #Structured Output
- #JSON
- #JSON Schema
- #Validierung