Prompt Caching: Der Trick der Ihre LLM-Kosten durch 10 teilt

Explodiert Ihre LLM-Rechnung? Senden Sie die gleichen System-Anweisungen, die gleichen Few-Shot-Beispiele, den gleichen RAG-Kontext bei jeder Anfrage? Es gibt eine Lösung die Ihre Kosten um 90% bei Anthropic und 50% bei OpenAI senken kann -- und die meisten Entwickler nutzen sie noch nicht.

Willkommen in der Welt des Prompt Caching.

TL;DR

• Prompt Caching = der LLM-Anbieter speichert den Präfix Ihres Prompts im Cache, damit er nicht bei jeder Anfrage neu verarbeitet wird
• Anthropic: -90% auf gecachte Tokens (am aggressivsten), Minimum 1.024 Tokens, TTL 5 Minuten
• OpenAI: -50% auf gecachte Tokens, vollautomatisch, Minimum 1.024 Tokens
• Google: -75% auf gecachte Tokens, explizites Context Caching, Minimum 32.768 Tokens
• Für RAG: System-Prompt + Few-Shot-Beispiele + statischen Kontext cachen, nur die Query variieren
• Typische Einsparungen: 40-80% Reduktion der monatlichen LLM-Rechnung

Wie Prompt Caching funktioniert

Das Prinzip: Prefix Matching

Bei jedem LLM-Aufruf vergleicht der Anbieter den Anfang Ihres Prompts mit kürzlichen Prompts. Wenn ein identischer Präfix im Cache gefunden wird, wird nur der neue Teil zum vollen Preis verarbeitet.

Anfrage 1:
┌──────────────────────────────────────────────────────────┐
│ System-Prompt (2000 Tokens) │ Few-Shots (1000) │ Query 1 │
│ ████████████████████████████ │ ████████████████ │ ████    │
│        Normal verarbeitet        │                │         │
└──────────────────────────────────────────────────────────┘
Kosten: 3000 Tokens × Normalpreis = $0,045

Anfrage 2 (gleicher Präfix):
┌──────────────────────────────────────────────────────────┐
│ System-Prompt (2000 Tokens) │ Few-Shots (1000) │ Query 2 │
│ ░░░░░░░░░░░░░░░░░░░░░░░░░░ │ ░░░░░░░░░░░░░░░ │ ████    │
│        IM CACHE (reduzierter Preis)│               │ Normal  │
└──────────────────────────────────────────────────────────┘
Kosten: 3000 Tokens × Cache-Preis + 50 Tokens × Normalpreis = deutlich weniger

Bedingungen für Cache-Hits

Anthropic: Der Caching-Champion (-90%)

Funktionsweise

Anthropic bietet die aggressivste Reduktion: 90% Rabatt auf gecachte Tokens, mit einem leichten 25%-Aufschlag beim initialen Cache-Schreiben.

Detaillierte Preise: Claude 3.5 Sonnet

Anthropic-Implementierung

DEVELOPERpython
import anthropic

client = anthropic.Anthropic()

# Der System-Prompt wird nach dem ersten Aufruf gecacht
SYSTEM_PROMPT = """Du bist ein Experten-Assistent für {company_name}.
Du antwortest nur anhand der bereitgestellten Dokumente.
Du zitierst immer deine Quellen mit [Quelle: dokumentname].
Du halluzinierst niemals. Wenn du es nicht weißt, sage es.

## Formatierungsregeln
- Knappe Antworten (maximal 3-5 Sätze)
- Verwende Aufzählungszeichen für Listen
- Zitiere die Quelle in eckigen Klammern

## Erwartete Antwortbeispiele

F: Was ist die Rückgaberichtlinie?
A: Unsere Rückgaberichtlinie erlaubt Rückgaben innerhalb von 30 Tagen
   für jeden unbenutzten Artikel [Quelle: rueckgaberichtlinie.pdf].
   Rücksendekosten trägt der Kunde, außer bei Produktmängeln
   [Quelle: AGB-2026.pdf].

F: Wie konfiguriere ich SSO?
A: Um SSO zu konfigurieren, gehen Sie zu Einstellungen > Sicherheit > SSO.
   Wählen Sie Ihren Anbieter (Okta, Azure AD, Google)
   und fügen Sie die Metadaten-URL ein [Quelle: admin-handbuch.pdf].
""" + context_documents

