---
title: "LLM-Antworten cachen, Kosten senken (Python, SQLite)"
description: "Ein getesteter Exact-Match-Cache für LLM-API-Antworten in Python: was in den Schlüssel gehört, was nie, TTLs, Datenschutz und wie Sie die Trefferquote vorab messen."
url: https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/
lang: de
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/cache-llm-responses-cut-cost/) (aktualisiert am 2026-11-15).

# LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python

Vom Team von BroadNet Inference · 8 Min. Lesezeit · Veröffentlicht 2026-11-15

Hashen Sie die vollständige Anfrage (Modell, Nachrichten, temperature, max\_tokens, response\_format, Tools, Reasoning-Einstellungen und Ihre Prompt-Version) zu einem Schlüssel und speichern Sie die Antwort darunter mit Ablaufzeit. Liefern Sie gespeicherte Antworten nur für deterministische Anfragen ohne Nebenwirkungen aus. Messen Sie zuerst in Ihren Logs, wie oft sich identische Anfragen wiederholen: Dieser Anteil ist das Maximum, das ein exakter Cache sparen kann.

## Das Wichtigste in Kürze

-   Ein exakter Cache spart den ganzen Aufruf, Output- und Reasoning-Tokens inklusive, aber nur bei byte-identischen Anfragen. Umformulierte Fragen verfehlen ihn immer.
-   Nehmen Sie jeden Parameter, der die Antwort verändert, in den Schlüssel auf, dazu eine Prompt-Version. Fehlt einer, werden falsche Antworten ausgeliefert; Rauschen wie ein Zeitstempel lässt jede Anfrage verfehlen.
-   Cachen Sie keine gesampelten Antworten (temperature über 0), keine gestreamten Antworten, keine Tool Calls und keine Antworten, die bei max\_tokens abgeschnitten wurden.
-   Zuerst messen: Hashen Sie jede Anfrage in Ihren Nutzungs-Logs und zählen Sie Wiederholungen. Veröffentlichte Einsparzahlen sagen nichts über Ihren Traffic.
-   Ein Cache speichert Prompts und Antworten. Speichert Ihr Anbieter keine Inferenz-Inhalte, liegen diese Inhalte jetzt im Cache; geben Sie ihm also eine TTL und Zugriffsregeln.

**Auf dieser Seite**

1.  Ist Response Caching dasselbe wie Prompt Caching?
2.  Spart ein Cache tatsächlich Geld?
3.  Was gehört in den Cache-Schlüssel?
4.  Der Cache: SQLite, TTL und eine Ausnahmeregel
5.  Was sollte nie aus einem Cache ausgeliefert werden?
6.  Wann sollten gecachte Antworten ablaufen?
7.  Was ist mit Semantic Caching?
8.  Was bedeutet ein Cache für den Datenschutz?
9.  Wie passt Caching zu anderen Maßnahmen der Kostenkontrolle?
10.  Wo BroadNet Inference hineinpasst

Jede identische LLM-Anfrage, die Sie zweimal senden, bezahlen Sie zweimal. Ein Response-Cache speichert die Antwort beim ersten Mal und liefert sie beim nächsten Mal aus, ohne abgerechnete Tokens und ohne Wartezeit. Die Idee ist einfach. Schwierig ist zu entscheiden, was zwei Anfragen „identisch“ macht, welche Anfragen nie aus dem Speicher bedient werden dürfen und ob sich Ihr Traffic oft genug wiederholt, dass es sich lohnt.

Dieser Beitrag baut einen kleinen Exact-Match-Cache in Python auf SQLite, getestet gegen einen Mock-Server mit OpenAI-kompatibler API, und zeigt, wie Sie die Trefferquote aus Ihren Logs messen, bevor Sie eine Zeile davon schreiben.

## Ist Response Caching dasselbe wie Prompt Caching?

Nein. Beide sparen Unterschiedliches, und Sie können beide nutzen.

