---
title: Edição de contexto
url: https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing
description: Gerencie automaticamente o contexto da conversa à medida que ele cresce com a edição de contexto.
---

<Note>
  Para saber como a "zero data retention" (retenção zero de dados), ou ZDR, se aplica a este recurso, consulte [API e retenção de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention).
</Note>

## Visão geral

<Note>
  Para a maioria dos casos de uso, a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) é a principal estratégia para gerenciar o contexto em conversas de longa duração. As estratégias nesta página são úteis para cenários específicos em que você precisa de um controle mais refinado sobre qual conteúdo é limpo.
</Note>

A "context editing" (edição de contexto) permite que você limpe seletivamente conteúdo específico do histórico da conversa à medida que ele cresce. Além de otimizar custos e permanecer dentro dos limites, trata-se de fazer uma curadoria ativa do que Claude vê: o contexto é um recurso finito com retornos decrescentes, e conteúdo irrelevante degrada o foco do modelo. A edição de contexto oferece a você um controle refinado em tempo de execução sobre essa curadoria. Para os princípios mais amplos por trás do gerenciamento de contexto, consulte [Engenharia de contexto eficaz](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). Esta página aborda:

* **Limpeza de resultados de ferramentas** - Ideal para fluxos de trabalho agênticos com uso intenso de ferramentas, em que resultados de ferramentas antigos não são mais necessários
* **Limpeza de blocos de pensamento** - Para gerenciar blocos de pensamento de turnos anteriores, com opções para preservar o pensamento recente para continuidade do contexto
* **Compactação do SDK do lado do cliente** - Uma alternativa baseada em SDK para gerenciamento de contexto baseado em resumos (a compactação do lado do servidor é geralmente preferida)

