JSON Toolkit

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

Fazit: 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. LesezeitVeröffentlicht 2026-11-14Aktualisiert 2026-11-14
Stack-basiertes Schließen eines abgeschnittenen JSON nach stringbewusstem Scan

Eine Abschneidung ist kein Syntaxfehler, sondern fehlende Daten. Syntax lässt sich reparieren, eine Abschneidung nur teilweise zurückholen. In dem Moment, in dem ein Reparaturwerkzeug die Lücke schließt, ist der Rest der Lücke kein Parse-Fehler mehr, sondern etwas, von dem niemand weiß.

Wie eine Abschneidung aussieht: eine Spaltennummer reicht nicht

Das Modell schreibt JSON nach Ihrem Schema, erreicht das Ausgabelimit und der Text endet abrupt. Dies hier an das Modul json von Python 3.11 geben:

{"scores": {"clarity": 8, "depth": 7}, "items": [{"name": "a", "qty": 2}, {"name": "b", "qty"

json.loads wirft Expecting ':' delimiter, col 94. Die Spalte zeigt auf den Schlüssel "qty" ohne Wert, die eigentliche Ursache ist aber, dass das Dokument kein Ende hat. Schließt man es per gieriger Regex mit "} ab, scheitert das Parsen; ein stringbewusster Stack-Abschluss (Abschnitt sechs) parst, doch items enthält nur noch 2 Einträge, der dritte unvollständige Datensatz ist weg. Die Spaltennummer sagt, wo der Text endete. Sie sagt nie, wie viel fehlt.

Das ist der erste echte Unterschied zu einem gewöhnlichen JSON-Fehler. Ein abschließendes Komma hat einen klaren Endzustand: entfernen, Dokument ganz. Eine Abschneidung hat diesen Endzustand nicht. Repariert bleibt es ein Fragment.

Abschneidung ist keine Syntaxschädigung: der blinde Fleck der Reparaturwerkzeuge

Reparaturwerkzeuge wie jsonrepair machen syntaktisch kaputtes JSON zu legalem JSON: Markdown-Zäune entfernen, abschließende Kommas streichen, einfache Anführungszeichen umwandeln. Dort ist die Absicht intakt, die Reparatur nur Reinigung. Eine abgeschnittene Eingabe sieht für dasselbe Werkzeug wie kaputtes JSON aus, also schließt es die offene Zeichenkette, das offene Array und Objekt und liefert etwas Parsebares. Von 83 abgeschnittenen Claude-Berichten „reparierte" es 79, nur 4 scheiterten hart. Die Fehlerüberwachung sah eine zwanzigfach zu niedrige Fehlerrate.

Wie sah die reparierte Ausgabe aus? Die Rückmeldung zu Frage 6 endete mitten im Satz, Fragen 7 bis 9 fehlten, das Array next_steps war weg. Pydantic validierte trotzdem, weil next_steps den Standardwert [] hatte und die Liste keine Längenbeschränkung. Jede Schicht tat ihre Arbeit. Das Produkt lieferte einen selbstsicheren falschen Bericht.

Setzt man Syntaxreparatur auf einen Abschneide-Pfad, wechselt sie still von Reinigung zu Erfindung. Also zuerst die Grenze: ein Reparaturwerkzeug bearbeitet nur Formatunsauberkeiten vollständiger Antworten; eine abgeschnittene Antwort darf es nie erreichen. Für die Formatunsauberkeiten siehe den JSON-Reparaturleitfaden.

Der erste Schritt ist immer der Stoppgrund

Jede große API nennt in den Response-Metadaten, warum die Generierung endete — kostenlos. Es ist zugleich die meist ignorierte Codezeile in LLM-Integrationen. Anthropic liefert stop_reason, die Chat-API von OpenAI finish_reason: max_tokens heißt abgeschnitten, end_turn oder stop heißt selbst beendet.

resp = client.messages.create(model=MODEL, max_tokens=4096, ...)
if resp.stop_reason != "end_turn":
    raise TruncatedOutput(
        f"stop_reason={resp.stop_reason}, "
        f"output_tokens={resp.usage.output_tokens}"
    )
data = json.loads(resp.content[0].text)

Wird Abschneidung zur expliziten Ausnahme, hat der Retry-Pfad einen Auslöser und das Monitoring eine Alarmquelle. Die 83 Berichte wurden im Nachhinein mit einer Abfrage über das Feld stop_reason in Logs gefunden, die längst gespeichert und nie gelesen wurden. Gemini meldet length/incomplete im selben Sinne; bei neuen Anbietern erst die Zuordnungstabelle prüfen.

max_tokens ist ein Schutzgitter, kein Budget

Die direkte Ursache ist meist ein Ausgabelimit aus einer früheren Produktversion: 1500 Token, das mit langen Sitzungen 39 % der langen Berichte abschneidet. Das Limit zu erhöhen ist kostenlos. Abgerechnet werden tatsächlich erzeugte Token, ein Limit von 4096 auf einen Bericht mit 1100 Token kostet genau so viel wie 1500. Das Limit soll Amokläufe stoppen, nicht sparen.

Dimensionieren Sie aus Daten: eine Woche reale Verteilung beobachten, p99 nehmen, Reserve lassen. Das Team des Vorfalls wählte 4096, weil der p99 danach 2350 war. Der andere Weg ist, die Ausgabe selbst zu verkleinern. Wiederholte Schlüssel in homogenen Arrays verbrauchen den Großteil der Token; ein tabellarisches Encoding vor dem Aufruf (siehe den TOON-Leitfaden) verringert die Menge, die unter das Limit passen muss.

Die Feldreihenfolge im Schema bestimmt, was abgeschnitten wird

Modelle schreiben JSON von oben nach unten. Geht das Budget aus, verschwindet zuerst, was am Ende der Eigenschaftsliste steht. Ein Schema in der Reihenfolge summary, per_question_feedback, scores, next_steps verliert zuerst scores — genau den Teil, den Nutzer wöchentlich vergleichen. Die Lösung ist Umsortieren: kurze kritische Felder nach vorn, lange regenerierbare Details danach, Freitext zuletzt.

Das Verhalten der Anbieter verändert zudem die Folgen derselben Abschneidung:

Anbieter Mechanismus für strukturierte Ausgabe Verhalten beim Abschneiden
OpenAI response_format mit strict: true Garantie auf Sampling-Ebene, schmalster Dialekt; verweigert meist die Generierung
Anthropic input_schema im tool use Keine Garantie beim Decoding; kann ungeschlossene Klammern liefern
Gemini responseSchema mit JSON-MIME Beim Decoding nur Enum und Typ erzwungen; Abschneiden bleibt möglich

„Structured Output ist an, Validierung entfällt" ist also ein Irrtum. Je lockerer die Anbietergarantie, desto mehr brauchen Sie eigene Schema-Validierung und eine Retry-Schleife. Wie man diesen Vertragstest baut, steht in JSON-Schema-Vertragstest.

Wenn wirklich Teilwiederherstellung nötig ist: stringbewusstes Stack-Schließen

Manche Fälle müssen aus dem Fragment etwas holen: Streaming-Vorschauen, degradierte Antworten, menschliche Prüfwarteschlangen. Dort ist das Schließen die letzte Sprosse der Reparaturleiter und braucht zwei Bedingungen. Erstens muss der Klammer-Scan stringbewusst sein: Anführungszeichen- und Escape-Zustand Zeichen für Zeichen verfolgen, sonst zerstört ein { im Wert den Stack. Zweitens unvollständige Schlüssel-Wert-Paare vor dem Schließen entfernen. Ein "qty" ohne Wert lässt sich nicht zu {"qty"} schließen; das ganze Paar muss weg.

def close_truncated(s: str) -> str:
    # 1) Stringbewusster Scan, offene Zeichenkette zuerst schließen
    out, in_str, esc = [], False, False
    for ch in s:
        out.append(ch)
        if esc: esc = False; continue
        if ch == '\\' and in_str: esc = True; continue
        if ch == '"': in_str = not in_str
    text = ''.join(out) + ('"' if in_str else '')
    # 2) Teilpaare und hängende Doppelpunkte/Kommas entfernen
    text = re.sub(r',\s*"[^"]*"\s*$', '', text)
    text = re.sub(r'[{,]\s*"[^"]*"\s*:\s*$', '}', text)
    text = re.sub(r':\s*$', '', text)
    text = re.sub(r',\s*$', '', text)
    # 3) Stack erneut scannen und LIFO schließen
    stack, in_str, esc = [], False, False
    for ch in text:
        if esc: esc = False; continue
        if ch == '\\' and in_str: esc = True; continue
        if ch == '"': in_str = not in_str; continue
        if not in_str:
            if ch in '{[': stack.append(ch)
            elif ch in '}]' and stack: stack.pop()
    return text + ''.join('}' if c == '{' else ']' for c in reversed(stack))

Auf die Eingabe vom Anfang angewandt liefert das mit Python 3.11 und nur der Standardbibliothek {"scores": {...}, "items": [{"name": "a", "qty": 2}, {"name": "b"}]}. Es parst, und der dritte Datensatz ist verloren. Auf der Seite lokaler Modelle erledigen dedizierte Bibliotheken wie partial-json-parser dieselbe Arbeit: per Stack schließen, per Vollständigkeit beschneiden.

Entscheidend ist die Offenlegung. Die Schließfunktion muss berichten, auf welcher Sprosse das Ergebnis entstand; alles aus der Sprosse truncation ist ein Teilergebnis und muss so markiert werden: fehlenden Bereich nachfragen, mit höherem Limit erneut anfragen oder dem Nutzer sagen, dass seine Daten unvollständig sind. So zu tun, als wäre nichts gewesen, heißt Halluzinationen mit deterministischem Code zu erzeugen.

Reparieren oder erneut anfragen: eine Grenztabelle

Eingabeform Richtige Aktion Warum
Zäune, abschließende Kommas, einfache Anführungszeichen Reparaturwerkzeug Absicht vollständig, nur Syntax schmutzig
Mitten in einer Zeichenkette abgeschnitten Retry oder Teilwiederherstellung mit Offenlegung Der Wert selbst fehlt
Mitten in einer Struktur abgeschnitten Teilwiederherstellung mit Offenlegung Fertige Felder bleiben, Teilpaare müssen weg
Parst, wirkt aber falsch Fachliche Validierung Kein Abschneiden, kommt aber oft gleichzeitig vor

Ein Finanzteam hat die Kosten beziffert. Lange Rechnungen wurden abgeschnitten, das Klammernschließen erzeugte valides JSON, das fehlende Feld total nahm den Standardwert 0, und ein System mit 98,2 % Formatkonformität erzeugte monatlich rund 200 falsche Rechnungen. Nachdem Abschneiden als harte Degradierung behandelt und eine Identitätsprüfung (total == Summe der Positionen) ergänzt wurde, fiel die Geld-Fehlerrate von 0,8 % auf 0,02 %, während die Formatkonformität nur auf 99,1 % stieg. Drei Monate Optimierung auf „Formatkonformität" trafen die falsche Kennzahl. Den Parser zu passieren heißt nicht, das Fach zu passieren.

Die Vier-Punkte-Checkliste: vor dem Parsen den Stoppgrund prüfen; das Limit aus p99 statt als Budget setzen; kritische Schemafelder nach vorn; dem Reparaturwerkzeug nur Formatunsauberkeiten vollständiger Antworten geben. Mit allen vieren wird Abschneiden aus stiller Datenkorruption wieder ein lauter, wiederholbarer Fehler.

Kann ich einfach die Klammern schließen und das Ergebnis nutzen

Nein. Schließen garantiert nur syntaktische Legalität, die Daten bleiben ein Fragment mit halbem Satz, verlorenen Enddatensätzen und Standardwerten statt echter Werte. Markieren Sie die Ausgabe als Teilresultat, lösen Sie Retry oder Degradierung aus und protokollieren Sie die Wiederherstellungsrate.

Wie unterscheide ich Abschneiden von einem echten Syntaxfehler

Lesen Sie den Stoppgrund in den Metadaten: max_tokens, length oder incomplete heißt abgeschnitten; end_turn oder stop mit Parse-Fehler heißt echte Syntaxschädigung. Ohne Metadaten hilft das Ende: mitten im Anführungszeichen oder in einer Klammer mit ungeschlossener äußerer Struktur ist fast immer Abschneiden.

Warum ist eine reparierte Abschneidung gefährlicher als ein lauter Fehler

Ein Reparaturwerkzeug optimiert „parst", und eine geschlossene Abschneidung parst — Monitoring bleibt still, nachgelagerte Validierung passiert dank Standardwerten. So ergaben 83 abgeschnittene Berichte nur 4 Fehler. Das Werkzeug kennt keine Absicht und kann nicht wissen, was fehlt; Abschneiden muss vorgelagert abgefangen werden.

Kostet ein höheres max_tokens mehr Geld

Nein. Abgerechnet werden tatsächlich erzeugte Token, das Limit ist nur ein Schutzgitter. 4096 auf 1100 erzeugte Token kostet exakt wie 1500. Setzen Sie es auf den realen p99 plus Reserve und stecken Sie Aufwand in die Verhinderung von Amokausgaben.

Quellen

Passende Tools

Verwandte Artikel

JSON-Reparatur-Leitfaden: Kaputte LLM-Ausgaben retten, ohne das Vertrauen zu verlieren

LLM-Ausgaben in Markdown-Zäunen, mit trailing commas und Python-Literalen übersteht kein strikter Parser — ebenso wenig wie manuell editierte Konfigurationen ohne Anführungszeichen. Dieser Leitfaden zieht die echte Grenze zwischen neun reparierbaren Fehlerklassen und vier unheilbaren, erklärt, warum Zustandsmaschinen Regex schlagen, und liefert eine produktionsreife Parse-Kette mit jsonrepair und json-repair.

Fortgeschritten~6 Min. LesezeitAktualisiert 2026-11-08

TOON-Format-Leitfaden: JSON verschlanken, bevor es in den LLM geht

Wenn Sie ein gleichförmiges Array als JSON an ein großes Sprachmodell übergeben, verbrennen Token wiederholte Schlüsselnamen und Klammern. TOON deklariert die Struktur einmalig über eingerückte Objekte und tabellarische Arrays und streamt die Daten zeilenweise. Offizielle Benchmarks zeigen rund 40 % weniger Tokens bei höherer Parse-Genauigkeit. Dieser Leitfaden deckt die Syntax ab, wann die Ersparnis greift, wann eine Konvertierung falsch ist und wie encode und decode eingebunden werden.

Fortgeschritten~6 Min. LesezeitAktualisiert 2026-11-10

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