Compaction: lange gesprekken comprimeren
Op deze pagina
Het probleem met lange gesprekken
Elk bericht dat aan een gesprek wordt toegevoegd, verhoogt het aantal tokens dat naar de API wordt verzonden. Een gesprek van 50 beurten kan gemakkelijk oplopen tot 30.000 input-tokens, wat zowel de latentie als de kosten opdrijft. Het probleem is verraderlijk: de eerste beurt van een supportassistent kost een paar honderd tokens, terwijl de dertigste beurt enkele duizenden tokens kost, ook al stelt de gebruiker exact hetzelfde type vraag. U betaalt steeds meer voor een identieke dienst en de gebruiker wacht steeds langer op een antwoord.
Compaction lost dit op door de geschiedenis te comprimeren zonder essentiële informatie te verliezen. Het komt erop neer oudere uitwisselingen samen te vatten om het aantal tokens te verlagen, terwijl de noodzakelijke context behouden blijft. In plaats van de volledige geschiedenis te verzenden, stuurt u een samenvatting van eerdere uitwisselingen plus de recente berichten. Het model weet nog steeds dat de klant Dupont heet, dat er een betwiste bestelling is en dat u al een terugbetaling hebt aangeboden, zonder de veertig berichten te hoeven herlezen die deze feiten hebben vastgesteld.
Het mechanisme
De onderstaande functie past deze logica in zijn eenvoudigste vorm toe: hij schat het volume, doet niets totdat de drempel wordt overschreden en splitst de geschiedenis vervolgens in twee delen. Oudere berichten gaan naar de samenvatting; de meest recente blijven ongewijzigd.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Compacts history when it exceeds the threshold."""
# Estimate token count (approximation)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # No need to compact
# Split: old messages vs recent ones
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Summarize old messages
old_text = "\n".join(
f"{m['role']}: {m['content']}" for m in old_messages
)
response = client.responses.create(
model="gpt-5.6-terra",
input=(
"Summarize this conversation concisely. "
"Keep key factual information, decisions made, "
"and the context needed to understand what follows.\n\n"
f"{old_text}"
),
max_output_tokens=500,
)
# Rebuild compacted history
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Twee details verdienen uw aandacht. De samenvattingsprompt vraagt expliciet om genomen beslissingen, omdat een samenvatting die alleen thema’s behoudt, ervoor zorgt dat het model het geheugen aan zijn eigen toezeggingen verliest. En max_output_tokens=500 begrenst de samenvatting: zonder deze limiet groeit de samenvatting bij elke compaction, en eindigt u met precies het probleem dat u probeerde op te lossen.
Twee strategieën om te kennen
Schuivend venster met samenvatting
De volgende klasse industrialiseert het principe. Het onderhoudt één samenvatting die bij elke compaction wordt herschreven door nieuwe uitwisselingen te integreren, terwijl een venster van ruwe berichten behouden blijft. De context die naar de API wordt verzonden, bestaat daarom altijd uit drie blokken: de systeemprompt, de cumulatieve samenvatting en het recente venster.
class CompactedConversation:
"""Manages a conversation with automatic compaction."""
def __init__(
self,
system_prompt: str,
compaction_threshold: int = 8_000,
window_size: int = 8,
):
self.system_prompt = system_prompt
self.threshold = compaction_threshold
self.window_size = window_size
self.summary: str | None = None
self.messages: list[dict] = []
def build_context(self) -> list[dict]:
"""Builds the context to send to the API."""
context = [{"role": "system", "content": self.system_prompt}]
if self.summary:
context.append({
"role": "system",
"content": f"Previous context: {self.summary}",
})
context.extend(self.messages[-self.window_size:])
return context
def add_message(self, role: str, content: str):
self.messages.append({"role": role, "content": content})
self._check_compaction()
def _check_compaction(self):
tokens = sum(len(m["content"]) // 4 for m in self.messages)
if tokens > self.threshold:
self._compact()
def _compact(self):
old_messages = self.messages[:-self.window_size]
if not old_messages:
return
text = "\n".join(
f"{m['role']}: {m['content']}" for m in old_messages
)
existing_context = f"Existing summary: {self.summary}\n\n" if self.summary else ""
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"{existing_context}"
f"New exchanges to integrate into the summary:\n{text}\n\n"
"Produce an updated, concise, and factual summary."
),
max_output_tokens=400,
)
self.summary = response.output_text
self.messages = self.messages[-self.window_size:]
Merk op dat _compact de bestaande samenvatting opnieuw in de prompt injecteert vóór de nieuwe uitwisselingen. Dit voorkomt progressieve geheugenverlies: zonder deze herinjectie zou elke compaction alles wissen wat de vorige had behouden.
Selectieve compaction
Samenvatten is destructief en sommige inhoud overleeft herformulering niet. Een codefragment, een JSON-API-reactie of een tabel met cijfers verliest zijn nut zodra het wordt geparafraseerd. Selectieve compaction sorteert daarom oude berichten voordat ze worden samengevat: berichten met code of gestructureerde gegevens gaan intact door, terwijl alleen conversatietekst wordt gecomprimeerd.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Compacts while keeping structured messages intact."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Keep messages containing code or data
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Summarize only conversational text
summary = ""
if to_summarize:
text = "\n".join(f"{m['role']}: {m['content']}" for m in to_summarize)
response = client.responses.create(
model="gpt-5.6-terra",
input=f"Summarize these exchanges in 3 sentences:\n{text}",
max_output_tokens=200,
)
summary = response.output_text
result = []
if summary:
result.append({
"role": "system",
"content": f"Summary of exchanges: {summary}",
})
result.extend(to_keep)
result.extend(recent_messages)
return result
Het hier gebruikte sorteercriterium – de aanwezigheid van drie backticks of een accolade – is bewust ruw. Pas dit aan aan wat uw tools daadwerkelijk produceren: voor een assistent die zaakreferenties behandelt, wilt u misschien elk bericht bewaren dat een klant-ID bevat.
Verifiëren of compaction de moeite waard is
Slecht gekalibreerde compaction kost een extra API-oproep zonder merkbare winst, of comprimeert zo agressief dat het model de draad kwijtraakt en vragen stelt die al zijn opgelost. Meet daarom de verhouding voordat u uw definitieve drempels vastlegt, met behulp van een steekproef van echte gesprekken.
def compaction_ratio(
before: list[dict],
after: list[dict],
) -> dict:
tokens_before = sum(len(m["content"]) // 4 for m in before)
tokens_after = sum(len(m["content"]) // 4 for m in after)
reduction = 1 - (tokens_after / tokens_before) if tokens_before else 0
return {
"tokens_before": tokens_before,
"tokens_after": tokens_after,
"reduction": f"{reduction:.0%}",
"messages_before": len(before),
"messages_after": len(after),
}
Neem een dozijn transcripties uit uw productieomgeving, voer ze door compaction en lees de geproduceerde samenvattingen: als u het gesprek niet kunt hervatten op basis van alleen de samenvatting, is uw drempel te laag of uw samenvattingsprompt te vaag.
Belangrijkste punten
- Compaction vermindert tokens door oudere berichten samen te vatten
- Houd de meest recente berichten altijd intact (schuivend venster)
- Bewaar berichten die code of gestructureerde gegevens bevatten
- Injecteer de bestaande samenvatting bij elke nieuwe compaction opnieuw om progressief geheugenverlies te voorkomen
- Meet de compressieverhouding om uw drempels te kalibreren