Prompt-Caching mit Deep Agents

Prompt Caching mit Deep Agents

Einführung

Große Sprachmodelle (LLMs) sind zu unverzichtbaren Werkzeugen für Entwickler und Unternehmen geworden, doch ihre Kosten und Latenzzeiten bleiben erhebliche Hürden für eine breite Einführung. Eine der vielversprechendsten Lösungen für diese Herausforderungen ist **Prompt Caching** – eine Technik, die verarbeitete Prompt-Abschnitte speichert und wiederverwendet, um redundante Berechnungen zu vermeiden. In Kombination mit tiefen Agentenarchitekturen, bei denen mehrere Denkschritte oder Tool-Aufrufe sequenziell ausgeführt werden, kann Prompt Caching sowohl Antwortzeiten als auch API-Kosten drastisch reduzieren.

Dieser Artikel bietet eine praktische, technische Anleitung zur Implementierung von Prompt Caching mit Deep Agents. Wir gehen Schritt für Schritt durch Installation, Konfiguration und praxisnahe Beispiele und stützen uns dabei auf Erkenntnisse von Branchenführern wie LangChain, OpenAI, Microsoft und Anthropic.

Was ist Prompt Caching?

Prompt Caching funktioniert, indem der Key-Value (KV)-Cache zuvor verarbeiteter Prompts gespeichert wird. Wenn ein neuer Prompt ein gemeinsames Präfix mit einem zwischengespeicherten Prompt hat, verwendet das System die zwischengespeicherte Berechnung erneut, anstatt die gesamte Eingabe erneut zu verarbeiten. Dies ist besonders wertvoll für:

• Lange System-Prompts, die über mehrere Anfragen hinweg konstant bleiben
• Few-Shot-Beispiele, die für ähnliche Aufgaben wiederverwendet werden
• Deep-Agent-Schleifen, bei denen derselbe Kontext an mehrere Tool-Aufrufe übergeben wird

Deep Agents – autonome Systeme, die denken, planen und mehrere Schritte ausführen – profitieren überproportional vom Caching, da sie wiederholt denselben Basiskontext (Systemanweisungen, Gesprächsverlauf, Tool-Definitionen) verarbeiten, während sie unterschiedliche Aktionssequenzen generieren.

Voraussetzungen

Bevor Sie Prompt Caching mit Deep Agents implementieren, stellen Sie sicher, dass Folgendes vorhanden ist:

• **Python 3.10 oder höher** (3.11+ wird für die Leistung empfohlen)
• **LangChain** (Version 0.3 oder höher) für die Agenten-Orchestrierung
• **Ein LLM-Anbieter mit Prompt-Caching-Unterstützung** (z. B. OpenAI, Anthropic oder Microsoft Azure OpenAI)
• **Ein Deep-Agent-Framework** (LangGraph oder LangChains AgentExecutor)
• **Mindestens 8 GB RAM** (16 GB+ werden für größere Modelle empfohlen)

Schritt-für-Schritt-Installation

1. Virtuelle Umgebung einrichten

Isolieren Sie Ihre Abhängigkeiten, um Konflikte zu vermeiden:

python -m venv prompt-cache-env
source prompt-cache-env/bin/activate  # Unter Windows: prompt-cache-env\Scripts\activate

2. Kernabhängigkeiten installieren

Installieren Sie LangChain und das Agent-Framework:

pip install langchain langchain-openai langchain-anthropic langgraph

Für Microsoft Azure OpenAI-Benutzer installieren Sie die Azure-Integration:

pip install langchain-azure-openai

3. API-Schlüssel konfigurieren

Legen Sie Ihre API-Schlüssel als Umgebungsvariablen fest. So bleiben Anmeldeinformationen sicher und außerhalb Ihres Codes:

export OPENAI_API_KEY="ihr-openai-api-schluessel"
export ANTHROPIC_API_KEY="ihr-anthropic-api-schluessel"
export AZURE_OPENAI_API_KEY="ihr-azure-api-schluessel"
export AZURE_OPENAI_ENDPOINT="https://ihre-resource.openai.azure.com/"

Unter Windows verwenden Sie der Einfachheit halber `set` anstelle von `export`:

set OPENAI_API_KEY="ihr-openai-api-schluessel"

4. Optionale Überwachungstools installieren

Um das Cache-Verhalten zu beobachten, installieren Sie LangSmith für das Tracing:

pip install langsmith
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="ihr-langsmith-api-schluessel"

Konfiguration für Prompt Caching

Prompt Caching wird in der Regel auf Anbieterebene aktiviert. Hier erfahren Sie, wie Sie es für die wichtigsten Anbieter konfigurieren.

OpenAI

