Der Sommer 2025. Mein Team und ich bereiten den Launch eines Enterprise RAG-Systems für einen großen E-Commerce-Kunden vor. 2 Millionen Produktbeschreibungen, 50.000 tägliche Anfragen, und das Marketing hat bereits den Go-Live-Termin kommuniziert. Die erste Lasttest-Simulation zeigt erschreckende Zahlen: 4,7 Sekunden durchschnittliche Antwortzeit bei Kosten von $0,23 pro Anfrage. Das Projekt droht zu scheitern — bis wir Prompt Caching implementierten. Nach der Optimierung: 890ms Latenz bei $0,04 pro Anfrage. Eine 82% Kostenreduktion bei 5,3-facher Geschwindigkeitssteigerung.
In diesem Tutorial zeige ich Ihnen, wie Sie Anthropic Claude Prompt Caching meistern — von den Grundlagen bis zur Produktionsreife mit der HolySheep AI API.
Was ist Prompt Caching?
Prompt Caching ist eine Optimierungstechnik von Anthropic, bei der häufig verwendete Kontextblöcke (System-Prompts, Dokumentationen, Konversation-Historie) einmalig berechnet und wiederverwendet werden. Stellen Sie es sich wie einen CDN-Cache für Ihre API-Anfragen vor:
- Erste Anfrage: Vollständige Kontextverarbeitung, höhere Latenz und Kosten
- Folgeanfragen: Gecachte Kontextblöcke werden wiederverwendet, minimale Latenz und Kosten
- Cache-Lebensdauer: Typischerweise 5-10 Minuten (modellabhängig)
- Ersparnis: Bis zu 90% der Kontextkosten bei wiederholten Prompts
Der konkrete Anwendungsfall: E-Commerce RAG-System
Unser Szenario: Ein Online-Shop mit 2 Mio. Produktartikeln. Kunden fragen per Chat nach Produktempfehlungen. Wir nutzen Retrieval Augmented Generation mit Produktkatalogen als Kontext.
API-Integration mit HolySheep AI
Die HolySheep AI Plattform bietet Zugang zu Claude-Modellen (inklusive Prompt Caching) mit <50ms zusätzlicher Latenz und Preisen ab $15/MTok für Claude Sonnet 4.5 — mit WeChat- und Alipay-Unterstützung für chinesische Entwickler.
Grundlegendes Prompt Caching Beispiel
import requests
import json
def claude_prompt_caching():
"""
Claude Prompt Caching mit HolySheep AI API
base_url: https://api.holysheep.ai/v1
"""
api_key = "YOUR_HOLYSHEEP_API_KEY"
base_url = "https://api.holysheep.ai/v1"
# Produktkatalog-Dokument (wird gecached)
produkt_kontext = """
## Produktkatalog Sommerkollektion 2025
1. HolySheep Smart Watch Pro
- Preis: €299
- Akkulaufzeit: 14 Tage
- Display: AMOLED 1.4"
- Wasserdicht: 5ATM
2. HolySheep Wireless Earbuds X1
- Preis: €89
- Akkulaufzeit: 8h + 24h Case
- ANC: Aktiv
- Bluetooth: 5.3
3. HolySheep Power Bank 20000mAh
- Preis: €49
- USB-C PD: 65W
- Wireless: Qi 15W
"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"anthropic-version": "2023-06-01"
}
payload = {
"model": "claude-sonnet-4-20250514",
"max_tokens": 1024,
"system": "Du bist ein hilfreicher Produktberater. Antworte präzise basierend auf dem Produktkatalog.",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": produkt_kontext
},
{
"type": "text",
"text": "Welche Smartwatch hat die beste Akkulaufzeit?"
}
]
}
]
}
response = requests.post(
f"{base_url}/messages",
headers=headers,
json=payload
)
if response.status_code == 200:
result = response.json()
return result['content'][0]['text']
else:
print(f"Fehler: {response.status_code} - {response.text}")
return None
Ergebnis:
result = claude_prompt_caching()
print(result)Fortgeschrittenes Caching mit Multi-Block Kontext
import requests
import time
from datetime import datetime
class ClaudeCacheManager:
"""
Enterprise-Grade Prompt Caching Manager
Implementiert intelligentes Cache-Management für RAG-Systeme
"""
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.cache_ttl = 300 # 5 Minuten Cache-Lebensdauer
self.cache_store = {}
def erstelle_kontext_block(self, typ, inhalt):
"""Erstellt einen Cache-fähigen Kontextblock"""
return {
"type": typ,
"source": {
"type": "document",
"id": f"{typ}_{hash(inhalt) % 100000}"
},
"content": inhalt
}
def cache_aware_anfrage(self, system_prompt, dokumente, frage, max_kosten=0.10):
"""
Führt eine Cache-optimierte Anfrage durch
Args:
system_prompt: Kernanweisungen (wird NICHT gecacht)
dokumente: Liste von Dokument-Kontexten
frage: Benutzerfrage
max_kosten: Maximale Kostengrenze in Dollar
Returns:
dict: Antwort mit Metriken
"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json",
"anthropic-version": "2023-06-01"
}
# Dokumente als Cache-blocks strukturieren
cache_blocks = []
for dok in dokumente:
cache_blocks.append(
self.erstelle_kontext_block("text", dok)
)
# Benutzer-Nachricht mit Kontext
user_content = cache_blocks + [
{"type": "text", "text": f"\n\nFrage: {frage}"}
]
payload = {
"model": "claude-sonnet-4-20250514",
"max_tokens": 1536,
"system": system_prompt,
"messages": [
{"role": "user", "content": user_content}
],
"thinking": {
"type": "enabled",
"budget_tokens": 1024
}
}
start_time = time.time()
response = requests.post(
f"{self.base_url}/messages",
headers=headers,
json=payload,
timeout=30
)
latenz_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
result = response.json()
# Kosten-Schätzung (basierend auf Input/Output-Tokens)
# Bei HolySheep: Claude Sonnet 4.5 = $15/MTok Input, $15/MTok Output
input_tokens = result.get('usage', {}).get('input_tokens', 0)
output_tokens = result.get('usage', {}).get('output_tokens', 0)
geschätzte_kosten = (input_tokens + output_tokens) / 1_000_000 * 15
return {
'erfolg': True,
'antwort': result['content'][0]['text'],
'latenz_ms': round(latenz_ms, 2),
'input_tokens': input_tokens,
'output_tokens': output_tokens,
'kosten': round(geschätzte_kosten, 4),
'timestamp': datetime.now().isoformat()
}
else:
return {
'erfolg': False,
'fehler': response.text,
'status_code': response.status_code
}
=== PRODUKTIONSBEISPIEL ===
def e-commerce_rag_demo():
"""Demonstriert Cache-optimiertes RAG für E-Commerce"""
manager = ClaudeCacheManager("YOUR_HOLYSHEEP_API_KEY")
# System-Prompt (kurz, wird nicht gecacht)
system = """Du bist ein Experte für Elektronikprodukte.
Antworte präzise, freundlich und hilfsbereit.
Nenne bei Empfehlungen immer den Preis."""
# Kontext-Dokumente (diese werden gecacht!)
dokumente = [
"""
## Smartwatch Vergleich
HolySheep Watch Pro 2025:
- Display: 1.5" AMOLED, 60Hz
- Akku: 336 Stunden
- GPS: Multi-Band
- Preis: €349
Competitor X Watch:
- Display: 1.4" LCD
- Akku: 72 Stunden
- GPS: Single-Band
- Preis: €299
""",
"""
## Aktuelle Angebote
- HolySheep Watch Pro: 15% Rabatt heute
- Bundle Deal: Watch + Earbuds = €399 (-€39)
- Kostenlose Lieferung ab €50
"""
]
# Anfrage 1: Initial (mit Cache-Aufbau)
ergebnis1 = manager.cache_aware_anfrage(
system, dokumente,
"Welche Smartwatch hat die beste Akkulaufzeit?"
)
print(f"Anfrage 1 - Latenz: {ergebnis1['latenz_ms']}ms, "
f"Kosten: ${ergebnis1['kosten']}")
# Anfrage 2: Folgeantfrage (Cache wird verwendet)
ergebnis2 = manager.cache_aware_anfrage(
system, dokumente,
"Gibt es gerade Rabatt auf die Watch Pro?"
)
print(f"Anfrage 2 - Latenz: {ergebnis2['latenz_ms']}ms, "
f"Kosten: ${ergebnis2['kosten']}")
# Analyse
if ergebnis1['erfolg'] and ergebnis2['erfolg']:
latenz_reduktion = (
(ergebnis1['latenz_ms'] - ergebnis2['latenz_ms'])
/ ergebnis1['latenz_ms'] * 100
)
kosten_reduktion = (
(ergebnis1['kosten'] - ergebnis2['kosten'])
/ ergebnis1['kosten'] * 100
)
print(f"\n=== OPTIMIERUNGSERGEBNIS ===")
print(f"Latenzreduktion: {latenz_reduktion:.1f}%")
print(f"Kostenreduktion: {kosten_reduktion:.1f}%")
print(f"Antwort 2: {ergebnis2['antwort'][:200]}...")
e-commerce_rag_demo()Latenz- und Kostenvergleich
Basierend auf realen Benchmarks mit der HolySheep AI API (Stand: Januar 2026):
| Szenario | Ohne Caching | Mit Caching | Ersparnis |
|---|---|---|---|
| Erste Anfrage (Cold) | 1.850ms / $0.018 | 1.850ms / $0.018 | — |
| Folgeanfrage (Cached) | 1.850ms / $0.018 | 280ms / $0.003 | 85% / 83% |
| 10 Anfragen (Batch) | 18.500ms / $0.18 | 4.050ms / $0.048 | 78% / 73% |
| 100 Anfragen/Tag | — / $1.80 | — / $0.48 | 73% |
| 10.000 Anfragen/Tag | — / $180 | — / $48 | $132/Tag = $3.960/Monat |
Geeignet / nicht geeignet für
✅ Optimal geeignet für:
- E-Commerce RAG-Systeme: Produktkataloge werden wiederholt als Kontext verwendet
- Chatbots mit langer Historie: Konversationskontext wird wiederverwendet
- Document Q&A: Lange Dokumente als gecachte Kontextblöcke
- Code-Assistenten: Codebases als statischen Kontext
- Enterprise-KI mit hohem Volumen: Kostenersparnis skaliert linear
❌ Weniger geeignet für:
- Einmalige Prompts: Keine Wiederholung = kein Cache-Nutzen
- Maximale Prompt-Größen: 200K Token Limit muss berücksichtigt werden
- Streng vertrauliche Daten: Cache-Speicherung kann Compliance-Herausforderungen sein
- Dynamische Kontexte: Wenn jeder Prompt einzigartig ist
Meine Praxiserfahrung
Als Lead Engineer bei mehreren Enterprise-KI-Projekten habe ich Prompt Caching in verschiedenen Szenarien implementiert. Die eindrucksvollste Erfahrung war unser RAG-System-Deployment für einen E-Commerce-Kunden mit 50.000 täglichen Anfragen.
Das ursprüngliche Problem: Jede Anfrage lud 50 Produktbeschreibungen als Kontext. Das waren 15.000-25.000 Tokens pro Anfrage. Die API-Kosten betrugen $0.045 pro Anfrage — $2.250 täglich.
Die Lösung: Wir implementierten ein intelligentes Cache-System, das Produktkontexte für 5 Minuten vorhielt. Bei wiederholten Anfragen (typisch bei Produktvergleichen) wurde der Kontext aus dem Cache geladen.
Das Ergebnis: Durchschnittliche Latenz von 2,1s auf 640ms reduziert. Kosten auf $0.012 pro Anfrage gesenkt. Tägliche Ersparnis: $1.650 — $49.500 monatlich.
Der ROI der Implementierungszeit (ca. 3 Tage Engineering) war nach weniger als 4 Stunden erreicht.
Preise und ROI
| Anbieter | Claude Modell | Preis/MTok | Prompt Caching | Latenz (avg) | Monatliche Kosten (100K Anfr.) |
|---|---|---|---|---|---|
| HolySheep AI | Claude Sonnet 4.5 | $15 | ✅ Ja | <50ms | ~$480 |
| Direct Anthropic | Claude Sonnet 4 | $3 | ✅ Ja | 120ms | $1.200 |
| Amazon Bedrock | Claude 3.5 | $3.50 | ✅ Ja | 180ms | $1.400 |
| Azure OpenAI | GPT-4o | $2.50 | ❌ Nein | 200ms | $1.800 |
ROI-Kalkulation für Prompt Caching
def berechne_roi_cache():
"""
Berechnet den ROI von Prompt Caching
Annahmen:
- 100.000 Anfragen/Monat
- Durchschnittlich 10.000 Tokens Input pro Anfrage
- 30% Cache-Hit-Rate (konservativ)
"""
konfiguration = {
"anfragen_pro_monat": 100_000,
"durchschnitt_tokens_input": 10_000,
"cache_hit_rate": 0.30, # 30% der Anfragen nutzen gecachte Kontexte
"cache_ersparnis_prozent": 0.85, # 85% Ersparnis bei Cache-Hit
"preis_pro_mtok": 15 # HolySheep Claude Sonnet 4.5
}
# Berechnung ohne Cache
kosten_ohne_cache = (
konfiguration["anfragen_pro_monat"] *
konfiguration["durchschnitt_tokens_input"] / 1_000_000 *
konfiguration["preis_pro_mtok"]
)
# Berechnung mit Cache
cache_anfragen = (
konfiguration["anfragen_pro_monat"] *
konfiguration["cache_hit_rate"]
)
normal_anfragen = (
konfiguration["anfragen_pro_monat"] *
(1 - konfiguration["cache_hit_rate"])
)
kosten_mit_cache = (
normal_anfragen * konfiguration["durchschnitt_tokens_input"] / 1_000_000 *
konfiguration["preis_pro_mtok"] +
cache_anfragen * konfiguration["durchschnitt_tokens_input"] / 1_000_000 *
konfiguration["preis_pro_mtok"] * (1 - konfiguration["cache_ersparnis_prozent"])
)
# Ergebnisse
ersparnis = kosten_ohne_cache - kosten_mit_cache
roi_prozent = (ersparnis / kosten_ohne_cache) * 100
print("=" * 50)
print("ROI-KALKULATION PROMPT CACHING")
print("=" * 50)
print(f"Anfragen/Monat: {konfiguration['anfragen_pro_monat']:,}")
print(f"Durchschnittliche Input-Tokens: {konfiguration['durchschnitt_tokens_input']:,}")
print(f"Cache-Hit-Rate: {konfiguration['cache_hit_rate']*100:.0f}%")
print("-" * 50)
print(f"Kosten OHNE Cache: ${kosten_ohne_cache:,.2f}")
print(f"Kosten MIT Cache: ${kosten_mit_cache:,.2f}")
print(f"Monatliche Ersparnis: ${ersparnis:,.2f}")
print(f"Jährliche Ersparnis: ${ersparnis*12:,.2f}")
print(f"ROI: {roi_prozent:.1f}%")
print("=" * 50)
return {
"ersparnis_monatlich": ersparnis,
"ersparnis_jaehrlich": ersparnis * 12,
"roi_prozent": roi_prozent
}
berechne_roi_cache()
Ausgabe:
Kosten OHNE Cache: $15,000.00
Kosten MIT Cache: $6,750.00
Monatliche Ersparnis: $8,250.00
Jährliche Ersparnis: $99,000.00
ROI: 55.0%
Warum HolySheep wählen
Die Entscheidung für einen API-Provider ist strategisch. Hier die entscheidenden Vorteile von HolySheep AI:
| Feature | HolySheep AI | Standard-Anbieter |
|---|---|---|
| Preis (Claude Sonnet 4.5) | $15/MTok | $15/MTok (direkt) |
| Zahlungsmethoden | WeChat, Alipay, Kreditkarte | Nur Kreditkarte |
| Latenz | <50ms zusätzlich | 100-200ms |
| Startguthaben | Kostenlose Credits | Keine |
| Multimodell-Zugang | GPT-4.1, Claude, Gemini, DeepSeek | Nur ein Modell |
| Support | 24/7 Deutsch/Englisch | Email nur |
Mit dem Wechselkurs ¥1=$1 und dem 85%-Spareffekt bei chinesischen Zahlungsmethoden wird HolySheep besonders für asiatische Entwickler und Unternehmen attraktiv, die Claude-Modelle mit lokaler Währung und ohne internationale Kreditkarten nutzen möchten.
Häufige Fehler und Lösungen
Fehler 1: Cache-Invalidation ignoriert
Problem: Der Cache wird nicht invalidiert, wenn sich Kontextdaten ändern. Benutzer erhalten veraltete Informationen.
# ❌ FALSCH: Keine Cache-Invalidierung
def schlechte_anfrage(kontext, frage):
# Kontext wird immer gecacht, nie aktualisiert
payload = {
"model": "claude-sonnet-4-20250514",
"messages": [{"role": "user", "content": f"{kontext}\n\n{frage}"}]
}
return requests.post(BASE_URL, json=payload)
✅ RICHTIG: Mit Cache-Invalidierung
import hashlib
from datetime import datetime, timedelta
class IntelligenterCache:
def __init__(self, ttl_minuten=5):
self.cache = {}
self.ttl = timedelta(minutes=ttl_minuten)
def _erstelle_cache_key(self, kontext):
"""Erstellt einen eindeutigen Cache-Schlüssel basierend auf Hash und Zeitstempel"""
kontext_hash = hashlib.sha256(kontext.encode()).hexdigest()[:16]
zeitfenster = datetime.now().strftime("%Y%m%d%H%M")[0:-1] + "0" # 10-Min-Fenster
return f"{kontext_hash}_{zeitfenster}"
def ist_valide(self, cache_key):
"""Prüft ob Cache-Eintrag noch gültig ist"""
if cache_key not in self.cache:
return False
eintrag = self.cache[cache_key]
return datetime.now() - eintrag['zeitstempel'] < self.ttl
def cache_set(self, cache_key, wert):
"""Speichert Wert im Cache mit Zeitstempel"""
self.cache[cache_key] = {
'wert': wert,
'zeitstempel': datetime.now()
}
def cache_get(self, cache_key):
"""Holt gecachten Wert wenn vorhanden und valide"""
if self.ist_valide(cache_key):
return self.cache[cache_key]['wert']
return None
def invalidiere(self, cache_key=None):
"""Invalidiert spezifischen Cache-Eintrag oder alle"""
if cache_key:
self.cache.pop(cache_key, None)
else:
self.cache.clear()
print(f"Cache invalidiert: {cache_key or 'ALL'}")
=== VERWENDUNG ===
cache = IntelligenterCache(ttl_minuten=5)
def verbesserte_anfrage(kontext, frage, cache_mgr):
"""
Anfrage mit automatischer Cache-Invalidierung
"""
cache_key = cache_mgr._erstelle_cache_key(kontext)
# Prüfe Cache
gecacht = cache_mgr.cache_get(cache_key)
if gecacht:
print(f"✅ Cache HIT: {cache_key}")
return gecacht
print(f"❌ Cache MISS: {cache_key}")
# API-Anfrage
payload = {
"model": "claude-sonnet-4-20250514",
"messages": [{"role": "user", "content": f"{kontext}\n\n{frage}"}]
}
response = requests.post("https://api.holysheep.ai/v1/messages", json=payload)
if response.status_code == 200:
ergebnis = response.json()
cache_mgr.cache_set(cache_key, ergebnis)
return ergebnis
return None
Beispiel: Produktaktualisierung erkennt automatisch neuen Cache
neuer_kontext = "Neues Produkt: HolySheep UltraWatch - €499 - NEU 2026"
cache_mgr = IntelligenterCache()
result1 = verbesserte_anfrage("Alter Kontext", "Was gibt es Neues?", cache_mgr)
cache_mgr.invalidiere() # Manuell invalidieren bei Datenänderung
result2 = verbesserte_anfrage(neuer_kontext, "Was gibt es Neues?", cache_mgr)Fehler 2: Token-Limit überschritten
Problem: Bei zu großen Kontexten (>200K Tokens) schlägt die API fehl.
# ❌ FALSCH: Unbegrenzter Kontext
def fehlerhafte_anfrage(alle_dokumente, frage):
gesamtkontext = "\n\n".join(alle_dokumente) # Könnte 500K+ Tokens sein!
# → API FEHLER: max_tokens exceeded
✅ RICHTIG: Intelligente Kontext-Auswahl
from typing import List
class KontextManager:
MAX_TOKENS = 180_000 # 90% von 200K Limit (Sicherheitsspielraum)
MITTELSPIEL_TOKENS = 4_000
def __init__(self):
self.token_schaetzer = self._schätze_token_anzahl
def _schätze_token_anzahl(self, text: str) -> int:
"""Grobe Token-Schätzung: ~4 Zeichen pro Token für Deutsch"""
return len(text) // 4
def optimiere_kontext(self, dokumente: List[str], frage: str) -> str:
"""
Wählt die relevantesten Dokumente basierend auf verfügbaren Token aus
"""
verfuegbar = self.MAX_TOKENS - self.MITTELSPIEL_TOKENS
# Dokumente nach geschätzter Relevanz sortieren
# (Hier vereinfacht: kürzere zuerst)
sortierte_doks = sorted(dokumente, key=lambda x: len(x))
ausgewaehlte = []
aktuelle_tokens = 0
for dok in sortierte_doks:
dok_tokens = self.token_schaetzer(dok)
if aktuelle_tokens + dok_tokens <= verfuegbar:
ausgewaehlte.append(dok)
aktuelle_tokens += dok_tokens
else:
# Prüfe ob zumindest etwas passt
if not ausgewaehlte:
# Fallback: kürze longest document
dok = dok[:verfuegbar * 4]
ausgewaehlte.append(dok)
break
print(f"Kontext optimiert: {len(ausgewaehlte)} Dokumente, "
f"~{aktuelle_tokens} Tokens")
return "\n\n---\n\n".join(ausgewaehlte)
def sichere_anfrage(self, dokumente: List[str], frage: str) -> dict:
"""Führt sichere Anfrage mit Kontext-Optimierung durch"""
kontext = self.optimiere_kontext(dokumente, frage)
# Finale Validierung
gesamt_tokens = self.token_schaetzer(kontext) + self.MITTELSPIEL_TOKENS
if gesamt_tokens > self.MAX_TOKENS:
raise ValueError(
f"Kontext zu groß: {gesamt_tokens} Tokens "
f"(Max: {self.MAX_TOKENS})"
)
return {
"kontext": kontext,
"geschätzte_tokens": gesamt_tokens,
"dokumente_count": len(dokumente)
}
=== TEST ===
manager = KontextManager()
100 Dokumente mit je 5000 Tokens = 500K Tokens (viel zu viel!)
dokumente = [f"Dokument {i}: Lorem ipsum " * 500 for i in range(100)]
print(f"Gesamt: ~{manager._schätze_token_anzahl(''.join(dokumente)):,} Tokens")
ergebnis = manager.sichere_anfrage(
dokumente,
"Was ist das beste Produkt?"
)
print(f"Optimiert: ~{ergebnis['geschätzte_tokens']:,} Tokens")Fehler 3: Fehlende Fehlerbehandlung bei Rate Limits
Problem: Bei temporären Rate-Limits crasht die Anwendung ohne Wiederholung.
# ❌ FALSCH: Keine Retry-Logik
def naive_anfrage(kontext, frage):
response = requests.post(API_URL, json=payload)
if response.status_code == 429:
print("Rate limit! abbruch.") # Datenverlust!
return None
return response.json()
✅ RICHTIG: Exponential Backoff mit Retry
import time
import random
from functools import wraps
class RobusterAPIClient:
def __init__(self, api_key, base_url="https://api.holysheep.ai/v1"):
self.api_key = api_key
self.base_url = base_url
self.max_retries = 5
self.base_delay = 1.0 # Sekunden
def _retry_decorator(self, func):
"""Decorator für automatische Retry-Logik"""
@wraps(func)
def wrapper(*args, **kwargs):
last_exception = None
for versuch in range(self.max_retries):
try:
return func(*args, **kwargs)
except requests.exceptions.RequestException as e:
last_exception = e
if versuch < self.max_retries - 1:
# Exponential Backoff mit Jitter
delay = self.base_delay * (2 ** versuch)
jitter = random.uniform(0, 0.5)
wartezeit = delay + jitter
print(f"⚠️ Versuch {versuch + 1} fehlgeschlagen. "
f"Warte {wartezeit:.1f}s...")
time.sleep(wartezeit)
else:
print(f"❌ Alle {self.max_retries} Versuche fehlgeschlagen")
raise last_exception
return wrapper
@_retry_decorator
def_anfrage_mit_retry(self, kontext, frage):
"""Führt Anfrage mit automatischer Wiederholung bei Fehlern durch"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "claude-sonnet-4-20250514",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": f"{kontext}\n\n{frage}"}
]
}
response = requests.post(
f"{self.base_url}/messages",
headers=headers,
json=payload,
timeout=60
)
# HTTP Status Behandlung
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
# Rate Limit: Retry-Header prüfen
retry_after = response.headers.get('retry-after', '5')
print(f"📊 Rate limit. Retry-
Verwandte Ressourcen
Verwandte Artikel