Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Compaction: Comprimir Conversas Longas

Aula 11 de 20 Atualizada a 28 de julho de 2026 Avancado
Nesta página
  1. O Problema das Conversas Longas
  2. Duas Estratégias a Conhecer
  3. Verificar se a Compaction Vale a Pena
  4. Pontos-chave

O Problema das Conversas Longas

Cada mensagem adicionada a uma conversa aumenta o número de tokens enviados para a API. Uma conversa de 50 trocas pode facilmente atingir 30 000 tokens de entrada, aumentando tanto a latência como os custos. O problema é insidioso: a primeira intervenção de um assistente de suporte custa algumas centenas de tokens, enquanto a trigésima custa vários milhares, mesmo que o utilizador faça exatamente o mesmo tipo de pergunta. Paga cada vez mais por um serviço idêntico e o utilizador espera cada vez mais pela resposta.

A compaction resolve este problema ao comprimir o histórico sem perder informações essenciais. Consiste em resumir as trocas mais antigas para reduzir a contagem de tokens, preservando simultaneamente o contexto necessário. Em vez de enviar todo o histórico, envia um resumo das trocas passadas juntamente com as mensagens recentes. O modelo continua a saber que o nome do cliente é Dupont, que existe uma encomenda contestada e que já foi oferecido um reembolso, sem ter de reler as quarenta mensagens que estabeleceram esses factos.

O Mecanismo

A função abaixo aplica esta lógica na sua forma mais simples: estima o volume, não faz nada até o limiar ser ultrapassado e, em seguida, divide o histórico em duas partes. As mensagens mais antigas vão para o resumo; as mais recentes permanecem inalteradas.

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

Dois detalhes merecem a sua atenção. O prompt de resumo solicita explicitamente as decisões tomadas, pois um resumo que retenha apenas temas faz com que o modelo perca a memória dos seus próprios compromissos. E max_output_tokens=500 limita o resumo: sem este limite, o resumo cresce a cada compaction e acaba por criar exatamente o problema que tentava eliminar.

Duas Estratégias a Conhecer

Janela Deslizante com Resumo

A classe seguinte industrializa o princípio. Mantém um único resumo que reescreve em cada compaction, integrando novas trocas, enquanto preserva uma janela de mensagens brutas. O contexto enviado para a API consiste, portanto, sempre em três blocos: o prompt do sistema, o resumo cumulativo e a janela recente.

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

Note que _compact reinjeta o resumo existente no prompt antes das novas trocas. Isto evita a amnésia progressiva: sem esta reinjeção, cada compaction apagaria tudo o que a anterior tinha retido.

Compaction Seletiva

A sumarização é destrutiva e algum conteúdo não sobrevive à reformulação. Um excerto de código, uma resposta JSON de uma API ou uma tabela de valores perde a sua utilidade assim que é parafraseado. A compaction seletiva ordena, portanto, as mensagens antigas antes de as resumir: as que contêm código ou dados estruturados passam intactas, enquanto apenas o texto conversacional é comprimido.

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

O critério de ordenação utilizado aqui — presença de três crases ou de uma chave — é intencionalmente rudimentar. Adapte-o ao que as suas ferramentas produzem realmente: para um assistente que gere referências de processos, poderá querer preservar qualquer mensagem que contenha um ID de cliente.

Verificar se a Compaction Vale a Pena

Uma compaction mal calibrada custa uma chamada à API extra sem ganho visível, ou comprime de forma tão agressiva que o modelo perde o fio à meada e faz perguntas já resolvidas. Meça, portanto, a rácio antes de fixar os seus limiares finais, utilizando uma amostra de conversas reais.

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

Pegue numa dúzia de transcrições do seu ambiente de produção, submeta-as à compaction e leia os resumos produzidos: se não conseguir retomar a conversa com base apenas no resumo, o seu limiar é demasiado baixo ou o seu prompt de resumo é demasiado vago.

Pontos-chave

  • A compaction reduz os tokens ao resumir mensagens mais antigas
  • Mantenha sempre as mensagens mais recentes intactas (janela deslizante)
  • Preserve as mensagens que contêm código ou dados estruturados
  • Reinjete o resumo existente em cada nova compaction para evitar a amnésia progressiva
  • Meça a rácio de compressão para calibrar os seus limiares