Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kompaktavimas: ilgų pokalbių suspaudimas

Paskaita 11 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Ilgų pokalbių problema
  2. Dvi strategijos, kurias reikia žinoti
  3. Tikrinimas, ar kompaktavimas vertas efforto
  4. Svarbiausi punktai

Ilgų pokalbių problema

Kiekvienas pokalbiui pridėtas žinutės pranešimas padidina API siunčiamų tokenų skaičių. 50 ėjimų pokalbis lengvai gali pasiekti 30 000 įvesties tokenų, todėl didėja tiek delsos, tiek išlaidos. Problema yra klastinga: pirmasis pagalbos asistento ėjimas kainuoja kelis šimtus tokenų, o trisdešimtasis – kelis tūkstančius, nors vartotojas užduoda точно tokio paties tipo klausimą. Mokate vis daugiau už identišką paslaugą, o vartotojas laukia atsakymo vis ilgiau.

Kompaktavimas tai išsprendžia suspausdamas istoriją neprarandant esminės informacijos. Tai apima senesnių mainų apibendrinimą, siekiant sumažinti tokenų skaičių išlaikant būtiną kontekstą. Vietoj visos istorijos siuntimo siunčiate praeities mainų santrauką plus naujausius pranešimus. Modelis vis dar žino, kad kliento pavardė yra Dupont, kad jis turi ginčytiną užsakymą ir kad jau pasiūlėte grąžinti pinigus, nereikėdamas iš naujo perskaityti keturiasdešimties žinučių, kurios nustatė šiuos faktus.

Mechanizmas

Toliau pateikta funkcija taiko šią logiką paprasčiausia forma: ji įvertina apimtį, nieko nedaro, kol nepasiekiamas slenkstis, tada padalija istoriją į dvi dalis. Senesni pranešimai skirti santraukai; naujausi lieka nepakitę.

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

Du aspektai nusipelno tavo dėmesio. Santraukos raginimas aiškiai prašo įtraukti priimtus sprendimus, nes santrauka, išsauganti tik temas, priverčia modelį pamiršti savo įsipareigojimus. Be to, max_output_tokens=500 riboja santraukos dydį: be šio limito santrauka augtų su kiekvienu kompaktavimu ir galiausiai susidurtumėte būtent su ta problema, kurią bandėte pašalinti.

Dvi strategijos, kurias reikia žinoti

Slankusis langas su santrauka

Toliau pateikta klasė industrializuoja šį principą. Ji palaiko vieną santrauką, kurią perrašo kiekvieno kompaktavimo metu, integruodama naujus mainus, kartu išlaikydama žalių pranešimų langą. API siunčiamas kontekstą todėl visada sudaro trys blokai: sistemos raginimas, kaupiamoji santrauka ir naujausias langas.

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

Atkreipk dėmesį, kad _compact prieš naujus mainus į raginimą vėl įterpia esamą santrauką. Tai apsaugo nuo progresuojančios amnezijos: be šio įterpimo kiekvienas kompaktavimas ištrintų viską, ką buvo išsaugojęs ankstesnis.

Atrankinis kompaktavimas

Apibendrinimas yra destruktyvus, ir kai kuri turinys neišgyvena performulavimo. Kodo fragmentas, JSON API atsakas arba skaičių lentelė praranda savo naudą, kai tik yra parafruojami. Todėl atrankinis kompaktavimas prieš apibendrinant rūšiuoja senus pranešimus: tie, kuriuose yra kodo arba struktūrizuotų duomenų, praeina nepakitę, o suspaudžiamas tik pokalbių tekstas.

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

Čia naudojamas rūšiavimo kriterijus – trigubų atvirkštinių kabučių arba figūrinių skliaustų buvimas – sąmoningai yra grubus. Pritaikyk jį tam, ką iš tikrųjų generuoja tavo įrankiai: pavyzdžiui, asistentui, tvarkančiam bylų nuorodas, gali tekti išsaugoti bet kurį pranešimą, kuriame yra kliento ID.

Tikrinimas, ar kompaktavimas vertas efforto

Netinkamai sureguliuotas kompaktavimas kainuoja papildomą API užklausą be pastebimos naudos arba suspaudžia taip agresyviai, kad modelis praranda siūlą ir pradeda klausti klausimų, į kuriuos jau buvo atsakyta. Todėl prieš nustatydami galutinius slenksčius išmatuokite santykį naudodami realių pokalbių imtį.

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

Paimk tuziną transkriptų iš savo gamybinės aplinkos, paleisk juos per kompaktavimą ir perskaityk sugeneruotas santraukas: jei negali tęsti pokalbio remdamasis tik santrauka, tavo slenkstis yra per žemas arba santraukos raginimas per daug miglotas.

Svarbiausi punktai

  • Kompaktavimas sumažina tokenų skaičių apibendrinant senesnius pranešimus
  • Visada palikite naujausius pranešimus nepaliestus (slankusis langas)
  • Išsaugokite pranešimus, kuriuose yra kodo arba struktūrizuotų duomenų
  • Kiekvieno naujo kompaktavimo metu vėl įterpkite esamą santrauką, kad išvengtumėte progresuojančios amnezijos
  • Išmatuokite suspaudimo santykį, kad tinkamai sureguliuotumėte savo slenksčius