Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kompaktering: Komprimering af lange samtaler

Lektion 11 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Problemet med lange samtaler
  2. To strategier, du skal kende
  3. Verificering af, at kompaktering er det værd
  4. Vigtige pointer

Problemet med lange samtaler

Hver besked, der føjes til en samtale, øger antallet af tokens, der sendes til API’et. En samtale på 50 turer kan nemt nå op på 30.000 input-tokens, hvilket driver både ventetid og omkostninger i vejret. Problemet er snigende: Den første tur for en support-assistent koster et par hundrede tokens, mens den tredive tur koster flere tusind, selvom brugeren stiller præcis den samme type spørgsmål. Du betaler mere og mere for en identisk ydelse, og brugeren venter længere og længere på et svar.

Kompaktering løser dette ved at komprimere historikken uden at miste væsentlig information. Det indebærer at opsummere ældre udvekslinger for at reducere antallet af tokens, mens den nødvendige kontekst bevares. I stedet for at sende hele historikken sender du et resumé af tidligere udvekslinger plus de seneste beskeder. Modellen ved stadig, at kundens navn er Dupont, at de har en omtvistet ordre, og at du allerede har tilbudt en refusion, uden at skulle genlæse de fyrre beskeder, der etablerede disse fakta.

Mekanismen

Funktionen nedenfor anvender denne logik i sin enkleste form: Den estimerer volumenet, gør ingenting, før tærsklen overskrides, og deler derefter historikken i to dele. Ældre beskeder går til resuméet; de seneste forbliver uændrede.

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

To detaljer fortjener din opmærksomhed. Prompten til resuméet anmoder eksplicit om trufne beslutninger, fordi et resumé, der kun beholder temaer, får modellen til at glemme sine egne forpligtelser. Og max_output_tokens=500 sætter et loft for resuméet: Uden denne grænse vokser resuméet ved hver kompaktering, og du ender med præcis det problem, du forsøgte at eliminere.

To strategier, du skal kende

Glidende vindue med resumé

Klassen nedenfor industrialiserer princippet. Den vedligeholder et enkelt resumé, som den omskriver ved hver kompaktering ved at integrere nye udvekslinger, mens den beholder et vindue af rå beskeder. Den kontekst, der sendes til API’et, består derfor altid af tre blokke: system-prompten, det kumulative resumé og det seneste vindue.

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:]

Bemærk, at _compact genindsætter det eksisterende resumé i prompten før de nye udvekslinger. Dette forhindrer progressiv amnesi: Uden denne genindsættelse ville hver kompaktering slette alt, som den tidligere havde beholdt.

Selektiv kompaktering

Opsummering er destruktiv, og noget indhold overlever ikke en omformulering. Et kodeudsnit, et JSON-API-svar eller en tabel med tal mister sin nytteværdi, så snart det bliver parafraseret. Selektiv kompaktering sorterer derfor gamle beskeder før opsummering: De, der indeholder kode eller strukturerede data, går intakte igennem, mens kun konversationstekst komprimeres.

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, der bruges her – tilstedeværelsen af triple backticks eller en krøllet parentes – er bevidst groft. Tilpas det til, hvad dine værktøjer faktisk producerer: For en assistent, der håndterer sagsreferencer, vil du måske gerne bevare enhver besked, der indeholder et kunde-ID.

Verificering af, at kompaktering er det værd

Dårligt kalibreret kompaktering koster et ekstra API-kald uden mærkbar gevinst, eller også komprimerer den så aggressivt, at modellen mister tråden og stiller spørgsmål, der allerede er besvaret. Mål derfor forholdet, før du fastlægger dine endelige tærskler, ved hjælp af en stikprøve af rigtige samtaler.

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),
    }

Tag et dusin transkripter fra dit produktionsmiljø, kør dem gennem kompaktering, og læs de producerede resuméer: Hvis du ikke kan genoptage samtalen udelukkende på baggrund af resuméet, er din tærskel for lav, eller din resumé-prompt for vag.

Vigtige pointer

  • Kompaktering reducerer tokens ved at opsummere ældre beskeder
  • Behold altid de seneste beskeder intakte (glidende vindue)
  • Bevar beskeder, der indeholder kode eller strukturerede data
  • Genindsæt det eksisterende resumé ved hver ny kompaktering for at undgå progressiv amnesi
  • Mål komprimeringsforholdet for at kalibrere dine tærskler