def query_with_caching(user_query: str, rag_context: str):
    """Anfrage mit Anthropic Prompt Caching."""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": SYSTEM_PROMPT,
                "cache_control": {"type": "ephemeral"}  # Cache aktivieren
            }
        ],
        messages=[
            {
                "role": "user",
                "content": f"RAG-Kontext:\n{rag_context}\n\nFrage: {user_query}"
            }
        ],
    )

    # Cache-Hit prüfen
    usage = response.usage
    print(f"Cache gelesen: {usage.cache_read_input_tokens} Tokens")
    print(f"Cache geschrieben: {usage.cache_creation_input_tokens} Tokens")
    print(f"Ungecachter Input: {usage.input_tokens} Tokens")

    return response.content[0].text

Multi-Breakpoint-Strategie bei Anthropic

DEVELOPERpython
def query_with_multi_cache(user_query: str, rag_context: str):
    """Mehrere Cache-Ebenen für maximale Einsparungen."""
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": STATIC_SYSTEM_PROMPT,  # Ändert sich selten
                "cache_control": {"type": "ephemeral"}
            },
            {
                "type": "text",
                "text": FEW_SHOT_EXAMPLES,  # Ändert sich manchmal
                "cache_control": {"type": "ephemeral"}
            }
        ],
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": rag_context,  # Ändert sich oft aber geteilt
                        "cache_control": {"type": "ephemeral"}
                    },
                    {
                        "type": "text",
                        "text": user_query,  # Immer einzigartig
                    }
                ]
            }
        ],
    )
    return response

OpenAI: Automatisches Caching (-50%)

Funktionsweise

OpenAI hat automatisches Caching eingeführt: keine Konfiguration nötig, das System erkennt und cached identische Präfixe automatisch.

Detaillierte Preise: GPT-4o

OpenAI-Implementierung

DEVELOPERpython
from openai import OpenAI

client = OpenAI()

# Caching ist bei OpenAI AUTOMATISCH
# Einfach den Prompt mit stabilem Präfix strukturieren

SYSTEM_PROMPT = """Du bist ein Experten-Assistent für {company_name}.
... (gleicher langer System-Prompt) ...
"""

