Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Compaction: lange gesprekken comprimeren

Les 11 van 20 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. Het probleem met lange gesprekken
  2. Twee strategieën om te kennen
  3. Verifiëren of compaction de moeite waard is
  4. Belangrijkste punten

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