| Abordagem            | Onde é executada | Estratégias                                                                                                                        | Como funciona                                                                                                                                                                                                                                                                                                                                                                                                                     |
| -------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Lado do servidor** | API              | Limpeza de resultados de ferramentas (`clear_tool_uses_20250919`)<br />Limpeza de blocos de pensamento (`clear_thinking_20251015`) | Aplicada antes que o prompt chegue ao Claude. Limpa conteúdo específico do histórico da conversa. Cada estratégia pode ser configurada de forma independente.                                                                                                                                                                                                                                                                     |
| **Lado do cliente**  | SDK              | Compactação                                                                                                                        | Disponível nos [SDKs TypeScript e Ruby](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) ao usar o [`tool_runner`](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-runner). Gera um resumo e substitui o histórico completo da conversa. Consulte [Compactação do lado do cliente](https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing#client-side-compaction-sdk). |

## Estratégias do lado do servidor

<Note>
  A edição de contexto está em beta com suporte para limpeza de resultados de ferramentas e limpeza de blocos de pensamento. Para habilitá-la, use o cabeçalho beta `context-management-2025-06-27` em suas requisições de API.

  Compartilhe feedback sobre este recurso por meio do [formulário de feedback](https://forms.gle/YXC2EKGMhjN1c4L88).
</Note>

### Limpeza de resultados de ferramentas

A estratégia `clear_tool_uses_20250919` limpa resultados de ferramentas quando o contexto da conversa cresce além do limite configurado. Isso é particularmente útil para fluxos de trabalho agênticos com "tool use" (uso de ferramentas) intenso. Resultados de ferramentas mais antigos (como conteúdos de arquivos ou resultados de pesquisa) não são mais necessários depois que Claude os processou.

Quando ativada, a API limpa automaticamente os resultados de ferramentas mais antigos em ordem cronológica. A API substitui cada resultado limpo por um texto de espaço reservado indicando ao Claude que ele foi removido. Por padrão, apenas os resultados de ferramentas são limpos. Opcionalmente, você pode limpar tanto os resultados de ferramentas quanto as chamadas de ferramentas (os parâmetros de uso de ferramentas) definindo `clear_tool_inputs` como true.

### Limpeza de blocos de pensamento

A estratégia `clear_thinking_20251015` gerencia blocos `thinking` de turnos anteriores do assistente. Essa estratégia oferece controle sobre a preservação do pensamento: você pode optar por manter mais blocos de pensamento para preservar a continuidade do raciocínio, ou limpá-los de forma mais agressiva para economizar espaço de contexto.

<Tip>
  **Comportamento padrão:** O padrão varia de acordo com a classe do modelo.

  | Classe do modelo | Manter todo o pensamento anterior | Manter apenas o pensamento do último turno     |
  | ---------------- | --------------------------------- | ---------------------------------------------- |
  | Opus             | Claude Opus 4.5 e posteriores     | Claude Opus 4.1 e anteriores                   |
  | Sonnet           | Claude Sonnet 4.6 e posteriores   | Claude Sonnet 4.5 (descontinuado) e anteriores |
  | Haiku            | Claude Haiku 5.5 e posteriores    | Claude Haiku 4.5 e anteriores                  |
  | Fable e Mythos   | Todos os modelos                  | (nenhum)                                       |

  Use esta estratégia para substituir o padrão. Se o seu código é executado em vários níveis de modelo, defina `keep` explicitamente em vez de depender do padrão por modelo.
</Tip>

Um turno de conversa do assistente pode incluir vários blocos de conteúdo (por exemplo, ao usar ferramentas) e vários blocos de pensamento (por exemplo, com [pensamento intercalado](https://platform.claude.com/docs/pt-BR/build-with-claude/thinking#interleaved-thinking)).

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

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

Nos modelos Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, o gerenciamento de contexto no lado do servidor nunca invalida blocos de pensamento. Edições no lado do cliente em turnos anteriores podem invalidar os blocos de pensamento em todos os turnos posteriores do assistente. Para novas contas criadas a partir de 31 de agosto de 2026, uma solicitação que reenvia um bloco invalidado é rejeitada, a menos que você opte por descartá-lo. Consulte [Manter o prefixo inalterado](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#prefix-check).

### Edição de contexto e cache de prompt

A interação da edição de contexto com o ["prompt caching" (cache de prompt)](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching) varia de acordo com a estratégia:

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

* **Limpeza de blocos de pensamento:** Quando os blocos de pensamento são **mantidos** no contexto (não limpos), o cache de prompt é preservado, permitindo acertos de cache e reduzindo os custos de tokens de entrada. Quando os blocos de pensamento são **limpos**, o cache é invalidado no ponto em que a limpeza ocorre. Configure o parâmetro `keep` com base em se você deseja priorizar o desempenho do cache ou a disponibilidade da "context window" (janela de contexto).

## Modelos suportados

A edição de contexto está disponível em todos os modelos Claude suportados.

## Uso da limpeza de resultados de ferramentas

A maneira mais simples de habilitar a limpeza de resultados de ferramentas é especificar apenas o tipo de estratégia. Todas as outras [opções de configuração](https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) usam seus valores padrão:

<CodeGroup>
  ```bash cURL
  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-5-5",
          "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"}
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  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
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[{"role": "user", "content": "Search for recent developments in AI"}],
      tools=[{"type": "web_search_20250305", "name": "web_search"}],
      betas=["context-management-2025-06-27"],
      context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    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" }]
    },
    betas: ["context-management-2025-06-27"]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() { Role = Role.User, Content = "Search for recent developments in AI" }
      ],
      Tools = [
          new BetaWebSearchTool20250305()
      ],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [new BetaClearToolUses20250919Edit()]
      },
      Betas = [AnthropicBeta.ContextManagement2025_06_27]
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for recent developments in AI")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{}},
  	},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
  		},
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaContextManagement2025_06_27,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Search for recent developments in AI")
          .addTool(BetaWebSearchTool20250305.builder().build())
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder().build())
              .build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Search for recent developments in AI']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          ['type' => 'web_search_20250305', 'name' => 'web_search']
      ],
      contextManagement: [
          'edits' => [
              ['type' => 'clear_tool_uses_20250919']
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    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" }
      ]
    },
    betas: ["context-management-2025-06-27"]
  )
  puts response
  ```
</CodeGroup>

### Configuração avançada

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

<CodeGroup>
  ```bash cURL
  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-5-5",
          "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"]
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  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
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      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},
      ],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_tool_uses_20250919",
                  # Aciona a limpeza quando o limite é excedido
                  "trigger": {"type": "input_tokens", "value": 30000},
                  # Número de usos de ferramentas a manter após a limpeza
                  "keep": {"type": "tool_uses", "value": 3},
                  # Opcional: limpa pelo menos esta quantidade de tokens
                  "clear_at_least": {"type": "input_tokens", "value": 5000},
                  # Exclui estas ferramentas da limpeza
                  "exclude_tools": ["web_search"],
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    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
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          // Aciona a limpeza quando o limite é excedido
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          // Número de usos de ferramentas a manter após a limpeza
          keep: {
            type: "tool_uses",
            value: 3
          },
          // Opcional: limpa pelo menos esta quantidade de tokens
          clear_at_least: {
            type: "input_tokens",
            value: 5000
          },
          // Exclui estas ferramentas da limpeza
          exclude_tools: ["web_search"]
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() { Role = Role.User, Content = "Create a simple command line calculator app using Python" }
      ],
      Tools = [
          new BetaToolTextEditor20250728 { MaxCharacters = 10000 },
          new BetaWebSearchTool20250305 { MaxUses = 3 }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearToolUses20250919Edit
              {
                  Trigger = new BetaInputTokensTrigger(30000),
                  Keep = new BetaToolUsesKeep(3),
                  ClearAtLeast = new BetaInputTokensClearAtLeast(5000),
                  ExcludeTools = ["web_search"]
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a simple command line calculator app using Python")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{
  			MaxCharacters: anthropic.Int(10000),
  		}},
  		{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
  			MaxUses: anthropic.Int(3),
  		}},
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
  				Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
  					OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
  						Value: 30000,
  					},
  				},
  				Keep: anthropic.BetaToolUsesKeepParam{
  					Value: 3,
  				},
  				ClearAtLeast: anthropic.BetaInputTokensClearAtLeastParam{
  					Value: 5000,
  				},
  				ExcludeTools: []string{"web_search"},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
  import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
  import com.anthropic.models.beta.messages.BetaInputTokensClearAtLeast;
  import com.anthropic.models.beta.messages.BetaToolUsesKeep;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Create a simple command line calculator app using Python")
          .addTool(BetaToolTextEditor20250728.builder()
              .maxCharacters(10000L)
              .build())
          .addTool(BetaWebSearchTool20250305.builder()
              .maxUses(3L)
              .build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder()
                  .trigger(BetaInputTokensTrigger.builder()
                      .value(30000L)
                      .build())
                  .keep(BetaToolUsesKeep.builder()
                      .value(3L)
                      .build())
                  .clearAtLeast(BetaInputTokensClearAtLeast.builder()
                      .value(5000L)
                      .build())
                  .addExcludeTool("web_search")
                  .build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => 'Create a simple command line calculator app using Python'
          ]
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          [
              'type' => 'text_editor_20250728',
              'name' => 'str_replace_based_edit_tool',
              'max_characters' => 10000
          ],
          [
              'type' => 'web_search_20250305',
              'name' => 'web_search',
              'max_uses' => 3
          ]
      ],
      contextManagement: [
          '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']
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    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
      }
    ],
    betas: ["context-management-2025-06-27"],
    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"]
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

## Uso da limpeza de blocos de pensamento

Use a limpeza de blocos de pensamento para gerenciar o contexto e o cache de prompt em conversas que carregam blocos de pensamento de turnos anteriores:

<CodeGroup>
  ```bash cURL
  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-5-5",
          "max_tokens": 16000,
          "messages": [{"role": "user", "content": "Hello"}],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": {
                          "type": "thinking_turns",
                          "value": 2
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Hello
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep:
          type: thinking_turns
          value: 2
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[{"role": "user", "content": "Hello"}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": {"type": "thinking_turns", "value": 2},
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 2
          }
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new BetaThinkingTurns(2)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
  						Value: 2,
  					},
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
  import com.anthropic.models.beta.messages.BetaThinkingTurns;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .addUserMessage("Hello")
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearThinking20251015Edit.builder()
                  .keep(BetaThinkingTurns.builder()
                      .value(2L)
                      .build())
                  .build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => [
                      'type' => 'thinking_turns',
                      'value' => 2
                  ]
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 2
          }
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

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

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

| Opção de configuração | Padrão               | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                         |
| --------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `keep`                | Específico do modelo | Define quantos turnos recentes do assistente com blocos de pensamento devem ser preservados. Use `{type: "thinking_turns", value: N}`, em que N deve ser > 0, para manter os últimos N turnos, ou `"all"` para manter todos os blocos de pensamento. Opus 4.5+, Sonnet 4.6+ e Haiku 5.5+: todos os turnos. Modelos Fable e Mythos: todos os turnos. Opus/Sonnet anteriores e Haiku até o Claude Haiku 4.5: apenas o último turno. |

**Exemplos de configuração:**

Manter blocos de pensamento dos últimos 3 turnos do assistente:

<CodeGroup>
  ```bash cURL
  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-5-5",
          "max_tokens": 16000,
          "messages": [{"role": "user", "content": "Hello"}],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": {
                          "type": "thinking_turns",
                          "value": 3
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Hello
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep:
          type: thinking_turns
          value: 3
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[{"role": "user", "content": "Hello"}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": {"type": "thinking_turns", "value": 3},
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 3
          }
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new BetaThinkingTurns(3)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
  						Value: 3,
  					},
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(16000L)
      .addUserMessage("Hello")
      .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
      .contextManagement(BetaContextManagementConfig.builder()
          .addEdit(BetaClearThinking20251015Edit.builder()
              .keep(BetaThinkingTurns.builder()
                  .value(3L)
                  .build())
              .build())
          .build())
      .build();

  BetaMessage response = client.beta().messages().create(params);
  IO.println(response);
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => [
                      'type' => 'thinking_turns',
                      'value' => 3
                  ]
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 3
          }
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

Manter todos os blocos de pensamento (maximiza os acertos de cache):

<CodeGroup>
  ```bash cURL
  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-5-5",
          "max_tokens": 16000,
          "messages": [{"role": "user", "content": "Hello"}],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": "all"
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Hello
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep: all
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[{"role": "user", "content": "Hello"}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": "all",
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: "all"
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new All()
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfAll: constant.ValueOf[constant.All](),
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(16000L)
      .addUserMessage("Hello")
      .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
      .contextManagement(BetaContextManagementConfig.builder()
          .addEdit(BetaClearThinking20251015Edit.builder()
              .keepAll()
              .build())
          .build())
      .build();

  BetaMessage response = client.beta().messages().create(params);
  IO.println(response);
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => 'all'
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: "all"
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

### Combinando estratégias

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

<Note>
  Ao usar várias estratégias, a estratégia `clear_thinking_20251015` deve ser listada primeiro no array `edits`.
</Note>

<CodeGroup>
  ```bash cURL
  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-5-5",
          "max_tokens": 16000,
          "messages": [
              {
                  "role": "user",
                  "content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
              }
          ],
          "tools": [
              {
                  "type": "web_search_20250305",
                  "name": "web_search",
                  "max_uses": 5
              }
          ],
          "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
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Search for the latest developments in quantum error correction and summarize the key breakthroughs.
  tools:
    - type: web_search_20250305
      name: web_search
      max_uses: 5
  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
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[
          {
              "role": "user",
              "content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs.",
          }
      ],
      tools=[
          {
              "type": "web_search_20250305",
              "name": "web_search",
              "max_uses": 5,
          }
      ],
      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},
              },
          ]
      },
  )

  print(response)
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [
      {
        role: "user",
        content:
          "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
      }
    ],
    tools: [
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 5
      }
    ],
    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
          }
        }
      ]
    }
  });

  console.log(response);
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Search for the latest developments in quantum error correction and summarize the key breakthroughs." }
      ],
      Tools = [
          new BetaWebSearchTool20250305 { MaxUses = 5 }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new BetaThinkingTurns(2)
              },
              new BetaClearToolUses20250919Edit
              {
                  Trigger = new BetaInputTokensTrigger(50000),
                  Keep = new BetaToolUsesKeep(5)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
  			MaxUses: anthropic.Int(5),
  		}},
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaContextManagement2025_06_27,
  	},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
  						Value: 2,
  					},
  				},
  			}},
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
  				Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
  					OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
  						Value: 50000,
  					},
  				},
  				Keep: anthropic.BetaToolUsesKeepParam{
  					Value: 5,
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.messages.BetaThinkingTurns;
  import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
  import com.anthropic.models.beta.messages.BetaToolUsesKeep;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .addUserMessage("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")
          .addTool(BetaWebSearchTool20250305.builder()
              .maxUses(5L)
              .build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearThinking20251015Edit.builder()
                  .keep(BetaThinkingTurns.builder()
                      .value(2L)
                      .build())
                  .build())
              .addEdit(BetaClearToolUses20250919Edit.builder()
                  .trigger(BetaInputTokensTrigger.builder()
                      .value(50000L)
                      .build())
                  .keep(BetaToolUsesKeep.builder()
                      .value(5L)
                      .build())
                  .build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          [
              'role' => 'user',
              'content' => 'Search for the latest developments in quantum error correction and summarize the key breakthroughs.'
          ]
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          [
              'type' => 'web_search_20250305',
              'name' => 'web_search',
              'max_uses' => 5
          ]
      ],
      contextManagement: [
          '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
                  ]
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [
      {
        role: "user",
        content: "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
      }
    ],
    tools: [
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 5
      }
    ],
    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
          }
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

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

| Opção de configuração | Padrão                    | Descrição                                                                                                                                                                                                                                                                         |
| --------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger`             | 100.000 tokens de entrada | Define quando a estratégia de edição de contexto é ativada. Quando o prompt excede esse limite, a limpeza começa. Você pode especificar esse valor em `input_tokens` ou `tool_uses`.                                                                                              |
| `keep`                | 3 usos de ferramentas     | Define quantos pares recentes de uso/resultado de ferramentas devem ser mantidos após a limpeza. A API remove primeiro as interações de ferramentas mais antigas, preservando as mais recentes.                                                                                   |
| `clear_at_least`      | Nenhum                    | Garante que um número mínimo de tokens seja limpo cada vez que a estratégia é ativada. Se a API não conseguir limpar pelo menos a quantidade especificada, a estratégia não será aplicada. Isso ajuda a determinar se a limpeza de contexto vale a quebra do seu cache de prompt. |
| `exclude_tools`       | Nenhum                    | Lista de nomes de ferramentas cujos usos e resultados nunca devem ser limpos. Útil para preservar contexto importante.                                                                                                                                                            |
| `clear_tool_inputs`   | `false`                   | Controla se os parâmetros da chamada de ferramenta são limpos junto com os resultados da ferramenta. Por padrão, apenas os resultados de ferramentas são limpos, mantendo visíveis as chamadas de ferramentas originais do Claude.                                                |

## Resposta da edição de contexto

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

```json Output
{
  "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 em streaming, as edições de contexto são incluídas no evento final `message_delta`:

```json Streaming Response
{
  "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](https://platform.claude.com/docs/pt-BR/build-with-claude/token-counting) suporta gerenciamento de contexto, permitindo que você visualize previamente quantos tokens seu prompt usará após a aplicação da edição de contexto.

<CodeGroup>
  ```bash cURL
  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-5-5",
          "messages": [
              {
                  "role": "user",
                  "content": "Continue our conversation..."
              }
          ],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_tool_uses_20250919",
                      "trigger": {
                          "type": "input_tokens",
                          "value": 30000
                      },
                      "keep": {
                          "type": "tool_uses",
                          "value": 5
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ORIGINAL=$(ant beta:messages count-tokens \
    --beta context-management-2025-06-27 \
    --transform context_management.original_input_tokens \
    --raw-output <<'YAML'
  model: claude-opus-5-5
  messages:
    - role: user
      content: Continue our conversation...
  context_management:
    edits:
      - type: clear_tool_uses_20250919
        trigger:
          type: input_tokens
          value: 30000
        keep:
          type: tool_uses
          value: 5
  YAML
  )

  INPUT_TOKENS=$(ant beta:messages count-tokens \
    --beta context-management-2025-06-27 \
    --transform input_tokens --raw-output <<'YAML'
  model: claude-opus-5-5
  messages:
    - role: user
      content: Continue our conversation...
  context_management:
    edits:
      - type: clear_tool_uses_20250919
        trigger:
          type: input_tokens
          value: 30000
        keep:
          type: tool_uses
          value: 5
  YAML
  )

  printf 'Original tokens: %s\n' "$ORIGINAL"
  printf 'After clearing: %s\n' "$INPUT_TOKENS"
  printf 'Savings: %s tokens\n' "$((ORIGINAL - INPUT_TOKENS))"
  ```

  ```python Python
  response = client.beta.messages.count_tokens(
      model="claude-opus-5-5",
      messages=[{"role": "user", "content": "Continue our conversation..."}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_tool_uses_20250919",
                  "trigger": {"type": "input_tokens", "value": 30000},
                  "keep": {"type": "tool_uses", "value": 5},
              }
          ]
      },
  )

  print(f"Original tokens: {response.context_management.original_input_tokens}")
  print(f"After clearing: {response.input_tokens}")
  print(
      f"Savings: {response.context_management.original_input_tokens - response.input_tokens} tokens"
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.countTokens({
    model: "claude-opus-5-5",
    messages: [
      {
        role: "user",
        content: "Continue our conversation..."
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          keep: {
            type: "tool_uses",
            value: 5
          }
        }
      ]
    }
  });

  console.log(`Original tokens: ${response.context_management?.original_input_tokens}`);
  console.log(`After clearing: ${response.input_tokens}`);
  console.log(
    `Savings: ${
      (response.context_management?.original_input_tokens || 0) - response.input_tokens
    } tokens`
  );
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCountTokensParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      Messages = [new() { Role = Role.User, Content = "Continue our conversation..." }],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearToolUses20250919Edit
              {
                  Trigger = new BetaInputTokensTrigger(30000),
                  Keep = new BetaToolUsesKeep(5)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.CountTokens(parameters);

  Console.WriteLine($"Original tokens: {response.ContextManagement?.OriginalInputTokens}");
  Console.WriteLine($"After clearing: {response.InputTokens}");
  Console.WriteLine($"Savings: {(response.ContextManagement?.OriginalInputTokens ?? 0) - response.InputTokens} tokens");
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
  	Model: anthropic.ModelClaudeOpus5_5,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Continue our conversation...")),
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaContextManagement2025_06_27,
  	},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
  				Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
  					OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
  						Value: 30000,
  					},
  				},
  				Keep: anthropic.BetaToolUsesKeepParam{
  					Value: 5,
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("Original tokens: %d\n", response.ContextManagement.OriginalInputTokens)
  fmt.Printf("After clearing: %d\n", response.InputTokens)
  fmt.Printf("Savings: %d tokens\n", response.ContextManagement.OriginalInputTokens-response.InputTokens)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaMessageTokensCount;
  import com.anthropic.models.beta.messages.MessageCountTokensParams;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
  import com.anthropic.models.beta.messages.BetaToolUsesKeep;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCountTokensParams params = MessageCountTokensParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .addUserMessage("Continue our conversation...")
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder()
                  .trigger(BetaInputTokensTrigger.builder()
                      .value(30000L)
                      .build())
                  .keep(BetaToolUsesKeep.builder()
                      .value(5L)
                      .build())
                  .build())
              .build())
          .build();

      BetaMessageTokensCount response = client.beta().messages().countTokens(params);

      IO.println("Original tokens: " + response.contextManagement().get().originalInputTokens());
      IO.println("After clearing: " + response.inputTokens());
      IO.println("Savings: " + (response.contextManagement().get().originalInputTokens() - response.inputTokens()) + " tokens");
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->countTokens(
      messages: [
          ['role' => 'user', 'content' => 'Continue our conversation...']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_tool_uses_20250919',
                  'trigger' => [
                      'type' => 'input_tokens',
                      'value' => 30000
                  ],
                  'keep' => [
                      'type' => 'tool_uses',
                      'value' => 5
                  ]
              ]
          ]
      ],
  );

  echo "Original tokens: " . $response->contextManagement->originalInputTokens . "\n";
  echo "After clearing: " . $response->inputTokens . "\n";
  echo "Savings: " . ($response->contextManagement->originalInputTokens - $response->inputTokens) . " tokens\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.count_tokens(
    model: "claude-opus-5-5",
    messages: [
      { role: "user", content: "Continue our conversation..." }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          keep: {
            type: "tool_uses",
            value: 5
          }
        }
      ]
    }
  )

  puts "Original tokens: #{response.context_management.original_input_tokens}"
  puts "After clearing: #{response.input_tokens}"
  puts "Savings: #{response.context_management.original_input_tokens - response.input_tokens} tokens"
  ```
</CodeGroup>

```json Output
{
  "input_tokens": 25000,
  "context_management": {
    "original_input_tokens": 70000
  }
}
```

A resposta mostra tanto a contagem final de tokens após a aplicação do gerenciamento de contexto (`input_tokens`) quanto a contagem original de tokens antes de qualquer limpeza (`original_input_tokens`).

## Usando com a ferramenta de memória

A edição de contexto pode ser combinada com a [ferramenta de memória](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/memory-tool). Quando o contexto da sua 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 que sejam limpos do histórico da conversa.

Essa combinação permite que você:

* **Preserve contexto importante:** Claude pode gravar informações essenciais dos 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 agênticos que, de outra forma, excederiam os limites de contexto, transferindo informações para armazenamento persistente
* **Acesse informações sob demanda:** Claude pode consultar informações limpas anteriormente nos 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 arquivos em que Claude realiza muitas operações, Claude pode resumir as alterações concluídas em arquivos de memória à medida que o contexto cresce. Quando os resultados de ferramentas são limpos, Claude mantém o acesso a essas informações por meio de seu sistema de memória e pode continuar trabalhando de forma eficaz.

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

<CodeGroup>
  ```bash cURL
  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-5-5",
          "max_tokens": 4096,
          "messages": [
              {
                  "role": "user",
                  "content": "Hello"
              }
          ],
          "tools": [
              {
                  "type": "memory_20250818",
                  "name": "memory"
              }
          ],
          "context_management": {
              "edits": [
                  {"type": "clear_tool_uses_20250919"}
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content: Hello
  tools:
    - type: memory_20250818
      name: memory
  context_management:
    edits:
      - type: clear_tool_uses_20250919
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[{"role": "user", "content": "Hello"}],
      tools=[{"type": "memory_20250818", "name": "memory"}],
      betas=["context-management-2025-06-27"],
      context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [{ role: "user", content: "Hello" }],
    tools: [
      {
        type: "memory_20250818",
        name: "memory"
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [{ type: "clear_tool_uses_20250919" }]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Tools = [
          new BetaMemoryTool20250818()
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [new BetaClearToolUses20250919Edit()]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfMemoryTool20250818: &anthropic.BetaMemoryTool20250818Param{}},
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaMemoryTool20250818;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Hello")
          .addTool(BetaMemoryTool20250818.builder().build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder().build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          [
              'type' => 'memory_20250818',
              'name' => 'memory'
          ]
      ],
      contextManagement: [
          'edits' => [
              ['type' => 'clear_tool_uses_20250919']
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [{ role: "user", content: "Hello" }],
    tools: [
      {
        type: "memory_20250818",
        name: "memory"
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        { type: "clear_tool_uses_20250919" }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

Para a referência completa da ferramenta de memória, incluindo comandos e exemplos, consulte [Ferramenta de memória](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/memory-tool).

## Compactação do lado do cliente (SDK)

<Warning>
  **A Anthropic recomenda a compactação do lado do servidor em vez da compactação do SDK.** A [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) lida com o gerenciamento de contexto automaticamente, com menos complexidade de integração, melhor cálculo de uso de tokens e sem limitações do lado do cliente. Use a compactação do SDK apenas se você precisar especificamente de controle do lado do cliente sobre o processo de resumo.

  O parâmetro `compaction_control` está descontinuado nos SDKs TypeScript e Ruby e será removido em uma versão futura. Os SDKs emitem um aviso de descontinuação quando ele está habilitado. O SDK Python o removeu na v1.0. Para usar a compactação do lado do servidor com um tool runner, passe a edição `compact_20260112` no parâmetro `context_management` da requisição.
</Warning>

<Note>
  A compactação está disponível nos [SDKs TypeScript e Ruby](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/overview) ao usar o [método `tool_runner`](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-runner).
</Note>

A compactação é um recurso do SDK que gerencia automaticamente o contexto da conversa gerando resumos quando o uso de tokens cresce demais. Diferentemente das estratégias de edição de contexto do lado do servidor que limpam conteúdo, a compactação instrui Claude a resumir o histórico da conversa e, em seguida, 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](https://platform.claude.com/docs/pt-BR/build-with-claude/context-windows).

### 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 o total de tokens como `input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens` (consulte [Cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching) para os campos de tokens de cache).
2. **Geração de resumo:** Quando o limite é excedido, um prompt de resumo é injetado como um turno do usuário, e Claude gera um resumo estruturado envolto 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 é retomada a partir do resumo, com Claude continuando de onde parou.

### Usando a compactação

Adicione `compaction_control` à sua chamada de `tool_runner` para habilitar o resumo automático quando o uso de tokens exceder o limite.

<Tabs>
  <Tab title="cURL">
    <Note>
      A compactação é executada do lado do cliente nos helpers `tool_runner` do SDK, portanto não tem equivalente HTTP direto. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI não inclui um helper `tool_runner`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic sem integração do lado do SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      Na v1.0 e posteriores, o tool runner do SDK Python não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compactionControl: { enabled: true, contextTokenThreshold: 100000 }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      O SDK C# inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      O SDK Go inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      O SDK Java inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      O SDK PHP inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: { enabled: true, context_token_threshold: 100000 }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

#### O que ocorre durante a compactação

À medida que a conversa cresce, o histórico de mensagens se acumula:

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

```json
[
  { "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 os tokens excedem o limite, o SDK injeta uma solicitação de resumo e Claude gera um resumo. Todo o histórico é então substituído:

**Após a compactação (de volta a \~2–3k tokens):**

```json
[
  {
    "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 desse resumo como se fosse o histórico original da conversa.

### Opções de configuração

| Parâmetro                 | Tipo    | Obrigatório | Padrão                                                                                                                              | Descrição                                           |
| ------------------------- | ------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| `enabled`                 | boolean | Sim         | -                                                                                                                                   | Se a compactação automática deve ser habilitada     |
| `context_token_threshold` | number  | Não         | 100.000                                                                                                                             | Contagem de tokens na qual a compactação é acionada |
| `model`                   | string  | Não         | Mesmo que o modelo principal                                                                                                        | Modelo a ser usado para gerar resumos               |
| `summary_prompt`          | string  | Não         | Consulte [Prompt de resumo padrão](https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing#default-summary-prompt) | Prompt personalizado para geração de resumo         |

#### 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 corre o risco de atingir os limites.

<Tabs>
  <Tab title="cURL">
    <Note>
      A compactação é executada do lado do cliente nos helpers `tool_runner` do SDK, portanto não tem equivalente HTTP direto. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI não inclui um helper `tool_runner`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic sem integração do lado do SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      Na v1.0 e posteriores, o tool runner do SDK Python não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      // Valores menores compactam com mais frequência; aumente para 150000 se a tarefa precisar de mais contexto
      compactionControl: { enabled: true, contextTokenThreshold: 50000 }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      O SDK C# inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      O SDK Go inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      O SDK Java inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      O SDK PHP inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      # Valores menores compactam com mais frequência; aumente para 150000 quando a tarefa precisar de mais contexto
      compaction_control: { enabled: true, context_token_threshold: 50000 }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

#### Usando um modelo diferente para resumos

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

<Tabs>
  <Tab title="cURL">
    <Note>
      A compactação é executada do lado do cliente nos helpers `tool_runner` do SDK, portanto não tem equivalente HTTP direto. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI não inclui um helper `tool_runner`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic sem integração do lado do SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      Na v1.0 e posteriores, o tool runner do SDK Python não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compactionControl: {
        enabled: true,
        contextTokenThreshold: 100000,
        model: "claude-haiku-4-5"
      }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      O SDK C# inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      O SDK Go inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      O SDK Java inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      O SDK PHP inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: {
        enabled: true,
        context_token_threshold: 100000,
        model: "claude-haiku-4-5"
      }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

#### Prompts de resumo personalizados

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

<Tabs>
  <Tab title="cURL">
    <Note>
      A compactação é executada do lado do cliente nos helpers `tool_runner` do SDK, portanto não tem equivalente HTTP direto. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI não inclui um helper `tool_runner`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic sem integração do lado do SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      Na v1.0 e posteriores, o tool runner do SDK Python não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compactionControl: {
        enabled: true,
        contextTokenThreshold: 100000,
        summaryPrompt: `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.`
      }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      O SDK C# inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      O SDK Go inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      O SDK Java inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      O SDK PHP inclui um tool runner, mas ele não oferece suporte a `compaction_control` no lado do cliente. Em vez disso, use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold): ela funciona com o tool runner quando você passa a edição `compact_20260112` no parâmetro `context_management` da requisição.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: {
        enabled: true,
        context_token_threshold: 100000,
        summary_prompt: <<~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
      }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

### 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óximos passos:** Ações específicas necessárias, bloqueios e ordem de prioridade.
5. **Contexto a preservar:** Preferências do usuário, detalhes específicos do domínio e compromissos assumidos.

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

<Accordion title="Ver o prompt padrão completo">
  ```text wrap
  You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:

  1. Task Overview
  The user's core request and success criteria
  Any clarifications or constraints they specified

  2. Current State
  What has been completed so far
  Files created, modified, or analyzed (with paths if relevant)
  Key outputs or artifacts produced

  3. Important Discoveries
  Technical constraints or requirements uncovered
  Decisions made and their rationale
  Errors encountered and how they were resolved
  What approaches were tried that didn't work (and why)

  4. Next Steps
  Specific actions needed to complete the task
  Any blockers or open questions to resolve
  Priority order if multiple steps remain

  5. Context to Preserve
  User preferences or style requirements
  Domain-specific details that aren't obvious
  Any promises made to the user

  Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.

  Wrap your summary in <summary></summary> tags.
  ```
</Accordion>

### Limitações

#### Ferramentas do lado do servidor

<Warning>
  A compactação requer consideração especial ao usar ferramentas do lado do servidor, como [pesquisa na web](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-search-tool) ou [busca na web](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool).
</Warning>

Ao usar ferramentas do lado do servidor, o SDK pode calcular incorretamente o uso de tokens, fazendo com que a compactação seja acionada no momento errado.

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

```json Output
{
  "usage": {
    "input_tokens": 63000,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 270000,
    "output_tokens": 1400
  }
}
```

O SDK calcula o uso total como 63.000 + 0 + 270.000 + 1.400 = 334.400 tokens. No entanto, o valor de `cache_read_input_tokens` inclui leituras acumuladas de várias chamadas internas de API feitas pela ferramenta do lado do servidor, não o contexto real da sua conversa. O comprimento real do seu contexto pode ser apenas os 63.000 `input_tokens`, mas o SDK vê 334k e aciona a compactação prematuramente.

**Soluções alternativas:**

* Use o endpoint de [contagem de tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/token-counting) para obter o comprimento preciso do contexto
* Evite a compactação ao usar ferramentas do lado do servidor extensivamente

#### Casos extremos de uso de ferramentas

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

### Monitorando a compactação

Entender quando a compactação é acionada ajuda você a ajustar os limites e verificar o comportamento esperado.

<Tabs>
  <Tab title="cURL">
    <Note>
      A compactação é executada do lado do cliente nos helpers `tool_runner` do SDK, portanto não tem equivalente HTTP direto. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      A CLI não inclui um helper `tool_runner`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso, que lida com a compactação nos servidores da Anthropic sem integração do lado do SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      Na v1.0 e posteriores, o tool runner do SDK Python não suporta `compaction_control`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    O `toolRunner` do SDK TypeScript suporta compactação, mas não registra eventos. Detecte a compactação observando `runner.params.messages.length` diminuir entre os turnos:

    ```typescript TypeScript
    let prevMsgCount = 0;
    for await (const message of runner) {
      const currMsgCount = runner.params.messages.length;
      if (currMsgCount < prevMsgCount) {
        console.log(`Compaction occurred: ${prevMsgCount} -> ${currMsgCount} messages`);
        console.log(`Input tokens after compaction: ${message.usage.input_tokens}`);
      }
      prevMsgCount = currMsgCount;
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      O tool runner do SDK C# não suporta `compaction_control`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      O tool runner do SDK Go não suporta `compaction_control`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      O tool runner do SDK Java não suporta `compaction_control`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      O tool runner do SDK PHP não suporta `compaction_control`. Use a [compactação do lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) em vez disso.
    </Note>
  </Tab>

  <Tab title="Ruby">
    O SDK Ruby suporta um callback `on_compact:` que é disparado quando a compactação ocorre. Adicione-o à sua configuração de `compaction_control`:

    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: {
        enabled: true,
        context_token_threshold: 100000,
        on_compact: ->(tokens_before, tokens_after) do
          puts "Compaction occurred: #{tokens_before} -> #{tokens_after} tokens"
        end
      }
    )

    runner.each_message do |message|
      puts "Tokens: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

### Quando usar a 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ção
* Tarefas de várias 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 exigem recordação precisa de detalhes iniciais da conversa
* Fluxos de trabalho que usam ferramentas do lado do servidor extensivamente
* Tarefas que precisam manter o estado exato de muitas variáveis

## Próximos passos

<CardGroup cols={2}>
  <Card title="Compactação" icon="arrows-clockwise" href="https://platform.claude.com/docs/pt-BR/build-with-claude/compaction">
    Gerencie conversas longas com a compactação do lado do servidor, a estratégia recomendada para a maioria dos casos de uso.
  </Card>

  <Card title="Cache de prompt" icon="database" href="https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching">
    Reduza custo e latência armazenando prefixos de prompt em cache, e saiba como a edição de contexto interage com o cache.
  </Card>
</CardGroup>