---
title: Modifica del contesto
url: https://platform.claude.com/docs/it/build-with-claude/context-editing
description: Gestisci automaticamente il contesto della conversazione man mano che cresce con la modifica del contesto.
---
Per scoprire come la "zero data retention" (conservazione zero dei dati), o ZDR, si applica a questa funzionalità, consulta [API e conservazione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention).
## Panoramica
Per la maggior parte dei casi d'uso, la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction) è la strategia principale per gestire il contesto nelle conversazioni di lunga durata. Le strategie in questa pagina sono utili per scenari specifici in cui hai bisogno di un controllo più granulare su quali contenuti vengono rimossi.
Il "context editing" (modifica del contesto) ti consente di rimuovere selettivamente contenuti specifici dalla cronologia della conversazione man mano che cresce. Oltre a ottimizzare i costi e rimanere entro i limiti, si tratta di curare attivamente ciò che Claude vede: il contesto è una risorsa finita con rendimenti decrescenti, e i contenuti irrilevanti degradano la concentrazione del modello. La modifica del contesto ti offre un controllo granulare a runtime su questa cura. Per i principi più ampi alla base della gestione del contesto, consulta [Effective context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). Questa pagina tratta:
* **Rimozione dei risultati degli strumenti** - Ideale per flussi di lavoro agentici con un intenso uso degli strumenti, in cui i vecchi risultati degli strumenti non sono più necessari
* **Rimozione dei blocchi di ragionamento** - Per gestire i blocchi di ragionamento dei turni precedenti, con opzioni per preservare il ragionamento recente per la continuità del contesto
* **Compattazione SDK lato client** - Un'alternativa basata su SDK per la gestione del contesto basata su riepiloghi (la compattazione lato server è generalmente preferibile)
| Approccio | Dove viene eseguito | Strategie | Come funziona |
| --------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Lato server** | API | Rimozione dei risultati degli strumenti (`clear_tool_uses_20250919`)
Rimozione dei blocchi di ragionamento (`clear_thinking_20251015`) | Applicata prima che il prompt raggiunga Claude. Rimuove contenuti specifici dalla cronologia della conversazione. Ogni strategia può essere configurata in modo indipendente. |
| **Lato client** | SDK | Compattazione | Disponibile negli [SDK TypeScript e Ruby](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) quando si usa [`tool_runner`](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-runner). Genera un riepilogo e sostituisce l'intera cronologia della conversazione. Vedi [Compattazione lato client](https://platform.claude.com/docs/it/build-with-claude/context-editing#client-side-compaction-sdk). |
## Strategie lato server
La modifica del contesto è in beta con supporto per la rimozione dei risultati degli strumenti e la rimozione dei blocchi di ragionamento. Per abilitarla, usa l'header beta `context-management-2025-06-27` nelle tue richieste API.
Condividi il tuo feedback su questa funzionalità tramite il [modulo di feedback](https://forms.gle/YXC2EKGMhjN1c4L88).
### Rimozione dei risultati degli strumenti
La strategia `clear_tool_uses_20250919` rimuove i risultati degli strumenti quando il contesto della conversazione cresce oltre la soglia configurata. Questo è particolarmente utile per flussi di lavoro agentici con un intenso uso degli strumenti. I risultati degli strumenti più vecchi (come contenuti di file o risultati di ricerca) non sono più necessari una volta che Claude li ha elaborati.
Quando attivata, l'API rimuove automaticamente i risultati degli strumenti più vecchi in ordine cronologico. L'API sostituisce ogni risultato rimosso con un testo segnaposto che indica a Claude che è stato rimosso. Per impostazione predefinita, vengono rimossi solo i risultati degli strumenti. Puoi facoltativamente rimuovere sia i risultati degli strumenti sia le chiamate agli strumenti (i parametri di uso degli strumenti) impostando `clear_tool_inputs` su true.
### Rimozione dei blocchi di ragionamento
La strategia `clear_thinking_20251015` gestisce i blocchi `thinking` dei turni precedenti dell'assistente. Questa strategia ti dà il controllo sulla conservazione del ragionamento: puoi scegliere di mantenere più blocchi di ragionamento per preservare la continuità del ragionamento, oppure rimuoverli in modo più aggressivo per risparmiare spazio nel contesto.
**Comportamento predefinito:** Il valore predefinito varia in base alla classe del modello.
| Classe del modello | Mantiene tutto il ragionamento precedente | Mantiene solo il ragionamento dell'ultimo turno |
| ------------------ | ----------------------------------------- | ----------------------------------------------- |
| Opus | Claude Opus 4.5 e successivi | Claude Opus 4.1 e precedenti |
| Sonnet | Claude Sonnet 4.6 e successivi | Claude Sonnet 4.5 (deprecato) e precedenti |
| Haiku | Claude Haiku 5.5 e successivi | Claude Haiku 4.5 e precedenti |
| Fable e Mythos | Tutti i modelli | (nessuno) |
Usa questa strategia per sovrascrivere il valore predefinito. Se il tuo codice viene eseguito su più livelli di modelli, imposta `keep` esplicitamente invece di affidarti al valore predefinito per modello.
Un turno di conversazione dell'assistente può includere più blocchi di contenuto (ad esempio, quando si usano strumenti) e più blocchi di ragionamento (ad esempio, con il [ragionamento interlacciato](https://platform.claude.com/docs/it/build-with-claude/thinking#interleaved-thinking)).
### La modifica del contesto avviene lato server
La modifica del contesto viene applicata lato server prima che il prompt raggiunga Claude. La tua applicazione client mantiene la cronologia completa e non modificata della conversazione. Non è necessario sincronizzare lo stato del client con la versione modificata. Continua a gestire localmente la cronologia completa della conversazione come faresti normalmente.
Su Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, la gestione del contesto lato server non invalida mai i blocchi di ragionamento. Le modifiche lato client ai turni precedenti possono invalidare i blocchi di ragionamento in ogni turno successivo dell'assistente. Per i nuovi account creati a partire dal 31 agosto 2026, una richiesta che ripropone un blocco invalidato viene rifiutata a meno che tu non scelga esplicitamente di scartarlo. Consulta [Mantenere invariato il prefisso](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#prefix-check).
### Modifica del contesto e cache dei prompt
L'interazione della modifica del contesto con la [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) varia in base alla strategia:
* **Rimozione dei risultati degli strumenti:** Invalida i prefissi dei prompt in cache quando il contenuto viene rimosso. Per tenerne conto, rimuovi abbastanza token da rendere conveniente l'invalidazione della cache. Usa il parametro `clear_at_least` per garantire che venga rimosso un numero minimo di token ogni volta. Sosterrai costi di scrittura nella cache ogni volta che il contenuto viene rimosso, ma le richieste successive potranno riutilizzare il nuovo prefisso in cache.
* **Rimozione dei blocchi di ragionamento:** Quando i blocchi di ragionamento vengono **mantenuti** nel contesto (non rimossi), la cache dei prompt viene preservata, consentendo cache hit e riducendo i costi dei token di input. Quando i blocchi di ragionamento vengono **rimossi**, la cache viene invalidata nel punto in cui avviene la rimozione. Configura il parametro `keep` in base a se vuoi dare priorità alle prestazioni della cache o alla disponibilità della finestra di contesto.
## Modelli supportati
La modifica del contesto è disponibile su tutti i modelli Claude supportati.
## Utilizzo della rimozione dei risultati degli strumenti
Il modo più semplice per abilitare la rimozione dei risultati degli strumenti è specificare solo il tipo di strategia. Tutte le altre [opzioni di configurazione](https://platform.claude.com/docs/it/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) usano i loro valori predefiniti:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Search for recent developments in AI"
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Search for recent developments in AI
tools:
- type: web_search_20250305
name: web_search
context_management:
edits:
- type: clear_tool_uses_20250919
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Search for recent developments in AI"}],
tools=[{"type": "web_search_20250305", "name": "web_search"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Search for recent developments in AI"
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search"
}
],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
},
betas: ["context-management-2025-06-27"]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Search for recent developments in AI" }
],
Tools = [
new BetaWebSearchTool20250305()
],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
},
Betas = [AnthropicBeta.ContextManagement2025_06_27]
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for recent developments in AI")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{}},
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Search for recent developments in AI")
.addTool(BetaWebSearchTool20250305.builder().build())
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Search for recent developments in AI']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
['type' => 'web_search_20250305', 'name' => 'web_search']
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{ role: "user", content: "Search for recent developments in AI" }
],
tools: [
{ type: "web_search_20250305", name: "web_search" }
],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
},
betas: ["context-management-2025-06-27"]
)
puts response
```
### Configurazione avanzata
Puoi personalizzare il comportamento della rimozione dei risultati degli strumenti con parametri aggiuntivi:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
"tools": [
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 3
},
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
"exclude_tools": ["web_search"]
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Create a simple command line calculator app using Python
tools:
- type: text_editor_20250728
name: str_replace_based_edit_tool
max_characters: 10000
- type: web_search_20250305
name: web_search
max_uses: 3
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 3
clear_at_least:
type: input_tokens
value: 5000
exclude_tools:
- web_search
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python",
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000,
},
{"type": "web_search_20250305", "name": "web_search", "max_uses": 3},
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
# Attiva la cancellazione quando la soglia viene superata
"trigger": {"type": "input_tokens", "value": 30000},
# Numero di usi degli strumenti da mantenere dopo la cancellazione
"keep": {"type": "tool_uses", "value": 3},
# Facoltativo: cancella almeno questo numero di token
"clear_at_least": {"type": "input_tokens", "value": 5000},
# Escludi questi strumenti dalla cancellazione
"exclude_tools": ["web_search"],
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Create a simple command line calculator app using Python"
}
],
tools: [
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool",
max_characters: 10000
},
{
type: "web_search_20250305",
name: "web_search",
max_uses: 3
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
// Attiva la cancellazione quando la soglia viene superata
trigger: {
type: "input_tokens",
value: 30000
},
// Numero di usi degli strumenti da mantenere dopo la cancellazione
keep: {
type: "tool_uses",
value: 3
},
// Facoltativo: cancella almeno questo numero di token
clear_at_least: {
type: "input_tokens",
value: 5000
},
// Escludi questi strumenti dalla cancellazione
exclude_tools: ["web_search"]
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Create a simple command line calculator app using Python" }
],
Tools = [
new BetaToolTextEditor20250728 { MaxCharacters = 10000 },
new BetaWebSearchTool20250305 { MaxUses = 3 }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(3),
ClearAtLeast = new BetaInputTokensClearAtLeast(5000),
ExcludeTools = ["web_search"]
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a simple command line calculator app using Python")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{
MaxCharacters: anthropic.Int(10000),
}},
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(3),
}},
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 3,
},
ClearAtLeast: anthropic.BetaInputTokensClearAtLeastParam{
Value: 5000,
},
ExcludeTools: []string{"web_search"},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaInputTokensClearAtLeast;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Create a simple command line calculator app using Python")
.addTool(BetaToolTextEditor20250728.builder()
.maxCharacters(10000L)
.build())
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(3L)
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(3L)
.build())
.clearAtLeast(BetaInputTokensClearAtLeast.builder()
.value(5000L)
.build())
.addExcludeTool("web_search")
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
[
'role' => 'user',
'content' => 'Create a simple command line calculator app using Python'
]
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'text_editor_20250728',
'name' => 'str_replace_based_edit_tool',
'max_characters' => 10000
],
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 3
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 3
],
'clear_at_least' => [
'type' => 'input_tokens',
'value' => 5000
],
'exclude_tools' => ['web_search']
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Create a simple command line calculator app using Python"
}
],
tools: [
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool",
max_characters: 10000
},
{
type: "web_search_20250305",
name: "web_search",
max_uses: 3
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 3
},
clear_at_least: {
type: "input_tokens",
value: 5000
},
exclude_tools: ["web_search"]
}
]
}
)
puts response
```
## Utilizzo della rimozione dei blocchi di ragionamento
Usa la rimozione dei blocchi di ragionamento per gestire il contesto e la cache dei prompt nelle conversazioni che contengono blocchi di ragionamento dei turni precedenti:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
import com.anthropic.models.beta.messages.BetaThinkingTurns;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
)
puts response
```
### Opzioni di configurazione per la rimozione dei blocchi di ragionamento
La strategia `clear_thinking_20251015` supporta la seguente configurazione:
| Opzione di configurazione | Predefinito | Descrizione |
| ------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `keep` | Specifico per modello | Definisce quanti turni recenti dell'assistente con blocchi di ragionamento preservare. Usa `{type: "thinking_turns", value: N}` dove N deve essere > 0 per mantenere gli ultimi N turni, oppure `"all"` per mantenere tutti i blocchi di ragionamento. Opus 4.5+, Sonnet 4.6+ e Haiku 5.5+: tutti i turni. Modelli Fable e Mythos: tutti i turni. Opus/Sonnet precedenti e Haiku fino a Claude Haiku 4.5: solo l'ultimo turno. |
**Configurazioni di esempio:**
Mantieni i blocchi di ragionamento degli ultimi 3 turni dell'assistente:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 3
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 3
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 3},
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(3)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 3,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(3L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 3
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
)
puts response
```
Mantieni tutti i blocchi di ragionamento (massimizza i cache hit):
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep: all
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all",
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new All()
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfAll: constant.ValueOf[constant.All](),
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keepAll()
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => 'all'
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
)
puts response
```
### Combinare le strategie
Puoi usare insieme sia la rimozione dei blocchi di ragionamento sia la rimozione dei risultati degli strumenti:
Quando si usano più strategie, la strategia `clear_thinking_20251015` deve essere elencata per prima nell'array `edits`.
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
},
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 50000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Search for the latest developments in quantum error correction and summarize the key breakthroughs.
tools:
- type: web_search_20250305
name: web_search
max_uses: 5
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 50000
keep:
type: tool_uses
value: 5
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs.",
}
],
tools=[
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5,
}
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
},
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 50000},
"keep": {"type": "tool_uses", "value": 5},
},
]
},
)
print(response)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content:
"Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(response);
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Search for the latest developments in quantum error correction and summarize the key breakthroughs." }
],
Tools = [
new BetaWebSearchTool20250305 { MaxUses = 5 }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
},
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(50000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(5),
}},
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 50000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaThinkingTurns;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(5L)
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(50000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
[
'role' => 'user',
'content' => 'Search for the latest developments in quantum error correction and summarize the key breakthroughs.'
]
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 5
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
],
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 50000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content: "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts response
```
## Opzioni di configurazione per la rimozione dei risultati degli strumenti
| Opzione di configurazione | Predefinito | Descrizione |
| ------------------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger` | 100.000 token di input | Definisce quando si attiva la strategia di modifica del contesto. Una volta che il prompt supera questa soglia, inizia la rimozione. Puoi specificare questo valore in `input_tokens` o in `tool_uses`. |
| `keep` | 3 usi di strumenti | Definisce quante coppie recenti di uso/risultato degli strumenti mantenere dopo la rimozione. L'API rimuove prima le interazioni con gli strumenti più vecchie, preservando quelle più recenti. |
| `clear_at_least` | Nessuno | Garantisce che venga rimosso un numero minimo di token ogni volta che la strategia si attiva. Se l'API non riesce a rimuovere almeno la quantità specificata, la strategia non verrà applicata. Questo aiuta a determinare se la rimozione del contesto vale la rottura della cache dei prompt. |
| `exclude_tools` | Nessuno | Elenco di nomi di strumenti i cui usi e risultati non devono mai essere rimossi. Utile per preservare contesto importante. |
| `clear_tool_inputs` | `false` | Controlla se i parametri delle chiamate agli strumenti vengono rimossi insieme ai risultati degli strumenti. Per impostazione predefinita, vengono rimossi solo i risultati degli strumenti, mantenendo visibili le chiamate agli strumenti originali di Claude. |
## Risposta della modifica del contesto
Puoi vedere quali modifiche del contesto sono state applicate alla tua richiesta usando il campo di risposta `context_management`, insieme a statistiche utili sul contenuto e sui token di input rimossi.
```json Output
{
"id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
"type": "message",
"role": "assistant",
"content": [
// ...
],
"usage": {
// ...
},
"context_management": {
"applied_edits": [
// When using `clear_thinking_20251015`
{
"type": "clear_thinking_20251015",
"cleared_thinking_turns": 3,
"cleared_input_tokens": 15000
},
// When using `clear_tool_uses_20250919`
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8,
"cleared_input_tokens": 50000
}
]
}
}
```
Per le risposte in streaming, le modifiche del contesto sono incluse nell'evento finale `message_delta`:
```json Streaming Response
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [
// ...
]
}
}
```
## Conteggio dei token
L'endpoint di [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting) supporta la gestione del contesto, consentendoti di visualizzare in anteprima quanti token userà il tuo prompt dopo l'applicazione della modifica del contesto.
```bash cURL
curl https://api.anthropic.com/v1/messages/count_tokens \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"messages": [
{
"role": "user",
"content": "Continue our conversation..."
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}'
```
```bash CLI
ORIGINAL=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform context_management.original_input_tokens \
--raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
INPUT_TOKENS=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform input_tokens --raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
printf 'Original tokens: %s\n' "$ORIGINAL"
printf 'After clearing: %s\n' "$INPUT_TOKENS"
printf 'Savings: %s tokens\n' "$((ORIGINAL - INPUT_TOKENS))"
```
```python Python
response = client.beta.messages.count_tokens(
model="claude-opus-5-5",
messages=[{"role": "user", "content": "Continue our conversation..."}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 30000},
"keep": {"type": "tool_uses", "value": 5},
}
]
},
)
print(f"Original tokens: {response.context_management.original_input_tokens}")
print(f"After clearing: {response.input_tokens}")
print(
f"Savings: {response.context_management.original_input_tokens - response.input_tokens} tokens"
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.countTokens({
model: "claude-opus-5-5",
messages: [
{
role: "user",
content: "Continue our conversation..."
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(`Original tokens: ${response.context_management?.original_input_tokens}`);
console.log(`After clearing: ${response.input_tokens}`);
console.log(
`Savings: ${
(response.context_management?.original_input_tokens || 0) - response.input_tokens
} tokens`
);
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCountTokensParams
{
Model = Messages::Model.ClaudeOpus5_5,
Messages = [new() { Role = Role.User, Content = "Continue our conversation..." }],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.CountTokens(parameters);
Console.WriteLine($"Original tokens: {response.ContextManagement?.OriginalInputTokens}");
Console.WriteLine($"After clearing: {response.InputTokens}");
Console.WriteLine($"Savings: {(response.ContextManagement?.OriginalInputTokens ?? 0) - response.InputTokens} tokens");
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
Model: anthropic.ModelClaudeOpus5_5,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Continue our conversation...")),
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Original tokens: %d\n", response.ContextManagement.OriginalInputTokens)
fmt.Printf("After clearing: %d\n", response.InputTokens)
fmt.Printf("Savings: %d tokens\n", response.ContextManagement.OriginalInputTokens-response.InputTokens)
```
```java Java
import com.anthropic.models.beta.messages.BetaMessageTokensCount;
import com.anthropic.models.beta.messages.MessageCountTokensParams;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCountTokensParams params = MessageCountTokensParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.addUserMessage("Continue our conversation...")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessageTokensCount response = client.beta().messages().countTokens(params);
IO.println("Original tokens: " + response.contextManagement().get().originalInputTokens());
IO.println("After clearing: " + response.inputTokens());
IO.println("Savings: " + (response.contextManagement().get().originalInputTokens() - response.inputTokens()) + " tokens");
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->countTokens(
messages: [
['role' => 'user', 'content' => 'Continue our conversation...']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo "Original tokens: " . $response->contextManagement->originalInputTokens . "\n";
echo "After clearing: " . $response->inputTokens . "\n";
echo "Savings: " . ($response->contextManagement->originalInputTokens - $response->inputTokens) . " tokens\n";
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.count_tokens(
model: "claude-opus-5-5",
messages: [
{ role: "user", content: "Continue our conversation..." }
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts "Original tokens: #{response.context_management.original_input_tokens}"
puts "After clearing: #{response.input_tokens}"
puts "Savings: #{response.context_management.original_input_tokens - response.input_tokens} tokens"
```
```json Output
{
"input_tokens": 25000,
"context_management": {
"original_input_tokens": 70000
}
}
```
La risposta mostra sia il conteggio finale dei token dopo l'applicazione della gestione del contesto (`input_tokens`) sia il conteggio originale dei token prima di qualsiasi rimozione (`original_input_tokens`).
## Utilizzo con lo strumento di memoria
La modifica del contesto può essere combinata con lo [strumento di memoria](https://platform.claude.com/docs/it/agents-and-tools/tool-use/memory-tool). Quando il contesto della conversazione si avvicina alla soglia di rimozione configurata, Claude riceve un avviso automatico per preservare le informazioni importanti. Questo consente a Claude di salvare i risultati degli strumenti o il contesto nei suoi file di memoria prima che vengano rimossi dalla cronologia della conversazione.
Questa combinazione ti consente di:
* **Preservare il contesto importante:** Claude può scrivere le informazioni essenziali dai risultati degli strumenti nei file di memoria prima che tali risultati vengano rimossi
* **Mantenere flussi di lavoro di lunga durata:** Abilita flussi di lavoro agentici che altrimenti supererebbero i limiti di contesto, trasferendo le informazioni in un archivio persistente
* **Accedere alle informazioni su richiesta:** Claude può cercare informazioni precedentemente rimosse nei file di memoria quando necessario, invece di mantenere tutto nella finestra di contesto attiva
Ad esempio, in un flusso di lavoro di modifica di file in cui Claude esegue molte operazioni, Claude può riepilogare le modifiche completate nei file di memoria man mano che il contesto cresce. Quando i risultati degli strumenti vengono rimossi, Claude mantiene l'accesso a tali informazioni tramite il suo sistema di memoria e può continuare a lavorare in modo efficace.
Per usare entrambe le funzionalità insieme, abilitale nella tua richiesta API:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello"
}
],
"tools": [
{
"type": "memory_20250818",
"name": "memory"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello
tools:
- type: memory_20250818
name: memory
context_management:
edits:
- type: clear_tool_uses_20250919
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Hello"}],
tools=[{"type": "memory_20250818", "name": "memory"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Tools = [
new BetaMemoryTool20250818()
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfMemoryTool20250818: &anthropic.BetaMemoryTool20250818Param{}},
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaMemoryTool20250818;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Hello")
.addTool(BetaMemoryTool20250818.builder().build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'memory_20250818',
'name' => 'memory'
]
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
}
)
puts response
```
Per il riferimento completo dello strumento di memoria, inclusi comandi ed esempi, vedi [Strumento di memoria](https://platform.claude.com/docs/it/agents-and-tools/tool-use/memory-tool).
## Compattazione lato client (SDK)
**Anthropic consiglia la compattazione lato server rispetto alla compattazione SDK.** La [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction) gestisce automaticamente il contesto con minore complessità di integrazione, un migliore calcolo dell'utilizzo dei token e nessuna limitazione lato client. Usa la compattazione SDK solo se hai specificamente bisogno di un controllo lato client sul processo di riepilogo.
Il parametro `compaction_control` è deprecato negli SDK TypeScript e Ruby e verrà rimosso in una versione futura. Gli SDK emettono un avviso di deprecazione quando è abilitato. L'SDK Python lo ha rimosso nella v1.0. Per usare la compattazione lato server con un tool runner, passa la modifica `compact_20260112` nel parametro `context_management` della richiesta.
La compattazione è disponibile negli [SDK TypeScript e Ruby](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) quando si usa il [metodo `tool_runner`](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-runner).
La "compaction" (compattazione) è una funzionalità dell'SDK che gestisce automaticamente il contesto della conversazione generando riepiloghi quando l'utilizzo dei token diventa troppo elevato. A differenza delle strategie di modifica del contesto lato server che rimuovono contenuti, la compattazione istruisce Claude a riepilogare la cronologia della conversazione, quindi sostituisce l'intera cronologia con quel riepilogo. Questo consente a Claude di continuare a lavorare su attività di lunga durata che altrimenti supererebbero la [finestra di contesto](https://platform.claude.com/docs/it/build-with-claude/context-windows).
### Come funziona la compattazione
Quando la compattazione è abilitata, l'SDK monitora l'utilizzo dei token dopo ogni risposta del modello:
1. **Controllo della soglia:** L'SDK calcola i token totali come `input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens` (vedi [Cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) per i campi dei token di cache).
2. **Generazione del riepilogo:** Quando la soglia viene superata, un prompt di riepilogo viene iniettato come turno utente e Claude genera un riepilogo strutturato racchiuso nei tag ``.
3. **Sostituzione del contesto:** L'SDK estrae il riepilogo e sostituisce con esso l'intera cronologia dei messaggi.
4. **Continuazione:** La conversazione riprende dal riepilogo, con Claude che riparte da dove si era interrotto.
### Utilizzo della compattazione
Aggiungi `compaction_control` alla tua chiamata `tool_runner` per abilitare il riepilogo automatico quando l'utilizzo dei token supera la soglia.
La compattazione viene eseguita lato client negli helper `tool_runner` dell'SDK, quindi non ha un equivalente HTTP diretto. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic.
La CLI non include un helper `tool_runner`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic senza integrazione lato SDK.
Nella v1.0 e successive, il tool runner dell'SDK Python non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: { enabled: true, contextTokenThreshold: 100000 }
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
L'SDK C# include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Go include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Java include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK PHP include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: { enabled: true, context_token_threshold: 100000 }
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
#### Cosa accade durante la compattazione
Man mano che la conversazione cresce, la cronologia dei messaggi si accumula:
**Prima della compattazione (avvicinandosi a 100k token):**
```json
[
{ "role": "user", "content": "Analyze all files and write a report..." },
{ "role": "assistant", "content": "I'll help. Let me start by reading..." },
{
"role": "user",
"content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
},
{ "role": "assistant", "content": "Based on file1.txt, I see..." },
{
"role": "user",
"content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
},
{ "role": "assistant", "content": "After analyzing file2.txt..." }
// ... 50 more exchanges like this ...
]
```
Quando i token superano la soglia, l'SDK inietta una richiesta di riepilogo e Claude genera un riepilogo. L'intera cronologia viene quindi sostituita:
**Dopo la compattazione (di nuovo a \~2–3k token):**
```json
[
{
"role": "assistant",
"content": "# Task Overview\nThe user requested analysis of directory files to produce a summary report...\n\n# Current State\nAnalyzed 52 files across 3 subdirectories. Key findings documented in report.md...\n\n# Important Discoveries\n- Configuration files use YAML format\n- Found 3 deprecated dependencies\n- Test coverage at 67%\n\n# Next Steps\n1. Analyze remaining files in /src/legacy\n2. Complete final report sections...\n\n# Context to Preserve\nUser prefers markdown format with executive summary first..."
}
]
```
Claude continua a lavorare da questo riepilogo come se fosse la cronologia originale della conversazione.
### Opzioni di configurazione
| Parametro | Tipo | Obbligatorio | Predefinito | Descrizione |
| ------------------------- | ------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------ |
| `enabled` | boolean | Sì | - | Se abilitare la compattazione automatica |
| `context_token_threshold` | number | No | 100.000 | Conteggio di token al quale si attiva la compattazione |
| `model` | string | No | Uguale al modello principale | Modello da usare per generare i riepiloghi |
| `summary_prompt` | string | No | Vedi [Prompt di riepilogo predefinito](https://platform.claude.com/docs/it/build-with-claude/context-editing#default-summary-prompt) | Prompt personalizzato per la generazione del riepilogo |
#### Scegliere una soglia di token
La soglia determina quando avviene la compattazione. Una soglia più bassa significa compattazioni più frequenti con finestre di contesto più piccole. Una soglia più alta consente più contesto ma rischia di raggiungere i limiti.
La compattazione viene eseguita lato client negli helper `tool_runner` dell'SDK, quindi non ha un equivalente HTTP diretto. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic.
La CLI non include un helper `tool_runner`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic senza integrazione lato SDK.
Dalla v1.0 in poi, il tool runner dell'SDK Python non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
// Valori più bassi compattano più spesso; alza a 150000 se l'attività richiede più contesto
compactionControl: { enabled: true, contextTokenThreshold: 50000 }
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
L'SDK C# include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Go include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Java include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK PHP include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
# Valori più bassi compattano più spesso; alza a 150000 quando l'attività richiede più contesto
compaction_control: { enabled: true, context_token_threshold: 50000 }
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
#### Usare un modello diverso per i riepiloghi
Puoi usare un modello più veloce o più economico per generare i riepiloghi:
La compattazione viene eseguita lato client negli helper `tool_runner` dell'SDK, quindi non ha un equivalente HTTP diretto. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic.
La CLI non include un helper `tool_runner`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic senza integrazione lato SDK.
Dalla v1.0 in poi, il tool runner dell'SDK Python non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: {
enabled: true,
contextTokenThreshold: 100000,
model: "claude-haiku-4-5"
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
L'SDK C# include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Go include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Java include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK PHP include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
model: "claude-haiku-4-5"
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
#### Prompt di riepilogo personalizzati
Puoi fornire un prompt personalizzato per esigenze specifiche del dominio. Il tuo prompt dovrebbe istruire Claude a racchiudere il suo riepilogo nei tag ``.
La compattazione viene eseguita lato client negli helper `tool_runner` dell'SDK, quindi non ha un equivalente HTTP diretto. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic.
La CLI non include un helper `tool_runner`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic senza integrazione lato SDK.
Dalla v1.0 in poi, il tool runner dell'SDK Python non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: {
enabled: true,
contextTokenThreshold: 100000,
summaryPrompt: `Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps
Wrap your summary in tags.`
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
L'SDK C# include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Go include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK Java include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
L'SDK PHP include un tool runner, ma non supporta `compaction_control` lato client. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold): funziona con il tool runner passando la modifica `compact_20260112` nel parametro `context_management` della richiesta.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
summary_prompt: <<~PROMPT
Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps
Wrap your summary in tags.
PROMPT
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
### Prompt di riepilogo predefinito
Il prompt di riepilogo integrato istruisce Claude a creare un riepilogo strutturato di continuazione che include:
1. **Panoramica dell'attività:** La richiesta principale dell'utente, i criteri di successo e i vincoli.
2. **Stato attuale:** Cosa è stato completato, i file modificati e gli artefatti prodotti.
3. **Scoperte importanti:** Vincoli tecnici, decisioni prese, errori risolti e approcci falliti.
4. **Prossimi passi:** Azioni specifiche necessarie, blocchi e ordine di priorità.
5. **Contesto da preservare:** Preferenze dell'utente, dettagli specifici del dominio e impegni presi.
Questa struttura consente a Claude di riprendere il lavoro in modo efficiente senza perdere contesto importante o ripetere errori.
```text wrap
You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:
1. Task Overview
The user's core request and success criteria
Any clarifications or constraints they specified
2. Current State
What has been completed so far
Files created, modified, or analyzed (with paths if relevant)
Key outputs or artifacts produced
3. Important Discoveries
Technical constraints or requirements uncovered
Decisions made and their rationale
Errors encountered and how they were resolved
What approaches were tried that didn't work (and why)
4. Next Steps
Specific actions needed to complete the task
Any blockers or open questions to resolve
Priority order if multiple steps remain
5. Context to Preserve
User preferences or style requirements
Domain-specific details that aren't obvious
Any promises made to the user
Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
Wrap your summary in tags.
```
### Limitazioni
#### Strumenti lato server
La compattazione richiede particolare attenzione quando si usano strumenti lato server come la [ricerca web](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-search-tool) o il [web fetch](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool).
Quando si usano strumenti lato server, l'SDK potrebbe calcolare in modo errato l'utilizzo dei token, causando l'attivazione della compattazione nel momento sbagliato.
Ad esempio, dopo un'operazione di ricerca web, la risposta dell'API potrebbe mostrare:
```json Output
{
"usage": {
"input_tokens": 63000,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 270000,
"output_tokens": 1400
}
}
```
L'SDK calcola l'utilizzo totale come 63.000 + 0 + 270.000 + 1.400 = 334.400 token. Tuttavia, il valore `cache_read_input_tokens` include le letture accumulate da più chiamate API interne effettuate dallo strumento lato server, non il contesto effettivo della tua conversazione. La lunghezza reale del tuo contesto potrebbe essere solo i 63.000 `input_tokens`, ma l'SDK vede 334k e attiva la compattazione prematuramente.
**Soluzioni alternative:**
* Usa l'endpoint di [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting) per ottenere una lunghezza del contesto accurata
* Evita la compattazione quando usi ampiamente strumenti lato server
#### Casi limite dell'uso degli strumenti
Quando l'SDK attiva la compattazione mentre una risposta di uso degli strumenti è in sospeso, rimuove il blocco di uso dello strumento dalla cronologia dei messaggi prima di generare il riepilogo. Claude riemetterà la chiamata allo strumento dopo la ripresa dal riepilogo, se ancora necessaria.
### Monitoraggio della compattazione
Capire quando si attiva la compattazione ti aiuta a regolare le soglie e a verificare il comportamento previsto.
La compattazione viene eseguita lato client negli helper `tool_runner` dell'SDK, quindi non ha un equivalente HTTP diretto. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic.
La CLI non include un helper `tool_runner`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction), che gestisce la compattazione sui server di Anthropic senza integrazione lato SDK.
Nella v1.0 e successive, il tool runner dell'SDK Python non supporta `compaction_control`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction).
Il `toolRunner` dell'SDK TypeScript supporta la compattazione ma non registra eventi. Rileva la compattazione osservando la riduzione di `runner.params.messages.length` tra i turni:
```typescript TypeScript
let prevMsgCount = 0;
for await (const message of runner) {
const currMsgCount = runner.params.messages.length;
if (currMsgCount < prevMsgCount) {
console.log(`Compaction occurred: ${prevMsgCount} -> ${currMsgCount} messages`);
console.log(`Input tokens after compaction: ${message.usage.input_tokens}`);
}
prevMsgCount = currMsgCount;
}
```
Il tool runner dell'SDK C# non supporta `compaction_control`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction).
Il tool runner dell'SDK Go non supporta `compaction_control`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction).
Il tool runner dell'SDK Java non supporta `compaction_control`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction).
Il tool runner dell'SDK PHP non supporta `compaction_control`. Usa invece la [compattazione lato server](https://platform.claude.com/docs/it/build-with-claude/compaction).
L'SDK Ruby supporta una callback `on_compact:` che viene attivata quando avviene la compattazione. Aggiungila alla tua configurazione `compaction_control`:
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
on_compact: ->(tokens_before, tokens_after) do
puts "Compaction occurred: #{tokens_before} -> #{tokens_after} tokens"
end
}
)
runner.each_message do |message|
puts "Tokens: #{message.usage.input_tokens}"
end
```
### Quando usare la compattazione
**Casi d'uso adatti:**
* Attività di agenti di lunga durata che elaborano molti file o fonti di dati
* Flussi di lavoro di ricerca che accumulano grandi quantità di informazioni
* Attività in più fasi con progressi chiari e misurabili
* Attività che producono artefatti (file, report) che persistono al di fuori della conversazione
**Casi d'uso meno ideali:**
* Attività che richiedono un richiamo preciso dei dettagli iniziali della conversazione
* Flussi di lavoro che usano ampiamente strumenti lato server
* Attività che devono mantenere uno stato esatto su molte variabili
## Prossimi passi
Gestisci conversazioni lunghe con la compattazione lato server, la strategia consigliata per la maggior parte dei casi d'uso.
Riduci costi e latenza memorizzando nella cache i prefissi dei prompt e scopri come la modifica del contesto interagisce con la cache.