Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kompaktimine: pikkade vestluste tihendamine

Õppetund 11 / 20 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Pikkade vestluste probleem
  2. Kaks strateegiat, mida tundma õppida
  3. Kontrolli, kas tihendamine on seda väärt
  4. Peamised punktid

Pikkade vestluste probleem

Iga vestlusele lisatud sõnum suurendab API-le saadetavate tokenite arvu. 50 pöördega vestlus võib hõlpsasti jõuda 30 000 sisendtokenini, mis tõstab nii latentsust kui ka kulusid. Probleem on salakaval: tugiteenuse assistendi esimene pööre maksab paar sada tokenit, samas kui kolmekümnes pööre maksab mitu tuhat, kuigi kasutaja küsib täpselt sama tüüpi küsimust. Sa maksad üha rohkem identse teenuse eest ja kasutaja ootab vastust üha kauem.

Kompaktimine lahendab selle, tihendades ajalugu ilma olulist teavet kaotamata. See hõlmab vanemate vahetuste kokkuvõtmist tokenite arvu vähendamiseks, säilitades samal ajal vajaliku konteksti. Kogu ajaloo saatmise asemel saadad mineviku vahetuste kokkuvõtte koos viimaste sõnumitega. Mudel teab endiselt, et kliendi nimi on Dupont, et tal on vaidlustatud tellimus ja et oled juba tagasimakset pakkunud, ilma et peaks uuesti läbi lugema neljakümmet sõnumit, mis need faktid kindlaks tegid.

Mehhanism

Allpool olev funktsioon rakendab seda loogikat oma lihtsaimal kujul: see hindab mahtu, ei tee midagi enne lävendi ületamist ja jagab seejärel ajaloo kaheks osaks. Vanemad sõnumid lähevad kokkuvõttesse; kõige uuemad jäävad muutmata.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Tihendab ajaloo, kui see ületab lävendi."""

    # Hinda tokenite arvu (ligikaudne)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # Tihendamine pole vajalik

    # Jaota: vanad sõnumid vs viimased
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Võta vanadest sõnumitest kokkuvõte
    old_text = "\n".join(
        f"{m['role']}: {m['content']}" for m in old_messages
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            "Võta sellest vestlusest lühike kokkuvõte. "
            "Jäta alles peamised faktilised andmed, tehtud otsused "
            "ja kontekst, mis on vajalik järgneva mõistmiseks.\n\n"
            f"{old_text}"
        ),
        max_output_tokens=500,
    )

    # Taasta tihendatud ajalugu
    summary_message = {
        "role": "system",
        "content": f"Eelmise vestluse kokkuvõte:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Kaks detaili väärivad tähelepanu. Kokkuvõtte viip palub sõnaselgelt tehtud otsuseid, sest kokkuvõte, mis säilitab ainult teemad, paneb mudeli unustama oma enda kohustused. Ja max_output_tokens=500 piirab kokkuvõtet: ilma selle piiranguta kasvaks kokkuvõte iga tihendamisega ja lõpetaksid täpselt selle probleemiga, mida püüdsid kõrvaldada.

Kaks strateegiat, mida tundma õppida

Liuguv aken koos kokkuvõttega

Järgnev klass industrialiseerib põhimõtet. See haldab ühte kokkuvõtet, mida kirjutatakse iga tihendamise korral ümber, integreerides uusi vahetusi, hoides samal ajal toorsõnumite akent. API-le saadetav kontekst koosneb seega alati kolmest plokist: süsteemiviip, kumulatiivne kokkuvõte ja viimane aken.

class CompactedConversation:
    """Haldab vestlust automaatse tihendamisega."""

    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]:
        """Ehitab API-le saadetava konteksti."""
        context = [{"role": "system", "content": self.system_prompt}]

        if self.summary:
            context.append({
                "role": "system",
                "content": f"Eelnev kontekst: {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"Olemasolev kokkuvõte: {self.summary}\n\n" if self.summary else ""

        response = client.responses.create(
            model="gpt-5.6-terra",
            input=(
                f"{existing_context}"
                f"Uued vahetused, mis tuleb kokkuvõttesse integreerida:\n{text}\n\n"
                "Koosta uuendatud, lühike ja faktiline kokkuvõte."
            ),
            max_output_tokens=400,
        )

        self.summary = response.output_text
        self.messages = self.messages[-self.window_size:]

Pane tähele, et _compact sisestab olemasoleva kokkuvõtte enne uusi vahetusi uuesti viipa. See hoiab ära progresseeruva amneesia: ilma selle uuesti sisestamiseta kustutaks iga tihendamine kõik, mida eelmine oli säilitanud.

Valikuline tihendamine

Kokkuvõtete tegemine on destruktiivne ja mõni sisu ei ela ümberformuleerimist üle. Koodilõik, JSON-API vastus või arvude tabel kaotab oma kasulikkuse niipea, kui seda parafraseeritakse. Valikuline tihendamine sorteerib seega vanad sõnumid enne kokkuvõtte tegemist: need, mis sisaldavad koodi või struktureeritud andmeid, läbivad protsessi muutumatuna, samal ajal kui tihendatakse ainult vestlusteksti.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Tihendab, hoides struktureeritud sõnumid muutmatuna."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Säilita koodi või andmeid sisaldavad sõnumid
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Võta kokkuvõte ainult vestlustekstist
    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"Võta nendest vahetustest 3 lausega kokkuvõte:\n{text}",
            max_output_tokens=200,
        )
        summary = response.output_text

    result = []
    if summary:
        result.append({
            "role": "system",
            "content": f"Vahetuste kokkuvõte: {summary}",
        })
    result.extend(to_keep)
    result.extend(recent_messages)
    return result

Siin kasutatud sorteerimiskriteerium – kolme tagurpidi komaga või looksulu olemasolu – on tahtlikult toores. Kohanda seda selle järgi, mida sinu tööriistad tegelikult toodavad: näiteks juhtumeid haldava assistendi puhul võid soovida säilitada iga sõnumi, mis sisaldab kliendi ID-d.

Kontrolli, kas tihendamine on seda väärt

Halvasti kalibreeritud tihendamine toob kaasa täiendava API kõne ilma märgatava kasuta või tihendab nii agressiivselt, et mudel kaotab niidi otsa ja küsib juba lahendatud küsimusi. Seetõttu mõõda suhet enne lõplike lävendite fikseerimist, kasutades reaalsete vestluste valimit.

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

Võta tootmiskeskkonnast tosin transkripti, lase need läbi tihendamise ja loe loodud kokkuvõtteid: kui sa ei saa vestlust jätkata ainult kokkuvõtte põhjal, on sinu lävend liiga madal või kokkuvõtte viip liiga ebamäärane.

Peamised punktid

  • Kompaktimine vähendab tokeneid, võttes vanematest sõnumitest kokkuvõtte
  • Säilita alati kõige uuemad sõnumid muutumatuna (liuguv aken)
  • Säilita koodi või struktureeritud andmeid sisaldavad sõnumid
  • Sisesta olemasolev kokkuvõte iga uue tihendamise korral uuesti, et vältida progresseeruvat amneesiat
  • Mõõda tihendussuhet oma lävendite kalibreerimiseks