OpenAI speichert automatisch Prompts mit 1.024 Token oder mehr zwischen. Sie können dies optimieren, indem Sie Ihren System-Prompt als wiederverwendbares Präfix strukturieren:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    # Caching erfolgt automatisch; kein spezielles Flag erforderlich
)

Anthropic

Anthropic erfordert explizite Cache-Control-Header. Verwenden Sie den Parameter `cache_control` in Ihrem Prompt:

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(
    model="claude-3-5-sonnet-20241022",
    temperature=0,
)

# Markieren Sie in Ihrem Prompt die cachebaren Abschnitte:
system_prompt = [
    {
        "type": "text",
        "text": "Sie sind ein hilfreicher Assistent mit tiefgehenden Denkfähigkeiten.",
        "cache_control": {"type": "ephemeral"}
    }
]

Microsoft Azure OpenAI

Azure OpenAI unterstützt Prompt Caching ab GPT-4o-mini. Aktivieren Sie es über Ihre Bereitstellung:

from langchain_openai import AzureChatOpenAI

llm = AzureChatOpenAI(
    azure_deployment="gpt-4o-mini",
    api_version="2024-08-01-preview",
    temperature=0,
)
# Caching erfolgt automatisch für Prompts mit >= 1.024 Token

Erstellen eines Deep Agents mit Prompt Caching

Jetzt erstellen wir einen Deep Agent, der vom Caching profitiert. Wir bauen einen Recherche-Assistenten, der eine mehrstufige Analyse durchführt.

Schritt 1: System-Prompt definieren

Erstellen Sie einen langen, wiederverwendbaren System-Prompt, der zwischengespeichert wird:

system_prompt = """
Sie sind ein Recherche-Assistent, der auf die Analyse technischer Dokumente spezialisiert ist.
Ihre Fähigkeiten:
- Zusammenfassen langer Texte
- Extrahieren wichtiger Erkenntnisse
- Vergleichen und Gegenüberstellen von Quellen
- Identifizieren von Lücken in Argumenten
- Vorschlagen weiterführender Lektüre

Antworten Sie immer in einem strukturierten Format:
1. Wichtigste Erkenntnisse
2. Belege
3. Schlussfolgerungen

Seien Sie gründlich und nennen Sie konkrete Beispiele aus dem Text.
"""

Schritt 2: Agent mit Caching erstellen

Verwenden Sie Anthropics Cache-Control für explizites Caching:

from langchain.agents import create_openai_functions_agent
from langchain.tools import tool
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph, MessagesState

@tool
def search_database(query: str) -> str:
    """Durchsucht die interne Datenbank nach relevanten Dokumenten."""
    # Simulierte Suche
    return f"Ergebnisse für '{query}': 3 relevante Dokumente gefunden."

@tool
def extract_insights(text: str) -> str:
    """Extrahiert wichtige Erkenntnisse aus einem gegebenen Text."""
    return f"Wichtige Erkenntnisse: {text[:100]}..."

llm = ChatAnthropic(
    model="claude-3-5-sonnet-20241022",
    temperature=0,
)

# Agent mit Cache-Control erstellen
prompt = system_prompt + "\n\nBenutzeranfrage: {input}\n\nGesprächsverlauf: {chat_history}"

tools = [search_database, extract_insights]

# Prompt mit Cache-Control umschließen
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt_template = ChatPromptTemplate.from_messages([
    ("system", system_prompt, {"cache_control": {"type": "ephemeral"}}),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
])

agent = create_openai_functions_agent(llm, tools, prompt_template)

Schritt 3: Graph für tiefgehendes Denken hinzufügen

Verwenden Sie LangGraph, um einen mehrstufigen Agenten zu erstellen, der den zwischengespeicherten System-Prompt wiederverwendet:

from langgraph.graph import StateGraph, END
from typing import TypedDict, List, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[List, operator.add]
    step_count: int

def call_model(state: AgentState):
    # Der System-Prompt ist zwischengespeichert, daher sind wiederholte Aufrufe schnell
    response = agent.invoke({
        "input": state["messages"][-1].content,
        "chat_history": state["messages"][:-1]
    })
    return {"messages": [response], "step_count": state["step_count"] + 1}

def should_continue(state: AgentState):
    # Nach 5 Schritten oder wenn der Agent entscheidet, zu beenden, stoppen
    if state["step_count"] >= 5:
        return "end"
    return "continue"

# Graph erstellen
graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_conditional_edges(
    "agent",
    should_continue,
    {"continue": "agent", "end": END}
)
graph.set_entry_point("agent")

app = graph.compile()

Anwendungsbeispiele

Beispiel 1: Einfacher gecachter Agent

Führen Sie eine Abfrage aus, die vom zwischengespeicherten System-Prompt profitiert:

# Erste Anfrage (System-Prompt wird zwischengespeichert)
result = app.invoke({
    "messages": [{"role": "user", "content": "Fassen Sie die wichtigsten Erkenntnisse aus unserem Q3-Bericht zusammen."}],
    "step_count": 0
})
print("Erste Antwort:", result["messages"][-1].content)

# Zweite Anfrage (Cache-Treffer – viel schneller)
result2 = app.invoke({
    "messages": [{"role": "user", "content": "Vergleichen Sie diese Erkenntnisse mit Q2."}],
    "step_count": 0
})
print("Zweite Antwort:", result2["messages"][-1].content)

Beispiel 2: Überwachung der Cache-Leistung

Verwenden Sie LangSmith, um Cache-Treffer und Latenzverbesserungen zu beobachten:

import time

# Detailliertes Tracing aktivieren
from langsmith import Client
client = Client()

# Mehrere Abfragen ausführen und messen
for i in range(3):
    start = time.time()
    result = app.invoke({
        "messages": [{"role": "user", "content": f"Analysieren Sie Dokumentenset {i+1}."}],
        "step_count": 0
    })
    elapsed = time.time() - start
    print(f"Abfrage {i+1}: {elapsed:.2f}s")

Beispiel 3: Optimierung für maximale Cache-Treffer

Strukturieren Sie Ihre Prompts, um die Cache-Wiederverwendung zu maximieren:

# Immer dasselbe System-Prompt-Präfix verwenden
cached_prefix = """
Sie sind ein Recherche-Assistent.
Ihre Aufgaben:
- Zusammenfassen
- Extrahieren
- Vergleichen

"""

# Nur die Benutzernachricht variieren
queries = [
    "Fassen Sie den Q1-Bericht zusammen.",
    "Extrahieren Sie wichtige Kennzahlen aus Q1.",
    "Vergleichen Sie Q1- und Q2-Trends."
]

for query in queries:
    response = agent.invoke({
        "input": query,
        "chat_history": []
    })
    print(f"Abfrage: {query}")
    print(f"Antwort: {response.content[:50]}...")
    print("---")

Best Practices

1. **Lange, stabile System-Prompts entwerfen**: Caching funktioniert am besten, wenn das Prompt-Präfix über mehrere Anfragen hinweg unverändert bleibt. Halten Sie Systemanweisungen und Tool-Definitionen konstant.

2. **Geeignete Modellversionen verwenden**: OpenAIs GPT-4o-mini und Anthropics Claude 3.5 Sonnet bieten die beste Caching-Leistung. Überprüfen Sie die Anbieterdokumentation auf die neuesten unterstützten Modelle.

3. **Cache-Trefferquoten überwachen**: Verwenden Sie LangSmith oder Anbieter-Dashboards, um zu verfolgen, wie oft Ihre Prompts den Cache treffen. Streben Sie eine Cache-Trefferquote von >50 % an, um erhebliche Kosteneinsparungen zu erzielen.

4. **Batch-Verarbeitung in Betracht ziehen**: Strukturieren Sie ähnliche Abfragen so, dass sie gemeinsame Präfixe teilen. Dies maximiert die Cache-Wiederverwendung über mehrere Anfragen hinweg.

5. **Mit realistischen Arbeitslasten testen**: Die Cache-Leistung hängt von der Prompt-Länge und -Wiederholung ab. Führen Sie Benchmarks mit Ihrem tatsächlichen Anwendungsfall durch, bevor Sie in die Produktion gehen.

Fazit

Prompt Caching ist eine leistungsstarke Technik, die die Kosten und Latenzzeiten von Deep-Agent-Systemen erheblich reduziert. Durch das Speichern und Wiederverwenden verarbeiteter Prompt-Abschnitte können Sie Antwortzeiten erzielen, die 2-5x schneller sind, während Sie die API-Kosten um 30-60 % senken. Der Schlüssel liegt darin, Ihre Agent-Prompts mit Blick auf das Caching zu entwerfen – verwenden Sie lange, stabile System-Prompts, nutzen Sie anbieterspezifische Caching-Funktionen und überwachen Sie die Leistung mit Tools wie LangSmith.

Da LLM-Anbieter ihre Caching-Infrastruktur weiter verbessern (OpenAIs automatisches Caching, Anthropics explizites Cache-Control und Microsoft Azures Integration), werden Deep Agents noch praktikabler und wirtschaftlicher. Beginnen Sie noch heute mit der Implementierung von Prompt Caching, um schnellere, günstigere und skalierbarere KI-Anwendungen zu ermöglichen.

*Aktuelle Updates zu Prompt-Caching-Techniken finden Sie in den offiziellen Blogs von LangChain, OpenAI, Microsoft und Anthropic.*