Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Kompakcija: Garu sarunu saspiešana

Nodarbība 11 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Problēma ar garām sarunām
  2. Divas stratēģijas, kas jāzina
  3. Pārliecināšanās, ka kompakcija ir tā vērta
  4. Galvenās atziņas

Problēma ar garām sarunām

Katrs ziņojums, kas pievienots sarunai, palielina API nosūtāmo tokenus skaitu. 50 soļu saruna var viegli sasniegt 30 000 ievades tokenus, kas palielina gan latentumu, gan izmaksas. Problēma ir mānīga: atbalsta asistenta pirmais solis maksā dažus simtus tokenus, bet trīsdesmitais solis maksā vairākus tūkstošus, lai gan lietotājs uzdod tieši tāda paša veida jautājumu. Tu maksā arvien vairāk par identisku pakalpojumu, un lietotājs gaida arvien ilgāk uz atbildi.

Kompakcija to atrisina, saspiežot vēsturi, nezaudējot būtisku informāciju. Tas ietver vecāku apmaiņu apkopošanu, lai samazinātu tokenus skaitu, vienlaikus saglabājot nepieciešamo kontekstu. Visa vēstures nosūtīšanas vietā tu nosūti pagātnes apmaiņu kopsavilkumu plus jaunākos ziņojumus. Modelis joprojām zina, ka klienta uzvārds ir Dupont, ka viņam ir strīdīgs pasūtījums un ka tu jau piedāvāji naudas atmaksu, nevajadzējot atkārtoti lasīt četrdesmit ziņojumus, kas noteica šos faktus.

Mehānisms

Zemāk esošā funkcija piemēro šo loģiku tās vienkāršākajā formā: tā novērtē apjomu, neko nedara, līdz tiek pārsniegts slieksnis, un pēc tam sadala vēsturi divās daļās. Vecākie ziņojumi nonāk kopsavilkumā; jaunākie paliek nemainīgi.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Saspiež vēsturi, kad tā pārsniedz slieksni."""

    # Novērtē tokenus skaitu (aptuveni)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # Nav nepieciešams saspiest

    # Sadalījums: vecie ziņojumi pret jaunajiem
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Apkopojam vecos ziņojumus
    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,
    )

    # Atjaunojam saspiesto vēsturi
    summary_message = {
        "role": "system",
        "content": f"Summary of previous conversation:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Divas detaļas ir pelnījušas tavu uzmanību. Kopsavilkuma uzvedne tieši pieprasa pieņemtos lēmumus, jo kopsavilkums, kas saglabā tikai tēmas, liek modelim zaudēt atmiņu par saviem solījumiem. Un max_output_tokens=500 ierobežo kopsavilkumu: bez šī ierobežojuma kopsavilkums augtu ar katru kompakciju, un tu nonāktu pie tieši tās problēmas, kuru centies novērst.

Divas stratēģijas, kas jāzina

Slīdošais logs ar kopsavilkumu

Tālāk esošā klase industrializē šo principu. Tā uztur vienu kopsavilkumu, ko pārraksta katrā kompakcijā, integrējot jaunas apmaiņas, vienlaikus saglabājot neapstrādātu ziņojumu logu. Konteksts, kas tiek nosūtīts API, tāpēc vienmēr sastāv no trim blokiem: sistēmas uzvednes, kumulatīvā kopsavilkuma un jaunākā loga.

class CompactedConversation:
    """Pārvalda sarunu ar automātisku kompakciju."""

    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]:
        """Veido kontekstu, kas nosūtāms 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:]

Ņem vērā, ka _compact atkārtoti ievada esošo kopsavilkumu uzvednē pirms jaunajām apmaiņām. Tas novērš progresējošu amnēziju: bez šīs atkārtotas ievades katra kompakcija dzēstu visu, ko iepriekšējā bija saglabājusi.

Selektīvā kompakcija

Apkopošana ir destruktīva, un daži saturi nepārdzīvo pārfrazēšanu. Koda fragments, JSON API atbilde vai skaitļu tabula zaudē savu lietderību, tiklīdz tā tiek pārstāstīta. Selektīvā kompakcija tāpēc šķiro vecos ziņojumus pirms apkopošanas: tie, kas satur kodu vai strukturētus datus, tiek nodoti cauri neskarti, kamēr tiek saspiests tikai sarunu teksts.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Saspiež, saglabājot strukturētos ziņojumus neskartus."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Saglabā ziņojumus, kas satur kodu vai datus
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Apkopojam tikai sarunu tekstu
    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

Šeit izmantotais šķirošanas kritērijs – trīs atpakaļslīpsvītru vai figūriekavas klātbūtne – ir apzināti rupjš. Pielāgo to tam, ko tavī rīki faktiski rada: asistentam, kas apstrādā lietu atsauces, tu vari vēlēties saglabāt jebkuru ziņojumu, kas satur klienta ID.

Pārliecināšanās, ka kompakcija ir tā vērta

Slikti kalibrēta kompakcija izmaksā papildu API izsaukumu bez manāma ieguvuma vai saspiež tik agresīvi, ka modelis zaudē pavedienu un uzdod jau atrisinātus jautājumus. Tāpēc izmēri attiecību pirms nostiprini savus galīgos sliekšņus, izmantojot reālu sarunu paraugu.

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

Paņem duci transkriptu no savas ražošanas vides, izlaid tos caur kompakciju un izlasi iegūtos kopsavilkumus: ja tu nevari atsākt sarunu, balstoties tikai uz kopsavilkumu, tavs slieksnis ir pārāk zems vai tava kopsavilkuma uzvedne pārāk neskaidra.

Galvenās atziņas

  • Kompakcija samazina tokenus, apkopojot vecākos ziņojumus
  • Vienmēr saglabā jaunākos ziņojumus neskartus (slīdošais logs)
  • Saglabā ziņojumus, kas satur kodu vai strukturētus datus
  • Atkārtoti ievada esošo kopsavilkumu katrā jaunā kompakcijā, lai izvairītos no progresējošas amnēzijas
  • Izmēri saspiešanas koeficientu, lai kalibrētu savus sliekšņus