LLM-Kontextfenster: Prompts für GPT, Claude und Gemini…

Warum Prompts vor dem API-Aufruf dimensionieren?

Das Kontextfenster eines LLM begrenzt, wie viele Tokens Sie in einer Anfrage senden und empfangen können. Ein langer System-Prompt, zwanzig RAG-Chunks, Multi-Turn-Verlauf und die erwartete Antwort teilen sich dasselbe Budget — keine getrennten Kontingente. Überschreiten Sie das Limit, erhalten Sie einen 400-Fehler; liegen Sie an der Grenze, kann das Modell den Anfang oder das Ende des Kontexts abschneiden, ohne explizite Warnung. Auf FastMinify misst der Kontextfenster-Rechner Ihren Prompt gegen die GPT-, Claude- und Gemini-Modellliste — 100 % im Browser. Ergänzen Sie mit dem LLM-Token-Zähler und JSON-Formatierer für API-Message-Payloads. Siehe auch den Leitfaden LLM-Tokens zählen und API-Kosten schätzen und den KI- & LLM-Tools-Hub.

Effektive Budget-Auslastung in % vor dem API-Aufruf sehen

Output-Reserve (10–20 %) für abgeschnittene Completions einplanen

Alle Modelle der FastMinify-Liste mit demselben Paste vergleichen

Safe-, Near limit- und Won't-fit-Status mit 80 %-Schwelle

Kein Prompt an Anbieter — nur lokales Zählen

Häufige Fehler: Überlauf, Truncation und falsche Anzeige

Rohfenster mit nutzbarem Budget verwechseln

Ein „128k“-Modell bietet nicht 128k Input-Tokens, wenn Sie 8k Tokens Antwort erwarten. Ohne Output-Reserve glauben Sie zu passen, während die Generierung abgeschnitten wird.

Merken — 15–20 % Output-Reserve im Kontextfenster-Rechner setzen, bevor Sie einen großen RAG-Paste validieren.

Stille Truncation ignorieren

Manche Pipelines schneiden Anfang (System-Prompt) oder Ende (aktuelle Chunks) ab, wenn der Kontext das Limit überschreitet — ohne HTTP-Fehler. Das Modell antwortet trotzdem auf unvollständigem Kontext.

Merken — Safe (< 80 % des effektiven Budgets) für kritische RAG-Workflows anstreben; Near limit braucht Reduktionspuffer.

Wörter statt Tokens zählen

Wörter- oder Zeichenzähler spiegeln weder Abrechnung noch Fensterlimit wider. Code, JSON und nicht-lateinischer Text weichen stark vom Wort/Token-Verhältnis ab.

Merken — LLM-Token-Zähler am Zielmodell — Exact-Badge für OpenAI, Estimate für Claude/Gemini.

Message-Overhead und Tools vergessen

Zehn kurze Messages plus Tool-Definitionen können Hunderte Tokens mehr kosten als gleichwertiger Klartext. JSON-Parse-Fehler verbergen auch fehlende Keys.

Merken — Messages-Payload mit json-formatter formatieren, dann API-messages-Modus im Rechner.

Ehrliche Grenzen und Best Practices

Was der Rechner nicht vorhersagt

FastMinify hilft, das Kontextbudget im Browser zu planen — nicht das exakte Provider-Runtime-Verhalten zu simulieren.

Modellliste manuell gepflegt — offizielle Docs vor kritischem Prod prüfen

Estimate-Tier (Claude, Gemini): ±5–15 % — Grenze nicht nur mit Estimate anstreben

Keine Bild-, Audio- oder Tool-Call-Token-Regeln in v1

Tatsächliche Truncation hängt von SDK und Modell ab — Won't fit signalisiert Risiko, keinen garantierten HTTP-Fehler

Keine API-Aufrufe — Billing-Kontingente werden nicht abgefragt

Druck auf das Fenster reduzieren

Zählen zeigt oft vermeidbaren Ballast in System-Prompts und doppeltem Kontext.

