0Pricing
AI Engineering Academy · Lektion

Strategien zur Einhaltung von Kontextgrenzen

Sie implementieren ein Gedächtnis mit gleitendem Fenster, eine Nachrichtenzusammenfassung und das selektive Kürzen des Kontexts, um lange Gespräche ohne Überschreitung der Token-Grenzen zu verarbeiten.

Strategien zur Einhaltung von Kontextgrenzen ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Das wachsende Konversationsproblem

Jede in einer Chat-Konversation ausgetauschte Nachricht erhöht die Token-Anzahl des nächsten API-Aufrufs. In einer langen Kundensupport-Sitzung oder einer mehrstündigen Coding-Sitzung kann der angesammelte Konversationsverlauf leicht 20.000–50.000 Tokens überschreiten. All diese Tokens müssen Sie bei jedem einzelnen Durchlauf an die API senden und bezahlen somit wiederholt für bereits verarbeitete Tokens.

Ohne eine Strategie zur Kontextverwaltung erreicht Ihre Anwendung entweder das Kontextlimit und stürzt ab, oder Sie kürzen Nachrichten unbemerkt, sodass das Modell den Überblick über wichtigen früheren Kontext verliert. Jede LLM-Anwendung im Produktivbetrieb benötigt eine klar definierte Strategie für das Wachstum des Kontexts.

Strategie 1: Schiebefenster (letzte N Nachrichten)

Die einfachste Strategie besteht darin, nur die letzten N Nachrichten im Kontext zu behalten und ältere Nachrichten zu verwerfen. Dies wird als Schiebefenster bezeichnet. Die Implementierung ist einfach, die Kosten sind vorhersehbar, und für viele Anwendungsfälle reicht diese Strategie aus, wenn der aktuelle Kontext wichtiger ist als ältere Austausche.

import openai

client = openai.OpenAI()

class SlidingWindowConversation:
    def __init__(self, system_prompt, window_size=10):
        self.system = system_prompt
        self.window_size = window_size
        self.history = []

    def chat(self, user_message):
        self.history.append({'role': 'user', 'content': user_message})

        # Keep only the last N messages
        windowed = self.history[-self.window_size:]
        messages = [{'role': 'system', 'content': self.system}] + windowed

        response = client.chat.completions.create(
            model='gpt-4o-mini',
            messages=messages
        )
        reply = response.choices[0].message.content
        self.history.append({'role': 'assistant', 'content': reply})
        print(f'Context: {len(windowed)} messages ({len(self.history)} total)')
        return reply

conv = SlidingWindowConversation('You are a helpful assistant.', window_size=6)
print(conv.chat('Hello! My name is Alice.'))
print(conv.chat('What is the capital of France?'))
print(conv.chat('What is my name?'))  # Might forget if window is small

Strategie 2: Token-bewusstes Kürzen

Beim Token-bewussten Kürzen werden Nachrichten nicht anhand ihrer Anzahl gekürzt. Stattdessen werden Nachrichten entfernt, bis die Gesamtzahl der Tokens unter einem Schwellenwert liegt. Das ist präziser, weil Nachrichten sehr unterschiedlich lang sein können: Eine Begrenzung der Nachrichtenanzahl kann beispielsweise 10 kurze oder 3 sehr lange Nachrichten enthalten, die jeweils ganz unterschiedliche Token-Kosten verursachen.

import tiktoken

def trim_to_token_budget(
    messages, system_prompt, model='gpt-4o-mini', max_input_tokens=8000
):
    enc = tiktoken.encoding_for_model(model)

    def count(msgs):
        return sum(len(enc.encode(m.get('content',''))) + 4 for m in msgs) + 3

    # System prompt token count
    system_tokens = len(enc.encode(system_prompt)) + 4
    budget = max_input_tokens - system_tokens

    # Trim from the oldest messages until we fit
    trimmed = list(messages)
    while trimmed and count(trimmed) > budget:
        trimmed.pop(0)  # Remove oldest message

    removed = len(messages) - len(trimmed)
    if removed:
        print(f'Trimmed {removed} old messages to stay within {max_input_tokens} tokens')
    return trimmed