|  | Prompt Caching (Anbieter) | Response Caching (Sie) |
| --- | --- | --- |
| Was wiederverwendet wird | Der wiederholte Anfang des Prompts | Die ganze Antwort |
| Wer es betreibt | Der API-Anbieter | Ihr Code |
| Läuft das Modell trotzdem? | Ja, es schreibt eine neue Antwort | Nein |
| Was es spart | Einen Teil der Input-Kosten | Input-, Output- und Reasoning-Tokens, dazu Latenz |
| Wann es trifft | Gemeinsames Präfix, unterschiedliche Fragen | Exakt dieselbe Anfrage |

[Gecachte Input-Tokens](https://broadrouter.com/de/blog/cached-input-tokens-explained/) erklärt die Seite des Anbieters, und [Prompt-Struktur für Caching](https://broadrouter.com/de/blog/prompt-structure-for-caching/) zeigt, wie Sie einen Prompt so aufbauen, dass das Präfix wiederverwendet wird. Der [Prompt-Caching-Rechner](https://broadrouter.com/tools/prompt-caching-calculator/) beziffert es. Ein Response-Cache sitzt vor all dem: Bei einem Treffer verlässt keine Anfrage Ihren Server.

## Spart ein Cache tatsächlich Geld?

Messen Sie, bevor Sie bauen. Die Einsparquoten in vielen Caching-Tutorials stammen aus dem Traffic anderer Leute. Ihre Zahl hängt von einer Sache ab: wie oft dieselbe Anfrage innerhalb Ihres Ablauffensters erneut eintrifft.

Loggen Sie bereits jeden Aufruf, wie in [Nutzungs-Logging für LLM-APIs](https://broadrouter.com/de/blog/llm-api-usage-logging/), ergänzen Sie ein Feld: `request_hash`, den unten beschriebenen Cache-Schlüssel. Es speichert keinen Prompt-Text und passt daher in ein Log, das Inhalte draußen hält. Zählen Sie dann die Wiederholungen:

```python
import json
from collections import Counter

def potential_hit_rate(log_path: str) -> float:
    """Share of calls whose request_hash was already seen: an upper bound for an exact cache."""
    hashes = [json.loads(line)["request_hash"] for line in open(log_path)]
    seen, repeats = set(), 0
    for h in hashes:
        repeats += h in seen
        seen.add(h)
    print("top repeated requests:", Counter(hashes).most_common(3))
    return repeats / len(hashes) if hashes else 0.0

print(f"potential hit rate: {potential_hit_rate('calls.jsonl'):.1%}")
```

Auf einem synthetischen Log mit 20 Aufrufen, eine Anfrage fünfmal, eine andere dreimal und zwölf einzigartige, gab es eine potenzielle Trefferquote von 30,0 % aus. Das ist eine Obergrenze: Sie ignoriert den Ablauf und nimmt an, dass jede Wiederholung gefahrlos aus dem Speicher bedient werden kann.

Rechnen Sie die Quote dann in Geld um:

```text
monthly saving = hit rate × requests per month
                 × (input tokens × input price + output tokens × output price) ÷ 1,000,000
```

(Monatliche Ersparnis = Trefferquote × Anfragen pro Monat × (Input-Tokens × Input-Preis + Output-Tokens × Output-Preis) ÷ 1.000.000.)

Output-Tokens schließen Reasoning ein. Laut der Dokumentation von BroadNet denken DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B vor der Antwort nach, und Reasoning zählt zu `max_tokens`; ein Treffer spart also Tokens, die Sie in der Antwort nie sehen. Nehmen Sie `completion_tokens` aus der geloggten `usage`, nicht die Länge der Antwort.

Ein Rechenbeispiel in Tokens: 100.000 Anfragen im Monat mit je 1.200 Input- und 150 Output-Tokens vermeiden bei 30 % Trefferquote 36 Millionen Input-Tokens und 4,5 Millionen Output-Tokens. Bei [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) werden diese mit $0.175 bzw. $0.52 pro 1 Mio. abgerechnet; setzen Sie Ihre eigenen Zahlen in den [LLM-API-Kostenrechner](https://broadrouter.com/tools/llm-api-cost-calculator/) ein. War der größte Teil dieses Inputs bereits ein Cache-Treffer beim Anbieter, liegt die Input-Ersparnis beim niedrigeren Cache-Preis ($0.0055 pro 1 Mio. beim selben Modell); oft zählt also vor allem die Output-Seite.

## Was gehört in den Cache-Schlüssel?

Alles, was die Antwort verändern kann, und sonst nichts.

-   **Aufnehmen:** `model`, die vollständige `messages`\-Liste (inklusive System-Prompt), `temperature`, `top_p`, `max_tokens`, `seed`, `response_format`, `tools`, `tool_choice` und `reasoning_effort`.
-   **Eine Prompt-Version ergänzen**, die Sie kontrollieren, etwa `faq-v3`. Erhöhen Sie sie, wenn Sie Prompt-Templates, Retrieval-Daten oder Nachverarbeitung ändern, die der Anfragekörper nicht zeigt.
-   **Weglassen**, was sich pro Aufruf ändert, ohne die Antwort zu verändern: Request-IDs, Zeitstempel, Trace-Header, ein `user`\-Feld, das Sie nur zur Missbrauchserkennung senden.

Serialisieren Sie das Schlüsselmaterial jedes Mal gleich. Pythons `json.dumps` mit `sort_keys=True` und `separators=(",", ":")` liefert unabhängig von der Reihenfolge im Dictionary einen kanonischen String; `ensure_ascii=False` behält Arabisch und andere nichtlateinische Texte als UTF-8 statt als Escapes. Hashen Sie ihn mit SHA-256.

Ein fehlendes Feld ist der gefährliche Fehler. Steht `max_tokens` nicht im Schlüssel, wird eine Antwort, die unter einem kleinen Limit abgeschnitten wurde, an eine Anfrage ausgeliefert, die eine lange erlaubt hat.

## Der Cache: SQLite, TTL und eine Ausnahmeregel

```python
import hashlib, json, sqlite3, time

# Every field that changes the answer belongs in the key.
KEY_FIELDS = ("model", "messages", "temperature", "top_p", "max_tokens", "seed",
              "response_format", "tools", "tool_choice", "reasoning_effort")

def cache_key(params: dict, prompt_version: str) -> str:
    material = {k: params[k] for k in KEY_FIELDS if k in params}
    material["prompt_version"] = prompt_version
    canon = json.dumps(material, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
    return hashlib.sha256(canon.encode("utf-8")).hexdigest()

class ResponseCache:
    def __init__(self, path="llm_cache.sqlite", ttl_s=7 * 86400):
        self.db, self.ttl = sqlite3.connect(path), ttl_s
        self.db.execute("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, created REAL,"
                        " body TEXT, prompt_tokens INT, completion_tokens INT)")
        self.hits = self.misses = self.skips = self.saved_in = self.saved_out = 0

    def create(self, client, prompt_version: str, **params):
        if params.get("stream") or params.get("temperature", 1) > 0:
            self.skips += 1                       # not cacheable: call the model directly
            return client.chat.completions.create(**params)
        k = cache_key(params, prompt_version)
        row = self.db.execute("SELECT body, created, prompt_tokens, completion_tokens"
                              " FROM cache WHERE k = ?", (k,)).fetchone()
        if row and time.time() - row[1] < self.ttl:
            self.hits += 1; self.saved_in += row[2]; self.saved_out += row[3]
            return json.loads(row[0])             # a plain dict, not an SDK object
        self.misses += 1
        r = client.chat.completions.create(**params)
        choice = r.choices[0]
        if choice.finish_reason == "stop" and not choice.message.tool_calls:
            self.db.execute("INSERT OR REPLACE INTO cache VALUES (?, ?, ?, ?, ?)",
                            (k, time.time(), r.model_dump_json(),
                             r.usage.prompt_tokens, r.usage.completion_tokens))
            self.db.commit()
        return r.model_dump()
```

Und ein Durchlauf damit:

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
cache = ResponseCache("demo.sqlite", ttl_s=86400)
SYSTEM = {"role": "system", "content": "Answer questions about our refund policy in one sentence."}
questions = ["How long do refunds take?", "Can I refund a gift card?",
             "How long do refunds take?", "How long do refunds take?", "Can I refund a gift card?"]
for q in questions:
    r = cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0,
                     max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": q}])
    print(r["choices"][0]["message"]["content"])
# a personalised, sampled request is never cached
cache.create(client, "faq-v3", model="broadnet/deepseek-v4.1-flash", temperature=0.7,
             messages=[SYSTEM, {"role": "user", "content": "Write me a friendly reminder"}])
# a new prompt version is a new key
cache.create(client, "faq-v4", model="broadnet/deepseek-v4.1-flash", temperature=0,
             max_tokens=1200, messages=[SYSTEM, {"role": "user", "content": "How long do refunds take?"}])
print(f"hits={cache.hits} misses={cache.misses} skipped={cache.skips} "
      f"saved_input={cache.saved_in} saved_output={cache.saved_out}")
```

Wir haben das mit dem OpenAI Python SDK 3.51.0 gegen einen lokalen Mock-Server ausgeführt, der die Upstream-Aufrufe zählte und pro Antwort 1.200 Prompt- und 150 Completion-Tokens meldete (kein Aufruf der echten API). Sieben Anfragen erzeugten vier Upstream-Aufrufe. Das Skript gab `hits=3 misses=3 skipped=1 saved_input=3600 saved_output=450` aus. Bei einem erneuten Lauf auf derselben Datenbankdatei waren alle sechs cachebaren Anfragen Treffer (`hits=6 misses=0`): SQLite behält den Cache über Neustarts hinweg. Schlüssel, die aus denselben Feldern in anderer Reihenfolge gebaut wurden, stimmten überein.

Hinweise zum Code:

-   **`max_tokens=1200`** lässt Raum für Reasoning vor der Antwort. Mit einem kleinen Limit kann ein Reasoning-Modell eine leere Antwort liefern ([warum](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)). Solche Antworten werden nicht gespeichert, weil `finish_reason` dann `length` ist, nicht `stop`.
-   **Treffer liefern ein Dict.** Fehltreffer liefern ebenfalls `model_dump()`, Aufrufer sehen also eine einheitliche Form. Erwartet Ihr Code SDK-Objekte, verpacken Sie beides.
-   **Ein fehlendes `temperature` gilt als gesampelt.** Der Server wendet dann seinen eigenen Standardwert an, der über 0 liegen kann; der Wrapper cacht also nur, wenn Sie 0 ausdrücklich setzen.
-   **SQLite passt für einen oder wenige Prozesse.** Für mehrere Server legen Sie dieselbe Schlüssel- und TTL-Logik in Redis oder Ihre Datenbank.

## Was sollte nie aus einem Cache ausgeliefert werden?

-   **Gesampelte Antworten (temperature über 0).** Sie haben sich für Vielfalt entschieden. Caching nimmt sie weg, und wer auf „neu generieren“ drückt, bekommt denselben Text.
-   **Personalisierte Antworten**, sofern die Nutzer-ID nicht im Schlüssel steht. Zwei Nutzer, die „fasse mein Konto zusammen“ senden, haben unterschiedliche Konten. Besser: Cachen Sie nur Anfragen, deren Nachrichten keine nutzerbezogenen Daten enthalten.
-   **Tool Calls.** Ein [Tool Call](https://broadrouter.com/de/glossary/tool-calling/) ist eine Anweisung zu handeln. „Bestellung 1182 erstatten“ aus dem Speicher erneut abzuspielen, kann eine Nebenwirkung wiederholen, und der richtige nächste Schritt hängt vom aktuellen Zustand ab. Der Wrapper speichert keine Antwort mit `tool_calls`.
-   **Gestreamte Antworten.** Der Wrapper umgeht den Cache bei `stream=True`. Einen Stream zu cachen heißt, ihn zu puffern, zu prüfen, ob er fertig wurde, und ihn wiederzugeben; für Chat-Oberflächen lohnt sich das selten.
-   **Abgeschnittene oder fehlgeschlagene Antworten.** Speichern Sie nur `finish_reason == "stop"`. Eine abgeschnittene Antwort oder ein Fehler, eine Woche lang gecacht, ist ein Bug, der wie ein Modellproblem aussieht.
-   **Zeitabhängige Antworten.** „Wie ist der Wechselkurs heute?“ braucht eine kurze TTL oder gar keinen Cache.

Gut cachen lassen sich: Klassifikation einer festen Menge von Eingaben, Extraktion aus Dokumenten, die Sie erneut verarbeiten, FAQ-Antworten aus einem festen Prompt, Testsuiten und Evals, die Sie wiederholt ausführen, und Entwicklungsschleifen, in denen Sie dieselbe Anfrage immer wieder senden.

## Wann sollten gecachte Antworten ablaufen?

Nutzen Sie drei Arten der Invalidierung:

1.  **TTL.** Ein Zeitlimit pro Eintrag: Tage für stabile FAQ-Antworten, Minuten für alles, was Live-Daten liest.
2.  **Version im Schlüssel.** Ändern Sie die Prompt-Version, wenn sich System-Prompt, Retrieval-Index oder Ausgabeschema ändern. Alte Einträge passen dann nicht mehr und laufen aus.
3.  **Modell im Schlüssel.** Es steht bereits darin; ein Wechsel von einem Modell zum anderen beginnt also mit einem frischen Cache, und genau das wollen Sie, während Sie [einen Wechsel evaluieren](https://broadrouter.com/de/blog/evaluate-llm-before-switching/).

Löschen Sie abgelaufene Zeilen regelmäßig (`DELETE FROM cache WHERE created < ?`). Sonst wächst die Datei nur.

Es gibt einen Nebeneffekt. Serving-Engines versprechen keinen identischen Output bei identischem Input: Die Dokumentation von vLLM sagt, es „does not guarantee the reproducibility of the results by default“ (Übersetzung: „garantiert standardmäßig keine Reproduzierbarkeit der Ergebnisse“). Ein Cache gibt jedem Nutzer für die Lebensdauer des Eintrags dieselbe Antwort auf dieselbe Frage.

## Was ist mit Semantic Caching?

Ein Semantic Cache bettet jede Frage ein und liefert eine gespeicherte Antwort, wenn eine neue Frage nah genug liegt; so kann „wie lange dauert eine Erstattung?“ auf „wie lange dauern Erstattungen?“ treffen. GPTCache ist das bekannteste Open-Source-Beispiel. Seine README sagt, dass es einen Vektorspeicher für die Ähnlichkeitssuche und eine Ähnlichkeitsbewertung zur Entscheidung über einen Treffer nutzt, warnt, „you may encounter false positives during cache hits and false negatives during cache misses“ (Übersetzung: „bei Cache-Treffern können False Positives und bei Fehltreffern False Negatives auftreten“), und merkt an, dass es ohne Embeddings zu einem Keyword-Matching-Cache wird.

Zwei praktische Punkte. Erstens braucht es ein [Embedding](https://broadrouter.com/de/glossary/embeddings/)\-Modell und einen Vektorspeicher. BroadNet Inference bietet keine Embeddings an; für diese Schicht würden Sie also einen anderen Anbieter oder ein lokales Modell nutzen. Der [Rechner für Embedding-Kosten](https://broadrouter.com/tools/embedding-cost-calculator/) beziffert die Optionen. Zweitens liefert ein falscher Treffer eine selbstsichere Antwort auf eine andere Frage. Nutzen Sie einen strengen Ähnlichkeitsschwellenwert, testen Sie ihn an echten Beinahe-Treffer-Paaren und beschränken Sie Semantic Caching auf Antworten mit geringem Risiko. Setzen Sie in jedem Fall den exakten Cache davor: Seine Prüfung kostet nichts, und er irrt sich nie darüber, was gefragt wurde.

## Was bedeutet ein Cache für den Datenschutz?

Ein Cache ist ein Speicher für Prompts und Antworten. Das ändert, wo Ihre Daten liegen.

Die [Datenschutzerklärung von BroadNet zur Inferenz](https://www.broadnet.ai/inference-privacy), geprüft am 15.11.2026, sagt, dass das Gateway keine Prompts, Nachrichten, Antworten oder Transkripte speichert, während inhaltsfreie Traffic- und Nutzungsdatensätze (Token-Zahlen, Kosten, Zeiten) aufbewahrt werden. Inferenz-Inhalte werden nicht gespeichert. Notwendige Konto-, Abrechnungs- und Sicherheitsmetadaten werden so aufbewahrt, wie es die Erklärung beschreibt. Sobald Sie einen Response-Cache ergänzen, hält Ihr System die Inhalte, die der Anbieter nicht hält. Behandeln Sie ihn wie jeden anderen Speicher für Nutzerdaten:

-   Cachen Sie nach Möglichkeit nur Anfragen ohne personenbezogene Daten; das erhöht auch die Trefferquote.
-   Setzen Sie eine TTL, die kurz genug für Ihre Aufbewahrungsrichtlinie ist, und löschen Sie planmäßig.
-   Verschlüsseln Sie die Datei oder Tabelle im Ruhezustand und beschränken Sie, wer sie lesen darf.
-   Beziehen Sie den Cache in Löschanfragen ein, wenn er Nutzertext enthalten kann.

[Sensible Daten an eine LLM-API senden](https://broadrouter.com/de/blog/llm-api-sensitive-data/) behandelt den Rest dieser Checkliste.

## Wie passt Caching zu anderen Maßnahmen der Kostenkontrolle?

Caching entfernt wiederholte Aufrufe. Bei einzigartigen bewirkt es nichts; es steht also neben den anderen Maßnahmen, statt sie zu ersetzen: [kürzere Prompts](https://broadrouter.com/de/blog/reduce-prompt-tokens/), Prompt Caching beim Anbieter, eine `max_tokens`\-Obergrenze pro Anfrage sowie Budgets und Schleifenlimits aus [LLM-API-Kostenkontrolle](https://broadrouter.com/de/blog/llm-api-spend-control/). Bei großen einmaligen Jobs deduplizieren Sie die Eingaben, bevor Sie sie senden; das ist dieselbe Idee wie ein Cache, nur einmal ausgeführt. [Einen großen Job ohne Batch API verarbeiten](https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/) zeigt die Job-Seite.

Bei einem Flatrate-Plan ändert sich die Rechnung. Die DeepSeek-Sessions von BroadNet haben keinen Token-Zähler, ein Cache-Treffer spart dort also kein Geld. Er spart aber Zeit: Eine Session verarbeitet eine Anfrage gleichzeitig, jede Wiederholung, die Sie überspringen, macht die Session also für neue Arbeit frei.

## Wo BroadNet Inference hineinpasst

BroadRouter ist die eigene Website von BroadNet. BroadNet Inference stellt DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B und Gemma 4 VL 26B hinter einem OpenAI-kompatiblen Endpoint `/v1/chat/completions` bereit; der Wrapper oben funktioniert also mit dem [OpenAI Python SDK](https://broadrouter.com/de/guides/openai-python-sdk/), wenn Sie die Basis-URL ändern. Eine eigene Funktion für Response Caching hat es nicht; der Cache in diesem Beitrag gehört Ihnen. Cache-Treffer beim Anbieter werden laut der [API-Referenz](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-cache-llm-responses-cut-cost&utm_content=body) in `usage.prompt_tokens_details.cached_tokens` gemeldet und zum Preis für gecachten Input abgerechnet. Die Preise pro Modell stehen auf der [Preisseite](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-cache-llm-responses-cut-cost&utm_content=body).

Kostenlose Tools zum Thema (auf Englisch)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[Gecachte Input-Tokens (Cached Input Tokens)](https://broadrouter.com/de/glossary/cached-input-tokens/)

Gecachte Input-Tokens sind Prompt-Tokens, die ein LLM-Anbieter kürzlich verarbeitet hat und aus einem Cache wiederverwenden kann, statt sie neu zu berechnen, meist ein wiederholtes Präfix wie ein System-Prompt oder ein Dokument. Anbieter berechnen sie günstiger als neue Input-Tokens.

[Token](https://broadrouter.com/de/glossary/token/)

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

[Input- und Output-Tokens](https://broadrouter.com/de/glossary/input-and-output-tokens/)

Input-Tokens sind die Tokens, die ein Sprachmodell in einer Anfrage liest, einschließlich System-Prompt, Gesprächsverlauf, Tool-Definitionen und Bildern. Output-Tokens sind die Tokens, die es als Antwort erzeugt, einschließlich Reasoning. LLM-APIs berechnen beide meist getrennt, und Output ist in der Regel teurer.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Embeddings](https://broadrouter.com/de/glossary/embeddings/)

Embeddings sind Listen von Gleitkommazahlen (Vektoren), die ein Modell erzeugt, um einen Text, ein Bild oder einen anderen Input darzustellen. Inputs mit ähnlicher Bedeutung erhalten nah beieinanderliegende Vektoren; über den Abstand lassen sich Suchergebnisse ranken, Dokumente clustern oder verwandte Elemente finden.

[Eval (LLM-Evaluierung)](https://broadrouter.com/de/glossary/eval/)

Ein Eval (kurz für Evaluation) ist ein wiederholbarer Test eines Sprachmodells oder Prompts: eine feste Menge an Inputs, eine Beschreibung, wie ein guter Output aussieht, und ein Bewerter (Code, ein Mensch oder ein anderes Modell), der jeden Output benotet, damit sich Versionen vergleichen lassen.

[Vektordatenbank (vector database)](https://broadrouter.com/de/glossary/vector-database/)

Eine Vektordatenbank ist ein Datenspeicher für Embedding-Vektoren, oft zusammen mit Quelltext und Metadaten, der Nearest-Neighbour-Abfragen beantwortet: Zu einem Anfragevektor liefert sie die ähnlichsten gespeicherten Vektoren, meist nach Kosinus-Distanz, euklidischer Distanz oder Skalarprodukt.

[Wortfehlerrate (Word Error Rate, WER)](https://broadrouter.com/de/glossary/word-error-rate/)

Die Wortfehlerrate (WER) ist das Standardmaß für die Genauigkeit der Spracherkennung: die Zahl der Wortersetzungen, -löschungen und -einfügungen, die nötig sind, um ein Transkript in die korrekte Referenz zu verwandeln, geteilt durch die Zahl der Wörter in der Referenz. Niedriger ist besser.

## Häufige Fragen

### Was ist der Unterschied zwischen Prompt Caching und Response Caching?

Prompt Caching übernimmt der Anbieter: Ein wiederholtes Prompt-Präfix wird zum niedrigeren Preis für gecachten Input abgerechnet, und das Modell schreibt trotzdem eine neue Antwort. Response Caching übernehmen Sie: Sie speichern die ganze Antwort und liefern sie bei einer identischen Anfrage aus, ohne das Modell überhaupt aufzurufen.

### Sollte ich LLM-Antworten bei temperature 0 cachen?

Ja, wenn die Anfrage keine Nebenwirkungen hat und dieselbe Antwort für alle akzeptabel ist, die sie senden. Temperature 0 garantiert ohnehin keinen identischen Output einer Serving-Engine, ein Cache macht die Antwort also auch konsistent. Verzichten Sie aufs Caching, wenn temperature über 0 liegt oder fehlt.

### Wie viel spart Response Caching bei LLMs?

Den Anteil der Anfragen, die innerhalb Ihres Ablauffensters exakte Wiederholungen sind, multipliziert mit den Kosten dieser Anfragen. Zählen Sie wiederholte Anfrage-Hashes in Ihren eigenen Logs, um diesen Anteil zu ermitteln. Bei offenem Chat kann er nahe null liegen, bei festen FAQ- oder Klassifikations-Eingaben hoch.

### Ist Semantic Caching besser als Exact-Match-Caching?

Es trifft öfter, weil ähnliche Fragen übereinstimmen, kann aber eine Antwort auf eine andere Frage liefern. Außerdem braucht es ein Embedding-Modell und einen Vektorspeicher. Beginnen Sie mit einem exakten Cache und ergänzen Sie eine semantische Schicht nur dort, wo ein falscher Treffer wenig kostet.

### Kann ich gestreamte Antworten cachen?

Nicht mit dem einfachen Wrapper hier. Sie müssten den vollständigen Stream sammeln, prüfen, ob er normal beendet wurde, ihn speichern und später als Stream wiedergeben. Die meisten Teams cachen nur Aufrufe ohne Streaming, etwa Klassifikation, Extraktion und FAQ-Antworten.

## Weiterlesen

-   [Gecachte Input-Tokens: So senken Sie die Rechnung Ihrer LLM-API](https://broadrouter.com/de/blog/cached-input-tokens-explained/)
-   [Prompts so strukturieren, dass das Präfix gecacht wird](https://broadrouter.com/de/blog/prompt-structure-for-caching/)
-   [LLM-API-Kosten kontrollieren: Budgets, Key-Limits und Loop-Schutz](https://broadrouter.com/de/blog/llm-api-spend-control/)
-   [Prompt-Tokens reduzieren: gemessene Effekte bei Prompts, Tools, Daten](https://broadrouter.com/de/blog/reduce-prompt-tokens/)
-   [LLM-API-Nutzung loggen: Kosten pro Nutzer und Feature, ohne PII](https://broadrouter.com/de/blog/llm-api-usage-logging/)
-   [LLM-Batch-Verarbeitung ohne Batch API: ein fortsetzbarer Runner](https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [Menschliche Prüfung als festen Teil Ihres Dokumenten-KI-Workflows](https://broadrouter.com/de/blog/document-review-queues/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-cache-llm-responses-cut-cost&utm_content=page-cta) ·

**Quellen**

-   [API-Referenz von BroadNet Inference: Reasoning zählt zu max\_tokens, Nutzungsfelder für Reasoning und gecachte Tokens, Pay-as-you-go-Limits (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-cache-llm-responses-cut-cost&utm_content=sources)
-   [Datenschutzerklärung von BroadNet zur Inferenz: keine Prompts, Nachrichten, Antworten oder Transkripte gespeichert; inhaltsfreie Traffic- und Nutzungsdatensätze werden aufbewahrt (geprüft am 2026-11-15) (auf Englisch)](https://www.broadnet.ai/inference-privacy)
-   [GPTCache auf GitHub: Semantic Cache mit Embeddings und Ähnlichkeitsbewertung, False Positives und False Negatives, Keyword-Matching-Modus ohne Embeddings (geprüft am 2026-11-15)](https://github.com/zilliztech/GPTCache)
-   [vLLM-Dokumentation, Reproducibility: „vLLM does not guarantee the reproducibility of the results by default“ (Übersetzung: „vLLM garantiert standardmäßig keine Reproduzierbarkeit der Ergebnisse“) (geprüft am 2026-11-15)](https://docs.vllm.ai/en/latest/usage/reproducibility.html)
-   [Python-Dokumentation, Modul json: sort\_keys, separators und ensure\_ascii in json.dumps (geprüft am 2026-11-15)](https://docs.python.org/3/library/json.html)
