---
title: Edición de contexto
url: https://platform.claude.com/docs/es/build-with-claude/context-editing
description: Gestiona automáticamente el contexto de la conversación a medida que crece con la edición de contexto.
---

<Note>
  Para saber cómo se aplica la "zero data retention" (retención cero de datos), o ZDR, a esta función, consulta [API y retención de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention).
</Note>

## Descripción general

<Note>
  Para la mayoría de los casos de uso, la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction) es la estrategia principal para gestionar el contexto en conversaciones de larga duración. Las estrategias de esta página son útiles para escenarios específicos en los que necesitas un control más detallado sobre qué contenido se elimina.
</Note>

La "context editing" (edición de contexto) te permite eliminar selectivamente contenido específico del historial de la conversación a medida que crece. Más allá de optimizar costos y mantenerte dentro de los límites, se trata de curar activamente lo que Claude ve: el contexto es un recurso finito con rendimientos decrecientes, y el contenido irrelevante degrada el enfoque del modelo. La edición de contexto te da un control detallado en tiempo de ejecución sobre esa curación. Para conocer los principios más amplios detrás de la gestión del contexto, consulta [Ingeniería de contexto efectiva](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). Esta página cubre:

* **Eliminación de resultados de herramientas** - Ideal para flujos de trabajo agénticos con un uso de herramientas intensivo donde los resultados de herramientas antiguos ya no son necesarios
* **Eliminación de bloques de pensamiento** - Para gestionar los bloques de pensamiento de turnos anteriores, con opciones para conservar el pensamiento reciente y mantener la continuidad del contexto
* **Compactación del lado del cliente en el SDK** - Una alternativa basada en el SDK para la gestión de contexto basada en resúmenes (generalmente se prefiere la compactación del lado del servidor)

