Kontextfenster für KI-Agenten: Speicherbedarf senken und Task-Chains beschleunigen

von Denis Shokhirev, Enterprise AI Architect aus Freiburg im Breisgau. Ich entwickle und betreibe autonome Multi-Agenten-Systeme für DACH-B2B-Kunden (Logistik, FinTech, Industrie) mit Claude, Supabase, n8n, Doppler und selbst gehostetem Postgres. Bei einem Finanzkunden führte ein unkontrolliertes Kontextfenster dazu, dass der OpenAI-Budgetrahmen für einen Monat innerhalb von drei Tagen aufgebraucht war.

Kontextfenster: Produktionslimit statt Randnotiz

Das Token-Limit eines LLM ist in der Praxis der Engpass für Kosten, Performance und Zuverlässigkeit. Claude 3 Opus (Anthropic, 2024) erlaubt bis zu 200.000 Token – aber jede große Anfrage kostet deutlich mehr und erhöht die Latenz massiv (Anthropic Docs, 2024). Ohne striktes Fenster-Management wachsen Logs, Chat-Historien und Zwischenstände exponentiell – mit direktem Impact auf Kosten und Stabilität.

Bewährte Muster zur Speicheroptimierung in Agenten-Task-Chains

1. Filtern und Deduplizieren vor dem Prompt

Ohne Filterung landet alles im Prompt: Logs, irrelevante History, Zwischenstände. In einer realen RAG-Pipeline mit n8n stiegen die Inferenzkosten binnen 24 Stunden um den Faktor 4 nur durch Kontext-Bloat. Mein Ansatz: Deduplication und Entfernen nicht-informativer Abschnitte vor dem LLM-Call.

def prepare_context(messages):
    seen = set()
    filtered = []
    for msg in messages:
        key = hash(msg['content'])
        if key not in seen and len(msg['content']) > 32:
            filtered.append(msg)
            seen.add(key)
    return filtered[-60:]  # Nur die letzten 60 relevanten Nachrichten

Diese Methode spart in der Praxis 40–60% Tokens pro Prompt – gemessen in drei Produktivsystemen.

2. Tokenizer-bewusstes Chunking: Fenster niemals überfüllen

Mit tiktoken (OpenAI, 2024) kann die genaue Token-Anzahl vor jedem Prompt gemessen werden. Wird das Fenster überfüllt, drohen Fehler 413 oder unerwartetes Truncating – kritisch für stabile Systeme im DACH-Raum.

import tiktoken

def count_tokens(messages, model="claude-3-opus"):
    enc = tiktoken.encoding_for_model(model)
    return sum(len(enc.encode(m['content'])) for m in messages)

def fit_to_window(messages, window_size):
    total = 0
    result = []
    for msg in reversed(messages):
        tokens = len(tiktoken.encoding_for_model("claude-3-opus").encode(msg['content']))
        if total + tokens > window_size:
            break
        result.insert(0, msg)
        total += tokens
    return result

So bleiben nur die letzten N Nachrichten im Fenster. Das schützt vor Kostenexplosion und Latenzspitzen.

3. Externe Langzeitspeicherung: Supabase/Postgres statt Prompt

Die gesamte Historie im Prompt zu speichern, ist nicht wirtschaftlich und widerspricht DSGVO-Prinzipien (Datenminimierung). Für Langzeitspeicher nutze ich Supabase/Postgres: Der Agent schreibt Kernfakten und Zusammenfassungen in die Datenbank, und nur eine kompakte Auswahl (letzte 5–10 Nachrichten plus Kurz-Summary) landet im Prompt. Das reduziert die Kosten in ausgedehnten Task-Chains um 60–80%.

import psycopg2

def get_recent_summaries(agent_id):
    conn = psycopg2.connect("dbname=ai_prod user=agent password=secret")
    cur = conn.cursor()
    cur.execute("SELECT summary FROM memories WHERE agent_id=%s ORDER BY ts DESC LIMIT 3", (agent_id,))
    return [row[0] for row in cur.fetchall()]

Retrieval aus Postgres im RAG-Muster bringt stabile Latenz (bis zu 1,2 Sekunden pro Kette) und minimalen Tokenverbrauch.

Vergleich der Ansätze: Kosten und Geschwindigkeit

Kontextfenster in Task-Chains: Muster für die Praxis

In n8n+Claude-Agentenketten treten typische Fehler auf: Zielvergessen, Wiederholung, „Verheddern“ in Logs. Mein Gegenmittel: explizites Kontextfenster-Management in jedem Task. Beispiel n8n-Workflow:

- name: Fetch recent messages
  type: postgres
  params: {limit: 20}
- name: Summarize
  type: openai
  params: {prompt: "Summarize last 20 messages"}
- name: Build context window
  type: python
  params: {function: prepare_context}
- name: LLM decision
  type: anthropic
  params: {model: "claude-3-opus"}

So bleibt das Kontextfenster berechenbar. Die Pipeline läuft stabil – auch nach einer Woche Dauerbetrieb.

FAQ

Wie groß sollte das Kontextfenster sein?

4.000–8.000 Tokens pro Prompt genügen für die meisten Agentenaufgaben. Mehr bringt Kosten- und Latenzprobleme.

Wie speichert man Langzeit-Memory sicher?

Kernfakten und Zusammenfassungen werden in Supabase/Postgres persistiert. Nur kompakte Ausschnitte kommen in den Prompt – DSGVO-konform und effizient.

Wie überwachen Sie Tokenverbrauch?

Ich parse OpenAI/Anthropic-Logs täglich und reportiere je Agent. Ausreißer sind in Minuten gefunden.

Was tun bei Kontext-Overflow?

Filtern, chunking, Rauschen (Logs, Metadaten) entfernen. Nicht alles in den Prompt pressen – Zusammenfassungen reichen meist.

Wann sollte man das Fenster vergrößern?

Nur bei Tasks, die vollständige Historie verlangen (z.B. mehrtägige Verhandlungen oder komplexe Aktenläufe).

Wo erleben Sie die meisten Produktionsprobleme mit Agenten: Memory-Management, Latenz im LLM oder Retrieval aus der Datenbank? Das würde mich wirklich interessieren.
Ich biete einen kostenlosen 30-min Stack-Audit für DACH-Unternehmen mit KI-Projekten in regulierten Märkten. Kontaktieren Sie mich auf LinkedIn oder schreiben Sie an @ger_dennis_ai.