Edição de contexto

Visão geral

A edição de contexto permite que você limpe seletivamente conteúdo específico do histórico de conversa conforme ele cresce. Isso ajuda você a otimizar custos e permanecer dentro dos limites da janela de contexto. Esta página aborda:

• Limpeza de resultados de ferramentas - Melhor para fluxos de trabalho de agentes com uso intenso de ferramentas onde resultados antigos de ferramentas não são mais necessários
• Limpeza de blocos de pensamento - Para gerenciar blocos de pensamento ao usar pensamento estendido, com opções para preservar pensamento recente para continuidade de contexto
• Compactação do SDK do lado do cliente - Uma alternativa baseada em SDK para gerenciamento de contexto baseado em resumo (compactação do lado do servidor é geralmente preferida)

Estratégias do lado do servidor

Limpeza de resultados de ferramentas

A estratégia clear_tool_uses_20250919 limpa resultados de ferramentas quando o contexto de conversa cresce além do seu limite configurado. Isso é particularmente útil para fluxos de trabalho de agentes com uso intenso de ferramentas. Resultados antigos de ferramentas (como conteúdo de arquivos ou resultados de pesquisa) não são mais necessários uma vez que Claude os processou.

Quando ativada, a API limpa automaticamente os resultados de ferramentas mais antigos em ordem cronológica. Cada resultado limpo é substituído por texto de espaço reservado para que Claude saiba que foi removido. Por padrão, apenas resultados de ferramentas são limpos. Você pode opcionalmente limpar tanto resultados de ferramentas quanto chamadas de ferramentas (os parâmetros de uso de ferramentas) definindo clear_tool_inputs como verdadeiro.

Limpeza de blocos de pensamento

A estratégia clear_thinking_20251015 gerencia blocos thinking em conversas quando o pensamento estendido está habilitado. Esta estratégia lhe dá controle sobre preservação de pensamento: você pode escolher manter mais blocos de pensamento para manter continuidade de raciocínio, ou limpá-los mais agressivamente para economizar espaço de contexto.

Um turno de conversa do assistente pode incluir múltiplos blocos de conteúdo (por exemplo, ao usar ferramentas) e múltiplos blocos de pensamento (por exemplo, com pensamento intercalado).

A edição de contexto acontece do lado do servidor

A edição de contexto é aplicada do lado do servidor antes do prompt chegar ao Claude. Sua aplicação cliente mantém o histórico completo e não modificado de conversa. Você não precisa sincronizar seu estado de cliente com a versão editada. Continue gerenciando seu histórico completo de conversa localmente como você normalmente faria.

Edição de contexto e cache de prompt

A interação da edição de contexto com cache de prompt varia por estratégia:

• Limpeza de resultados de ferramentas: Invalida prefixos de prompt em cache quando conteúdo é limpo. Para levar isso em conta, limpe tokens suficientes para tornar a invalidação de cache valiosa. Use o parâmetro clear_at_least para garantir um número mínimo de tokens limpos cada vez. Você incorrerá em custos de escrita de cache cada vez que conteúdo for limpo, mas solicitações subsequentes podem reutilizar o prefixo recém armazenado em cache.

• Limpeza de blocos de pensamento: Quando blocos de pensamento são mantidos em contexto (não limpos), o cache de prompt é preservado, habilitando acertos de cache e reduzindo custos de token de entrada. Quando blocos de pensamento são limpos, o cache é invalidado no ponto onde a limpeza ocorre. Configure o parâmetro keep baseado em se você quer priorizar desempenho de cache ou disponibilidade de janela de contexto.

Modelos suportados

A edição de contexto está disponível em:

• Claude Opus 4.6 (claude-opus-4-6)
• Claude Opus 4.5 (claude-opus-4-5-20251101)
• Claude Opus 4.1 (claude-opus-4-1-20250805)
• Claude Opus 4 (claude-opus-4-20250514)
• Claude Sonnet 4.5 (claude-sonnet-4-5-20250929)
• Claude Sonnet 4 (claude-sonnet-4-20250514)
• Claude Haiku 4.5 (claude-haiku-4-5-20251001)

Uso de limpeza de resultados de ferramentas

A forma mais simples de habilitar limpeza de resultados de ferramentas é especificar apenas o tipo de estratégia. Todas as outras opções de configuração usam seus valores padrão:

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --header "anthropic-beta: context-management-2025-06-27" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [
            {
                "role": "user",
                "content": "Search for recent developments in AI"
            }
        ],
        "tools": [
            {
                "type": "web_search_20250305",
                "name": "web_search"
            }
        ],
        "context_management": {
            "edits": [
                {"type": "clear_tool_uses_20250919"}
            ]
        }
    }'

Configuração avançada

Você pode personalizar o comportamento de limpeza de resultados de ferramentas com parâmetros adicionais:

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --header "anthropic-beta: context-management-2025-06-27" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [
            {
                "role": "user",
                "content": "Create a simple command line calculator app using Python"
            }
        ],
        "tools": [
            {
                "type": "text_editor_20250728",
                "name": "str_replace_based_edit_tool",
                "max_characters": 10000
            },
            {
                "type": "web_search_20250305",
                "name": "web_search",
                "max_uses": 3
            }
        ],
        "context_management": {
            "edits": [
                {
                    "type": "clear_tool_uses_20250919",
                    "trigger": {
                        "type": "input_tokens",
                        "value": 30000
                    },
                    "keep": {
                        "type": "tool_uses",
                        "value": 3
                    },
                    "clear_at_least": {
                        "type": "input_tokens",
                        "value": 5000
                    },
                    "exclude_tools": ["web_search"]
                }
            ]
        }
    }'

Uso de limpeza de blocos de pensamento

Habilite limpeza de blocos de pensamento para gerenciar contexto e cache de prompt efetivamente quando o pensamento estendido está habilitado:

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --header "anthropic-beta: context-management-2025-06-27" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 1024,
        "messages": [...],
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10000
        },
        "context_management": {
            "edits": [
                {
                    "type": "clear_thinking_20251015",
                    "keep": {
                        "type": "thinking_turns",
                        "value": 2
                    }
                }
            ]
        }
    }'

Opções de configuração para limpeza de blocos de pensamento

A estratégia clear_thinking_20251015 suporta a seguinte configuração:

Exemplos de configuração:

// Keep thinking blocks from the last 3 assistant turns
{
  "type": "clear_thinking_20251015",
  "keep": {
    "type": "thinking_turns",
    "value": 3
  }
}

// Keep all thinking blocks (maximizes cache hits)
{
  "type": "clear_thinking_20251015",
  "keep": "all"
}

Combinando estratégias

Você pode usar limpeza de blocos de pensamento e limpeza de resultados de ferramentas juntas:

response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[...],
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[...],
    betas=["context-management-2025-06-27"],
    context_management={
        "edits": [
            {
                "type": "clear_thinking_20251015",
                "keep": {
                    "type": "thinking_turns",
                    "value": 2
                }
            },
            {
                "type": "clear_tool_uses_20250919",
                "trigger": {
                    "type": "input_tokens",
                    "value": 50000
                },
                "keep": {
                    "type": "tool_uses",
                    "value": 5
                }
            }
        ]
    }
)

Opções de configuração para limpeza de resultados de ferramentas

Resposta de edição de contexto

Você pode ver quais edições de contexto foram aplicadas à sua solicitação usando o campo de resposta context_management, junto com estatísticas úteis sobre o conteúdo e tokens de entrada limpos.

{
    "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
    "type": "message",
    "role": "assistant",
    "content": [...],
    "usage": {...},
    "context_management": {
        "applied_edits": [
            // When using `clear_thinking_20251015`
            {
                "type": "clear_thinking_20251015",
                "cleared_thinking_turns": 3,
                "cleared_input_tokens": 15000
            },
            // When using `clear_tool_uses_20250919`
            {
                "type": "clear_tool_uses_20250919",
                "cleared_tool_uses": 8,
                "cleared_input_tokens": 50000
            }
        ]
    }
}

Para respostas de streaming, as edições de contexto serão incluídas no evento final message_delta:

{
    "type": "message_delta",
    "delta": {
        "stop_reason": "end_turn",
        "stop_sequence": null
    },
    "usage": {
        "output_tokens": 1024
    },
    "context_management": {
        "applied_edits": [...]
    }
}

Contagem de tokens

O endpoint de contagem de tokens suporta gerenciamento de contexto, permitindo que você visualize quantos tokens seu prompt usará após a edição de contexto ser aplicada.

curl https://api.anthropic.com/v1/messages/count_tokens \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --header "anthropic-beta: context-management-2025-06-27" \
    --data '{
        "model": "claude-opus-4-6",
        "messages": [
            {
                "role": "user",
                "content": "Continue our conversation..."
            }
        ],
        "tools": [...],
        "context_management": {
            "edits": [
                {
                    "type": "clear_tool_uses_20250919",
                    "trigger": {
                        "type": "input_tokens",
                        "value": 30000
                    },
                    "keep": {
                        "type": "tool_uses",
                        "value": 5
                    }
                }
            ]
        }
    }'

{
    "input_tokens": 25000,
    "context_management": {
        "original_input_tokens": 70000
    }
}

A resposta mostra tanto a contagem final de tokens após o gerenciamento de contexto ser aplicado (input_tokens) quanto a contagem original de tokens antes de qualquer limpeza ocorrer (original_input_tokens).

Usando com a Ferramenta de Memória

A edição de contexto pode ser combinada com a ferramenta de memória. Quando o contexto de conversa se aproxima do limite de limpeza configurado, Claude recebe um aviso automático para preservar informações importantes. Isso permite que Claude salve resultados de ferramentas ou contexto em seus arquivos de memória antes de serem limpos do histórico de conversa.

Esta combinação permite que você:

• Preserve contexto importante: Claude pode escrever informações essenciais de resultados de ferramentas em arquivos de memória antes que esses resultados sejam limpos
• Mantenha fluxos de trabalho de longa duração: Habilite fluxos de trabalho de agentes que de outra forma excederiam limites de contexto descarregando informações para armazenamento persistente
• Acesse informações sob demanda: Claude pode procurar informações previamente limpas em arquivos de memória quando necessário, em vez de manter tudo na janela de contexto ativa

Por exemplo, em um fluxo de trabalho de edição de arquivo onde Claude realiza muitas operações, Claude pode resumir alterações concluídas em arquivos de memória conforme o contexto cresce. Quando resultados de ferramentas são limpos, Claude retém acesso a essa informação através de seu sistema de memória e pode continuar trabalhando efetivamente.

Para usar ambos os recursos juntos, habilite-os em sua solicitação de API:

response = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=4096,
    messages=[...],
    tools=[
        {
            "type": "memory_20250818",
            "name": "memory"
        },
        # Your other tools
    ],
    betas=["context-management-2025-06-27"],
    context_management={
        "edits": [
            {"type": "clear_tool_uses_20250919"}
        ]
    }
)

Compactação do lado do cliente (SDK)

Compactação é um recurso do SDK que gerencia automaticamente o contexto de conversa gerando resumos quando o uso de tokens cresce muito grande. Diferentemente de estratégias de edição de contexto do lado do servidor que limpam conteúdo, compactação instrui Claude a resumir o histórico de conversa, então substitui o histórico completo por esse resumo. Isso permite que Claude continue trabalhando em tarefas de longa duração que de outra forma excederiam a janela de contexto.

Como a compactação funciona

Quando a compactação está habilitada, o SDK monitora o uso de tokens após cada resposta do modelo:

1. Verificação de limite: O SDK calcula tokens totais como input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens.
2. Geração de resumo: Quando o limite é excedido, um prompt de resumo é injetado como um turno de usuário, e Claude gera um resumo estruturado envolvido em tags <summary></summary>.
3. Substituição de contexto: O SDK extrai o resumo e substitui todo o histórico de mensagens por ele.
4. Continuação: A conversa retoma do resumo, com Claude continuando de onde parou.

Usando compactação

Adicione compaction_control à sua chamada tool_runner:

import anthropic

client = anthropic.Anthropic()

runner = client.beta.messages.tool_runner(
    model="claude-opus-4-6",
    max_tokens=4096,
    tools=[...],
    messages=[
        {
            "role": "user",
            "content": "Analyze all the files in this directory and write a summary report."
        }
    ],
    compaction_control={
        "enabled": True,
        "context_token_threshold": 100000
    }
)

for message in runner:
    print(f"Tokens used: {message.usage.input_tokens}")

final = runner.until_done()

O que acontece durante a compactação

Conforme a conversa cresce, o histórico de mensagens se acumula:

Antes da compactação (aproximando-se de 100k tokens):

[
  { "role": "user", "content": "Analyze all files and write a report..." },
  { "role": "assistant", "content": "I'll help. Let me start by reading..." },
  { "role": "user", "content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }] },
  { "role": "assistant", "content": "Based on file1.txt, I see..." },
  { "role": "user", "content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }] },
  { "role": "assistant", "content": "After analyzing file2.txt..." },
  // ... 50 more exchanges like this ...
]

Quando tokens excedem o limite, o SDK injeta um pedido de resumo e Claude gera um resumo. O histórico inteiro é então substituído:

Após compactação (voltando a ~2-3k tokens):

[
  {
    "role": "assistant",
    "content": "# Task Overview\nThe user requested analysis of directory files to produce a summary report...\n\n# Current State\nAnalyzed 52 files across 3 subdirectories. Key findings documented in report.md...\n\n# Important Discoveries\n- Configuration files use YAML format\n- Found 3 deprecated dependencies\n- Test coverage at 67%\n\n# Next Steps\n1. Analyze remaining files in /src/legacy\n2. Complete final report sections...\n\n# Context to Preserve\nUser prefers markdown format with executive summary first..."
  }
]

Claude continua trabalhando a partir deste resumo como se fosse o histórico de conversa original.

Opções de configuração

Escolhendo um limite de tokens

O limite determina quando a compactação ocorre. Um limite mais baixo significa compactações mais frequentes com janelas de contexto menores. Um limite mais alto permite mais contexto mas arrisca atingir limites.

# More frequent compaction for memory-constrained scenarios
compaction_control={
    "enabled": True,
    "context_token_threshold": 50000
}

# Less frequent compaction when you need more context
compaction_control={
    "enabled": True,
    "context_token_threshold": 150000
}

Usando um modelo diferente para resumos

Você pode usar um modelo mais rápido ou mais barato para gerar resumos:

compaction_control={
    "enabled": True,
    "context_token_threshold": 100000,
    "model": "claude-haiku-4-5"
}

Prompts de resumo customizados

Você pode fornecer um prompt customizado para necessidades específicas de domínio. Seu prompt deve instruir Claude a envolver seu resumo em tags <summary></summary>.

compaction_control={
    "enabled": True,
    "context_token_threshold": 100000,
    "summary_prompt": """Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps

Wrap your summary in <summary></summary> tags."""
}

Prompt de resumo padrão

O prompt de resumo integrado instrui Claude a criar um resumo de continuação estruturado incluindo:

1. Visão Geral da Tarefa: A solicitação principal do usuário, critérios de sucesso e restrições.
2. Estado Atual: O que foi concluído, arquivos modificados e artefatos produzidos.
3. Descobertas Importantes: Restrições técnicas, decisões tomadas, erros resolvidos e abordagens que falharam.
4. Próximas Etapas: Ações específicas necessárias, bloqueadores e ordem de prioridade.
5. Contexto a Preservar: Preferências do usuário, detalhes específicos do domínio e compromissos feitos.

Esta estrutura permite que Claude retome o trabalho de forma eficiente sem perder contexto importante ou repetir erros.

Limitações

Ferramentas do lado do servidor

Ao usar ferramentas do lado do servidor, o SDK pode calcular incorretamente o uso de tokens, causando compactação para ser acionada no momento errado.

Por exemplo, após uma operação de busca na web, a resposta da API pode mostrar:

{
  "usage": {
    "input_tokens": 63000,
    "cache_read_input_tokens": 270000,
    "output_tokens": 1400
  }
}

O SDK calcula o uso total como 63.000 + 270.000 = 333.000 tokens. No entanto, o valor cache_read_input_tokens inclui leituras acumuladas de múltiplas chamadas internas de API feitas pela ferramenta do lado do servidor, não seu contexto de conversa real. Seu comprimento de contexto real pode ser apenas os 63.000 input_tokens, mas o SDK vê 333k e aciona a compactação prematuramente.

Soluções alternativas:

• Use o endpoint de contagem de tokens para obter o comprimento de contexto preciso
• Evite compactação ao usar ferramentas do lado do servidor extensivamente

Casos extremos de uso de ferramentas

Quando a compactação é acionada enquanto uma resposta de uso de ferramenta está pendente, o SDK remove o bloco de uso de ferramenta do histórico de mensagens antes de gerar o resumo. Claude reabrirá a chamada de ferramenta após retomar do resumo se ainda for necessário.

Monitorando compactação

Ative o registro para rastrear quando a compactação ocorre:

import logging

logging.basicConfig(level=logging.INFO)
logging.getLogger("anthropic.lib.tools").setLevel(logging.INFO)

# Os logs mostrarão:
# INFO: Token usage 105000 has exceeded the threshold of 100000. Performing compaction.
# INFO: Compaction complete. New token usage: 2500

Quando usar compactação

Bons casos de uso:

• Tarefas de agente de longa duração que processam muitos arquivos ou fontes de dados
• Fluxos de trabalho de pesquisa que acumulam grandes quantidades de informações
• Tarefas de múltiplas etapas com progresso claro e mensurável
• Tarefas que produzem artefatos (arquivos, relatórios) que persistem fora da conversa

Casos de uso menos ideais:

• Tarefas que requerem recall preciso de detalhes de conversa inicial
• Fluxos de trabalho usando ferramentas do lado do servidor extensivamente
• Tarefas que precisam manter estado exato em muitas variáveis