def query_with_openai_caching(user_query: str, rag_context: str):
    """Caching ist automatisch - Präfix einfach identisch halten."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": f"Kontext:\n{rag_context}"},
            {"role": "assistant", "content": "Kontext notiert."},
            {"role": "user", "content": user_query},
        ],
        max_tokens=1024,
    )

    # Gecachte Tokens in der Nutzung prüfen
    usage = response.usage
    cached = getattr(usage, 'prompt_tokens_details', {})
    if cached:
        print(f"Gecachte Tokens: {cached.get('cached_tokens', 0)}")

    return response.choices[0].message.content

Cache-Hit-Rate bei OpenAI maximieren

DEVELOPERpython
# SCHLECHT: Nachrichtenreihenfolge ändert sich → kein Cache-Hit
messages_v1 = [
    {"role": "system", "content": SYSTEM},
    {"role": "user", "content": f"Kontext: {context_A}\nFrage: {query_1}"},
]
messages_v2 = [
    {"role": "system", "content": SYSTEM},
    {"role": "user", "content": f"Kontext: {context_B}\nFrage: {query_2}"},
]
# context_A ≠ context_B → Cache-Miss ab der 2. Nachricht

# GUT: stabilen und variablen Kontext trennen
messages_v1 = [
    {"role": "system", "content": SYSTEM},  # ← Immer identisch
    {"role": "user", "content": "Kontext: " + STATIC_CONTEXT},  # ← Identisch
    {"role": "assistant", "content": "OK."},
    {"role": "user", "content": query_1},  # ← Einziges variables Element
]
messages_v2 = [
    {"role": "system", "content": SYSTEM},  # ← Cache-Hit!
    {"role": "user", "content": "Kontext: " + STATIC_CONTEXT},  # ← Cache-Hit!
    {"role": "assistant", "content": "OK."},
    {"role": "user", "content": query_2},  # ← Einziges variables Element
]

Google: Explizites Context Caching (-75%)

Funktionsweise

Google bietet explizites Context Caching mit konfigurierbaren TTLs und 75% Rabatt.

Detaillierte Preise: Gemini 1.5 Pro

Google-Implementierung

DEVELOPERpython
import google.generativeai as genai
from google.generativeai import caching
import datetime

genai.configure(api_key="GOOGLE_API_KEY")

# Expliziten Cache erstellen
cache = caching.CachedContent.create(
    model="models/gemini-1.5-pro-002",
    display_name="rag-system-prompt",
    system_instruction=SYSTEM_PROMPT,
    contents=[
        # Statischen RAG-Kontext vorladen (muss > 32K Tokens sein)
        {"role": "user", "parts": [{"text": LARGE_RAG_CONTEXT}]},
        {"role": "model", "parts": [{"text": "Kontext geladen."}]},
    ],
    ttl=datetime.timedelta(hours=1),  # 1 Stunde cachen
)

# Cache für Anfragen nutzen
model = genai.GenerativeModel.from_cached_content(cached_content=cache)

def query_with_google_caching(user_query: str):
    """Anfrage mit Google Context Cache."""
    response = model.generate_content(user_query)

    # Cache-Nutzung prüfen
    print(f"Gecachte Tokens: {response.usage_metadata.cached_content_token_count}")
    print(f"Gesamt-Tokens: {response.usage_metadata.total_token_count}")

    return response.text

# Cache löschen wenn nicht mehr benötigt
cache.delete()

Anbieter-Vergleich

Zusammenfassungstabelle

Kosten-Simulator: 10.000 Anfragen / Tag

Annahme: 3.000-Token-System-Prompt + 200-Token-Query, GPT-4o / Claude 3.5 Sonnet / Gemini 1.5 Pro.

Hinweis: Tatsächliche Einsparungen hängen von der Cache-Hit-Rate ab. Bei stabilem System-Prompt und stetigem Traffic übersteigt die Hit-Rate 90%.

Welcher Anbieter für Caching?

RAG-spezifische Caching-Strategien

Optimale Architektur für RAG

┌─────────────────────────────────────────────────────┐
│               RAG-PROMPT-STRUKTUR                     │
├─────────────────────────────────────────────────────┤
│                                                       │
│  ┌─────────────────────────────────┐ ← GECACHT       │
│  │   System-Prompt (Anweisungen)   │   (identisch     │
│  │   + Formatierungsregeln         │    für alle      │
│  │   + Tonalität                   │    Anfragen)     │
│  └─────────────────────────────────┘                  │
│                                                       │
│  ┌─────────────────────────────────┐ ← GECACHT       │
│  │   Few-Shot-Beispiele (3-5)      │   (ändert sich   │
│  │   + erwartetes Format           │    selten)       │
│  └─────────────────────────────────┘                  │
│                                                       │
│  ┌─────────────────────────────────┐ ← TEILWEISE     │
│  │   Dynamischer RAG-Kontext       │   GECACHT        │
│  │   (abgerufene Dokumente)        │   (bei gleichen  │
│  │                                 │    Dokumenten)   │
│  └─────────────────────────────────┘                  │
│                                                       │
│  ┌─────────────────────────────────┐ ← NICHT GECACHT │
│  │   Nutzer-Anfrage                │   (immer         │
│  │                                 │    einzigartig)  │
│  └─────────────────────────────────┘                  │
└─────────────────────────────────────────────────────┘

Strategie 1: System-Prompt + Few-Shots cachen

Die einfachste und effektivste Strategie:

DEVELOPERpython
# System-Prompt und Few-Shots ändern sich nie
# → Cache-Hit-Rate nahe 100%

CACHED_PREFIX = f"""{SYSTEM_PROMPT}

## Beispiele
{FEW_SHOT_EXAMPLES}
"""

# Nur RAG-Kontext und Query ändern sich
def build_prompt(rag_docs: list, query: str) -> str:
    return f"""{CACHED_PREFIX}

