Compaction: Comprimir Conversas Longas
Nesta página
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