Премини към основното съдържание
Български— Изберете език
Меню

Компактизиране: Компресиране на дълги разговори

Урок 11 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Проблемът с дългите разговори
  2. Две стратегии, които трябва да знаете
  3. Проверка дали компактизирането си струва
  4. Ключови изводи

Проблемът с дългите разговори

Всяко съобщение, добавено към разговора, увеличава броя на токените, изпращани към API. Разговор от 50 обръщения лесно може да достигне 30 000 входни токена, което повишава както латентността, така и разходите. Проблемът е коварен: първото обръщение към асистент за поддръжка струва няколкостотин токена, докато тридесетото струва няколко хиляди, въпреки че потребителят задава точно същия тип въпрос. Вие плащате все повече за една и съща услуга, а потребителят чака все по-дълго за отговор.

Компактизирането решава този проблем чрез компресиране на историята без загуба на съществена информация. То включва обобщаване на по-старите размени, за да се намали броят на токените, като същевременно се запази необходимият контекст. Вместо да изпращате цялата история, Вие изпращате обобщение на миналите размени плюс последните съобщения. Моделът все още знае, че името на клиента е Дюпон, че има оспорана поръчка и че вече сте предложили възстановяване на средства, без да се налага да препрочита четирите десетки съобщения, установили тези факти.

Механизмът

Функцията по-долу прилага тази логика в най-простата ѝ форма: тя оценява обема, не прави нищо, докато не се премине прагът, след което разделя историята на две части. По-старите съобщения отиват за обобщение; най-новите остават непроменени.

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

Два детайла заслужават вниманието Ви. Промптът за обобщение изрично изисква взетите решения, защото обобщение, което запазва само темите, кара модела да загуби памет за собствените си ангажименти. А max_output_tokens=500 ограничава обобщението: без този лимит обобщението расте с всяко компактизиране и в крайна сметка стигате до точно проблема, който се опитвате да елиминирате.

Две стратегии, които трябва да знаете

Плъзгащ се прозорец с обобщение

Следният клас индустриализира принципа. Той поддържа едно единствено обобщение, което преправя при всяко компактизиране, интегрирайки нови размени, докато запазва прозорец от сурови съобщения. Контекстът, изпращан към API, следователно винаги се състои от три блока: системния промпт, кумулативното обобщение и скорошния прозорец.

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

Обърнете внимание, че _compact reinjectира съществуващото обобщение в промпта преди новите размени. Това предотвратява прогресивната амнезия: без това повторно въвеждане всяко компактизиране би изтрило всичко, запазено от предишното.

Селективно компактизиране

Обобщаването е деструктивно и някои съдържания не оцеляват при преформулиране. Кодов фрагмент, JSON отговор от API или таблица с фигури губят полезността си веднага щом бъдат парафразирани. Селективното компактизиране следователно сортира старите съобщения преди обобщаване: тези, съдържащи код или структурирани данни, преминават непокътнати, докато само разговорният текст се компресира.

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

Критерият за сортиране, използван тук – наличието на тройни обратни кавички или фигурна скоба – е умишлено груб. Адаптирайте го към това, което Вашите инструменти действително произвеждат: за асистент, който обработва препратки към случаи, може да искате да запазите всяко съобщение, съдържащо ID на клиент.

Проверка дали компактизирането си струва

Лошо калибрираното компактизиране струва допълнително API обаждане без забележима полза или компресира толкова агресивно, че моделът губи нишката и задава въпроси, които вече са решени. Затова измервайте съотношението, преди да фиксирате окончателните си прагове, като използвате извадка от реални разговори.

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

Вземете дузина транскрипции от Вашата производствена среда, пропуснете ги през компактизиране и прочетете получените обобщения: ако не можете да възобновите разговора въз основа единствено на обобщението, Вашият праг е твърде нисък или промптът за обобщение е твърде неясен.

Ключови изводи

  • Компактизирането намалява токените чрез обобщаване на по-старите съобщения
  • Винаги запазвайте най-новите съобщения непокътнати (плъзгащ се прозорец)
  • Запазвайте съобщенията, съдържащи код или структурирани данни
  • Reinjectирайте съществуващото обобщение при всяко ново компактизиране, за да избегнете прогресивна амнезия
  • Измервайте коефициента на компресия, за да калибрирате праговете си