Kompaktering: Komprimera långa konversationer
På denna sida
Problemet med långa konversationer
Varje meddelande som läggs till i en konversation ökar antalet token som skickas till API:et. En konversation på 50 turer kan lätt nå 30 000 input-token, vilket driver upp både latens och kostnad. Problemet är lömskt: den första turen för en supportassistent kostar några hundra token, medan den trettionde turen kostar flera tusen trots att användaren ställer exakt samma typ av fråga. Du betalar mer och mer för en identisk tjänst, och användaren väntar längre och längre på ett svar.
Kompaktering löser detta genom att komprimera historiken utan att förlora väsentlig information. Det innebär att du sammanfattar äldre utbyten för att minska antalet token samtidigt som nödvändig kontext bevaras. Istället för att skicka hela historiken skickar du en sammanfattning av tidigare utbyten plus de senaste meddelandena. Modellen vet fortfarande att kundens namn är Dupont, att det finns en omtvistad order och att du redan erbjudit återbetalning, utan att behöva läsa om de fyrtio meddelanden som fastställde dessa fakta.
Mekanismen
Funktionen nedan tillämpar denna logik i sin enklaste form: den uppskattar volymen, gör ingenting förrän tröskeln passeras, och delar sedan upp historiken i två delar. Äldre meddelanden går till sammanfattningen; de senaste lämnas orörda.
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
Två detaljer förtjänar din uppmärksamhet. Prompten för sammanfattningen begär uttryckligen fattade beslut, eftersom en sammanfattning som bara behåller teman får modellen att glömma sina egna åtaganden. Och max_output_tokens=500 sätter ett tak för sammanfattningen: utan denna gräns växer sammanfattningen vid varje kompaktering, och du hamnar med exakt det problem du försökte eliminera.
Två strategier att känna till
Glidande fönster med sammanfattning
Klassen nedan industrialiserar principen. Den underhåller en enda sammanfattning som skrivs om vid varje kompaktering genom att integrera nya utbyten, samtidigt som ett fönster av råa meddelanden behålls. Kontexten som skickas till API:et består därför alltid av tre block: systemprompten, den kumulativa sammanfattningen och det senaste fönstret.
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:]
Observera att _compact matar in den befintliga sammanfattningen i prompten innan de nya utbytena. Detta förhindrar progressiv amnesi: utan denna återinmatning skulle varje kompaktering radera allt som den föregående hade behållit.
Selektiv kompaktering
Sammanfattning är destruktivt, och visst innehåll överlever inte en omformulering. Ett kodsnutt, ett JSON-svar från ett API eller en tabell med siffror förlorar sin nytta så snart det parafraseras. Selektiv kompaktering sorterar därför gamla meddelanden innan sammanfattning: de som innehåller kod eller strukturerad data passerar intakta, medan endast konversationstext komprimeras.
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
Sorteringskriteriet som används här – förekomst av tre backticks eller en klammerparentes – är avsiktligt grovt. Anpassa det till vad dina verktyg faktiskt producerar: för en assistent som hanterar ärendereferenser kanske du vill bevara alla meddelanden som innehåller ett kund-ID.
Verifiera att kompaktering lönar sig
Dåligt kalibrerad kompaktering kostar ett extra API-anrop utan märkbar vinst, eller komprimerar så aggressivt att modellen tappar tråden och ställer frågor som redan är lösta. Mät därför förhållandet innan du låser dina slutgiltiga tröskelvärden, med hjälp av ett urval av verkliga konversationer.
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),
}
Ta ett dussin transkript från din produktionsmiljö, kör dem genom kompaktering och läs de producerade sammanfattningarna: om du inte kan återuppta konversationen baserat enbart på sammanfattningen är din tröskel för låg eller din sammanfattningsprompt för vag.
Viktiga punkter
- Kompaktering minskar antalet token genom att sammanfatta äldre meddelanden
- Behåll alltid de senaste meddelandena intakta (glidande fönster)
- Bevara meddelanden som innehåller kod eller strukturerad data
- Mata in den befintliga sammanfattningen vid varje ny kompaktering för att undvika progressiv amnesi
- Mät komprimeringsförhållandet för att kalibrera dina tröskelvärden