Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Kompakcia: Komprimovanie dlhých konverzácií

Lekcia 11 z 20 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Problém s dlhými konverzáciami
  2. Dve stratégie, ktoré musíš poznať
  3. Overenie, či sa kompakcia oplatí
  4. Kľúčové poznatky

Problém s dlhými konverzáciami

Každá správa pridaná do konverzácie zvyšuje počet tokenov odoslaných do API. Konverzácia s 50 obratmi môže ľahko dosiahnuť 30 000 vstupných tokenov, čo zvyšuje latenciu aj náklady. Problém je zákerný: prvý obrat asistenta podpory stojí niekoľko stoviek tokenov, zatiaľ čo tridsiaty obrat stojí niekoľko tisíc, hoci používateľ kladie presne rovnaký typ otázky. Platíš čoraz viac za identickú službu a používateľ čaká čoraz dlhšie na odpoveď.

Kompakcia tento problém rieši kompresiou histórie bez straty podstatných informácií. Spočíva v zhrnutí starších výmen na zníženie počtu tokenov pri zachovaní potrebného kontextu. Namiesto odoslania celej histórie odošleš zhrnutie minulých výmen plus najnovšie správy. Model stále vie, že meno zákazníka je Dupont, že má spornú objednávku a že si už ponúkol vrátenie peňazí, bez toho, aby musel znova čítať štyridsať správ, ktoré tieto skutočnosti stanovili.

Mechanizmus

Nižšie uvedená funkcia aplikuje túto logiku v jej najjednoduchšej forme: odhadne objem, neurobí nič, kým sa neprekročí prah, a potom rozdelí históriu na dve časti. Staršie správy idú do zhrnutia; tie najnovšie zostávajú nezmenené.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Kompaktuje históriu, keď prekročí prah."""

    # Odhad počtu tokenov (aproximácia)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # Nie je potrebné kompaktovať

    # Rozdelenie: staré správy vs. najnovšie
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Zhrnutie starých správ
    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,
    )

    # Zostavenie kompaktnnej histórie
    summary_message = {
        "role": "system",
        "content": f"Summary of previous conversation:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Dva detaily si zaslúžia tvoju pozornosť. Prompt pre zhrnutie explicitne požaduje prijaté rozhodnutia, pretože zhrnutie, ktoré si ponechá len témy, spôsobí, že model stratí pamäť na vlastné záväzky. A max_output_tokens=500 obmedzuje zhrnutie: bez tohto limitu by zhrnutie rástlo pri každej kompakcii a skončil by si presne s tým problémom, ktorý si sa snažil eliminovať.

Dve stratégie, ktoré musíš poznať

Posuvné okno so zhrnutím

Nasledujúca trieda industrializuje tento princíp. Udržiava jediné zhrnutie, ktoré prepisuje pri každej kompakcii integrovaním nových výmen, pričom zachováva okno surových správ. Kontext odoslaný do API sa preto vždy skladá z troch blokov: systémový prompt, kumulatívne zhrnutie a nedávne okno.

class CompactedConversation:
    """Spravuje konverzáciu s automatickou kompakciou."""

    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]:
        """Vytvára kontext na odoslanie do 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:]

Všimni si, že _compact vracia existujúce zhrnutie späť do promptu pred nové výmeny. To zabraňuje progresívnej amnézii: bez tohto vrátenia by každá kompakcia vymazala všetko, čo si tá predchádzajúca ponechala.

Selektívna kompakcia

Zhrňovanie je deštruktívne a niektorý obsah neprežije preformulovanie. Úryvok kódu, odpoveď JSON API alebo tabuľka čísel strácajú svoju užitočnosť hneď, ako sú parafrázované. Selektívna kompakcia preto triedi staré správy pred zhrnutím: tie obsahujúce kód alebo štruktúrované dáta prechádzajú nedotknuté, zatiaľ čo komprimovaný je len konverzačný text.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Kompaktuje pri zachovaní štruktúrovaných správ nedotknutých."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Ponechať správy obsahujúce kód alebo dáta
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Zhrnúť len konverzačný 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

Kritérium triedenia použité tu – prítomnosť trojitých spätných úvodzoviek alebo zloženej zátvorky – je zámerne hrubé. Prispôsob ho tomu, čo tvoje nástroje skutočne produkujú: pre asistenta, ktorý vybavuje referencie prípadov, môžeš chcieť zachovať každú správu obsahujúcu ID zákazníka.

Overenie, či sa kompakcia oplatí

Zle nastavená kompakcia stojí extra volanie API bez znateľného zisku, alebo komprimuje tak agresívne, že model stratí nit a pýta sa otázky, ktoré boli už vyriešené. Preto zmeraj pomer pred fixáciou konečných prahov pomocou vzorky reálnych konverzácií.

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

Zober tucet prepisov z tvojej produkčného prostredia, prežeň ich cez kompakciu a prečítaj si vyprodukované zhrnutia: ak nemôžeš obnoviť konverzáciu len na základe zhrnutia, tvoj prah je príliš nízky alebo tvoj prompt pre zhrnutie príliš vágny.

Kľúčové poznatky

  • Kompakcia znižuje počet tokenov zhrnutím starších správ
  • Vždy ponechaj najnovšie správy nedotknuté (posuvné okno)
  • Zachovaj správy obsahujúce kód alebo štruktúrované dáta
  • Pri každej novej kompakcii vráť existujúce zhrnutie späť, aby sa predišlo progresívnej amnézii
  • Zmeraj pomer kompresie na kalibráciu svojich prahov