Zusammenfassungsspeicher und tokenbewusstes Kürzen
Sie verwenden ConversationSummaryMemory, um ältere Gesprächsrunden automatisch zusammenzufassen, das Gespräch kompakt zu halten und dabei wichtige zuvor genannte Fakten zu bewahren.
Zusammenfassungsspeicher und tokenbewusstes Kürzen ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Die Tokenkosten des vollständigen Verlaufs
Der Gesprächspufferspeicher behält jede jemals ausgetauschte Nachricht, wodurch Ihr Kontextfenster schnell aufgebraucht wird. Ein Gespräch mit 100 Runden kann allein für den Verlauf 20.000 Tokens benötigen, sodass nur wenig Platz für die eigentliche Antwort bleibt. Der Zusammenfassungsspeicher löst dieses Problem, indem er alte Runden durch eine komprimierte Zusammenfassung ersetzt.
So funktioniert der Zusammenfassungsspeicher
Wenn die Gesamtzahl der Tokens einen Schwellenwert überschreitet, übergibt ConversationSummaryMemory die ältesten Gesprächsrunden an ein LLM und fordert es auf, die wichtigsten Punkte zusammenzufassen. Die vollständigen Runden werden verworfen und durch diese kompakte Zusammenfassung ersetzt. Nachfolgende Runden bauen auf der Zusammenfassung auf.
- Alte Runden: durch eine Zusammenfassung ersetzt
- Aktuelle Runden: wörtlich beibehalten
- Ergebnis: sinnvolle Komprimierung bei minimalem Informationsverlust
LangChain ConversationSummaryMemory
LangChain stellt ConversationSummaryMemory bereit, das den Verlauf automatisch zusammenfasst, sobald der Puffer zu groß wird. Sie übergeben dem Speicherobjekt ein LLM, damit es das Modell bei Bedarf zur Erstellung von Zusammenfassungen aufrufen kann.
from langchain.memory import ConversationSummaryMemory
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model='gpt-4o-mini')
memory = ConversationSummaryMemory(
llm=llm,
return_messages=True
)
# Add messages manually
memory.save_context(
{'input': 'My name is Alice and I am building a RAG system.'},
{'output': 'Great, I can help you build a RAG system, Alice.'}
)
print(memory.load_memory_variables({}))Zusammenfassungs-Pufferspeicher: Das Beste aus beiden Ansätzen
ConversationSummaryBufferMemory ist ein hybrider Ansatz: Er behält die aktuellsten Runden zur Gewährleistung der Genauigkeit wörtlich bei und fasst nur die älteren Runden zusammen, die ein max_token_limit überschreiten. So erhalten Sie exakte Rückbezüge auf den aktuellen Kontext und komprimierte Rückbezüge auf ältere Inhalte.
from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model='gpt-4o-mini')
memory = ConversationSummaryBufferMemory(
llm=llm,
max_token_limit=500, # Summarize when older turns exceed 500 tokens
return_messages=True
)
# As the conversation grows, old turns get summarized automatically
print('Moving summary:', memory.moving_summary_buffer)Tokens vor dem Kürzen zählen
Für intelligente Entscheidungen beim Kürzen müssen Sie wissen, wie viele Tokens Ihre Nachrichten verbrauchen. Mit der Bibliothek tiktoken können Sie Tokens für jedes OpenAI-Modell zählen. So können Sie ein tokenbewusstes Kürzen implementieren, das strikt innerhalb eines Budgets bleibt.
import tiktoken
def count_tokens(messages: list, model: str = 'gpt-4o') -> int:
encoding = tiktoken.encoding_for_model(model)
total = 0
for msg in messages:
# Each message has overhead tokens for role framing
total += 4
total += len(encoding.encode(msg.get('content', '')))
total += 2 # Reply primer
return total
messages = [
{'role': 'user', 'content': 'Explain RAG to me.'},
{'role': 'assistant', 'content': 'RAG stands for Retrieval-Augmented Generation...'}
]
print('Token count:', count_tokens(messages))Manuelles tokenbewusstes Kürzen
Manchmal möchten Sie das Kürzen vollständig selbst steuern, ohne die Speicherklassen von LangChain zu verwenden. Ein einfacher Ansatz: Behalten Sie alle Nachrichten und entfernen Sie anschließend nacheinander die ältesten Nicht-Systemnachrichten, bis die Gesamtzahl der Tokens in Ihr Budget passt.
def truncate_to_budget(messages: list, budget: int, model: str = 'gpt-4o') -> list:
'''Remove oldest non-system messages until under budget.'''
import tiktoken
encoding = tiktoken.encoding_for_model(model)
def token_count(msgs):
total = 2
for m in msgs:
total += 4 + len(encoding.encode(m.get('content', '')))
return total
result = list(messages)
while token_count(result) > budget and len(result) > 1:
# Never remove the system prompt at index 0
if result[0]['role'] == 'system':
del result[1]
else:
del result[0]
return resultDen Zusammenfassungs-Prompt erstellen
Wenn Sie Ihren eigenen Zusammenfassungsspeicher erstellen, formulieren Sie einen Prompt, der das LLM auffordert, die wichtigsten Fakten herauszuarbeiten. Der Prompt sollte das Modell anweisen, Benutzerpräferenzen, benannte Entitäten und offene Fragen zu erfassen – also die Fakten, die in späteren Runden am wahrscheinlichsten relevant sind.
from openai import OpenAI
client = OpenAI()
def summarize_history(old_summary: str, new_turns: list) -> str:
turns_text = '\n'.join(
f'{m["role"].capitalize()}: {m["content"]}' for m in new_turns
)
prompt = f'''Current summary:\n{old_summary}\n\nNew conversation turns:\n{turns_text}\n\nWrite an updated summary that captures key facts, user preferences, and open questions.'''
resp = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return resp.choices[0].message.contentDie Zusammenfassung in den System-Prompt integrieren
Sobald Sie eine Zusammenfassung haben, fügen Sie sie in den System-Prompt ein, damit das LLM stets Kontext zum Gesprächsverlauf besitzt. Stellen Sie die Zusammenfassung als kurzen Kontextblock voran und platzieren Sie ihn vor den eigentlichen Persona-Anweisungen.
def build_messages_with_summary(summary: str, recent_turns: list, user_input: str) -> list:
system_content = (
'You are a helpful AI assistant.'
+ ('\n\n[Conversation summary]\n' + summary if summary else '')
)
messages = [{'role': 'system', 'content': system_content}]
messages.extend(recent_turns)
messages.append({'role': 'user', 'content': user_input})
return messagesZusammenfassungen automatisch auslösen
Ein gängiges Muster besteht darin, die Zusammenfassung auszulösen, sobald das Gespräch einen Token-Schwellenwert überschreitet – beispielsweise wenn der laufende Verlauf mehr als 2.000 Tokens umfasst. Fassen Sie dann alle bis auf die letzten beiden Runden zusammen und ersetzen Sie sie durch die Zusammenfassung.
class SummaryBufferChat:
def __init__(self, max_tokens=2000):
self.summary = ''
self.recent_turns = []
self.max_tokens = max_tokens
def chat(self, user_message: str) -> str:
from openai import OpenAI
client = OpenAI()
messages = build_messages_with_summary(self.summary, self.recent_turns, user_message)
resp = client.chat.completions.create(model='gpt-4o', messages=messages)
reply = resp.choices[0].message.content
self.recent_turns.append({'role': 'user', 'content': user_message})
self.recent_turns.append({'role': 'assistant', 'content': reply})
if count_tokens(self.recent_turns) > self.max_tokens:
to_summarize = self.recent_turns[:-2]
self.recent_turns = self.recent_turns[-2:]
self.summary = summarize_history(self.summary, to_summarize)
return replyBenannte Entitäten in Zusammenfassungen bewahren
Die Qualität einer Zusammenfassung hängt maßgeblich vom Prompt zur Zusammenfassung ab. Wenn Nutzer ihren Namen, Standort, ihre Präferenzen oder Fristen nennen, muss Ihr Prompt das Modell ausdrücklich anweisen, diese Angaben aufzunehmen. Allgemeine Zusammenfassungen lassen häufig Eigennamen weg, die für die Personalisierung besonders wichtig sind.
- Aufnehmen: Namen, Daten, getroffene technische Entscheidungen, offene Fragen
- Weglassen: belanglose Gesprächsanteile, Bestätigungen, wiederholte Höflichkeitsfloskeln
Abwägung: Zusammenfassung oder Window Memory
Welche Variante Sie wählen sollten, hängt vom Anwendungsfall ab. Window Memory bewahrt den genauen Wortlaut, was für präzises Erinnern wichtig ist, aber Tokens für irrelevanten Kontext verbraucht. Summary Memory komprimiert Inhalte stark, erfordert jedoch einen zusätzlichen LLM-Aufruf und kann Details aus Sonderfällen verlieren. Die meisten Chatbots in Produktionsumgebungen verwenden einen hybriden Ansatz: die letzten Gesprächsrunden im Original sowie eine fortlaufend aktualisierte Zusammenfassung älterer Inhalte.
Kurze Überprüfung
Testen Sie Ihr Verständnis der Konzepte Summary Memory und tokenbewusster Kürzung.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Summary Memory komprimiert ältere Gesprächsrunden mithilfe eines LLM-Aufrufs, ConversationSummaryBufferMemory kombiniert die exakten letzten Gesprächsrunden mit zusammengefassten älteren Inhalten und tiktoken ermöglicht eine tokenbewusste Kürzung, damit Gespräche innerhalb des Budgets bleiben. Als Nächstes sehen Sie sich an, wie sich der Chatverlauf für eine dauerhafte und skalierbare Speicherung in Redis und PostgreSQL persistieren lässt.
Lerne Python mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Zusammenfassungsspeicher und tokenbewusstes Kürzen“ kostenlos?
Ja — der vollständige Text von „Zusammenfassungsspeicher und tokenbewusstes Kürzen“ 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 „Zusammenfassungsspeicher und tokenbewusstes Kürzen“?
Sie verwenden ConversationSummaryMemory, um ältere Gesprächsrunden automatisch zusammenzufassen, das Gespräch kompakt zu halten und dabei wichtige zuvor genannte Fakten zu bewahren. 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 3 von 4.
Wie lange dauert die Lektion „Zusammenfassungsspeicher und tokenbewusstes Kürzen“?
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
- Warum zustandslose LLMs externen Speicher benötigen
- Puffer- und Fensterspeicher
- Zusammenfassungsspeicher und tokenbewusstes Kürzen
- Chatverläufe in Redis und PostgreSQL speichern