System-Anweisungen kürzen — jeder Token wiederholt sich pro Anfrage

RAG-Chunks deduplizieren — nahezu identische Passagen entfernen

Multi-Turn-Verlauf zusammenfassen statt Roh-Transkripte

Größeres Fenster für Ingestion, kleineres Modell für Synthese wenn möglich

TOON für einheitliche Tabellen — siehe wann TOON JSON schlägt (messen, nicht annehmen)

Datenschutz und sensible Daten

Zählen ist 100 % clientseitig — geeignet für Prompts mit proprietärem Code, PII oder internen Specs.

Kein Upload des eingefügten Inhalts an OpenAI, Anthropic oder Google

Kein Konto nötig — keine Identitäts-↔-Prompt-Korrelation

512 KiB max pro Paste — sehr große Exporte teilen

API-Logs (vom Provider zurückgegebene Usage-Tokens) in Prod ergänzend instrumentieren

KI-Hub: Kontextrechner → Token-Zähler → Preisrechner je nach Bedarf

Kontextfenster vs. Tokens: was wirklich zählt

Gemessene Tokens, vom Modell veröffentlichtes Fenster

Anbieter werben mit Token-Limits (z. B. 128k, 200k, 1M) — nicht mit Wörtern oder Zeichen. Ein Token kann ein ganzes Wort, ein Fragment oder Satzzeichen sein. Der LLM-Token-Zähler nutzt js-tiktoken (Exact-Badge) für OpenAI und eine Zeichen/Token-Heuristik (Estimate-Badge, ±5–15 %) für Claude und Gemini.

Kontextfenster = Input- + Output-Obergrenze pro Anfrage (modellabhängig)

System-Prompt, RAG, Verlauf und Nutzerfrage summieren sich als Input-Tokens

Tool-Definitionen und strukturiertes JSON zählen als tokenisierter Text

Immer am Zielmodell vergleichen — Zählungen unterscheiden sich zwischen Familien

512 KiB UTF-8 max pro Paste bei FastMinify-KI-Tools

Effektives Budget: Platz für die Ausgabe reservieren

Der Kontextfenster-Rechner zieht eine konfigurierbare Output-Reserve ab (10 %, 15 % oder 20 % — Standard 15 %), bevor das effektive Input-Budget berechnet wird. Nutzt Ihr Prompt 85 % dieses Budgets, sind Sie Near limit, auch wenn das Rohfenster noch Reserve zeigt.

effectiveLimit = contextWindow − reserveTokens

remainingTokens = effectiveLimit − promptTokens (Minimum 0)

usagePercent = promptTokens / effectiveLimit × 100

Verdict Safe bei < 80 %, Near limit bei ≥ 80 %, Won't fit bei Überschreitung

Multi-Turn-Agenten: Reserve erhöhen, wenn Completions oft 2–4k Tokens überschreiten

RAG, Agenten und API-Message-Prompts

Im Modus API messages fügt ein [{"role","content"}]-Array ChatML-Overhead hinzu (+3 Tokens pro Message, +1 pro name, +3 Response-Priming). Struktur mit dem JSON-Formatierer prüfen, bevor Sie in den Rechner einfügen. Bei RAG den injizierten Kontext zusätzlich zur Nutzerfrage zählen — nicht nur die finale Frage.

Schweres RAG: Chunks dominieren oft, nicht die Nutzerfrage

Multi-Turn-Agenten: Verlauf wächst pro Runde — vor jedem Aufruf neu zählen

Stabile System-Prompts: gute Kandidaten für Prompt Caching (siehe Preis-Leitfaden)

Auto-Modus erkennt Klartext vs. Messages-JSON-Array

Compare all models: Tabellenansicht über die FastMinify-Liste

Workflow: Kontextrechner, Token-Zähler und JSON-Messages

Schritt 1 — Einfügen und zählen im Kontextfenster-Rechner

Öffnen Sie den Kontextfenster-Rechner. Fügen Sie Klartext oder ein Messages-JSON-Array ein. Wählen Sie Modell, Output-Reserve (10 / 15 / 20 %) und Encoding (Auto oder o200k_base / cl100k_base Override). Compare all models listet Nutzung %, verbleibende Tokens und Verdict pro Modell.

