BroadRouter

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

Vom Team von BroadNet Inference · 8 Min. Lesezeit · Veröffentlicht

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.

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 erklärt die Seite des Anbieters, und Prompt-Struktur für Caching zeigt, wie Sie einen Prompt so aufbauen, dass das Präfix wiederverwendet wird. Der Prompt-Caching-Rechner 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, 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:

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:

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 werden diese mit $0.175 bzw. $0.52 pro 1 Mio. abgerechnet; setzen Sie Ihre eigenen Zahlen in den LLM-API-Kostenrechner 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

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:

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). 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 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.

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-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 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, 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 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, Prompt Caching beim Anbieter, eine max_tokens-Obergrenze pro Anfrage sowie Budgets und Schleifenlimits aus LLM-API-Kostenkontrolle. 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 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, 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 in usage.prompt_tokens_details.cached_tokens gemeldet und zum Preis für gecachten Input abgerechnet. Die Preise pro Modell stehen auf der Preisseite.

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.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen