Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Kompaktiranje: Stiskanje dolgih pogovorov

Lekcija 11 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Težava z dolgimi pogovori
  2. Dve strategiji, ki ju moraš poznati
  3. Preverjanje, ali se kompaktiranje splača
  4. Ključne ugotovitve

Težava z dolgimi pogovori

Vsako sporočilo, dodano v pogovor, poveča število žetonov, poslanih API-ju. Pogovor s 50 izmenjavami zlahka doseže 30.000 vhodnih žetonov, kar poveča tako zakasnitev kot stroške. Težava je zahrbtna: prvi klic podpornega asistenta stane nekaj sto žetonov, medtem ko trideseti klic stane več tisoč, čeprav uporabnik zastavlja popolnoma enako vrsto vprašanja. Plačuješ vse več za identično storitev, uporabnik pa čaka vse dlje na odgovor.

Kompaktiranje to reši s stiskanjem zgodovine brez izgube bistvenih informacij. Vključuje povzemanje starejših izmenjav za zmanjšanje števila žetonov ob ohranjanju potrebnega konteksta. Namesto pošiljanja celotne zgodovine pošlješ povzetek preteklih izmenjav plus nedavna sporočila. Model še vedno ve, da se stranka imenuje Dupont, da ima sporni naročilo in da ste že ponudili povračilo, ne da bi moral znova prebrati štirideset sporočil, ki so ta dejstva vzpostavila.

Mehanizem

Spodnja funkcija uporablja to logiko v najpreprostejši obliki: oceni volumen, ne stori ničesar, dokler ni presežen prag, nato pa zgodovino razdeli na dva dela. Starejša sporočila gredo v povzetek; najnovejša ostanejo nespremenjena.

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

Dve podrobnosti si zaslužita tvojo pozornost. Poziv za povzetek izrecno zahteva sprejete odločitve, saj povzetek, ki ohranja le teme, povzroči, da model izgubi spomin na lastne zaveze. In max_output_tokens=500 omeji povzetek: brez te omejitve bi povzetek rasel z vsakim kompaktiranjem in končal bi s prav tisto težavo, ki si jo želel odpraviti.

Dve strategiji, ki ju moraš poznati

Drsno okno s povzetkom

Spodnji razred industrializira to načelo. Vzdržuje en sam povzetek, ki ga prepisuje ob vsakem kompaktiranju z vključevanjem novih izmenjav, hkrati pa ohranja okno surovih sporočil. Kontekst, poslan API-ju, zato vedno sestavljajo trije bloki: sistemski poziv, kumulativni povzetek in nedavno okno.

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

Upoštevaj, da _compact ponovno vbrizga obstoječi povzetek v poziv pred nove izmenjave. To preprečuje progresivno amnezijo: brez tega ponovnega vbrizgavanja bi vsako kompaktiranje izbrisalo vse, kar je ohranilo prejšnje.

Selektivno kompaktiranje

Povzemanje je destruktivno in nekatere vsebine ne preživijo preoblikovanja. Izsek kode, odgovor API-ja v formatu JSON ali tabela s številkami izgubijo svojo uporabnost, takoj ko so parafrazirani. Selektivno kompaktiranje zato razvrsti stara sporočila pred povzemanjem: tista, ki vsebujejo kodo ali strukturirane podatke, gredo skozi nespremenjena, stisnjen pa je le pogovorni tekst.

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

Merilo za razvrščanje, uporabljeno tukaj – prisotnost trojnih obratnih narekovajev ali oklepaja – je namerno grobo. Prilagodi ga temu, kar tvoja orodja dejansko proizvajajo: za asistenta, ki obravnava reference primerov, bi morda želel ohraniti vsako sporočilo, ki vsebuje ID stranke.

Preverjanje, ali se kompaktiranje splača

Slabo umerjeno kompaktiranje stane dodatni klic API-ja brez opaznega dobička ali pa stisne tako agresivno, da model izgubi nit in zastavlja vprašanja, ki so že bila razrešena. Zato izmeri razmerje pred določitvijo končnih pragov z uporabo vzorca resničnih pogovorov.

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

Vzemi ducat prepisov iz svojega produkcijskega okolja, jih poženi skozi kompaktiranje in preberi nastale povzetke: če na podlagi samega povzetka ne moreš nadaljevati pogovora, je tvoj prag prenizek ali tvoj poziv za povzetek preveč nejasen.

Ključne ugotovitve

  • Kompaktiranje zmanjša število žetonov s povzemanjem starejših sporočil
  • Vedno ohrani najnovejša sporočila nespremenjena (drsno okno)
  • Ohrani sporočila, ki vsebujejo kodo ali strukturirane podatke
  • Ponovno vbrizgaj obstoječi povzetek ob vsakem novem kompaktiranju, da se izogneš progresivni amneziji
  • Izmeri razmerje stiskanja za umeritev svojih pragov