---
title: Compactación en un umbral de tokens
url: https://platform.claude.com/docs/es/build-with-claude/compaction-threshold
description: Haz que la API resuma automáticamente el contexto más antiguo, dentro de una solicitud normal, cuando la conversación alcance un umbral de tokens que tú establezcas.
featureMetadata:
status: beta
betaHeader: compact-2026-01-12
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Los resultados de la compactación del lado del servidor se devuelven y se reenvían sin estado a través de la respuesta de la API.
supportedModels:
- claude-fable-5-1
- claude-mythos-5-1
- claude-fable-5
- claude-mythos-5
- claude-mythos-preview
- claude-opus-5-5
- claude-opus-5
- claude-sonnet-5-5
- claude-sonnet-5
- claude-haiku-5-5
- claude-opus-4-8
- claude-opus-4-7
- claude-opus-4-6
- claude-sonnet-4-6
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
Amazon Bedrock: beta
Amazon Bedrock (InvokeModel): beta
Claude Models on Google Cloud (Google managed): beta
Microsoft Foundry: beta
---
**Compatibilidad con la API**: El uso varía según el producto.
* **Messages API**: Actívala con una edición `compact_20260112`; la compactación comienza en 150,000 tokens de entrada de forma predeterminada.
* **Managed Agents**: Siempre activo. Compacta el historial de conversación de la sesión para que quepa en la ventana de contexto.
La “threshold compaction” (compactación por umbral) es el tipo automático de “compaction” (compactación): estableces un umbral de tokens en tus solicitudes ordinarias, y la API resume el contexto anterior a mitad de una solicitud una vez que se alcanza el umbral. Se admite junto con la compactación bajo demanda, en la que tú decides cuándo se escribe el resumen (consulta [Compactación bajo demanda](https://platform.claude.com/docs/es/build-with-claude/compaction-on-demand)). Para elegir entre ambas, consulta [Elige cómo compactar](https://platform.claude.com/docs/es/build-with-claude/compaction#choose-how-to-compact).
La compactación amplía la longitud de contexto efectiva para conversaciones y tareas de larga duración al resumir automáticamente el contexto anterior cuando se acerca al límite de la “context window” (ventana de contexto). También mantiene pequeño el contexto activo: a medida que una conversación crece, la calidad de las respuestas se degrada, por lo que la compactación reemplaza el contenido anterior con un resumen conciso.
Para profundizar en por qué los contextos largos se degradan y cómo ayuda la compactación, consulta [Ingeniería de contexto efectiva](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents).
Esto es ideal para:
* Conversaciones de múltiples turnos basadas en chat en las que quieres que los usuarios utilicen un mismo chat durante un período prolongado
* Prompts orientados a tareas que requieren mucho trabajo de seguimiento (a menudo uso de herramientas) que podría exceder la ventana de contexto
## Cómo funciona la compactación
Cuando la compactación está habilitada, Claude resume automáticamente tu conversación cuando alcanza el umbral de tokens configurado. La API:
1. Detecta cuándo los tokens de entrada alcanzan el umbral de activación que especificaste.
2. Genera un resumen de la conversación actual.
3. Crea un bloque `compaction` que contiene el resumen.
4. Continúa la respuesta con el contexto compactado.
En las solicitudes posteriores, agrega la respuesta a tus mensajes. La API descarta automáticamente todos los bloques de contenido anteriores al bloque `compaction` y continúa la conversación a partir del resumen.
## Uso básico
Habilita la compactación agregando la estrategia `compact_20260112` a `context_management.edits` en tu solicitud a la Messages API.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Help me build a website
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Help me build a website"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
messages.append({"role": "assistant", "content": response.content})
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Help me build a website" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
});
// Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
messages.push({
role: "assistant",
content: response.content
});
```
```csharp C#
AnthropicClient client = new();
var messages = new List
{
new BetaUserMessageParam { Content = "Help me build a website" }
};
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
var response = await client.Beta.Messages.Create(parameters);
// Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a website")),
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
// Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
messages = append(messages, response.ToParam())
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a website")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
// incluyéndola en los mensajes de la siguiente solicitud
System.out.println(response);
```
```php PHP
$client = new Client();
$messages = [
['role' => 'user', 'content' => 'Help me build a website']
];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
// Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
$messages[] = ['role' => 'assistant', 'content' => $response->content];
echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [
{ role: "user", content: "Help me build a website" }
]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
# Agrega la respuesta (incluido cualquier bloque de compactación) para continuar la conversación
messages << { role: "assistant", content: response.content }
puts response
```
## Parámetros
| Parámetro | Tipo | Predeterminado | Descripción |
| ------------------------ | ------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `type` | string | Obligatorio | Debe ser `"compact_20260112"` |
| `trigger` | object | `{"type": "input_tokens", "value": 150000}` | Cuándo activar la compactación. `input_tokens` es el único tipo de disparador admitido. `value` debe ser de al menos 50,000 tokens. |
| `pause_after_compaction` | boolean | `false` | Si se debe pausar después de generar el resumen de compactación |
| `instructions` | string | `null` | Prompt de resumen personalizado. Reemplaza por completo el prompt predeterminado cuando se proporciona. |
### Configuración del disparador
Configura cuándo se activa la compactación usando el parámetro `trigger`:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 150000
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
trigger:
type: input_tokens
value: 150000
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": 150000},
}
]
},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: {
type: "input_tokens",
value: 150000
}
}
]
}
});
```
```csharp C#
AnthropicClient client = new();
List messages = [new BetaUserMessageParam { Content = "Hello" }];
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Betas = ["compact-2026-01-12"],
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(150000)
}]
}
};
var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: 150000},
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(150000L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
System.out.println(response);
```
```php PHP
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$message = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => [
'type' => 'input_tokens',
'value' => 150000
]
]
]
]
);
echo $message;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: {
type: "input_tokens",
value: 150000
}
}
]
}
)
puts response
```
### Instrucciones de resumen personalizadas
El prompt de resumen predeterminado varía según el modelo. Cada prompt predeterminado le indica a Claude que escriba un resumen dentro de etiquetas `` con la información necesaria para continuar la tarea en una ventana de contexto futura. Por ejemplo, algunos modelos usan el siguiente prompt:
```text wrap
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a block.
```
Puedes proporcionar instrucciones personalizadas mediante el parámetro `instructions`. Las instrucciones personalizadas no complementan el prompt predeterminado. Lo reemplazan por completo:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
instructions: >-
Focus on preserving code snippets, variable names, and
technical decisions.
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions.",
}
]
},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
instructions:
"Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
});
```
```csharp C#
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages =
[
new BetaUserMessageParam { Content = "Help me build a Python web scraper" },
new BetaAssistantMessageParam { Content = "I'll help you build a web scraper..." },
new BetaUserMessageParam { Content = "Add support for JavaScript-rendered pages" }
],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Instructions = "Focus on preserving code snippets, variable names, and technical decisions."
}]
}
};
var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);
```
```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("Help me build a Python web scraper")),
{OfAssistant: &anthropic.BetaAssistantMessageParam{Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("I'll help you build a web scraper...")}}},
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Add support for JavaScript-rendered pages")),
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Instructions: anthropic.String("Focus on preserving code snippets, variable names, and technical decisions."),
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a Python web scraper")
.addAssistantMessage("I'll help you build a web scraper...")
.addUserMessage("Add support for JavaScript-rendered pages")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.instructions("Focus on preserving code snippets, variable names, and technical decisions.")
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
System.out.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Help me build a Python web scraper'],
['role' => 'assistant', 'content' => "I'll help you build a web scraper..."],
['role' => 'user', 'content' => 'Add support for JavaScript-rendered pages']
],
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'instructions' => 'Focus on preserving code snippets, variable names, and technical decisions.'
]
]
]
);
echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: [
{ role: "user", content: "Help me build a Python web scraper" },
{ role: "assistant", content: "I'll help you build a web scraper..." },
{ role: "user", content: "Add support for JavaScript-rendered pages" }
],
context_management: {
edits: [
{
type: "compact_20260112",
instructions:
"Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
)
puts response
```
En Claude 5.1 y modelos posteriores, una solicitud con `instructions` personalizadas resume únicamente a partir de la conversación visible: los bloques de pensamiento anteriores no forman parte de la entrada del resumidor.
### Pausar después de la compactación
Usa `pause_after_compaction` para pausar la API después de generar el resumen de compactación. Esto te permite agregar bloques de contenido adicionales (como conservar mensajes recientes o mensajes específicos orientados a instrucciones) antes de que la API continúe con la respuesta.
Cuando está habilitado, la API devuelve un mensaje con el motivo de detención `compaction` después de generar el bloque de compactación:
```bash cURL
# pause_after_compaction detiene la respuesta justo después del resumen
# de compactación para que puedas ajustar los mensajes antes de continuar. El paso
# de continuar no se adapta bien a un comando de shell aislado; consulta las pestañas del SDK
# para ver el flujo completo de pausa y continuación. Solicitud pausada única:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": true
}
]
}
}'
```
```bash CLI
# pause_after_compaction detiene la respuesta justo después del resumen
# de compactación para que puedas ajustar los mensajes antes de continuar. El paso
# de continuar no se adapta bien a un comando CLI puntual; consulta las pestañas del SDK
# para ver el flujo completo de pausa y continuación. Solicitud pausada única:
ant beta:messages create --beta compact-2026-01-12 --format jsonl <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
pause_after_compaction: true
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [{"type": "compact_20260112", "pause_after_compaction": True}]
},
)
# Comprueba si la compactación provocó una pausa
if response.stop_reason == "compaction":
# La respuesta contiene solo el bloque de compactación
messages.append({"role": "assistant", "content": response.content})
# Continúa la solicitud
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
let response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
pause_after_compaction: true
}
]
}
});
// Comprueba si la compactación provocó una pausa
if (response.stop_reason === "compaction") {
// La respuesta contiene solo el bloque de compactación
messages.push({
role: "assistant",
content: response.content
});
// Continúa la solicitud
response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
}
```
```csharp C#
var client = new AnthropicClient();
var messages = new List
{
new BetaUserMessageParam { Content = "Hello, Claude" }
};
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Betas = ["compact-2026-01-12"],
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
PauseAfterCompaction = true
}]
}
};
var response = await client.Beta.Messages.Create(parameters);
if (response.StopReason == BetaStopReason.Compaction)
{
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
parameters = new()
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Betas = ["compact-2026-01-12"],
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
response = await client.Beta.Messages.Create(parameters);
}
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
compactEdit := anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
PauseAfterCompaction: anthropic.Bool(true),
}},
},
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
if response.StopReason == "compaction" {
messages = append(messages, response.ToParam())
response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Help me build a website")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.pauseAfterCompaction(true)
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Comprueba si la compactación provocó una pausa
if (response.stopReason().isPresent()
&& response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
// Agrega el bloque de compactación y continúa la solicitud
// creando una nueva solicitud con el contexto compactado
MessageCreateParams continueParams = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Help me build a website")
.addMessage(response)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
response = client.beta().messages().create(continueParams);
}
System.out.println(response);
```
```php PHP
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'pause_after_compaction' => true
]
]
]
);
if ($response->stopReason === 'compaction') {
$messages[] = [
'role' => 'assistant',
'content' => $response->content
];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
}
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
pause_after_compaction: true
}
]
}
)
if response.stop_reason == :compaction
messages << { role: "assistant", content: response.content }
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
end
puts response
```
La API se pausa incluso si no se genera ningún resumen. En ese caso, el `content` del bloque `compaction` es `null`, así que conserva los mensajes originales cuando continúes. Si las salvaguardas bloquean el resumen, `content` también es `null` y el motivo de detención es `refusal` en lugar de `compaction`. [`stop_details`](https://platform.claude.com/docs/es/build-with-claude/handling-stop-reasons#refusal) indica la categoría de política, si la hay. Continúa de la misma manera en ambos casos: busca el bloque `compaction` en lugar de comprobar `stop_reason`, como lo hace el [ejemplo que conserva los mensajes recientes](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold#examples).
#### Aplicar un presupuesto total de tokens
Cuando un modelo trabaja en tareas largas con muchas iteraciones de uso de herramientas, el consumo total de tokens puede crecer considerablemente. Puedes combinar `pause_after_compaction` con un contador de compactaciones para estimar el uso acumulado y concluir la tarea de forma ordenada una vez que se alcance un presupuesto.
Este ejemplo aparece solo en los lenguajes de los SDK: su valor está en la lógica de seguimiento del presupuesto alrededor de la solicitud. La solicitud sin procesar combina el `trigger` de [Configuración del disparador](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold#trigger-configuration) con `pause_after_compaction` de [Pausar después de la compactación](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold#pausing-after-compaction).
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
TRIGGER_THRESHOLD = 100_000
TOTAL_TOKEN_BUDGET = 3_000_000
n_compactions = 0
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": TRIGGER_THRESHOLD},
"pause_after_compaction": True,
}
]
},
)
if response.stop_reason == "compaction":
n_compactions += 1
messages.append({"role": "assistant", "content": response.content})
# Estima el total de tokens consumidos; pide cerrar si se excede el presupuesto
if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
messages.append(
{
"role": "user",
"content": "Please wrap up your current work and summarize the final state.",
}
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const TRIGGER_THRESHOLD = 100_000;
const TOTAL_TOKEN_BUDGET = 3_000_000;
let compactionCount = 0;
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD },
pause_after_compaction: true
}
]
}
});
if (response.stop_reason === "compaction") {
compactionCount += 1;
messages.push({ role: "assistant", content: response.content });
// Estima el total de tokens consumidos; pide cerrar si se excede el presupuesto
if (compactionCount * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET) {
messages.push({
role: "user",
content: "Please wrap up your current work and summarize the final state."
});
}
}
```
```csharp C#
AnthropicClient client = new();
List messages = [new BetaUserMessageParam { Content = "Hello, Claude" }];
const int TriggerThreshold = 100_000;
const int TotalTokenBudget = 3_000_000;
int compactionCount = 0;
var response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(TriggerThreshold),
PauseAfterCompaction = true
}]
}
});
if (response.StopReason == BetaStopReason.Compaction)
{
compactionCount += 1;
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
// Estima el total de tokens consumidos; solicita concluir si se excede el presupuesto
if (compactionCount * TriggerThreshold >= TotalTokenBudget)
{
messages.Add(new BetaUserMessageParam
{
Content = "Please wrap up your current work and summarize the final state."
});
}
}
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
const triggerThreshold = 100_000
const totalTokenBudget = 3_000_000
compactionCount := 0
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: triggerThreshold},
PauseAfterCompaction: anthropic.Bool(true),
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
if response.StopReason == "compaction" {
compactionCount++
messages = append(messages, response.ToParam())
// Estima el total de tokens consumidos; pide cerrar si se excede el presupuesto
if compactionCount*triggerThreshold >= totalTokenBudget {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Please wrap up your current work and summarize the final state.")))
}
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
long triggerThreshold = 100_000;
long totalTokenBudget = 3_000_000;
int compactionCount = 0;
List messages = new ArrayList<>();
messages.add(BetaMessageParam.ofUser("Hello, Claude"));
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(triggerThreshold)
.build())
.pauseAfterCompaction(true)
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
if (response.stopReason().isPresent()
&& response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
compactionCount += 1;
messages.add(response.toParam());
// Estima el total de tokens consumidos; pide cerrar si se excede el presupuesto
if (compactionCount * triggerThreshold >= totalTokenBudget) {
messages.add(BetaMessageParam.ofUser(
"Please wrap up your current work and summarize the final state."));
}
}
System.out.println(response);
```
```php PHP
$client = new Client();
$triggerThreshold = 100_000;
$totalTokenBudget = 3_000_000;
$compactionCount = 0;
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => ['type' => 'input_tokens', 'value' => $triggerThreshold],
'pause_after_compaction' => true
]
]
]
);
if ($response->stopReason === 'compaction') {
$compactionCount += 1;
$messages[] = ['role' => 'assistant', 'content' => $response->content];
// Estima el total de tokens consumidos; pide cerrar si se excede el presupuesto
if ($compactionCount * $triggerThreshold >= $totalTokenBudget) {
$messages[] = [
'role' => 'user',
'content' => 'Please wrap up your current work and summarize the final state.'
];
}
}
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
TRIGGER_THRESHOLD = 100_000
TOTAL_TOKEN_BUDGET = 3_000_000
compaction_count = 0
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD },
pause_after_compaction: true
}
]
}
)
if response.stop_reason == :compaction
compaction_count += 1
messages << { role: "assistant", content: response.content }
# Estima el total de tokens consumidos; pide cerrar si se excede el presupuesto
if compaction_count * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET
messages << {
role: "user",
content: "Please wrap up your current work and summarize the final state."
}
end
end
```
## Trabajar con bloques de compactación
Cuando se activa la compactación, la API devuelve un bloque `compaction` al inicio de la respuesta del asistente.
Una conversación de larga duración puede dar lugar a múltiples compactaciones. El último bloque de compactación refleja el estado final del prompt y reemplaza el contenido anterior a él con el resumen generado.
```json Output
{
"content": [
{
"type": "compaction",
"content": "Summary of the conversation: The user requested help building a web scraper..."
},
{
"type": "text",
"text": "Based on our conversation so far..."
}
]
}
```
### Devolver los bloques de compactación
Debes devolver el bloque `compaction` a la API en las solicitudes posteriores para continuar la conversación con el prompt acortado. El enfoque más sencillo es agregar todo el contenido de la respuesta a tus mensajes:
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Después de recibir una respuesta con un bloque de compactación
messages.append({"role": "assistant", "content": response.content})
# Continúa la conversación
messages.append({"role": "user", "content": "Now add error handling"})
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
// Después de recibir una respuesta con un bloque de compactación
messages.push({
role: "assistant",
content: response.content
});
// Continúa la conversación
messages.push({ role: "user", content: "Now add error handling" });
const nextResponse = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
```
```csharp C#
AnthropicClient client = new();
var messages = new List
{
new BetaUserMessageParam { Content = "Help me build a web scraper" }
};
var response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
messages.Add(new BetaUserMessageParam { Content = "Now add error handling" });
var nextResponse = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
Console.WriteLine(nextResponse);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a web scraper")),
}
compactEdit := anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Now add error handling")))
nextResponse, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(nextResponse)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
// Primera solicitud
BetaMessage response = client.beta().messages().create(
MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a web scraper")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build());
// Tras recibir una respuesta con un bloque de compactación, agrega todo el
// contenido (incluidos los bloques de compactación) y continúa la conversación
BetaMessage nextResponse = client.beta().messages().create(
MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a web scraper")
.addMessage(response)
.addUserMessage("Now add error handling")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build());
System.out.println(nextResponse);
```
```php PHP
$client = new Client();
$messages = [
['role' => 'user', 'content' => 'Help me build a web scraper']
];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
$messages[] = ['role' => 'user', 'content' => 'Now add error handling'];
$nextResponse = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
echo json_encode($nextResponse, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [
{ role: "user", content: "Help me build a web scraper" }
]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
messages << { role: "assistant", content: response.content }
messages << { role: "user", content: "Now add error handling" }
next_response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
puts next_response.content
```
En Python, usa `client.beta.messages`, como hacen los ejemplos de esta página. Si llamas a `client.messages` y serializas los bloques tú mismo, un `model_dump()` simple agrega `text: null` y `citations: null` al bloque `compaction`. La API entonces rechaza la solicitud con un error 400 (`Extra inputs are not permitted`). Usa `to_dict()` o `model_dump(exclude_none=True)` en su lugar. [Continuar a partir del resumen](https://platform.claude.com/docs/es/build-with-claude/compaction-on-demand#continue-from-the-summary) da el mismo consejo para la compactación bajo demanda.
Cuando la API recibe un bloque `compaction`, se ignoran todos los bloques de contenido anteriores a él. Puedes:
* Mantener los mensajes originales en tu lista y dejar que la API se encargue de eliminar el contenido compactado
* Descartar manualmente los mensajes compactados e incluir solo desde el bloque de compactación en adelante
Si no se genera ningún resumen, el `content` del bloque es `null` y la API ignora el bloque. No se compacta nada, así que conserva los mensajes originales.
En Claude 5.1 y modelos posteriores, los bloques de pensamiento anteriores a un bloque `compaction` no se conservan, por lo que el resumen es todo lo que el modelo tiene de ese trabajo anterior. Si escribes tus propias `instructions`, indícale al modelo qué debe conservar el resumen; consulta [Indica al modelo qué conservar en los resúmenes de compactación](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries).
### Streaming
El bloque de compactación se transmite por streaming de forma diferente a los bloques de texto. Recibes un evento `content_block_start`, seguido de un único `content_block_delta` con el contenido completo del resumen (sin streaming intermedio), y luego un evento `content_block_stop`.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"stream": true,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages create \
--stream \
--beta compact-2026-01-12 \
--format jsonl <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
with client.beta.messages.stream(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
) as stream:
for event in stream:
match event.type:
case "content_block_start":
block = event.content_block
match block.type:
case "compaction":
print("Compaction started...")
case "text":
print("Text response started...")
case "content_block_delta":
delta = event.delta
match delta.type:
case "compaction_delta":
print(f"Compaction complete: {len(delta.content or '')} chars")
case "text_delta":
print(delta.text, end="", flush=True)
# Obtén el mensaje final acumulado
message = stream.get_final_message()
messages.append({"role": "assistant", "content": message.content})
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const stream = await client.beta.messages.stream({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
for await (const event of stream) {
switch (event.type) {
case "content_block_start":
switch (event.content_block.type) {
case "compaction":
console.log("Compaction started...");
break;
case "text":
console.log("Text response started...");
break;
}
break;
case "content_block_delta":
switch (event.delta.type) {
case "compaction_delta":
console.log(`Compaction complete: ${event.delta.content?.length ?? 0} chars`);
break;
case "text_delta":
process.stdout.write(event.delta.text);
break;
}
break;
}
}
// Obtén el mensaje final acumulado
const message = await stream.finalMessage();
messages.push({
role: "assistant",
content: message.content
});
```
```csharp C#
var client = new AnthropicClient();
List messages = [new BetaUserMessageParam { Content = "Hello" }];
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
await foreach (var streamEvent in client.Beta.Messages.CreateStreaming(parameters))
{
if (streamEvent.TryPickContentBlockStart(out var startEvent))
{
if (startEvent.ContentBlock.TryPickBetaCompaction(out _))
{
Console.WriteLine("Compaction started...");
}
else if (startEvent.ContentBlock.TryPickBetaText(out _))
{
Console.WriteLine("Text response started...");
}
}
else if (streamEvent.TryPickContentBlockDelta(out var deltaEvent))
{
if (deltaEvent.Delta.TryPickCompaction(out var compactionDelta))
{
Console.WriteLine($"Compaction complete: {compactionDelta.Content?.Length ?? 0} chars");
}
else if (deltaEvent.Delta.TryPickText(out var textDelta))
{
Console.Write(textDelta.Text);
}
}
}
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
stream := client.Beta.Messages.NewStreaming(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
for stream.Next() {
event := stream.Current()
switch eventVariant := event.AsAny().(type) {
case anthropic.BetaRawContentBlockStartEvent:
switch eventVariant.ContentBlock.AsAny().(type) {
case anthropic.BetaCompactionBlock:
fmt.Println("Compaction started...")
case anthropic.BetaTextBlock:
fmt.Println("Text response started...")
}
case anthropic.BetaRawContentBlockDeltaEvent:
switch deltaVariant := eventVariant.Delta.AsAny().(type) {
case anthropic.BetaCompactionContentBlockDelta:
fmt.Printf("Compaction complete: %d chars\n", len(deltaVariant.Content))
case anthropic.BetaTextDelta:
fmt.Print(deltaVariant.Text)
}
}
}
if err := stream.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
try (var streamResponse = client.beta().messages().createStreaming(params)) {
streamResponse.stream().forEach(event -> {
event.contentBlockStart().ifPresent(startEvent -> {
startEvent.contentBlock().compaction().ifPresent(compactionBlock ->
System.out.println("Compaction started...")
);
startEvent.contentBlock().text().ifPresent(textBlock ->
System.out.println("Text response started...")
);
});
event.contentBlockDelta().ifPresent(deltaEvent -> {
deltaEvent.delta().compaction().ifPresent(compactionDelta ->
System.out.println("Compaction complete: " + compactionDelta.content().map(String::length).orElse(0) + " chars")
);
deltaEvent.delta().text().ifPresent(textDelta ->
System.out.print(textDelta.text())
);
});
});
}
```
```php PHP
use Anthropic\Beta\Messages\BetaCompactionBlock;
use Anthropic\Beta\Messages\BetaCompactionContentBlockDelta;
use Anthropic\Beta\Messages\BetaRawContentBlockDeltaEvent;
use Anthropic\Beta\Messages\BetaRawContentBlockStartEvent;
use Anthropic\Beta\Messages\BetaTextBlock;
use Anthropic\Beta\Messages\BetaTextDelta;
use Anthropic\Messages\Model;
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$stream = $client->beta->messages->createStream(
maxTokens: 4096,
messages: $messages,
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
foreach ($stream as $event) {
switch (true) {
case $event instanceof BetaRawContentBlockStartEvent:
switch (true) {
case $event->contentBlock instanceof BetaCompactionBlock:
echo "Compaction started...\n";
break;
case $event->contentBlock instanceof BetaTextBlock:
echo "Text response started...\n";
break;
}
break;
case $event instanceof BetaRawContentBlockDeltaEvent:
switch (true) {
case $event->delta instanceof BetaCompactionContentBlockDelta:
echo 'Compaction complete: ' . strlen($event->delta->content ?? '') . " chars\n";
break;
case $event->delta instanceof BetaTextDelta:
echo $event->delta->text;
break;
}
break;
}
}
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
stream = client.beta.messages.stream(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
stream.each do |event|
case event
when Anthropic::Models::BetaRawContentBlockStartEvent
case event.content_block
when Anthropic::Models::BetaCompactionBlock
puts "Compaction started..."
when Anthropic::Models::BetaTextBlock
puts "Text response started..."
end
when Anthropic::Models::BetaRawContentBlockDeltaEvent
delta = event.delta
case delta
when Anthropic::Models::BetaCompactionContentBlockDelta
puts "Compaction complete: #{(delta.content || "").length} chars"
when Anthropic::Models::BetaTextDelta
print delta.text
end
end
end
```
### Almacenamiento en caché de prompts
La compactación funciona bien con el [“prompt caching” (almacenamiento en caché de prompts)](https://platform.claude.com/docs/es/build-with-claude/prompt-caching). Puedes agregar un punto de interrupción `cache_control` en los bloques de compactación para almacenar en caché el contenido resumido.
```json
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": { "type": "ephemeral" }
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
#### Maximizar los aciertos de caché con indicaciones del sistema
Cuando ocurre una compactación, el resumen se convierte en contenido nuevo que debe escribirse en la caché. Sin puntos de interrupción de caché adicionales, esto también invalidaría cualquier “system prompt” (indicación del sistema) almacenada en caché, lo que obligaría a volver a almacenarla en caché junto con el resumen de compactación.
Para maximizar las tasas de aciertos de caché, agrega un punto de interrupción `cache_control` al final de tu indicación del sistema. Esto mantiene la indicación del sistema almacenada en caché por separado de la conversación, de modo que cuando ocurre una compactación:
* La caché de la indicación del sistema sigue siendo válida y se lee desde la caché
* Solo el resumen de compactación debe escribirse como una nueva entrada de caché
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"system": [
{
"type": "text",
"text": "You are a helpful coding assistant...",
"cache_control": {
"type": "ephemeral"
}
}
],
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
system:
- type: text
text: You are a helpful coding assistant...
cache_control:
type: ephemeral
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
system=[
{
"type": "text",
"text": "You are a helpful coding assistant...",
"cache_control": {
"type": "ephemeral"
}, # Cache the system prompt separately
}
],
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
system: [
{
type: "text",
text: "You are a helpful coding assistant...",
cache_control: { type: "ephemeral" } // Cache the system prompt separately
}
],
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
```
```csharp C#
var client = new AnthropicClient();
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
System = new List
{
new()
{
Text = "You are a helpful coding assistant...",
CacheControl = new BetaCacheControlEphemeral()
}
},
Messages = [new BetaUserMessageParam { Content = "Hello, Claude" }],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
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,
System: []anthropic.BetaTextBlockParam{
{
Text: "You are a helpful coding assistant...",
CacheControl: anthropic.NewBetaCacheControlEphemeralParam(),
},
},
Messages: []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaCacheControlEphemeral;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.systemOfBetaTextBlockParams(List.of(
BetaTextBlockParam.builder()
.text("You are a helpful coding assistant...")
.cacheControl(BetaCacheControlEphemeral.builder().build())
.build()
))
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
System.out.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
system: [
[
'type' => 'text',
'text' => 'You are a helpful coding assistant...',
'cache_control' => [
'type' => 'ephemeral'
]
]
],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
system: [
{
type: "text",
text: "You are a helpful coding assistant...",
cache_control: {
type: "ephemeral"
}
}
],
messages: [{ role: "user", content: "Hello, Claude" }],
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
puts response
```
Esto mantiene las indicaciones del sistema largas almacenadas en caché a lo largo de múltiples eventos de compactación durante una conversación.
## Comprender el uso
La compactación requiere un paso de muestreo adicional, que cuenta para los “rate limits” (límites de velocidad) y la facturación. La API devuelve información detallada de uso en la respuesta:
```json Output
{
"usage": {
"input_tokens": 23000,
"output_tokens": 1000,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
El arreglo `iterations` muestra el uso de cada iteración de muestreo. Cuando ocurre una compactación, verás una iteración `compaction` seguida de la iteración principal `message`. Los valores de nivel superior `input_tokens` y `output_tokens` coinciden exactamente con la iteración `message` en este ejemplo porque solo hay una iteración que no es de compactación. Los recuentos de tokens de la iteración final reflejan el tamaño de contexto efectivo después de la compactación.
Los valores de nivel superior `input_tokens` y `output_tokens` no incluyen el uso de la iteración de compactación. Reflejan la suma de todas las iteraciones que no son de compactación. Para calcular el total de tokens consumidos y facturados en una solicitud, suma todas las entradas del arreglo `usage.iterations`.
Si antes dependías de `usage.input_tokens` y `usage.output_tokens` para el seguimiento de costos o auditorías, deberás actualizar tu lógica de seguimiento para agregar los valores de `usage.iterations` cuando la compactación esté habilitada. Con la beta de compactación habilitada, cada respuesta incluye `usage.iterations`, incluso si no ocurrió ninguna compactación. Una entrada `compaction` aparece solo cuando se activa una nueva compactación durante la solicitud. Volver a aplicar un bloque `compaction` anterior no genera ningún costo de compactación adicional, y en ese caso los campos de uso de nivel superior siguen siendo precisos.
## Combinar con otras funciones
### Herramientas de servidor
Al usar herramientas de servidor (como la búsqueda web), el disparador de compactación se verifica al inicio de cada iteración de muestreo. La compactación puede ocurrir varias veces dentro de una sola solicitud, según tu umbral de activación y la cantidad de salida generada.
### Conteo de tokens
El endpoint de conteo de tokens (`/v1/messages/count_tokens`) aplica los bloques `compaction` existentes en tu prompt, pero no activa nuevas compactaciones. Úsalo para verificar tu recuento de tokens efectivo después de compactaciones anteriores:
```bash cURL
curl https://api.anthropic.com/v1/messages/count_tokens \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages count-tokens --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
count_response = client.beta.messages.count_tokens(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
print(f"Current tokens: {count_response.input_tokens}")
print(f"Original tokens: {count_response.context_management.original_input_tokens}")
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Summarize the key points of our conversation so far." }
];
const countResponse = await client.beta.messages.countTokens({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
console.log(`Current tokens: ${countResponse.input_tokens}`);
console.log(`Original tokens: ${countResponse.context_management!.original_input_tokens}`);
```
```csharp C#
AnthropicClient client = new();
List messages = [new BetaUserMessageParam { Content = "Hello" }];
var countParams = new MessageCountTokensParams
{
Model = Model.ClaudeOpus5_5,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
},
Betas = ["compact-2026-01-12"]
};
var countResponse = await client.Beta.Messages.CountTokens(countParams);
Console.WriteLine($"Current tokens: {countResponse.InputTokens}");
Console.WriteLine($"Original tokens: {countResponse.ContextManagement?.OriginalInputTokens}");
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
countResponse, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
Model: anthropic.ModelClaudeOpus5_5,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Current tokens: %d\n", countResponse.InputTokens)
fmt.Printf("Original tokens: %d\n", countResponse.ContextManagement.OriginalInputTokens)
```
```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.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCountTokensParams params = MessageCountTokensParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.addBeta("compact-2026-01-12")
.build();
BetaMessageTokensCount countResponse = client.beta().messages().countTokens(params);
System.out.println("Current tokens: " + countResponse.inputTokens());
System.out.println("Original tokens: " + countResponse.contextManagement().get().originalInputTokens());
```
```php PHP
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$countResponse = $client->beta->messages->countTokens(
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
echo 'Current tokens: ' . $countResponse->inputTokens . "\n";
echo 'Original tokens: ' . $countResponse->contextManagement->originalInputTokens . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
count_response = client.beta.messages.count_tokens(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
puts "Current tokens: #{count_response.input_tokens}"
puts "Original tokens: #{count_response.context_management.original_input_tokens}"
```
## Ejemplos
Aquí tienes un ejemplo completo de una conversación de larga duración con compactación:
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
```python Python
client = anthropic.Anthropic()
messages: list[dict] = []
def chat(user_message: str) -> str:
messages.append({"role": "user", "content": user_message})
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": 100000},
}
]
},
)
# Agrega la respuesta (los bloques de compactación se incluyen automáticamente)
messages.append({"role": "assistant", "content": response.content})
# Devuelve el contenido de texto
return next((block.text for block in response.content if block.type == "text"), "")
# Ejecuta una conversación larga
print(chat("Briefly, help me build a Python web scraper"))
print(chat("Briefly, add support for JavaScript-rendered pages"))
print(chat("Briefly, add rate limiting and error handling"))
# Sigue llamando a chat() mientras la conversación lo necesite
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [];
async function chat(userMessage: string): Promise {
messages.push({ role: "user", content: userMessage });
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 }
}
]
}
});
// Agrega la respuesta (los bloques de compactación se incluyen automáticamente)
messages.push({ role: "assistant", content: response.content });
// Devuelve el contenido de texto
const textBlock = response.content.find((block) => block.type === "text");
return textBlock?.text ?? "";
}
// Ejecuta una conversación larga
console.log(await chat("Briefly, help me build a Python web scraper"));
console.log(await chat("Briefly, add support for JavaScript-rendered pages"));
console.log(await chat("Briefly, add rate limiting and error handling"));
// Sigue llamando a chat() mientras la conversación lo necesite
```
```csharp C#
AnthropicClient client = new();
List messages = new();
Console.WriteLine(await Chat(client, messages, "Briefly, help me build a Python web scraper"));
Console.WriteLine(await Chat(client, messages, "Briefly, add support for JavaScript-rendered pages"));
Console.WriteLine(await Chat(client, messages, "Briefly, add rate limiting and error handling"));
static async Task Chat(AnthropicClient client, List messages, string userMessage)
{
messages.Add(new BetaUserMessageParam { Content = userMessage });
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(100000)
}]
}
};
var response = await client.Beta.Messages.Create(parameters);
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
return response.Content
.Select(block => block.Value)
.OfType()
.Select(textBlock => textBlock.Text)
.FirstOrDefault() ?? "";
}
```
```go Go
package main
import (
"context"
"fmt"
"log"
"github.com/anthropics/anthropic-sdk-go/v2"
)
var (
client = anthropic.NewClient()
messages []anthropic.BetaMessageParam
)
func chat(userMessage string) string {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage)))
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000},
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
for _, block := range response.Content {
if variant, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
return variant.Text
}
}
return ""
}
func main() {
fmt.Println(chat("Briefly, help me build a Python web scraper"))
fmt.Println(chat("Briefly, add support for JavaScript-rendered pages"))
fmt.Println(chat("Briefly, add rate limiting and error handling"))
}
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv();
private static final List messages = new ArrayList<>();
public static void main(String[] args) {
System.out.println(chat("Briefly, help me build a Python web scraper"));
System.out.println(chat("Briefly, add support for JavaScript-rendered pages"));
System.out.println(chat("Briefly, add rate limiting and error handling"));
}
private static String chat(String userMessage) {
messages.add(BetaMessageParam.ofUser(userMessage));
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(100000L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Agrega la respuesta (los bloques de compactación se incluyen automáticamente)
messages.add(response.toParam());
return response.content().stream()
.filter(block -> block.text().isPresent())
.map(block -> block.text().get().text())
.findFirst()
.orElse("");
}
```
```php PHP
$client = new Client();
$messages = [];
function chat($client, &$messages, $userMessage)
{
$messages[] = ['role' => 'user', 'content' => $userMessage];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => ['type' => 'input_tokens', 'value' => 100000]
]
]
]
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
foreach ($response->content as $block) {
if ($block->type === 'text') {
return $block->text;
}
}
return '';
}
echo chat($client, $messages, 'Briefly, help me build a Python web scraper') . "\n";
echo chat($client, $messages, 'Briefly, add support for JavaScript-rendered pages') . "\n";
echo chat($client, $messages, 'Briefly, add rate limiting and error handling') . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
messages = []
def chat(client, messages, user_message)
messages << { role: "user", content: user_message }
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 }
}
]
}
)
messages << { role: "assistant", content: response.content }
response.content.find { |block| block.type == :text }&.text || ""
end
puts chat(client, messages, "Briefly, help me build a Python web scraper")
puts chat(client, messages, "Briefly, add support for JavaScript-rendered pages")
puts chat(client, messages, "Briefly, add rate limiting and error handling")
```
En Claude 5.1 y modelos posteriores, los bloques de pensamiento en cualquier turno del asistente que vuelvas a insertar después del bloque de compactación no superan la [verificación de prefijo](https://platform.claude.com/docs/es/build-with-claude/thinking#preserved-in-conversation), porque se produjeron cuando el historial completo estaba presente. Elimina los bloques `thinking` y `redacted_thinking` de esos turnos. Como alternativa, envía `thinking.block_binding.prefix_mismatch_behavior: "drop_block"` con el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `thinking-binding-controls-2026-08-01`. Los bloques de texto y de herramientas conservados pueden quedarse como están. Dejar que la API lo resuma todo, sin volver a insertar turnos anteriores, evita esto. En Claude Sonnet 5.5 y Claude Haiku 5.5, `block_binding` solo funciona con `thinking: {"type": "adaptive"}`. Con cualquier otra configuración de pensamiento en esos modelos, elimina los bloques.
Aquí tienes un ejemplo que usa `pause_after_compaction` para conservar el intercambio anterior y el mensaje actual del usuario (tres mensajes en total) en lugar de resumirlos. Mantiene sin cambios sus bloques de texto y de herramientas, elimina los bloques `thinking` y `redacted_thinking` del turno del asistente conservado y descarta ese turno si no queda nada más:
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [SDK de Claude](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
```python Python
from typing import Any
client = anthropic.Anthropic()
messages: list[dict[str, Any]] = []
def chat(user_message: str) -> str:
messages.append({"role": "user", "content": user_message})
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": 100000},
"pause_after_compaction": True,
}
]
},
)
# Busca el bloque de compactación, no el motivo de detención:
# stop_reason es "refusal", no "compaction", si se bloqueó el resumen
compaction_block = next(
(block for block in response.content if block.type == "compaction"), None
)
# Reemplaza el historial solo si se generó un resumen
if compaction_block is not None and compaction_block.content is not None:
# Conserva el intercambio anterior + el mensaje actual del usuario (3 mensajes)
# incluyéndolos después del bloque de compactación, sin bloques de
# pensamiento; se descarta un turno del asistente que quede sin contenido
preserved_messages = [
{
**message,
"content": [
block
for block in message["content"]
if block.type not in ("thinking", "redacted_thinking")
],
}
if message["role"] == "assistant"
else message
for message in messages[-3:]
]
preserved_messages = [m for m in preserved_messages if m["content"]]
# Construye la nueva lista de mensajes: compactación + mensajes conservados
new_assistant_content = [compaction_block]
messages_after_compaction = [
{"role": "assistant", "content": new_assistant_content}
] + preserved_messages
# Actualiza la lista de mensajes para reflejar la compactación
messages.clear()
messages.extend(messages_after_compaction)
if compaction_block is not None:
# Continúa la solicitud, con el historial completo si no hay resumen
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Agrega la respuesta final
messages.append({"role": "assistant", "content": response.content})
# Devuelve el contenido de texto
return next((block.text for block in response.content if block.type == "text"), "")
# Ejecuta una conversación larga
print(chat("Briefly, help me build a Python web scraper"))
print(chat("Briefly, add support for JavaScript-rendered pages"))
print(chat("Briefly, add rate limiting and error handling"))
# Sigue llamando a chat() mientras la conversación lo necesite
```
```typescript TypeScript
const client = new Anthropic();
let messages: Anthropic.Beta.Messages.BetaMessageParam[] = [];
async function chat(userMessage: string): Promise {
messages.push({ role: "user", content: userMessage });
let response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 },
pause_after_compaction: true
}
]
}
});
// Busca el bloque de compactación, no el motivo de detención:
// stop_reason es "refusal", no "compaction", si se bloqueó el resumen
const compactionBlock = response.content.find((block) => block.type === "compaction");
// Reemplaza el historial solo si se generó un resumen
if (compactionBlock && compactionBlock.content !== null) {
// Conserva el intercambio anterior + el mensaje actual del usuario (3 mensajes)
// incluyéndolos después del bloque de compactación, sin bloques de
// pensamiento; un turno del asistente que queda sin contenido se descarta
const preservedMessages = messages
.slice(-3)
.map((message) =>
message.role === "assistant" && Array.isArray(message.content)
? {
...message,
content: message.content.filter(
(block) => block.type !== "thinking" && block.type !== "redacted_thinking"
)
}
: message
)
.filter((message) => message.role !== "assistant" || message.content.length > 0);
// Construye la nueva lista de mensajes: compactación + mensajes conservados
const messagesAfterCompaction: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "assistant", content: [compactionBlock] },
...preservedMessages
];
// Actualiza la lista de mensajes para reflejar la compactación
messages = messagesAfterCompaction;
}
if (compactionBlock) {
// Continúa la solicitud, con el historial completo si no hay resumen
response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
}
// Agrega la respuesta final
messages.push({ role: "assistant", content: response.content });
// Devuelve el contenido de texto
const textBlock = response.content.find((block) => block.type === "text");
return textBlock?.text ?? "";
}
// Ejecuta una conversación larga
console.log(await chat("Briefly, help me build a Python web scraper"));
console.log(await chat("Briefly, add support for JavaScript-rendered pages"));
console.log(await chat("Briefly, add rate limiting and error handling"));
// Sigue llamando a chat() mientras la conversación lo necesite
```
```csharp C#
AnthropicClient client = new();
List messages = new();
Console.WriteLine(await Chat("Briefly, help me build a Python web scraper"));
Console.WriteLine(await Chat("Briefly, add support for JavaScript-rendered pages"));
Console.WriteLine(await Chat("Briefly, add rate limiting and error handling"));
async Task Chat(string userMessage)
{
messages.Add(new BetaUserMessageParam { Content = userMessage });
var response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(100000),
PauseAfterCompaction = true
}]
}
});
// Busca el bloque de compactación, no el motivo de detención:
// StopReason es Refusal, no Compaction, si se bloqueó el resumen
var compactionBlock = response.Content.FirstOrDefault(block => block.Value is BetaCompactionBlock);
// Reemplaza el historial solo si se generó un resumen
if (compactionBlock?.Value is BetaCompactionBlock { Content: not null })
{
// Conserva el intercambio previo + el mensaje actual del usuario (3 mensajes),
// sin bloques de pensamiento; se descarta un turno del asistente que quede vacío
var preserved = new List();
foreach (var message in messages.Skip(Math.Max(0, messages.Count - 3)))
{
if (!message.TryPickAssistant(out var assistant)
|| !assistant.Content.TryPickBetaContentBlockParams(out var blocks))
{
preserved.Add(message);
continue;
}
var kept = blocks
.Where(block => block.Type.Raw() is not ("thinking" or "redacted_thinking"))
.ToList();
if (kept.Count > 0)
{
preserved.Add(assistant with { Content = kept });
}
}
var messagesAfterCompaction = new List
{
new BetaAssistantMessageParam
{
Content = new List { new BetaContentBlockParam(compactionBlock.Json) }
}
};
messagesAfterCompaction.AddRange(preserved);
messages = messagesAfterCompaction;
}
if (compactionBlock is not null)
{
// Continúa la solicitud, con el historial completo si no hay resumen
response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
}
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
return response.Content
.Select(block => block.Value)
.OfType()
.Select(textBlock => textBlock.Text)
.FirstOrDefault() ?? "";
}
```
```go Go
package main
import (
"context"
"fmt"
"log"
"slices"
"github.com/anthropics/anthropic-sdk-go/v2"
)
var (
client = anthropic.NewClient()
messages []anthropic.BetaMessageParam
)
func chat(userMessage string) string {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage)))
compactEdit := anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000},
PauseAfterCompaction: anthropic.Bool(true),
}},
},
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
// Busca el bloque de compactación, no el motivo de detención:
// StopReason es "refusal", no "compaction", si se bloqueó el resumen
compactionIndex := slices.IndexFunc(response.Content, func(block anthropic.BetaContentBlockUnion) bool {
return block.Type == "compaction"
})
// Reemplaza el historial solo si se generó un resumen (content no es null)
if compactionIndex >= 0 && response.Content[compactionIndex].JSON.Content.Valid() {
compactionParam := response.Content[compactionIndex].ToParam()
// Conserva el intercambio previo + el mensaje actual del usuario (3 mensajes),
// sin bloques de pensamiento; un turno del asistente que quede vacío se descarta
var preserved []anthropic.BetaMessageParam
for _, message := range messages[max(0, len(messages)-3):] {
if message.OfAssistant == nil {
preserved = append(preserved, message)
continue
}
var content []anthropic.BetaContentBlockParamUnion
for _, block := range message.OfAssistant.Content {
if block.OfThinking == nil && block.OfRedactedThinking == nil {
content = append(content, block)
}
}
if len(content) == 0 {
continue
}
preserved = append(preserved, anthropic.BetaMessageParam{OfAssistant: &anthropic.BetaAssistantMessageParam{Content: content}})
}
messagesAfterCompaction := []anthropic.BetaMessageParam{
{OfAssistant: &anthropic.BetaAssistantMessageParam{Content: []anthropic.BetaContentBlockParamUnion{compactionParam}}},
}
messagesAfterCompaction = append(messagesAfterCompaction, preserved...)
messages = messagesAfterCompaction
}
if compactionIndex >= 0 {
// Continúa la solicitud, con el historial completo si no hay resumen
response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
}
messages = append(messages, response.ToParam())
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
return textBlock.Text
}
}
return ""
}
func main() {
fmt.Println(chat("Briefly, help me build a Python web scraper"))
fmt.Println(chat("Briefly, add support for JavaScript-rendered pages"))
fmt.Println(chat("Briefly, add rate limiting and error handling"))
}
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv();
private static final List messages = new ArrayList<>();
public static String chat(String userMessage) {
messages.add(BetaMessageParam.ofUser(userMessage));
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(100000L)
.build())
.pauseAfterCompaction(true)
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Busca el bloque de compactación, no el motivo de detención:
// stopReason() es REFUSAL, no COMPACTION, si se bloqueó el resumen
var compactionBlock = response.content().stream()
.flatMap(block -> block.compaction().stream())
.findFirst();
// Reemplaza el historial solo si se generó un resumen
if (compactionBlock.flatMap(block -> block.content()).isPresent()) {
// Conserva el intercambio previo + el mensaje actual del usuario (3 mensajes),
// sin bloques de pensamiento; se descarta un turno del asistente que quede vacío
List preservedMessages = new ArrayList<>();
for (BetaMessageParam message : messages.subList(Math.max(0, messages.size() - 3), messages.size())) {
if (message.isAssistant() && message.asAssistant().content().isContentBlockParams()) {
var keptBlocks = message.asAssistant().content().asContentBlockParams().stream()
.filter(block -> !block.isThinking() && !block.isRedactedThinking())
.toList();
if (keptBlocks.isEmpty()) {
continue;
}
message = BetaMessageParam.ofAssistantOfContentBlockParams(keptBlocks);
}
preservedMessages.add(message);
}
// Construye la nueva lista de mensajes: compactación + mensajes conservados
List messagesAfterCompaction = new ArrayList<>();
messagesAfterCompaction.add(response.toParam());
messagesAfterCompaction.addAll(preservedMessages);
// Actualiza la lista de mensajes para reflejar la compactación
messages.clear();
messages.addAll(messagesAfterCompaction);
}
if (compactionBlock.isPresent()) {
// Continúa la solicitud, con el historial completo si no hay resumen
MessageCreateParams continueParams = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
response = client.beta().messages().create(continueParams);
}
// Agrega la respuesta final
messages.add(response.toParam());
return response.content().stream()
.filter(block -> block.text().isPresent())
.map(block -> block.text().get().text())
.findFirst()
.orElse("");
}
public static void main(String[] args) {
System.out.println(chat("Briefly, help me build a Python web scraper"));
System.out.println(chat("Briefly, add support for JavaScript-rendered pages"));
System.out.println(chat("Briefly, add rate limiting and error handling"));
}
```
```php PHP
$client = new Client();
$messages = [];
function chat($client, &$messages, $userMessage)
{
$messages[] = ['role' => 'user', 'content' => $userMessage];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => ['type' => 'input_tokens', 'value' => 100000],
'pause_after_compaction' => true
]
]
]
);
// Busca el bloque de compactación, no el motivo de detención:
// stopReason es 'refusal', no 'compaction', si se bloqueó el resumen
$compactionBlock = null;
foreach ($response->content as $block) {
if ($block instanceof \Anthropic\Beta\Messages\BetaCompactionBlock) {
$compactionBlock = $block;
break;
}
}
// Reemplaza el historial solo si se generó un resumen
if ($compactionBlock?->content !== null) {
// Conserva el intercambio previo + el mensaje actual del usuario (3 mensajes),
// sin bloques de pensamiento; un turno del asistente que quede vacío se descarta
$preserved = array_values(array_filter(array_map(
fn($message) => $message['role'] === 'assistant'
? array_merge($message, ['content' => array_values(array_filter(
$message['content'],
fn($block) => !in_array($block->type, ['thinking', 'redacted_thinking'], true)
))])
: $message,
array_slice($messages, -3)
), fn($message) => $message['content'] !== []));
$messagesAfterCompaction = array_merge(
[['role' => 'assistant', 'content' => [$compactionBlock]]],
$preserved
);
$messages = $messagesAfterCompaction;
}
if ($compactionBlock !== null) {
// Continúa la solicitud, con el historial completo si no hay resumen
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
}
$messages[] = ['role' => 'assistant', 'content' => $response->content];
foreach ($response->content as $block) {
if ($block->type === 'text') {
return $block->text;
}
}
return '';
}
echo chat($client, $messages, 'Briefly, help me build a Python web scraper') . "\n";
echo chat($client, $messages, 'Briefly, add support for JavaScript-rendered pages') . "\n";
echo chat($client, $messages, 'Briefly, add rate limiting and error handling') . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
messages = []
def chat(client, messages, user_message)
messages << { role: "user", content: user_message }
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 },
pause_after_compaction: true
}
]
}
)
# Busca el bloque de compactación, no el motivo de detención:
# stop_reason es :refusal, no :compaction, si se bloqueó el resumen
compaction_block = response.content.find { |block| block.type == :compaction }
# Reemplaza el historial solo si se generó un resumen
if compaction_block&.content
# Conserva el intercambio previo + el mensaje actual del usuario (3 mensajes),
# sin bloques de pensamiento; un turno del asistente que quede vacío se descarta
preserved = messages.last(3).map do |message|
next message unless message[:role] == "assistant"
message.merge(content: message[:content].reject { |block| %i[thinking redacted_thinking].include?(block.type) })
end.reject { |message| message[:content].empty? }
messages_after_compaction = [
{ role: "assistant", content: [compaction_block] }
] + preserved
messages.clear
messages.concat(messages_after_compaction)
end
if compaction_block
# Continúa la solicitud, con el historial completo si no hay resumen
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
end
messages << { role: "assistant", content: response.content }
response.content.find { |block| block.type == :text }&.text || ""
end
puts chat(client, messages, "Briefly, help me build a Python web scraper")
puts chat(client, messages, "Briefly, add support for JavaScript-rendered pages")
puts chat(client, messages, "Briefly, add rate limiting and error handling")
```
## Limitaciones actuales
* **Mismo modelo para el resumen:** El modelo especificado en tu solicitud se usa para el resumen. No hay opción para usar un modelo diferente (por ejemplo, más económico) para el resumen.
* **La compactación puede fallar cuando hay herramientas definidas:** Cuando tu solicitud incluye `tools`, el modelo ocasionalmente llama a una herramienta durante el paso interno de resumen en lugar de escribir un resumen. Cuando esto ocurre, la respuesta contiene un bloque `compaction` con `content: null`. Para evitarlo, establece [`instructions`](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold#custom-summarization-instructions) con un prompt que le indique explícitamente al modelo que no llame a herramientas, por ejemplo:
```text wrap
Summarize the transcript inside tags. Include relevant information in the summary for continuing the task in the next context window. Do not call any tools while writing this summary; respond with text only.
```
## Próximos pasos
Gestiona automáticamente el contexto de la conversación a medida que crece con la edición de contexto.
Aprende sobre los tamaños de las ventanas de contexto y las estrategias de gestión.
Explora una implementación práctica que gestiona conversaciones de larga duración con compactación instantánea de la memoria de sesión mediante hilos en segundo plano y almacenamiento en caché de prompts.
## Disponibilidad
Compactación por umbral está en beta en algunos modelos y es elegible para retención de datos cero.
### Compatibilidad con la API
#### [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages)
* Disponibilidad: Disponible
* Uso: Actívala con una edición `compact_20260112` en `context_management.edits`. La compactación comienza cuando los tokens de entrada alcanzan el disparador, 150,000 de forma predeterminada y como mínimo 50,000.
| Estado | Plataformas en la nube | Modelos |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws), [Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock), [Amazon Bedrock (InvokeModel)](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry) | [Claude Fable 5.1](https://platform.claude.com/docs/es/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/es/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/es/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/es/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/es/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/es/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/es/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/es/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/es/models/sonnet-4-6/overview) |
#### [Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview)
* Disponibilidad: Siempre activo
* Uso: Compacta el historial de conversación de la sesión para que quepa en la ventana de contexto, y cada compactación emite un evento `agent.thread_context_compacted`.
| Estado | Plataformas en la nube | Modelos |
| ------ | ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws) | [Claude Fable 5.1](https://platform.claude.com/docs/es/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/es/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/es/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/es/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/es/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/es/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/es/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/es/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/es/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/es/models/sonnet-4-6/overview) |
### Encabezados beta requeridos
[Descripción general de los encabezados beta](https://platform.claude.com/docs/es/api/beta-headers)
Los encabezados beta te permiten acceder a funciones experimentales y nuevas capacidades de los modelos antes de que formen parte de la API estándar.
| Encabezado | API |
| -------------------- | ------------------------------------------------------------------------------------------- |
| `compact-2026-01-12` | [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages) |
### Manejo de datos
[Descripción general del manejo de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#feature-eligibility)
| Elemento | Retención de datos cero | HIPAA |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| Estado | Elegible (excluye [Modelos cubiertos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | No elegible |
| Detalles | Los resultados de la compactación del lado del servidor se devuelven y se reenvían sin estado a través de la respuesta de la API. | — |
Endpoints aplicables:
* `/v1/messages` con `context_management`