KI-Antwort abgeschnitten? Fix für finish_reason "length" und max_tokens

Dein Skript lief, das Modell antwortete, und die Funktion endet mitten in einer Zeile. Oder der JSON-Parser wirft bei einer völlig normal aussehenden Antwort einen Fehler. Meistens ist das Modell nicht gescheitert: Es hat das von dir gesetzte max_tokens-Limit erreicht (oder einen Default, den du nie gesehen hast), und die API hat es mitten im Wort gestoppt.

Der schnelle Fix: Lies finish_reason in der Antwort. Wenn er "length" ist (OpenAI-kompatible API) oder stop_reason gleich "max_tokens" ist (Anthropic Messages), wurde die Antwort abgeschnitten. Erhöhe max_tokens bis zum Output-Limit des Modells oder bitte das Modell, fortzufahren. Der Rest dieser Seite zeigt beides in Code, den du direkt einfügen kannst.

Wenn du die einfache Erklärung willst, warum das passiert, beginne mit warum eine KI-Antwort mitten im Satz stoppt. Diese Seite ist die Debugging-Version.

Wie eine abgeschnittene Antwort auf dem Bildschirm aussieht#

Die Symptome unterscheiden sich je nachdem, was du angefragt hast, aber die Ursache ist dieselbe. Versuche, diese mit dem abzugleichen, was du gesehen hast:

Die letzte Zeile ist wichtig. Wenn finish_reason gleich stop ist, ist das Limit nicht dein Problem, und eine Erhöhung von max_tokens ändert nichts.

Schritt 1: Lies das Feld, das es dir sagt#

Jede Antwort sagt, warum die Generierung endete. In einer OpenAI-kompatiblen Antwort ist es choices[0].finish_reason: "stop", wenn das Modell fertig wurde, "length", wenn ihm die Tokens ausgingen. In der Anthropic Messages API ist das Feld stop_reason, und der Wert für Abbruch ist "max_tokens". Anthropics stop-reason-Leitfaden (geprüft am 28. Oktober 2026) empfiehlt genau die beiden Fixes unten: max_tokens erhöhen oder die Antwort fortsetzen.

Hier ist dieselbe Prüfung in drei Formen. Die Base-URL ist https://api.cheaptokens.dev/v1 für das OpenAI SDK und https://api.cheaptokens.dev (ohne /v1) für das Anthropic SDK. Das max_tokens=200 ist absichtlich klein, damit du den Abbruch selbst sehen kannst.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    max_tokens=200,
    messages=[{"role": "user", "content": "Write a Python class for a todo list with tests."}],
)

choice = resp.choices[0]
if choice.finish_reason == "length":
    print("Cut off at the token limit")
print(choice.message.content)
print(resp.usage.completion_tokens)

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.cheaptokens.dev",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

msg = client.messages.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    max_tokens=200,
    messages=[{"role": "user", "content": "Write a Python class for a todo list with tests."}],
)

if msg.stop_reason == "max_tokens":
    print("Cut off at the token limit")
print(msg.content[0].text)

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
    "max_tokens": 200,
    "messages": [{"role": "user", "content": "Write a Python class for a todo list with tests."}]
  }'

Wenn es als Diagnose funktioniert, siehst du dieses Paar: ein niedriges Limit ergibt length, ein großzügiges Limit ergibt stop.

Schritt 2: Erhöhe max_tokens, aber nicht über die Obergrenze#

Der naheliegende Fix ist eine größere Zahl. Der Haken: Jedes Modell hat seine eigene Obergrenze für die Antwort. Setze keinen Wert darüber: Das Limit gilt pro Modell, also prüfe zuerst die Tabelle unten. Das sind die Limits pro Antwort auf CheapTokens (Fakten geprüft am 28. Oktober 2026):