| Enfoque                   | Dónde se ejecuta | Estrategias                                                                                                                                   | Cómo funciona                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ------------------------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Del lado del servidor** | API              | Eliminación de resultados de herramientas (`clear_tool_uses_20250919`)<br />Eliminación de bloques de pensamiento (`clear_thinking_20251015`) | Se aplica antes de que el prompt llegue a Claude. Elimina contenido específico del historial de la conversación. Cada estrategia se puede configurar de forma independiente.                                                                                                                                                                                                                                                              |
| **Del lado del cliente**  | SDK              | Compactación                                                                                                                                  | Disponible en los [SDK de TypeScript y Ruby](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) al usar [`tool_runner`](https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-runner). Genera un resumen y reemplaza el historial completo de la conversación. Consulta [Compactación del lado del cliente](https://platform.claude.com/docs/es/build-with-claude/context-editing#client-side-compaction-sdk). |

## Estrategias del lado del servidor

<Note>
  La edición de contexto está en beta con soporte para la eliminación de resultados de herramientas y la eliminación de bloques de pensamiento. Para habilitarla, usa el encabezado beta `context-management-2025-06-27` en tus solicitudes a la API.

  Comparte tus comentarios sobre esta función a través del [formulario de comentarios](https://forms.gle/YXC2EKGMhjN1c4L88).
</Note>

### Eliminación de resultados de herramientas

La estrategia `clear_tool_uses_20250919` elimina los resultados de herramientas cuando el contexto de la conversación crece más allá del umbral que configuraste. Esto es particularmente útil para flujos de trabajo agénticos con un uso de herramientas intensivo. Los resultados de herramientas más antiguos (como contenidos de archivos o resultados de búsqueda) ya no son necesarios una vez que Claude los ha procesado.

Cuando se activa, la API elimina automáticamente los resultados de herramientas más antiguos en orden cronológico. La API reemplaza cada resultado eliminado con un texto de marcador de posición que le indica a Claude que fue eliminado. De forma predeterminada, solo se eliminan los resultados de herramientas. Opcionalmente, puedes eliminar tanto los resultados de herramientas como las llamadas a herramientas (los parámetros de uso de herramientas) estableciendo `clear_tool_inputs` en true.

### Eliminación de bloques de pensamiento

La estrategia `clear_thinking_20251015` gestiona los bloques `thinking` de turnos anteriores del asistente. Esta estrategia te da control sobre la conservación del pensamiento: puedes elegir conservar más bloques de pensamiento para mantener la continuidad del razonamiento, o eliminarlos de forma más agresiva para ahorrar espacio de contexto.

<Tip>
  **Comportamiento predeterminado:** El valor predeterminado varía según la clase de modelo.

  | Clase de modelo | Conservar todo el pensamiento previo | Conservar solo el pensamiento del último turno |
  | --------------- | ------------------------------------ | ---------------------------------------------- |
  | Opus            | Claude Opus 4.5 y posteriores        | Claude Opus 4.1 y anteriores                   |
  | Sonnet          | Claude Sonnet 4.6 y posteriores      | Claude Sonnet 4.5 (obsoleto) y anteriores      |
  | Haiku           | Claude Haiku 5.5 y posteriores       | Claude Haiku 4.5 y anteriores                  |
  | Fable y Mythos  | Todos los modelos                    | (ninguno)                                      |

  Usa esta estrategia para anular el valor predeterminado. Si tu código se ejecuta en múltiples niveles de modelos, establece `keep` explícitamente en lugar de depender del valor predeterminado por modelo.
</Tip>

Un turno de conversación del asistente puede incluir múltiples bloques de contenido (por ejemplo, al usar herramientas) y múltiples bloques de pensamiento (por ejemplo, con [pensamiento intercalado](https://platform.claude.com/docs/es/build-with-claude/thinking#interleaved-thinking)).

### La edición de contexto ocurre del lado del servidor

La edición de contexto se aplica del lado del servidor antes de que el prompt llegue a Claude. Tu aplicación cliente mantiene el historial completo y sin modificar de la conversación. No necesitas sincronizar el estado de tu cliente con la versión editada. Continúa gestionando tu historial completo de la conversación localmente como lo harías normalmente.

En Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 y Claude Haiku 5.5, la gestión del contexto del lado del servidor nunca invalida los bloques de pensamiento. Las ediciones del lado del cliente en turnos anteriores pueden invalidar los bloques de pensamiento en cada turno posterior del asistente. Para las cuentas nuevas creadas a partir del 31 de agosto de 2026, una solicitud que reproduce un bloque invalidado se rechaza a menos que optes por descartarlo. Consulta [Mantener el prefijo sin cambios](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#prefix-check).

### Edición de contexto y almacenamiento en caché de prompts

La interacción de la edición de contexto con el ["prompt caching" (almacenamiento en caché de prompts)](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) varía según la estrategia:

* **Eliminación de resultados de herramientas:** Invalida los prefijos de prompt almacenados en caché cuando se elimina contenido. Para tener esto en cuenta, elimina suficientes tokens para que la invalidación de la caché valga la pena. Usa el parámetro `clear_at_least` para garantizar que se elimine un número mínimo de tokens cada vez. Incurrirás en costos de escritura en caché cada vez que se elimine contenido, pero las solicitudes posteriores pueden reutilizar el nuevo prefijo almacenado en caché.

* **Eliminación de bloques de pensamiento:** Cuando los bloques de pensamiento se **conservan** en el contexto (no se eliminan), la caché de prompts se preserva, lo que permite aciertos de caché y reduce los costos de tokens de entrada. Cuando los bloques de pensamiento se **eliminan**, la caché se invalida en el punto donde ocurre la eliminación. Configura el parámetro `keep` según si quieres priorizar el rendimiento de la caché o la disponibilidad de la ventana de contexto.

## Modelos compatibles

La edición de contexto está disponible en todos los modelos de Claude compatibles.

## Uso de la eliminación de resultados de herramientas

La forma más sencilla de habilitar la eliminación de resultados de herramientas es especificar solo el tipo de estrategia. Todas las demás [opciones de configuración](https://platform.claude.com/docs/es/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) usan sus valores predeterminados:

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

### Configuración avanzada

Puedes personalizar el comportamiento de la eliminación de resultados de herramientas con parámetros adicionales:

<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",
                  # Activa la limpieza cuando se supera el umbral
                  "trigger": {"type": "input_tokens", "value": 30000},
                  # Número de usos de herramientas que se conservan tras la limpieza
                  "keep": {"type": "tool_uses", "value": 3},
                  # Opcional: limpia al menos esta cantidad de tokens
                  "clear_at_least": {"type": "input_tokens", "value": 5000},
                  # Excluye estas herramientas de la limpieza
                  "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",
          // Activa la limpieza cuando se supera el umbral
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          // Número de usos de herramientas que se conservan tras la limpieza
          keep: {
            type: "tool_uses",
            value: 3
          },
          // Opcional: limpia al menos esta cantidad de tokens
          clear_at_least: {
            type: "input_tokens",
            value: 5000
          },
          // Excluye estas herramientas de la limpieza
          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 de la eliminación de bloques de pensamiento

Usa la eliminación de bloques de pensamiento para gestionar el contexto y el almacenamiento en caché de prompts en conversaciones que arrastran bloques de pensamiento 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>

### Opciones de configuración para la eliminación de bloques de pensamiento

La estrategia `clear_thinking_20251015` admite la siguiente configuración:

| Opción de configuración | Predeterminado        | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ----------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `keep`                  | Específico del modelo | Define cuántos turnos recientes del asistente con bloques de pensamiento se conservan. Usa `{type: "thinking_turns", value: N}`, donde N debe ser > 0, para conservar los últimos N turnos, o `"all"` para conservar todos los bloques de pensamiento. Opus 4.5+, Sonnet 4.6+ y Haiku 5.5+: todos los turnos. Modelos Fable y Mythos: todos los turnos. Opus/Sonnet anteriores y Haiku hasta Claude Haiku 4.5: solo el último turno. |

**Configuraciones de ejemplo:**

Conservar los bloques de pensamiento de los últimos 3 turnos del asistente:

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

Conservar todos los bloques de pensamiento (maximiza los aciertos de caché):

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

### Combinación de estrategias

Puedes usar la eliminación de bloques de pensamiento y la eliminación de resultados de herramientas juntas:

<Note>
  Al usar múltiples estrategias, la estrategia `clear_thinking_20251015` debe aparecer primero en el arreglo `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>

## Opciones de configuración para la eliminación de resultados de herramientas

| Opción de configuración | Predeterminado            | Descripción                                                                                                                                                                                                                                                                       |
| ----------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger`               | 100,000 tokens de entrada | Define cuándo se activa la estrategia de edición de contexto. Una vez que el prompt supera este umbral, comienza la eliminación. Puedes especificar este valor en `input_tokens` o en `tool_uses`.                                                                                |
| `keep`                  | 3 usos de herramientas    | Define cuántos pares recientes de uso/resultado de herramientas se conservan después de que ocurre la eliminación. La API elimina primero las interacciones de herramientas más antiguas, preservando las más recientes.                                                          |
| `clear_at_least`        | Ninguno                   | Garantiza que se elimine un número mínimo de tokens cada vez que se activa la estrategia. Si la API no puede eliminar al menos la cantidad especificada, la estrategia no se aplicará. Esto ayuda a determinar si vale la pena romper tu caché de prompts para eliminar contexto. |
| `exclude_tools`         | Ninguno                   | Lista de nombres de herramientas cuyos usos y resultados nunca deben eliminarse. Útil para preservar contexto importante.                                                                                                                                                         |
| `clear_tool_inputs`     | `false`                   | Controla si los parámetros de las llamadas a herramientas se eliminan junto con los resultados de herramientas. De forma predeterminada, solo se eliminan los resultados de herramientas, manteniendo visibles las llamadas a herramientas originales de Claude.                  |

## Respuesta de la edición de contexto

Puedes ver qué ediciones de contexto se aplicaron a tu solicitud usando el campo de respuesta `context_management`, junto con estadísticas útiles sobre el contenido y los tokens de entrada eliminados.

```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 las respuestas en streaming, las ediciones de contexto se incluyen en el 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": [
      // ...
    ]
  }
}
```

## Conteo de tokens

El endpoint de [conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting) admite la gestión de contexto, lo que te permite previsualizar cuántos tokens usará tu prompt después de que se aplique la edición 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
  }
}
```

La respuesta muestra tanto el conteo final de tokens después de aplicar la gestión de contexto (`input_tokens`) como el conteo original de tokens antes de que ocurriera cualquier eliminación (`original_input_tokens`).

## Uso con la herramienta de memoria

La edición de contexto se puede combinar con la [herramienta de memoria](https://platform.claude.com/docs/es/agents-and-tools/tool-use/memory-tool). Cuando el contexto de tu conversación se acerca al umbral de eliminación configurado, Claude recibe una advertencia automática para preservar la información importante. Esto permite que Claude guarde resultados de herramientas o contexto en sus archivos de memoria antes de que se eliminen del historial de la conversación.

Esta combinación te permite:

* **Preservar contexto importante:** Claude puede escribir información esencial de los resultados de herramientas en archivos de memoria antes de que esos resultados se eliminen
* **Mantener flujos de trabajo de larga duración:** Habilita flujos de trabajo agénticos que de otro modo superarían los límites de contexto al trasladar información a un almacenamiento persistente
* **Acceder a la información bajo demanda:** Claude puede buscar información previamente eliminada en los archivos de memoria cuando la necesite, en lugar de mantener todo en la ventana de contexto activa

Por ejemplo, en un flujo de trabajo de edición de archivos donde Claude realiza muchas operaciones, Claude puede resumir los cambios completados en archivos de memoria a medida que el contexto crece. Cuando se eliminan los resultados de herramientas, Claude conserva el acceso a esa información a través de su sistema de memoria y puede seguir trabajando de forma efectiva.

Para usar ambas funciones juntas, habilítalas en tu solicitud a la 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 la referencia completa de la herramienta de memoria, incluidos comandos y ejemplos, consulta [Herramienta de memoria](https://platform.claude.com/docs/es/agents-and-tools/tool-use/memory-tool).

## Compactación del lado del cliente (SDK)

<Warning>
  **Anthropic recomienda la compactación del lado del servidor en lugar de la compactación del SDK.** La [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction) gestiona el contexto automáticamente con menos complejidad de integración, mejor cálculo del uso de tokens y sin limitaciones del lado del cliente. Usa la compactación del SDK solo si necesitas específicamente control del lado del cliente sobre el proceso de resumen.

  El parámetro `compaction_control` está obsoleto en los SDK de TypeScript y Ruby y se eliminará en una versión futura. Los SDK emiten una advertencia de obsolescencia cuando está habilitado. El SDK de Python lo eliminó en la v1.0. Para usar la compactación del lado del servidor con un tool runner, pasa la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
</Warning>

<Note>
  La compactación está disponible en los [SDK de TypeScript y Ruby](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) al usar el [método `tool_runner`](https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-runner).
</Note>

La "compaction" (compactación) es una función del SDK que gestiona automáticamente el contexto de la conversación generando resúmenes cuando el uso de tokens crece demasiado. A diferencia de las estrategias de edición de contexto del lado del servidor que eliminan contenido, la compactación le indica a Claude que resuma el historial de la conversación y luego reemplaza el historial completo con ese resumen. Esto permite que Claude siga trabajando en tareas de larga duración que de otro modo superarían la [ventana de contexto](https://platform.claude.com/docs/es/build-with-claude/context-windows).

### Cómo funciona la compactación

Cuando la compactación está habilitada, el SDK monitorea el uso de tokens después de cada respuesta del modelo:

1. **Verificación del umbral:** El SDK calcula el total de tokens como `input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens` (consulta [Almacenamiento en caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) para los campos de tokens de caché).
2. **Generación del resumen:** Cuando se supera el umbral, se inyecta un prompt de resumen como turno del usuario, y Claude genera un resumen estructurado envuelto en etiquetas `<summary></summary>`.
3. **Reemplazo del contexto:** El SDK extrae el resumen y reemplaza todo el historial de mensajes con él.
4. **Continuación:** La conversación se reanuda desde el resumen, y Claude retoma donde lo dejó.

### Uso de la compactación

Agrega `compaction_control` a tu llamada a `tool_runner` para habilitar el resumen automático cuando el uso de tokens supere el umbral.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compactación se ejecuta del lado del cliente en los helpers `tool_runner` del SDK, por lo que no tiene un equivalente HTTP directo. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI no incluye un helper `tool_runner`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic sin integración del lado del SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      En la v1.0 y posteriores, el tool runner del SDK de Python no admite `compaction_control` del lado del cliente. Usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold) en su lugar: funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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>
      El SDK de C# incluye un tool runner, pero no admite `compaction_control` del lado del cliente. Usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold) en su lugar: funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      El SDK de Go incluye un tool runner, pero no admite `compaction_control` del lado del cliente. Usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold) en su lugar: funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      El SDK de Java incluye un tool runner, pero no admite `compaction_control` del lado del cliente. Usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold) en su lugar: funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      El SDK de PHP incluye un tool runner, pero no admite `compaction_control` del lado del cliente. Usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold) en su lugar: funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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>

#### Qué ocurre durante la compactación

A medida que la conversación crece, el historial de mensajes se acumula:

**Antes de la compactación (acercándose a 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 ...
]
```

Cuando los tokens superan el umbral, el SDK inyecta una solicitud de resumen y Claude genera un resumen. Luego se reemplaza todo el historial:

**Después de la compactación (de vuelta 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 sigue trabajando a partir de este resumen como si fuera el historial original de la conversación.

### Opciones de configuración

| Parámetro                 | Tipo    | Requerido | Predeterminado                                                                                                                            | Descripción                                          |
| ------------------------- | ------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| `enabled`                 | boolean | Sí        | -                                                                                                                                         | Si se habilita la compactación automática            |
| `context_token_threshold` | number  | No        | 100,000                                                                                                                                   | Conteo de tokens en el que se activa la compactación |
| `model`                   | string  | No        | El mismo que el modelo principal                                                                                                          | Modelo a usar para generar resúmenes                 |
| `summary_prompt`          | string  | No        | Consulta [Prompt de resumen predeterminado](https://platform.claude.com/docs/es/build-with-claude/context-editing#default-summary-prompt) | Prompt personalizado para la generación de resúmenes |

#### Elección de un umbral de tokens

El umbral determina cuándo ocurre la compactación. Un umbral más bajo significa compactaciones más frecuentes con ventanas de contexto más pequeñas. Un umbral más alto permite más contexto, pero corre el riesgo de alcanzar los límites.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compactación se ejecuta del lado del cliente en los helpers `tool_runner` del SDK, por lo que no tiene un equivalente HTTP directo. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI no incluye un helper `tool_runner`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic sin integración del lado del SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      En la v1.0 y versiones posteriores, el tool runner del SDK de Python no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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 más bajos compactan con más frecuencia; súbelo a 150000 si la tarea necesita más 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>
      El SDK de C# incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      El SDK de Go incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      El SDK de Java incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      El SDK de PHP incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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 más bajos compactan con más frecuencia; súbelo a 150000 si la tarea necesita más contexto
      compaction_control: { enabled: true, context_token_threshold: 50000 }
    )

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

#### Uso de un modelo diferente para los resúmenes

Puedes usar un modelo más rápido o más económico para generar resúmenes:

<Tabs>
  <Tab title="cURL">
    <Note>
      La compactación se ejecuta del lado del cliente en los helpers `tool_runner` del SDK, por lo que no tiene un equivalente HTTP directo. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI no incluye un helper `tool_runner`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic sin integración del lado del SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      En la v1.0 y versiones posteriores, el tool runner del SDK de Python no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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>
      El SDK de C# incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      El SDK de Go incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      El SDK de Java incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      El SDK de PHP incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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 resumen personalizados

Puedes proporcionar un prompt personalizado para necesidades específicas de un dominio. Tu prompt debe indicarle a Claude que envuelva su resumen en etiquetas `<summary></summary>`.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compactación se ejecuta del lado del cliente en los helpers `tool_runner` del SDK, por lo que no tiene un equivalente HTTP directo. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI no incluye un helper `tool_runner`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic sin integración del lado del SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      En la v1.0 y versiones posteriores, el tool runner del SDK de Python no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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>
      El SDK de C# incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      El SDK de Go incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      El SDK de Java incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      El SDK de PHP incluye un tool runner, pero no admite `compaction_control` del lado del cliente. En su lugar, usa la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold): funciona con el tool runner pasando la edición `compact_20260112` en el parámetro `context_management` de la solicitud.
    </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 resumen predeterminado

El prompt de resumen integrado le indica a Claude que cree un resumen de continuación estructurado que incluya:

1. **Descripción general de la tarea:** La solicitud principal del usuario, los criterios de éxito y las restricciones.
2. **Estado actual:** Lo que se ha completado, los archivos modificados y los artefactos producidos.
3. **Descubrimientos importantes:** Restricciones técnicas, decisiones tomadas, errores resueltos y enfoques fallidos.
4. **Próximos pasos:** Acciones específicas necesarias, bloqueos y orden de prioridad.
5. **Contexto a preservar:** Preferencias del usuario, detalles específicos del dominio y compromisos asumidos.

Esta estructura permite que Claude reanude el trabajo de forma eficiente sin perder contexto importante ni repetir errores.

<Accordion title="Ver el prompt predeterminado 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>

### Limitaciones

#### Herramientas del lado del servidor

<Warning>
  La compactación requiere una consideración especial al usar herramientas del lado del servidor como la [búsqueda web](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-search-tool) o la [obtención web](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool).
</Warning>

Al usar herramientas del lado del servidor, el SDK puede calcular incorrectamente el uso de tokens, lo que provoca que la compactación se active en el momento equivocado.

Por ejemplo, después de una operación de búsqueda web, la respuesta de la API podría mostrar:

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

El SDK calcula el uso total como 63,000 + 0 + 270,000 + 1,400 = 334,400 tokens. Sin embargo, el valor de `cache_read_input_tokens` incluye lecturas acumuladas de múltiples llamadas internas a la API realizadas por la herramienta del lado del servidor, no el contexto real de tu conversación. La longitud real de tu contexto podría ser solo los 63,000 `input_tokens`, pero el SDK ve 334k y activa la compactación prematuramente.

**Soluciones alternativas:**

* Usa el endpoint de [conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting) para obtener la longitud precisa del contexto
* Evita la compactación cuando uses herramientas del lado del servidor de forma extensiva

#### Casos límite del uso de herramientas

Cuando el SDK activa la compactación mientras hay una respuesta de uso de herramientas pendiente, elimina el bloque de uso de herramientas del historial de mensajes antes de generar el resumen. Claude volverá a emitir la llamada a la herramienta después de reanudar desde el resumen si aún es necesaria.

### Monitoreo de la compactación

Entender cuándo se activa la compactación te ayuda a ajustar los umbrales y verificar el comportamiento esperado.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compactación se ejecuta del lado del cliente en los helpers `tool_runner` del SDK, por lo que no tiene un equivalente HTTP directo. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI no incluye un helper `tool_runner`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction), que gestiona la compactación en los servidores de Anthropic sin integración del lado del SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      En la v1.0 y posteriores, el tool runner del SDK de Python no admite `compaction_control`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="TypeScript">
    El `toolRunner` del SDK de TypeScript admite la compactación, pero no registra eventos. Detecta la compactación observando cómo `runner.params.messages.length` se reduce entre 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>
      El tool runner del SDK de C# no admite `compaction_control`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      El tool runner del SDK de Go no admite `compaction_control`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      El tool runner del SDK de Java no admite `compaction_control`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      El tool runner del SDK de PHP no admite `compaction_control`. Usa en su lugar la [compactación del lado del servidor](https://platform.claude.com/docs/es/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Ruby">
    El SDK de Ruby admite un callback `on_compact:` que se dispara cuando ocurre la compactación. Agrégalo a tu configuración 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>

### Cuándo usar la compactación

**Buenos casos de uso:**

* Tareas de agentes de larga duración que procesan muchos archivos o fuentes de datos
* Flujos de trabajo de investigación que acumulan grandes cantidades de información
* Tareas de varios pasos con un progreso claro y medible
* Tareas que producen artefactos (archivos, informes) que persisten fuera de la conversación

**Casos de uso menos ideales:**

* Tareas que requieren recordar con precisión detalles tempranos de la conversación
* Flujos de trabajo que usan herramientas del lado del servidor de forma extensiva
* Tareas que necesitan mantener un estado exacto a través de muchas variables

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Compactación" icon="arrows-clockwise" href="https://platform.claude.com/docs/es/build-with-claude/compaction">
    Gestiona conversaciones largas con la compactación del lado del servidor, la estrategia recomendada para la mayoría de los casos de uso.
  </Card>

  <Card title="Almacenamiento en caché de prompts" icon="database" href="https://platform.claude.com/docs/es/build-with-claude/prompt-caching">
    Reduce el costo y la latencia almacenando en caché los prefijos de prompts, y aprende cómo la edición de contexto interactúa con la caché.
  </Card>
</CardGroup>