---
title: Compattazione a una soglia di token
url: https://platform.claude.com/docs/it/build-with-claude/compaction-threshold
description: Fai in modo che l'API riassuma automaticamente il contesto meno recente, all'interno di una normale richiesta, quando la conversazione raggiunge una soglia di token da te impostata.
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). I risultati della compattazione lato server vengono restituiti e rinviati senza stato tramite la risposta dell’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
---
**Supporto API**: L’utilizzo varia in base al prodotto.
* **Messages API**: Attivala con una modifica `compact_20260112`; la compattazione inizia a 150.000 token di input per impostazione predefinita.
* **Managed Agents**: Sempre attivo. Compatta la cronologia della conversazione della sessione per adattarla alla finestra di contesto.
La “threshold compaction” (compattazione a soglia) è il tipo automatico di compattazione: imposti una “token threshold” (soglia di token) sulle tue richieste ordinarie e l’API riassume il contesto meno recente durante una richiesta, una volta raggiunta la soglia. È supportata insieme alla compattazione su richiesta, in cui sei tu a decidere quando viene scritto il riepilogo (consulta [Compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand)). Per scegliere tra le due, consulta [Scegli come compattare](https://platform.claude.com/docs/it/build-with-claude/compaction#choose-how-to-compact).
La compattazione estende la lunghezza effettiva del contesto per conversazioni e attività di lunga durata, riassumendo automaticamente il contesto meno recente quando ci si avvicina al limite della “context window” (finestra di contesto). Mantiene inoltre ridotto il contesto attivo: man mano che una conversazione cresce, la qualità delle risposte peggiora, quindi la compattazione sostituisce il contenuto meno recente con un riepilogo conciso.
Per un approfondimento sul perché i contesti lunghi peggiorano e su come la compattazione aiuta, consulta [Context engineering efficace](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents).
È ideale per:
* Conversazioni multi-turno basate su chat in cui vuoi che gli utenti usino una sola chat per un lungo periodo di tempo
* Prompt orientati alle attività che richiedono molto lavoro successivo (spesso uso degli strumenti) che potrebbe superare la finestra di contesto
## Come funziona la compattazione
Quando la compattazione è abilitata, Claude riassume automaticamente la tua conversazione quando raggiunge la soglia di token configurata. L’API:
1. Rileva quando i token di input raggiungono la soglia di attivazione specificata.
2. Genera un riepilogo della conversazione corrente.
3. Crea un blocco `compaction` contenente il riepilogo.
4. Continua la risposta con il contesto compattato.
Nelle richieste successive, aggiungi la risposta ai tuoi messaggi. L’API elimina automaticamente tutti i blocchi di contenuto precedenti al blocco `compaction`, continuando la conversazione a partire dal riepilogo.
## Utilizzo di base
Abilita la compattazione aggiungendo la strategia `compact_20260112` a `context_management.edits` nella tua richiesta alla 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"}]},
)
# Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
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"
}
]
}
});
// Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
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);
// Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
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)
}
// Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
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);
// Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
// includendola nei messaggi della richiesta successiva
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']
]
]
);
// Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
$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" }]
}
)
# Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione
messages << { role: "assistant", content: response.content }
puts response
```
## Parametri
| Parametro | Tipo | Predefinito | Descrizione |
| ------------------------ | ------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `type` | string | Obbligatorio | Deve essere `"compact_20260112"` |
| `trigger` | object | `{"type": "input_tokens", "value": 150000}` | Quando attivare la compattazione. `input_tokens` è l’unico tipo di trigger supportato. `value` deve essere di almeno 50.000 token. |
| `pause_after_compaction` | boolean | `false` | Se mettere in pausa dopo aver generato il riepilogo di compattazione |
| `instructions` | string | `null` | Prompt di riepilogo personalizzato. Quando fornito, sostituisce completamente il prompt predefinito. |
### Configurazione del trigger
Configura quando si attiva la compattazione usando il parametro `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
```
### Istruzioni di riepilogo personalizzate
Il prompt di riepilogo predefinito varia in base al modello. Ogni prompt predefinito indica a Claude di scrivere un riepilogo all’interno dei tag `` con le informazioni necessarie per continuare l’attività in una futura finestra di contesto. Ad esempio, alcuni modelli usano il seguente 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.
```
Puoi fornire istruzioni personalizzate tramite il parametro `instructions`. Le istruzioni personalizzate non integrano il prompt predefinito, ma lo sostituiscono completamente:
```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
```
Sui modelli Claude 5.1 e successivi, una richiesta con `instructions` personalizzate genera il riepilogo solo a partire dalla conversazione visibile: i blocchi di ragionamento precedenti non fanno parte dell’input del processo di riepilogo.
### Pausa dopo la compattazione
Usa `pause_after_compaction` per mettere in pausa l’API dopo la generazione del riepilogo di compattazione. Questo ti consente di aggiungere ulteriori blocchi di contenuto (ad esempio per preservare i messaggi recenti o specifici messaggi orientati alle istruzioni) prima che l’API continui con la risposta.
Quando è abilitato, l’API restituisce un messaggio con il motivo di arresto `compaction` dopo aver generato il blocco di compattazione:
```bash cURL
# pause_after_compaction interrompe la risposta subito dopo il riepilogo
# di compattazione, così puoi modificare i messaggi prima di continuare. Il passo
# di continuazione non si adatta bene a un singolo comando shell; vedi le schede SDK
# per il flusso completo di pausa e ripresa. Singola richiesta in pausa:
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 interrompe la risposta subito dopo il riepilogo
# di compattazione, così puoi modificare i messaggi prima di continuare. Il passo
# di continuazione non si adatta bene a un singolo comando CLI; vedi le schede SDK
# per il flusso completo di pausa e ripresa. Singola richiesta in pausa:
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}]
},
)
# Verifica se la compattazione ha attivato una pausa
if response.stop_reason == "compaction":
# La risposta contiene solo il blocco di compattazione
messages.append({"role": "assistant", "content": response.content})
# Continua la richiesta
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
}
]
}
});
// Verifica se la compattazione ha attivato una pausa
if (response.stop_reason === "compaction") {
// La risposta contiene solo il blocco di compattazione
messages.push({
role: "assistant",
content: response.content
});
// Continua la richiesta
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);
// Verifica se la compattazione ha causato una pausa
if (response.stopReason().isPresent()
&& response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
// Aggiungi il blocco di compattazione e prosegui la richiesta
// creando una nuova richiesta con il contesto compattato
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
```
L’API si mette in pausa anche se non viene generato alcun riepilogo. Il `content` del blocco `compaction` è quindi `null`, perciò mantieni i messaggi originali quando continui. Se le misure di sicurezza bloccano il riepilogo, anche in questo caso `content` è `null` e il motivo di arresto è `refusal` invece di `compaction`. [`stop_details`](https://platform.claude.com/docs/it/build-with-claude/handling-stop-reasons#refusal) indica la categoria di policy, se presente. Continua allo stesso modo in entrambi i casi: cerca il blocco `compaction` invece di verificare `stop_reason`, come fa l’[esempio che preserva i messaggi recenti](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#examples).
#### Applicare un budget totale di token
Quando un modello lavora su attività lunghe con molte iterazioni di uso degli strumenti, il consumo totale di token può crescere in modo significativo. Puoi combinare `pause_after_compaction` con un contatore di compattazioni per stimare l’utilizzo cumulativo e concludere l’attività in modo ordinato una volta raggiunto un budget.
Questo esempio è disponibile solo nei linguaggi degli SDK: il suo valore risiede nella logica di monitoraggio del budget attorno alla richiesta. La richiesta grezza combina il `trigger` di [Configurazione del trigger](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#trigger-configuration) con `pause_after_compaction` di [Pausa dopo la compattazione](https://platform.claude.com/docs/it/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})
# Stima i token totali consumati; sollecita la chiusura se si supera il budget
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 });
// Stima i token totali consumati; chiedi di concludere se si supera il budget
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()
});
// Stima i token totali consumati; sollecita la chiusura se si supera il budget
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())
// Stima i token totali consumati; chiedi di concludere se si supera il budget
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());
// Stima i token totali consumati; sollecita la chiusura se si supera il budget
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];
// Stima i token totali consumati; sollecita la chiusura se oltre il budget
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 }
# Stima i token totali consumati; sollecita la chiusura se si supera il budget
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
```
## Lavorare con i blocchi di compattazione
Quando viene attivata la compattazione, l’API restituisce un blocco `compaction` all’inizio della risposta dell’assistente.
Una conversazione di lunga durata potrebbe dare luogo a più compattazioni. L’ultimo blocco di compattazione riflette lo stato finale del prompt, sostituendo il contenuto che lo precede con il riepilogo generato.
```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..."
}
]
}
```
### Restituire i blocchi di compattazione
Devi restituire il blocco `compaction` all’API nelle richieste successive per continuare la conversazione con il prompt abbreviato. L’approccio più semplice è aggiungere l’intero contenuto della risposta ai tuoi messaggi:
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
```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"}]},
)
# Dopo aver ricevuto una risposta con un blocco di compattazione
messages.append({"role": "assistant", "content": response.content})
# Continua la conversazione
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" }]
}
});
// Dopo aver ricevuto una risposta con un blocco di compattazione
messages.push({
role: "assistant",
content: response.content
});
// Continua la conversazione
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();
// Prima richiesta
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());
// Dopo aver ricevuto una risposta con un blocco di compattazione, aggiungi l'intero
// contenuto (inclusi i blocchi di compattazione) e continua la conversazione
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
```
In Python, usa `client.beta.messages`, come fanno gli esempi in questa pagina. Se chiami `client.messages` e serializzi i blocchi autonomamente, un semplice `model_dump()` aggiunge `text: null` e `citations: null` al blocco `compaction`. L’API rifiuta quindi la richiesta con un errore 400 (`Extra inputs are not permitted`). Usa invece `to_dict()` o `model_dump(exclude_none=True)`. [Continua dal riepilogo](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#continue-from-the-summary) fornisce lo stesso consiglio per la compattazione su richiesta.
Quando l’API riceve un blocco `compaction`, tutti i blocchi di contenuto che lo precedono vengono ignorati. Puoi:
* Mantenere i messaggi originali nella tua lista e lasciare che sia l’API a gestire la rimozione del contenuto compattato
* Eliminare manualmente i messaggi compattati e includere solo il blocco di compattazione e ciò che segue
Se non viene generato alcun riepilogo, il `content` del blocco è `null` e l’API ignora il blocco. Non viene compattato nulla, quindi mantieni i messaggi originali.
Sui modelli Claude 5.1 e successivi, i blocchi di ragionamento precedenti a un blocco `compaction` non vengono riportati, quindi il riepilogo è tutto ciò che il modello conserva di quel lavoro precedente. Se scrivi le tue `instructions`, indica al modello cosa deve conservare il riepilogo; consulta [Indica al modello cosa preservare nei riepiloghi di compattazione](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries).
### Streaming
Il blocco di compattazione viene trasmesso in streaming in modo diverso rispetto ai blocchi di testo. Ricevi un evento `content_block_start`, seguito da un singolo `content_block_delta` con il contenuto completo del riepilogo (senza streaming intermedio), e poi 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)
# Ottieni il messaggio finale accumulato
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;
}
}
// Ottieni il messaggio finale accumulato
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
```
### Cache dei prompt
La compattazione funziona bene con il “prompt caching” ([cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching)). Puoi aggiungere un breakpoint `cache_control` sui blocchi di compattazione per memorizzare nella cache il contenuto riepilogato.
```json
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": { "type": "ephemeral" }
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
#### Massimizzare i cache hit con i prompt di sistema
Quando avviene una compattazione, il riepilogo diventa nuovo contenuto che deve essere scritto nella cache. Senza breakpoint di cache aggiuntivi, questo invaliderebbe anche qualsiasi “system prompt” (prompt di sistema) memorizzato nella cache, richiedendo di memorizzarlo nuovamente insieme al riepilogo di compattazione.
Per massimizzare il tasso di cache hit, aggiungi un breakpoint `cache_control` alla fine del tuo prompt di sistema. In questo modo il prompt di sistema resta memorizzato nella cache separatamente dalla conversazione, quindi quando avviene una compattazione:
* La cache del prompt di sistema rimane valida e viene letta dalla cache
* Solo il riepilogo di compattazione deve essere scritto come nuova voce della cache
```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
```
In questo modo i prompt di sistema lunghi restano memorizzati nella cache attraverso più eventi di compattazione nel corso di una conversazione.
## Comprendere l’utilizzo
La compattazione richiede un passaggio di campionamento aggiuntivo, che incide sui “rate limit” (limiti di velocità) e sulla fatturazione. L’API restituisce informazioni dettagliate sull’utilizzo nella risposta:
```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
}
]
}
}
```
L’array `iterations` mostra l’utilizzo per ogni iterazione di campionamento. Quando avviene una compattazione, vedrai un’iterazione `compaction` seguita dall’iterazione principale `message`. In questo esempio, i valori di primo livello `input_tokens` e `output_tokens` corrispondono esattamente all’iterazione `message` perché c’è una sola iterazione non di compattazione. I conteggi dei token dell’iterazione finale riflettono la dimensione effettiva del contesto dopo la compattazione.
I valori di primo livello `input_tokens` e `output_tokens` non includono l’utilizzo dell’iterazione di compattazione. Riflettono la somma di tutte le iterazioni non di compattazione. Per calcolare il totale dei token consumati e fatturati per una richiesta, somma tutte le voci dell’array `usage.iterations`.
Se in precedenza ti affidavi a `usage.input_tokens` e `usage.output_tokens` per il monitoraggio dei costi o per l’auditing, dovrai aggiornare la tua logica di monitoraggio per aggregare i valori di `usage.iterations` quando la compattazione è abilitata. Con la beta della compattazione abilitata, ogni risposta include `usage.iterations`, anche se non è avvenuta alcuna compattazione. Una voce `compaction` compare solo quando viene attivata una nuova compattazione durante la richiesta. La riapplicazione di un blocco `compaction` precedente non comporta costi di compattazione aggiuntivi e, in quel caso, i campi di utilizzo di primo livello restano accurati.
## Combinazione con altre funzionalità
### Strumenti server
Quando usi strumenti server (come la ricerca web), il trigger di compattazione viene verificato all’inizio di ogni iterazione di campionamento. La compattazione potrebbe avvenire più volte all’interno di una singola richiesta, a seconda della soglia di attivazione e della quantità di output generato.
### Conteggio dei token
L’endpoint di conteggio dei token (`/v1/messages/count_tokens`) applica i blocchi `compaction` esistenti nel tuo prompt, ma non attiva nuove compattazioni. Usalo per verificare il conteggio effettivo dei token dopo le compattazioni precedenti:
```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}"
```
## Esempi
Ecco un esempio completo di una conversazione di lunga durata con compattazione:
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
```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},
}
]
},
)
# Aggiungi la risposta (i blocchi di compattazione sono inclusi automaticamente)
messages.append({"role": "assistant", "content": response.content})
# Restituisci il contenuto testuale
return next((block.text for block in response.content if block.type == "text"), "")
# Esegui una conversazione lunga
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"))
# Continua a chiamare chat() finché la conversazione lo richiede
```
```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 }
}
]
}
});
// Aggiungi la risposta (i blocchi di compattazione sono inclusi automaticamente)
messages.push({ role: "assistant", content: response.content });
// Restituisci il contenuto testuale
const textBlock = response.content.find((block) => block.type === "text");
return textBlock?.text ?? "";
}
// Esegui una conversazione lunga
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"));
// Continua a chiamare chat() finché la conversazione lo richiede
```
```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);
// Aggiungi la risposta (i blocchi di compattazione sono inclusi automaticamente)
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")
```
Sui modelli Claude 5.1 e successivi, i blocchi di ragionamento in qualsiasi turno dell’assistente che reinserisci dopo il blocco di compattazione non superano il [controllo del prefisso](https://platform.claude.com/docs/it/build-with-claude/thinking#preserved-in-conversation), perché sono stati prodotti quando era presente la cronologia completa. Rimuovi i blocchi `thinking` e `redacted_thinking` da quei turni. In alternativa, invia `thinking.block_binding.prefix_mismatch_behavior: "drop_block"` con l’[header beta](https://platform.claude.com/docs/it/api/beta-headers) `thinking-binding-controls-2026-08-01`. I blocchi di testo e di strumenti preservati possono restare così come sono. Lasciare che l’API riassuma tutto, senza reinserire i turni precedenti, evita questo problema. Su Claude Sonnet 5.5 e Claude Haiku 5.5, `block_binding` funziona solo con `thinking: {"type": "adaptive"}`. Con qualsiasi altra impostazione di ragionamento su quei modelli, rimuovi i blocchi.
Ecco un esempio che usa `pause_after_compaction` per preservare lo scambio precedente e il messaggio utente corrente (tre messaggi in totale) invece di riassumerli. Mantiene invariati i loro blocchi di testo e di strumenti, rimuove i blocchi `thinking` e `redacted_thinking` dal turno dell’assistente preservato ed elimina quel turno se non rimane nient’altro:
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
```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,
}
]
},
)
# Cerca il blocco di compattazione, non il motivo di arresto:
# stop_reason è "refusal", non "compaction", se il riepilogo è stato bloccato
compaction_block = next(
(block for block in response.content if block.type == "compaction"), None
)
# Sostituisci la cronologia solo se è stato generato un riepilogo
if compaction_block is not None and compaction_block.content is not None:
# Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi)
# includendoli dopo il blocco di compattazione, senza i blocchi di
# ragionamento; un turno dell'assistente rimasto senza contenuto viene scartato
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"]]
# Crea la nuova lista di messaggi: compattazione + messaggi conservati
new_assistant_content = [compaction_block]
messages_after_compaction = [
{"role": "assistant", "content": new_assistant_content}
] + preserved_messages
# Aggiorna la lista di messaggi per riflettere la compattazione
messages.clear()
messages.extend(messages_after_compaction)
if compaction_block is not None:
# Continua la richiesta, con la cronologia completa se non c'è un riepilogo
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"}]},
)
# Aggiungi la risposta finale
messages.append({"role": "assistant", "content": response.content})
# Restituisci il contenuto testuale
return next((block.text for block in response.content if block.type == "text"), "")
# Esegui una conversazione lunga
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"))
# Continua a chiamare chat() finché la conversazione lo richiede
```
```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
}
]
}
});
// Cerca il blocco di compattazione, non il motivo di arresto:
// stop_reason è "refusal", non "compaction", se il riepilogo è stato bloccato
const compactionBlock = response.content.find((block) => block.type === "compaction");
// Sostituisci la cronologia solo se è stato generato un riepilogo
if (compactionBlock && compactionBlock.content !== null) {
// Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi)
// includendoli dopo il blocco di compattazione, senza i blocchi di ragionamento
// ; un turno dell'assistente rimasto senza contenuto viene scartato
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);
// Crea il nuovo elenco di messaggi: compattazione + messaggi conservati
const messagesAfterCompaction: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "assistant", content: [compactionBlock] },
...preservedMessages
];
// Aggiorna l'elenco dei messaggi per riflettere la compattazione
messages = messagesAfterCompaction;
}
if (compactionBlock) {
// Continua la richiesta, con la cronologia completa se non c'è un riepilogo
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" }]
}
});
}
// Aggiungi la risposta finale
messages.push({ role: "assistant", content: response.content });
// Restituisci il contenuto testuale
const textBlock = response.content.find((block) => block.type === "text");
return textBlock?.text ?? "";
}
// Esegui una conversazione lunga
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"));
// Continua a chiamare chat() finché la conversazione lo richiede
```
```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
}]
}
});
// Cerca il blocco di compattazione, non il motivo di arresto:
// StopReason è Refusal, non Compaction, se il riepilogo è stato bloccato
var compactionBlock = response.Content.FirstOrDefault(block => block.Value is BetaCompactionBlock);
// Sostituisci la cronologia solo se è stato generato un riepilogo
if (compactionBlock?.Value is BetaCompactionBlock { Content: not null })
{
// Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi),
// senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato
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)
{
// Continua la richiesta, con la cronologia completa se non c'è un riepilogo
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)
}
// Cerca il blocco di compattazione, non il motivo di arresto:
// StopReason è "refusal", non "compaction", se il riepilogo è stato bloccato
compactionIndex := slices.IndexFunc(response.Content, func(block anthropic.BetaContentBlockUnion) bool {
return block.Type == "compaction"
})
// Sostituisci la cronologia solo se è stato generato un riepilogo (content non è null)
if compactionIndex >= 0 && response.Content[compactionIndex].JSON.Content.Valid() {
compactionParam := response.Content[compactionIndex].ToParam()
// Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi),
// senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato
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 {
// Continua la richiesta, con la cronologia completa se non c'è un riepilogo
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);
// Cerca il blocco di compattazione, non il motivo di arresto:
// stopReason() è REFUSAL, non COMPACTION, se il riepilogo è stato bloccato
var compactionBlock = response.content().stream()
.flatMap(block -> block.compaction().stream())
.findFirst();
// Sostituisci la cronologia solo se è stato generato un riepilogo
if (compactionBlock.flatMap(block -> block.content()).isPresent()) {
// Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi),
// senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato
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);
}
// Costruisci il nuovo elenco di messaggi: compattazione + messaggi conservati
List messagesAfterCompaction = new ArrayList<>();
messagesAfterCompaction.add(response.toParam());
messagesAfterCompaction.addAll(preservedMessages);
// Aggiorna l'elenco dei messaggi per riflettere la compattazione
messages.clear();
messages.addAll(messagesAfterCompaction);
}
if (compactionBlock.isPresent()) {
// Continua la richiesta, con la cronologia completa se non c'è un riepilogo
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);
}
// Aggiungi la risposta finale
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
]
]
]
);
// Cerca il blocco di compattazione, non il motivo di arresto:
// stopReason è 'refusal', non 'compaction', se il riepilogo è stato bloccato
$compactionBlock = null;
foreach ($response->content as $block) {
if ($block instanceof \Anthropic\Beta\Messages\BetaCompactionBlock) {
$compactionBlock = $block;
break;
}
}
// Sostituisci la cronologia solo se è stato generato un riepilogo
if ($compactionBlock?->content !== null) {
// Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi),
// senza blocchi di ragionamento; un turno assistant rimasto vuoto viene scartato
$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) {
// Continua la richiesta, con la cronologia completa se non c'è un riepilogo
$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
}
]
}
)
# Cerca il blocco di compattazione, non il motivo di arresto:
# stop_reason è :refusal, non :compaction, se il riepilogo è stato bloccato
compaction_block = response.content.find { |block| block.type == :compaction }
# Sostituisci la cronologia solo se è stato generato un riepilogo
if compaction_block&.content
# Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi),
# senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato
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
# Continua la richiesta, con la cronologia completa se non c'è un riepilogo
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")
```
## Limitazioni attuali
* **Stesso modello per il riepilogo:** il modello specificato nella tua richiesta viene usato per il riepilogo. Non è possibile usare un modello diverso (ad esempio, più economico) per il riepilogo.
* **La compattazione potrebbe non riuscire quando sono definiti strumenti:** quando la tua richiesta include `tools`, il modello occasionalmente chiama uno strumento durante il passaggio interno di riepilogo invece di scrivere un riepilogo. Quando ciò accade, la risposta contiene un blocco `compaction` con `content: null`. Per evitarlo, imposta [`instructions`](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#custom-summarization-instructions) su un prompt che indichi esplicitamente al modello di non chiamare strumenti, ad esempio:
```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.
```
## Passaggi successivi
Gestisci automaticamente il contesto della conversazione man mano che cresce con la modifica del contesto.
Scopri le dimensioni delle finestre di contesto e le strategie di gestione.
Esplora un’implementazione pratica che gestisce conversazioni di lunga durata con la compattazione istantanea della memoria di sessione, usando il threading in background e la cache dei prompt.
## Disponibilità
La funzionalità Compattazione a soglia è in beta su alcuni modelli e idonea per conservazione zero dei dati.
### Supporto API
#### [Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages)
* Disponibilità: Disponibile
* Utilizzo: Attivala con una modifica `compact_20260112` in `context_management.edits`. La compattazione inizia quando i token di input raggiungono il trigger, 150.000 per impostazione predefinita e almeno 50.000.
| Stato | Piattaforme cloud | Modelli |
| ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), [Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock), [Amazon Bedrock (InvokeModel)](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry) | [Claude Fable 5.1](https://platform.claude.com/docs/it/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/it/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/it/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/it/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/it/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/it/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/it/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/it/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/it/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/it/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/it/models/sonnet-4-6/overview) |
#### [Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview)
* Disponibilità: Sempre attivo
* Utilizzo: Compatta la cronologia della conversazione della sessione per adattarla alla finestra di contesto e ogni compattazione emette un evento `agent.thread_context_compacted`.
| Stato | Piattaforme cloud | Modelli |
| ----- | ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws) | [Claude Fable 5.1](https://platform.claude.com/docs/it/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/it/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/it/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/it/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/it/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/it/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/it/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/it/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/it/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/it/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/it/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/it/models/sonnet-4-6/overview) |
### Header beta richiesti
[Panoramica degli header beta](https://platform.claude.com/docs/it/api/beta-headers)
Gli header beta consentono di accedere a funzionalità sperimentali e a nuove capacità dei modelli prima che entrino a far parte dell’API standard.
| Header | API |
| -------------------- | ------------------------------------------------------------------------------------------- |
| `compact-2026-01-12` | [Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages) |
### Gestione dei dati
[Panoramica sulla gestione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#feature-eligibility)
| Elemento | Conservazione zero dei dati | HIPAA |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
| Stato | Idoneo (esclude [Modelli coperti](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Non idoneo |
| Dettagli | I risultati della compattazione lato server vengono restituiti e rinviati senza stato tramite la risposta dell’API. | — |
Endpoint applicabili:
* `/v1/messages` con `context_management`