Safe-, Near limit (≥ 80 %) und Won't-fit-Verdicts (effektives Budget überschritten)

Output-Reserve 10 %, 15 % oder 20 % — Standard 15 %

Klartext oder API-messages-JSON mit Auto-Erkennung

Exact- (OpenAI) oder Estimate-Badge (Claude, Gemini) pro Zeile

512 KiB max — sehr große Payloads vor dem Einfügen teilen

Schritt 2 — Zählung mit dem Token-Zähler verfeinern

Für BPE-Detail (OpenAI Exact) oder Input-Tokens vor der Preisberechnung den LLM-Token-Zähler mit demselben Text öffnen. Beide Tools teilen die countTokensAsync-Pipeline — Summen sollten bei gleichem Modell und Format übereinstimmen.

Token-Pill-Visualisierung nur für Exact-Modelle

Compare all models — Zähl-Tabelle über die Liste

Summen in den Preisrechner kopieren bei Bedarf

Gleiches 512-KiB-Limit und Exact/Estimate-Tiers

Ergänzt den Kontextrechner — kein Duplikat

Schritt 3 — API-Message-Payloads vorbereiten

Chat-Completions-Integrationen senden oft ein messages-JSON. In den JSON-Formatierer einfügen, um Trailing Commas, ungültige Anführungszeichen oder falsche Struktur zu finden — dann formatiertes JSON im API-messages-Modus im Kontextrechner laden.

Syntax-Validierung vor dem Zählen — keine Parse-Überraschungen

Lesbare Struktur für redundante Messages

100 % lokal — für interne Specs oder proprietären Code

Weiter zum context-window-calculator im Messages-Modus

Siehe <a href="/de/blog/json-formatter-diff-tree-viewer-leitfaden" class="text-primary hover:underline">JSON-Formatierer, Diff und Tree Viewer</a> für tiefe Payloads

Szenario — Multi-Turn-RAG-Agent auf Claude

Sie injizieren 40 Vektor-Chunks + System-Prompt + 6 Verlaufs-Runden für Claude Sonnet.

Vollständigen Kontext zusammenstellen

System + Chunks + Verlauf + Frage in den Rechner (oder äquivalentes Messages-Array) einfügen. Ziel-Anthropic-Modell wählen und 20 % Reserve, wenn Antworten oft 4k Tokens überschreiten.

Verdict und Reserve lesen

Bei Won't fit: Chunks kürzen (niedrigeres top-k), Verlauf zusammenfassen oder per Compare all models auf größeres Fenster wechseln. Bei Near limit: Truncation oder Request-Splitting planen.

Messages-JSON validieren

Finalen Payload in json-formatter formatieren, im API-messages-Modus neu zählen, dann mit dem Token- und API-Kosten-Leitfaden USD projizieren.

Fazit

Einen Prompt zu dimensionieren heißt: Output-Reserve abziehen, Tokens am richtigen Modell zählen und das Verdict vor dem API-Aufruf lesen. FastMinifys Kontextfenster-Rechner kombiniert Multi-Provider-Liste, konfigurierbare Reserve und Safe / Near limit / Won't fit — alles lokal. Ergänzen Sie mit Token-Zähler für Details und json-formatter für Message-Payloads; Token- & Kosten-Leitfaden und KI-Hub decken den restlichen Workflow ab.

Prüfen Sie, ob Ihr Prompt ins Kontextfenster passt

15–20 % für Output bei Agenten und langen Ketten reservieren

Safe (< 80 %) für kritische RAG-Workflows anstreben

Nach jeder Multi-Turn-Runde neu zählen

Estimate als Planung behandeln, nicht als offizielles Anthropic/Google-Limit

Token- & API-Kosten-Leitfaden für USD-Projektion heranziehen

LLM-Kontextfenster: Prompts für GPT, Claude und Gemini dimensionieren