Compactação que mantém turnos recentes

A "keep-tail compaction" (compactação que mantém turnos recentes) preserva os últimos turnos de uma conversa palavra por palavra após o resumo. Ela muda duas coisas no loop de compactação: quais mensagens entram na solicitação de compactação e o que você envia após o bloco. Tudo em Continuar a partir do resumo se aplica sem alterações.

Escolha quais turnos manter

Nenhum parâmetro define quais turnos são mantidos. Você escolhe um "cut point" (ponto de corte) no seu histórico: as mensagens anteriores a ele entram na solicitação de compactação, e as mensagens a partir dele são mantidas.

Os turnos mantidos voltam para Claude em tamanho integral, então quanto mais você mantém, menos espaço a compactação libera.

Coloque o corte onde nenhuma chamada de ferramenta fique em aberto, com cada chamada de ferramenta e seu resultado do mesmo lado. Se as mensagens que você envia terminarem em um turno assistant cuja chamada de ferramenta ainda não tem resultado, a API rejeita a solicitação de compactação.

Compacte os turnos mais antigos e envie o restante após o bloco

Para manter os últimos turnos palavra por palavra, deixe esses turnos fora da solicitação de compactação. A API resume todas as mensagens que recebe, então envie apenas os turnos mais antigos e, em seguida, coloque o bloco na frente dos turnos que você manteve.

Envie os turnos mantidos exatamente como estão no seu histórico, incluindo os "thinking blocks" (blocos de pensamento). Ambas as solicitações carregam o cabeçalho beta, como em Solicitar um resumo.

No exemplo a seguir, o histórico contém dois turnos, e o corte mantém o segundo. A solicitação de compactação carrega o primeiro turno:

{
  "model": "claude-opus-5-5",
  "max_tokens": 4096,
  "messages": [
    {
      "role": "user",
      "content": "I am building a recipe app. Help me name the main entities in the data model."
    },
    {
      "role": "assistant",
      "content": "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
    }
  ],
  "compaction": { "type": "summarize" }
}

A próxima solicitação envia primeiro o bloco retornado, depois o turno mantido exatamente como estava e, em seguida, a nova mensagem user. Continuar a partir do resumo mostra uma solicitação que começa com um bloco.

O programa a seguir é o loop de Compactar em um loop, alterado para manter os dois últimos turnos. As linhas destacadas mostram onde ele difere do loop.

from anthropic.types.beta import BetaMessageParam

client = anthropic.Anthropic()

# Defina isto próximo ao seu orçamento real de entrada. Aqui está baixo para que uma conversa curta seja compactada.
COMPACT_AT_TOKENS = 2500
SYSTEM = "You help design a recipe app's data model. Keep answers short."
KEEP_TURNS = 2

QUESTIONS = [
    "What are the main entities in the data model?",
    "Which fields should Recipe have?",
    "Which fields should Ingredient have?",
    "Which fields should RecipeIngredient have?",
    "Which fields should Step have?",
    "Which indexes should these tables have?",
    "Which fields should be required?",
    "Which fields should have default values?",
]

history: list[BetaMessageParam] = []
for turn, question in enumerate(QUESTIONS, start=1):
    history.append({"role": "user", "content": question})
    response = client.beta.messages.create(
        model="claude-opus-5-5",
        max_tokens=8192,
        system=SYSTEM,
        betas=["compact-2026-09-04"],
        messages=history,
    )
    history.append({"role": "assistant", "content": response.content})

    # A próxima requisição também envia esta resposta, então conte-a.
    conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
    if conversation_tokens > COMPACT_AT_TOKENS and KEEP_TURNS < turn < len(QUESTIONS):
        # Um turno é uma mensagem do usuário e uma resposta do assistente,
        # então os turnos mantidos começam com uma mensagem do usuário.
        split = -2 * KEEP_TURNS
        older, recent = history[:split], history[split:]
        summary = client.beta.messages.create(
            model="claude-opus-5-5",
            max_tokens=4096,
            system=SYSTEM,
            betas=["compact-2026-09-04"],
            messages=older,
            compaction={"type": "summarize"},
        )
        if summary.stop_reason == "compaction":
            history = [{"role": "assistant", "content": summary.content}, *recent]
            print(f"Kept {len(recent) // 2} turns after the block")

• Escolhendo o corte: O programa mantém os dois últimos turnos, em que um turno é uma mensagem user e a resposta a ela. Ele divide o histórico a quatro mensagens do final, de modo que os turnos mantidos começam com uma mensagem user.
• Decidindo quando compactar: A verificação de tamanho também exige que a conversa tenha mais turnos do que o programa mantém, para que a parte mais antiga nunca fique vazia.
• A solicitação de compactação: Onde o loop envia o histórico inteiro, esta versão envia apenas as mensagens mais antigas.
• A substituição: Onde o loop substitui o histórico inteiro pela mensagem retornada, o novo histórico desta versão é a mensagem retornada seguida pelos turnos mantidos.

A verificação de stop_reason e todas as solicitações após a substituição permanecem inalteradas em relação ao loop.

Mantenha o pensamento válido nos turnos mantidos

Se você envia os blocos de pensamento de volta em um modelo com pensamento preservado, o pensamento nos turnos mantidos permanece válido apenas enquanto as condições para o pensamento mantido forem atendidas, e uma delas limita onde o corte pode ficar.

O corte do programa, entre uma resposta e a próxima mensagem user, atende a essa condição. O mesmo vale para um corte no final de uma solicitação que você já fez: compacte exatamente as messages dessa solicitação e mantenha tudo o que seu histórico ganhou desde então.

Compatibility