Strategie 3: Konversation zusammenfassen

Zusammenfassungen komprimieren ältere Gesprächsabschnitte zu einer kurzen Zusammenfassung und bewahren dabei die wichtigsten Fakten, Entscheidungen und vom Nutzer erwähnten Kontext. Diese Strategie ist ausgefeilter als ein Schiebefenster, weil sie den Kern früherer Austausche erhält, anstatt sie einfach zu verwerfen.

Das Muster funktioniert folgendermaßen: Wenn die Konversation einen Schwellenwert überschreitet, senden Sie die ältesten N Gesprächsabschnitte mit dem Prompt „Summarize this conversation so far“ an das Modell, ersetzen Sie diese Abschnitte durch eine einzelne Systemnachricht mit der Zusammenfassung und setzen Sie die Konversation mit dem neuen komprimierten Verlauf fort.

import openai

client = openai.OpenAI()

def summarize_conversation(messages_to_summarize, model='gpt-4o-mini'):
    summary_prompt = [
        {'role': 'system', 'content': 'You summarize conversations. Be concise but preserve key facts, decisions, and any specific information the user shared (names, numbers, preferences).'},
        {'role': 'user', 'content': 'Summarize this conversation:\n' + '\n'.join(
            f"{m['role'].upper()}: {m['content']}" for m in messages_to_summarize
        )}
    ]
    resp = client.chat.completions.create(model=model, messages=summary_prompt, max_tokens=500)
    return resp.choices[0].message.content

def compress_history(history, keep_recent=4):
    if len(history) <= keep_recent:
        return history
    to_summarize = history[:-keep_recent]
    summary = summarize_conversation(to_summarize)
    summary_msg = {'role': 'system', 'content': f'Earlier conversation summary: {summary}'}
    return [summary_msg] + history[-keep_recent:]

print('Summarization strategy compresses old turns into a single summary message')

Strategie 4: Entitätenspeicher

Der Entitätenspeicher extrahiert wichtige, in der Konversation erwähnte Fakten und hält sie strukturiert fest – etwa Nutzerpräferenzen, Namen, Projektdetails und getroffene Entscheidungen –, anstatt den rohen Nachrichtenverlauf zu speichern. Vor jedem Durchlauf werden die gespeicherten Fakten in den System-Prompt eingefügt.

Das ist hinsichtlich der Token-Anzahl effizienter als der vollständige Verlauf, weil Sie nur semantisch wichtige Informationen einbeziehen und nicht jedes Wort jedes Gesprächsabschnitts. Ein Entitätenspeicher eignet sich besonders gut für langfristig laufende Assistenten, bei denen Nutzer auf Präferenzen und Fakten zurückgreifen, die bereits viel früher in der Konversation festgelegt wurden.

import openai
import json

client = openai.OpenAI()