## Referenzdokumente
{format_documents(rag_docs)}

## Frage
{query}
"""

Strategie 2: Häufig abgerufenen RAG-Kontext cachen

Für wiederkehrende Fragen die die gleichen Dokumente zurückgeben:

DEVELOPERpython
from functools import lru_cache

@lru_cache(maxsize=100)
def get_top_documents(topic: str) -> str:
    """Lokaler Cache der meistangefragten Dokumente."""
    docs = search_qdrant(topic, limit=5)
    return format_documents(docs)

# Wenn 2 Nutzer Fragen zum gleichen Thema stellen
# → gleicher RAG-Kontext → Cache-Hit auf dem Präfix

Strategie 3: Gruppierung nach Mandant / Kategorie

DEVELOPERpython
# Multi-Mandant: jeder Mandant hat seinen eigenen gecachten System-Prompt
TENANT_PROMPTS = {
    "mandant_A": "Du bist der Assistent von TechCorp...",
    "mandant_B": "Du bist der Assistent von RetailCo...",
}

# Solange Anfragen desselben Mandanten innerhalb des TTL-Fensters ankommen
# → Cache funktioniert perfekt

Einsparungs-Rechner

Berechnungsformel

Monatliche Einsparung =
  (Anzahl_Anfragen × gecachte_Tokens × Normalpreis × (1 - Cache_Rabatt))
  - (Anzahl_Anfragen × gecachte_Tokens × Cache_Preis)
  - Cache_Schreibkosten

Konkrete Beispiele

Fallstricke und Best Practices

Häufige Fehler

Optimierungs-Checkliste

1. Prompt strukturieren: Statisches oben, Dynamisches unten
2. Änderungen im Präfix minimieren
3. Cache-Hit-Rate überwachen
4. Anfragen nach Mandant/Kategorie gruppieren
5. Dynamische Elemente (Datum, Uhrzeit) im Präfix vermeiden
6. Mit Vorher/Nachher-Metriken testen

FAQ

Ist Prompt Caching mit Streaming kompatibel?

Ja, Prompt Caching ist bei allen 3 Anbietern voll mit Streaming kompatibel. Das Caching wirkt auf die Eingabe-Tokens (Input), nicht auf die Generierung (Output). Sie können Ihren Prompt cachen und die Antwort normal streamen.

Was passiert wenn sich mein System-Prompt ändert?

Eine Änderung des System-Prompts invalidiert den Cache. Die erste Anfrage nach der Änderung zahlt den vollen Preis (+ Schreib-Aufschlag bei Anthropic). Nachfolgende Anfragen profitieren vom neuen Cache. Tipp: Versionieren Sie Ihre Prompts und deployen Sie Änderungen in verkehrsarmen Zeiten.

Funktioniert Caching im Multi-Mandanten-Setup?

Ja, aber jeder Mandant hat seinen eigenen Cache (da sich die System-Prompts unterscheiden). Der Trick: Strukturieren Sie den Prompt mit einem Teil der allen Mandanten gemeinsam ist (gecacht) und einem mandantenspezifischen Teil (ungecacht oder mit eigenem Cache über Anthropic-Breakpoints).

Wie lange bleibt der Cache aktiv?

Bei Anthropic: 5 Minuten, erneuert bei jedem Hit. Bei OpenAI: 5-10 Minuten, nicht garantiert. Bei Google: konfigurierbar bis 24h. Bei kontinuierlichem Traffic (> 1 Anfrage / 5 Min) läuft der Cache bei Anthropic praktisch nie ab.

Ist Prompt Caching bei kleinen Volumen sinnvoll?

Ab etwa 100 Anfragen pro Tag mit stabilem Prompt ist Prompt Caching rentabel. Darunter kann der Cache zwischen Anfragen ablaufen (besonders bei OpenAIs kurzem TTL). Bei sehr kleinen Volumen konzentrieren Sie sich zuerst auf die Optimierung der Modellwahl.

---

Bereit Ihre LLM-Rechnung zu halbieren? Erstellen Sie Ihr Ailog-Konto und profitieren Sie von einer optimierten RAG-Pipeline mit integriertem Prompt Caching, gehostet in Frankreich.