Eine Übersetzung mit 9.000 Tokens braucht ein Modell mit einem größeren Limit pro Antwort — DeepSeek-V4-Flash schafft bis zu 32.768 Tokens pro Antwort. Für langen Code, langes JSON oder ein ganzes Dokument hat deepseek-ai/DeepSeek-V4-Flash-0731 den meisten Spielraum: bis zu 32.768 Tokens pro Antwort, ein Preis zu jeder Tageszeit. Nimm die exakten Modell-IDs aus der CheapTokens-Doku und der Modellseite, da die Anbieter sie unterschiedlich benennen.

Eine praktische Regel: Setze max_tokens auf die längste Antwort, die du akzeptieren würdest, nicht auf das Maximum. Du zahlst für Tokens, die das Modell tatsächlich schreibt, also kostet eine hohe Obergrenze nichts, wenn die Antworten kurz sind.

Schritt 3: JSON, das auf halbem Weg stoppt#

Eine abgeschnittene JSON-Antwort ist der unangenehmste Fall, weil der Text richtig aussieht, bis der Parser das Ende erreicht. Angenommen, du extrahierst Felder aus 40 Rechnungen in einem Aufruf und fragst nach einem Array. Das Modell schreibt 31 Objekte, erreicht das Limit, und das Array wird nie geschlossen.

Versuche nicht, den String durch Hinzufügen von ]} zu reparieren. Du bekommst gültiges JSON mit fehlenden Datensätzen, was schlimmer ist als ein Fehler. Prüfe zuerst finish_reason; wenn er length ist, erhöhe entweder das Limit und führe den Aufruf erneut aus, oder teile die Eingabe in kleinere Batches auf. Wie du das Format selbst erzwingst, steht in gültiges JSON aus einer LLM-API.

Schritt 4: Lass das Modell fortfahren#

Manchmal ist die Antwort wirklich länger als jedes Limit: ein Buchkapitel, ein großes Refactoring. Dann gib das, was du hast, zurück und bitte das Modell, weiterzumachen. Die Schleife unten behält den bisherigen Text, fragt nach dem Rest und gibt nach ein paar Runden auf, damit ein Bug nicht ewig weiterläuft.

def complete(base_messages, model, max_tokens=4096, rounds=4):
    text = ""
    for _ in range(rounds):
        messages = list(base_messages)
        if text:
            messages += [
                {"role": "assistant", "content": text},
                {"role": "user", "content": "Continue exactly where you stopped. Do not repeat anything."},
            ]
        r = client.chat.completions.create(model=model, max_tokens=max_tokens, messages=messages)
        choice = r.choices[0]
        text += choice.message.content or ""
        if choice.finish_reason != "length":
            return text, True   # finished on its own
    return text, False          # still cut after all rounds

Zwei Gewohnheiten halten das ehrlich. Gib das True/False-Flag zurück und zeige dem Nutzer eine Warnung bei False, statt ein halbes Dokument als fertig darzustellen. Und denke daran, dass jede Runde den bisherigen Text erneut als Input sendet, sodass eine fortgesetzte Antwort mehr kostet als eine große Antwort. Bei strukturierten Daten bevorzuge ein größeres Limit oder kleinere Batches gegenüber dem Fortsetzen.

Was eine lange Antwort kostet#

Angenommen, eine lange Antwort hat 2.000 Tokens Input und 8.000 Tokens Output. Auf DeepSeek-V4-Flash kostet diese Anfrage $0.00083 zum heutigen Preis, und insgesamt, mit Input und Output zusammen gerechnet, ist es günstiger als OpenRouter. Ändere die Zahlen auf deine eigene Last:

Die Erkenntnis: Die Output-Seite dominiert in diesem Szenario, also ist Spielraum bei max_tokens eine günstige Versicherung gegen einen erneuten Lauf. Eine abgeschnittene Antwort, die du neu generieren musst, zahlst du doppelt. Hintergrund zu den beiden Seiten der Rechnung steht in Input- vs. Output-Tokens, und die vollständige Modellliste mit Preisen findest du auf der Preisseite.

Bevor du auslieferst: eine kurze Checkliste#