def extract_entities(messages, model='gpt-4o-mini'):
    prompt = [
        {'role': 'system', 'content': 'Extract key facts from this conversation as JSON: {"user_name": null, "preferences": [], "key_facts": []}'},
        {'role': 'user', 'content': '\n'.join(f"{m['role']}: {m['content']}" for m in messages)}
    ]
    resp = client.chat.completions.create(
        model=model,
        messages=prompt,
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

conversation = [
    {'role': 'user', 'content': 'Hi, I am Alice and I prefer Python over JavaScript.'},
    {'role': 'assistant', 'content': 'Great to meet you, Alice! Python is an excellent choice.'},
    {'role': 'user', 'content': 'I am building a REST API for my e-commerce startup.'}
]
entities = extract_entities(conversation)
print(json.dumps(entities, indent=2))

Wann Sie welche Strategie anwenden sollten

Wählen Sie Ihre Strategie anhand der Eigenschaften Ihrer Anwendung:

  • Schiebefenster: Einfache Chat-Apps, bei denen nur der aktuelle Kontext relevant ist und Nutzer nicht auf ältere Austausche zurückgreifen. Am günstigsten zu implementieren.
  • Token-bewusstes Kürzen: Jede Anwendung im Produktivbetrieb, in der die Nachrichtenlängen stark variieren. Immer besser als das Kürzen anhand der Nachrichtenanzahl.
  • Zusammenfassungen: Langfristig laufende Assistenten, Kundensupport-Sitzungen und Bots für Projektmanagement. Nutzer erwarten, dass sich der Assistent wichtige Fakten aus Stunden zurückliegenden Austauschen merkt.
  • Entitätenspeicher: Persönliche Assistenten, Chatbots mit Berücksichtigung von Nutzerpräferenzen und Tutorsysteme, bei denen das Nutzerprofil während der gesamten Sitzung relevant ist.

Diese Strategien lassen sich auch kombinieren: Verwenden Sie einen Entitätenspeicher für grundlegende Fakten und ein Schiebefenster für die aktuelle Konversation.

RAG als Alternative zum Auffüllen des Kontexts

Bei wissensintensiven Anwendungen besteht die beste Strategie zur Kontextverwaltung darin, Dokumente gar nicht erst in den Kontext aufzunehmen. Verwenden Sie stattdessen RAG (Retrieval-Augmented Generation), um nur die spezifischen Ausschnitte abzurufen, die für die aktuelle Anfrage relevant sind. Dadurch bleibt der Kontext fokussiert, die Kosten sinken, und häufig entstehen bessere Antworten, als wenn ein vollständiges Dokument eingefügt wird.

Die zentrale Erkenntnis ist, dass lange Kontextfenster zwar das Problem Passt es hinein? lösen, nicht aber das Problem Wird das Modell es sinnvoll nutzen?. Präziser Abruf löst beide Probleme, indem dem Modell nur die Informationen bereitgestellt werden, die es für die aktuelle Frage tatsächlich benötigt.

Fehler bei maximaler Kontextlänge angemessen behandeln

Trotz aller Vorsichtsmaßnahmen können im Produktivbetrieb Fehler aufgrund des Kontextlimits auftreten, insbesondere bei unerwartet langen, von Nutzern erstellten Inhalten. Behandeln Sie den Fehler context_length_exceeded immer explizit, statt ihn als unbehandelte Ausnahme bis zum Nutzer durchzureichen.

import openai
import tiktoken

client = openai.OpenAI()

def chat_with_context_guard(messages, model='gpt-4o-mini', max_tokens=100000):
    enc = tiktoken.encoding_for_model(model)
    total = sum(len(enc.encode(m.get('content',''))) + 4 for m in messages) + 3

    while total > max_tokens and len(messages) > 2:
        # Remove the second message (keep system prompt)
        removed = messages.pop(1)
        total -= len(enc.encode(removed.get('content',''))) + 4
        print(f'Trimmed a message. New total: {total} tokens')

    try:
        return client.chat.completions.create(model=model, messages=messages)
    except openai.BadRequestError as e:
        if 'context_length' in str(e):
            return {'error': 'Message history too long. Please start a new conversation.'}
        raise

Kontext sitzungsübergreifend speichern

In einer echten Anwendung schließen und öffnen Nutzer die App. Der Server wird neu gestartet. Die Kontextverwaltung muss daher die Persistenz über Sitzungen hinweg berücksichtigen, nicht nur innerhalb einer einzelnen Sitzung. Das bedeutet, den Konversationsverlauf in einer Datenbank zu speichern und zu Beginn jeder Sitzung zu laden.

Ein sinnvoller Ansatz: Speichern Sie den vollständigen Rohverlauf zu Prüfungs- und Fine-Tuning-Zwecken in PostgreSQL. Wenden Sie beim Laden des Kontexts für einen neuen API-Aufruf jedoch Ihre Strategie zum Zusammenfassen oder Kürzen an, damit der Verlauf in das Token-Budget passt. So gehen niemals Daten verloren, während Sie zugleich nicht bei jeder Anfrage für den vollständigen Verlauf bezahlen.

Kontextwachstum im Produktivbetrieb überwachen

Protokollieren Sie die Token-Anzahl jedes API-Aufrufs und verfolgen Sie sie im Zeitverlauf anhand der Konversations-ID. Eine gesunde Konversation sollte zunächst allmählich wachsen und anschließend ein Plateau erreichen, sobald Zusammenfassungen eingesetzt werden. Eine Konversation, die ungebremst bis zum Kontextlimit wächst, deutet darauf hin, dass Ihre Logik zum Kürzen nicht korrekt funktioniert.

Überwachen Sie außerdem die durchschnittliche Kontextlänge über alle Konversationen hinweg. Steigt sie im Laufe der Zeit an, kann das darauf hindeuten, dass Ihr Standard-System-Prompt durch zusätzliche Funktionen wächst, Nutzer längere Eingaben einfügen oder RAG zunehmend größere Textabschnitte zurückgibt. Für jeden dieser Fälle ist eine andere Lösung erforderlich.

Strategien kombinieren: Ein Muster für den Produktivbetrieb

Ein robustes System zur Kontextverwaltung im Produktivbetrieb kombiniert mehrere Strategien in mehreren Schichten:

  1. Vor dem Zusammenstellen des Kontexts: Token-Budget prüfen und protokollieren
  2. Entitäten extrahieren: Einen strukturierten Speicherblock mit wichtigen Fakten einfügen
  3. Aktuellen Verlauf hinzufügen: Die letzten 6–10 Nachrichten wörtlich einbeziehen
  4. Älteren Verlauf zusammenfassen: Wenn älterer Verlauf vorhanden ist, eine fortlaufende Zusammenfassung einfügen
  5. Schutzprüfung: Wenn das Budget weiterhin überschritten wird, die ältesten wörtlich übernommenen Nachrichten kürzen

Dieser mehrschichtige Ansatz bewahrt die wichtigsten Informationen (Entitätenspeicher und aktuellen Kontext) und reduziert den älteren Verlauf kontrolliert zunächst auf Zusammenfassungen und erst als letzten Ausweg auf eine Kürzung.

Kurzer Wissenstest

Testen Sie Ihr Verständnis der Konzepte aus dem Bereich AI Engineering aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie Folgendes gelernt: Sliding Windows und tokenbewusstes Kürzen sind einfache Strategien, bei denen alter Kontext verworfen wird, um innerhalb der Limits zu bleiben, Zusammenfassungen komprimieren alte Gesprächsbeiträge in eine kompakte Darstellung, die wichtige Fakten bewahrt, und der Entitätsspeicher extrahiert strukturierte Fakten für einen tokensparsamen Langzeitspeicher innerhalb einer Unterhaltung. Als Nächstes sehen wir uns an, wie Sie LLMs mithilfe des JSON-Modus und strukturierter Ausgaben dazu bringen, zuverlässiges JSON zurückzugeben.

Häufig gestellte Fragen

Ist die Lektion „Strategien zur Einhaltung von Kontextgrenzen“ kostenlos?

Ja — der vollständige Text von „Strategien zur Einhaltung von Kontextgrenzen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Strategien zur Einhaltung von Kontextgrenzen“?

Sie implementieren ein Gedächtnis mit gleitendem Fenster, eine Nachrichtenzusammenfassung und das selektive Kürzen des Kontexts, um lange Gespräche ohne Überschreitung der Token-Grenzen zu verarbeite… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Strategien zur Einhaltung von Kontextgrenzen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Was ist ein Token?
  2. Kontextfenster: Größe und Auswirkungen
  3. API-Kosten berechnen und prognostizieren
  4. Strategien zur Einhaltung von Kontextgrenzen
← Zurück zu AI Engineering Academy