Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# API Messages di Anthropic Claude
Questa sezione fornisce parametri di inferenza ed esempi di codice per l’utilizzo dell’API Messages di Anthropic Claude.
**Topics**
+ [Panoramica dell’API Messages di Anthropic Claude](#model-parameters-anthropic-claude-messages-overview)
+ [Utilizzo degli strumenti](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Pensiero esteso](claude-messages-extended-thinking.md)
+ [Pensiero adattivo](claude-messages-adaptive-thinking.md)
+ [Crittografia Thinking](claude-messages-thinking-encryption.md)
+ [Differenze di pensiero tra le versioni del modello](claude-messages-thinking-differences.md)
+ [Compattazione](claude-messages-compaction.md)
+ [Ottieni risultati JSON convalidati dai modelli](claude-messages-structured-outputs.md)
+ [Richiesta e risposta](model-parameters-anthropic-claude-messages-request-response.md)
+ [Esempi di codice](api-inference-examples-claude-messages-code-examples.md)
+ [Modelli supportati](claude-messages-supported-models.md)
## Panoramica dell’API Messages di Anthropic Claude
Puoi utilizzare l’API Messages per creare chatbot o applicazioni di assistente virtuale. L’API gestisce gli scambi conversazionali tra l’utente e un modello Anthropic Claude (assistente).
**Nota**
Questo argomento mostra come utilizzare l'API dei Anthropic Claude messaggi con le operazioni di inferenza di base ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)or [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). Tuttavia, ti consigliamo di utilizzare l’API Converse per implementare i messaggi nell’applicazione. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consulta [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
Le restrizioni si applicano alle seguenti operazioni:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, e`ConverseStream`. Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
I modelli Claude sono addestrati da Anthropic in modo da operare su turni di conversazione alternati tra utente e assistente. Quando crei un nuovo messaggio, i turni di conversazione precedenti vengono specificati con il parametro messages. Il modello genera quindi il messaggio successivo nella conversazione.
Ogni messaggio di input deve essere un oggetto con un ruolo e un contenuto. È possibile specificare un singolo messaggio con il ruolo di utente oppure includere più messaggi con i ruoli di utente e assistente.
Se stai utilizzando la tecnica di precompilazione della risposta da Claude (inserendo l’inizio della risposta di Claude utilizzando un messaggio finale con ruolo di assistente), Claude risponde riprendendo da dove avevi interrotto. Con questa tecnica, Claude restituisce comunque una risposta con il ruolo di assistente.
Se il messaggio finale utilizza il ruolo di assistente, il contenuto della risposta riprende immediatamente dal contenuto di tale messaggio. Puoi utilizzarlo per vincolare parte della risposta del modello.
Esempio con un singolo messaggio utente:
```
[{"role": "user", "content": "Hello, Claude"}]
```
Esempio con più turni di conversazione:
```
[
{"role": "user", "content": "Hello there."},
{"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
{"role": "user", "content": "Can you explain LLMs in plain English?"},
]
```
Esempio con una risposta parzialmente compilata da Claude:
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
Il contenuto di ogni messaggio di input può essere una singola stringa o un array di blocchi di contenuto, in cui ogni blocco ha un tipo specifico. Utilizzare una stringa è una scorciatoia per un array di un solo blocco di contenuto di tipo “text”. I seguenti messaggi di input sono equivalenti:
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Per informazioni sulla creazione di prompt per i modelli Anthropic Claude, consulta [Panoramica dell’ingegneria dei prompt](https://docs.anthropic.com/claude/docs/intro-to-prompting) nella documentazione di Anthropic Claude. Se disponi già di prompt di [Text Completions](model-parameters-anthropic-claude-text-completion.md) che vuoi migrare all’API Messages, consulta [Lavorare con l’API Messages](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**Importante**
Il periodo di timeout per le chiamate di inferenza ad Anthropic Claude 3.7 Sonnet e Claude 4 è 60 minuti. Per impostazione predefinita, i client AWS SDK scadono dopo 1 minuto. Ti consigliamo di aumentare il periodo di timeout di lettura del tuo client AWS SDK ad almeno 60 minuti. Ad esempio, per l’ AWS SDK per Python botocore, modifica il valore del campo `read_timeout` in [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) ad almeno 3.600.
### Prompt di sistema
Puoi anche includere un prompt di sistema nella richiesta. Un prompt di sistema ti permette di fornire contesto e istruzioni ad Anthropic Claude, ad esempio specificare un obiettivo o un ruolo particolare. Specifica un prompt di sistema nel campo `system`, come mostrato nell’esempio seguente.
```
"system": "You are Claude, an AI assistant created by Anthropic to be helpful,
harmless, and honest. Your goal is to provide informative and substantive responses
to queries while avoiding potential harms."
```
Per ulteriori informazioni, consulta [Dare un ruolo a Claude con un system prompt](https://docs.anthropic.com/en/docs/system-prompts) nella documentazione di Anthropic.
### Prompt multimodali
Un prompt multimodale combina più modalità (immagini e testo) in un unico prompt. Le modalità vengono specificate nel campo di input `content`. L’esempio seguente mostra come si potrebbe chiedere ad Anthropic Claude di descrivere il contenuto di un’immagine fornita. Per il codice di esempio, consulta [Esempi di codice multimodale](api-inference-examples-claude-messages-code-examples.md#api-inference-examples-claude-multimodal-code-example).
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw..."
}
},
{
"type": "text",
"text": "What's in these images?"
}
]
}
]
}
```
Ogni immagine che includi in una richiesta viene conteggiata ai fini dell’utilizzo dei token. Per ulteriori informazioni, consulta [Calcola i costi delle immagini](https://docs.anthropic.com/claude/docs/vision#image-costs) nella documentazione di Anthropic.
# Utilizzo degli strumenti
**avvertimento**
Come indicato, molte delle funzioni che seguono sono disponibili in versione beta. Queste funzionalità sono rese disponibili all'utente come «Servizio Beta», come definito nei Termini AWS di servizio. È soggetto al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello di EULA applicabile.
Con i modelli Anthropic Claude, è possibile specificare uno strumento che il modello può utilizzare per rispondere a un messaggio. Ad esempio, è possibile specificare uno strumento che riproduca il brano più popolare su una stazione radio. Se l’utente trasmette il messaggio *Qual è il brano più popolare su WZPZ?*, il modello determina che lo strumento specificato può aiutare a rispondere alla domanda. Nella sua risposta, il modello richiede l’esecuzione dello strumento per suo conto. Quindi esegui lo strumento e passa il risultato dello strumento al modello, che a sua volta genera una risposta per il messaggio originale. Per ulteriori informazioni, consulta [Utilizzo dello strumento (chiamata della funzione)](https://docs.anthropic.com/en/docs/tool-use) nella documentazione Anthropic Claude.
**Suggerimento**
È consigliabile utilizzare l’API Converse per integrare l’utilizzo dello strumento nella propria applicazione. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
**Importante**
Claude Sonnet 4.5 ora conserva la formattazione intenzionale nei parametri delle stringhe di chiamata dello strumento. In precedenza, le nuove righe finali nei parametri delle stringhe venivano talvolta rimosse erroneamente. Questa correzione garantisce che gli strumenti che richiedono una formattazione precisa (come gli editor di testo) ricevano i parametri esattamente come previsto. Si tratta di un behind-the-scenes miglioramento che non richiede modifiche all'API. Tuttavia, gli strumenti con parametri di stringa possono ora ricevere valori con nuove righe finali che in precedenza erano state rimosse.
**Nota**
Claude Sonnet 4.5 include ottimizzazioni automatiche per migliorare le prestazioni del modello. Queste ottimizzazioni possono aggiungere piccole quantità di token alle richieste, ma questi token aggiunti dal sistema non vengono fatturati.
Puoi specificare gli strumenti che vuoi rendere disponibili per un modello nel campo `tools`. L’esempio seguente è per uno strumento che riproduce i brani più popolari su una stazione radio.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"input_schema": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
]
```
Quando il modello necessita di uno strumento per generare una risposta a un messaggio, restituisce le informazioni sullo strumento richiesto e l’input allo strumento nel campo `content` del messaggio. Imposta inoltre il motivo dell’arresto della risposta a `tool_use`.
```
{
"id": "msg_bdrk_01USsY5m3XRUF4FCppHP8KBx",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"stop_sequence": null,
"usage": {
"input_tokens": 375,
"output_tokens": 36
},
"content": [
{
"type": "tool_use",
"id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"name": "top_song",
"input": {
"sign": "WZPZ"
}
}
],
"stop_reason": "tool_use"
}
```
Nel codice, chiami lo strumento per conto degli strumenti. Quindi passa lo strumento result (`tool_result`) in un messaggio utente al modello.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
Nella sua risposta, il modello utilizza il risultato dello strumento per generare una risposta per il messaggio originale.
```
{
"id": "msg_bdrk_012AaqvTiKuUSc6WadhUkDLP",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"content": [
{
"type": "text",
"text": "According to the tool, the most popular song played on radio station WZPZ is \"Elemental Hotel\"."
}
],
"stop_reason": "end_turn"
}
```
## Streaming granulare degli strumenti
Lo streaming granulare degli strumenti è una funzionalità del modello Anthropic Claude disponibile con Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 e Claude Opus 4. Con lo streaming granulare degli strumenti, gli sviluppatori Claude possono trasmettere in streaming i parametri di utilizzo degli strumenti senza buffering o convalida JSON, riducendo la latenza necessaria per iniziare a ricevere parametri di grandi dimensioni.
**Nota**
Quando si utilizza lo streaming granulare degli strumenti, è possibile ricevere input JSON non validi o parziali. Assicurati di tenere conto di questi casi edge nel tuo codice.
Per utilizzare questa funzionalità, è sufficiente aggiungere l’intestazione `fine-grained-tool-streaming-2025-05-14` a una richiesta di utilizzo dello strumento.
Ecco un esempio di come specificare l’intestazione di streaming granulare dello strumento:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"anthropic_beta": ["fine-grained-tool-streaming-2025-05-14"],
"messages": [
{
"role": "user",
"content": "Can you write a long poem and make a file called poem.txt?"
}
],
"tools": [
{
"name": "make_file",
"description": "Write text to a file",
"input_schema": {
"type": "object",
"properties": {
"filename": {
"type": "string",
"description": "The filename to write text to"
},
"lines_of_text": {
"type": "array",
"description": "An array of lines of text to write to the file"
}
},
"required": [
"filename",
"lines_of_text"
]
}
}
]
}
```
In questo esempio, lo streaming granulare dello strumento consente a Claude di trasmettere le righe di una lunga poesia nella chiamata allo strumento `make_file` senza buffering per verificare se il parametro `lines_of_text` è JSON valido. Ciò significa che è possibile visualizzare il flusso di parametri non appena arriva, senza dover attendere che l’intero parametro venga memorizzato nel buffer e convalidato.
Con lo streaming granulare dello strumento, i blocchi di utilizzo dello strumento iniziano a trasmettere più velocemente, sono spesso più lunghi e contengono meno interruzioni di parole. Ciò è dovuto alle differenze nel comportamento della suddivisione in blocchi.
Ad esempio, senza streaming granulare (ritardo di 15 secondi):
```
Chunk 1: '{"'
Chunk 2: 'query": "Ty'
Chunk 3: 'peScri'
Chunk 4: 'pt 5.0 5.1 '
Chunk 5: '5.2 5'
Chunk 6: '.3'
Chunk 8: ' new f'
Chunk 9: 'eatur'
...
```
Con streaming granulare (ritardo di 3 secondi):
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**Nota**
Poiché lo streaming granulare invia i parametri senza buffering o convalida JSON, non è garantito che lo streaming risultante venga completato in una stringa JSON valida. In particolare, se viene raggiunto il motivo dell’arresto `max_tokens`, lo streaming potrebbe terminare a metà di un parametro e risultare incompleto. In genere è necessario scrivere un supporto specifico da gestire quando `max_tokens` viene raggiunto.
## Utilizzo del computer (Beta)
L’utilizzo del computer è una funzionalità del modello Anthropic Claude (in versione beta) disponibile con Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 e Claude Opus 4. Con l’utilizzo del computer, Claude può aiutarti ad automatizzare le attività tramite azioni GUI di base.
**avvertimento**
La funzionalità di utilizzo del computer è resa disponibile all'utente come «Servizio beta», come definito nei Termini di AWS servizio. È soggetta al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello di EULA applicabile. Tieni presente che l’API per l’utilizzo del computer comporta rischi unici che sono diversi dalle funzionalità API standard o dalle interfacce di chat. Questi rischi aumentano quando si utilizza l’API per l’utilizzo del compute per interagire con Internet. Per ridurre al minimo i rischi, prendi delle precauzioni come:
Esegui la funzionalità di utilizzo del computer in una macchina virtuale o in un container dedicato con privilegi minimi per prevenire attacchi diretti al sistema o incidenti.
Per prevenire il furto di informazioni, evita di concedere all’API di utilizzo del computer l’accesso ad account o dati sensibili.
Limitazione dell'uso dell'accesso a APIs Internet da parte del computer ai domini richiesti per ridurre l'esposizione a contenuti dannosi.
Per garantire un’adeguata supervisione, mantieni un intervento di tipo HITL per le attività sensibili (come prendere decisioni che potrebbero avere conseguenze significative nel mondo reale) e per qualsiasi attività che richieda un consenso esplicito (come accettare i cookie, eseguire transazioni finanziarie o accettare i termini di servizio).
Qualsiasi contenuto reso disponibile a Claude per la visualizzazione o l’accesso può interferire con le istruzioni, causando errori o l’esecuzione di azioni indesiderate da parte di Claude. Adottare le dovute precauzioni, ad esempio isolare Claude dalle superfici sensibili, è essenziale, anche per evitare i rischi legati all’iniezione di prompt tempestiva. Prima di abilitare o richiedere le autorizzazioni necessarie per attivare le funzionalità di utilizzo del computer nei tuoi prodotti, informa gli utenti finali di eventuali rischi pertinenti e ottieni il loro consenso, se appropriato.
L’API per l’utilizzo del computer mette a disposizione diversi strumenti predefiniti di utilizzo del computer. Puoi quindi creare un prompt con la tua richiesta, ad esempio “invia un’e-mail a Ben con le note della mia ultima riunione” e uno screenshot (quando richiesto). La risposta contiene un elenco di azioni `tool_use` in formato JSON (ad esempio, scroll\$1down, left\$1button\$1press, screenshot). Il codice esegue le azioni del computer e fornisce a Claude schermate che mostrano gli output (quando richiesto).
Dalla versione Claude 3.5 v2, il parametro tools è stato aggiornato per accettare tipi di strumenti polimorfici; è stata aggiunta una proprietà `tool.type` per distinguerli. `type` è opzionale; se omesso, si presume che lo strumento sia uno strumento personalizzato (in precedenza era l’unico tipo di strumento supportato). Per accedere all’utilizzo del computer, è necessario utilizzare il parametro `anthropic_beta`, con un enum corrispondente, il cui valore dipende dalla versione del modello in uso. Per ulteriori informazioni, consulta la tabella seguente.
Solo le richieste effettuate con questo parametro ed enum possono utilizzare gli strumenti di utilizzo del computer. È possibile specificare quanto segue: `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modello | Intestazione Beta |
| --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet | computer-use-2025-01-24 |
| Claude 3.5 Sonnet v2 | computer-use-2024-10-22 |
Per ulteriori informazioni, consulta [Utilizzo del computer (beta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) nella documentazione di Anthropic.
Di seguito è riportato un esempio di risposta che presuppone che la richiesta contenga uno screenshot del desktop con l’icona di Firefox.
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"content": [
{
"type": "text",
"text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
},
{
"type": "tool_use",
"id": "toolu_123",
"name": "computer",
"input": {
"action": "mouse_move",
"coordinate": [
708,
736
]
}
},
{
"type": "tool_use",
"id": "toolu_234",
"name": "computer",
"input": {
"action": "left_click"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 3391,
"output_tokens": 132
}
}
```
## Strumenti Anthropic definiti
Anthropic fornisce una serie di strumenti per consentire a determinati modelli Claude di utilizzare efficacemente i computer. Quando si specifica uno strumento Anthropic definito, i campi `description` e `tool_schema` non sono necessari o consentiti. Gli strumenti definiti Anthropic sono definiti da Anthropic, ma è necessario valutare esplicitamente i risultati dello strumento e restituire `tool_results` a Claude. Come con qualsiasi strumento, il modello non esegue automaticamente lo strumento. Ogni strumento Anthropic definito ha versioni ottimizzate per modelli Claude 3.5 Sonnet (nuovi) e Claude 3.7 Sonnet specifici:
| Modello | Strumento | Note |
| --- | --- | --- |
| ClaudeClaude Opus4.1 ClaudeClaude Opus4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 | {
"type": "text_editor_20250124",
"name": "str_replace_based_edit_tool"
} | Aggiornamento allo strumento `str_replace_editor` esistente |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Include nuove azioni per un controllo più preciso |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Stesse funzionalità della versione 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Stesse funzionalità della versione 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "text_editor_20241022",
"name": "str_replace_editor"
} |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20241022",
"name": "bash"
} |
| Claude 3.5 Sonnet v2 | {
"type": "computer_20241022",
"name": "computer"
} |
Il campo `type` identifica lo strumento e i suoi parametri a fini di convalida, il campo `name` è il nome dello strumento esposto al modello.
Per richiedere l’utilizzo di uno degli strumenti da parte del modello, è possibile fare riferimento esplicito al relativo campo `name`. Il campo `name` deve essere univoco all’interno dell’elenco degli strumenti; non è possibile definire uno strumento con lo stesso `name` come uno strumento Anthropic definito nella stessa chiamata API.
## Cancellazione automatica delle chiamate allo strumento (Beta)
**avvertimento**
La cancellazione automatica delle chiamate agli strumenti è disponibile come «Servizio Beta», come definito nei Termini di AWS servizio.
**Nota**
Questa funzionalità è attualmente supportata su Claude Sonnet 4/4.5, Claude Haiku 4.5 e Claude Opus 4/4.1/4.5.
La cancellazione automatica delle chiamate agli strumenti è una funzionalità del modello Anthropic Claude (in versione beta). Con questa funzionalità, Claude può cancellare automaticamente i vecchi risultati di utilizzo degli strumenti man mano che si avvicinano i limiti dei token, consentendo una gestione più efficiente del contesto in scenari di utilizzo di utensili a più turni. Per utilizzare la funzionalità di cancellazione delle chiamate agli strumenti, devi aggiungere `context-management-2025-06-27` all’elenco delle intestazioni beta il parametro di richiesta anthropic\$1beta. Dovrete inoltre specificare l'uso `clear_tool_uses_20250919` e scegliere tra le seguenti opzioni di configurazione.
Questi sono i controlli disponibili per la strategia di gestione del contesto `clear_tool_uses_20250919`. Sono tutti opzionali o hanno dei valori predefiniti:
| **Opzione di configurazione** | **Descrizione** |
| --- | --- |
| `trigger` impostazione predefinita: 100.000 token di input | Definisce quando si attiva la strategia di modifica del contesto. Una volta che il prompt supera questa soglia, inizierà la cancellazione. Puoi specificare questo valore in input\$1tokens o tool\$1uses. |
| `keep` impostazione predefinita: 3 utilizzi dello strumento | Definisce quante use/result coppie di utensili recenti conservare dopo la cancellazione. L’API rimuove per prime le interazioni con gli strumenti più vecchie, preservando quelle più recenti. Utile quando il modello ha bisogno di accedere alle interazioni recenti con gli strumenti per continuare la conversazione in modo efficace. |
| `clear_at_least` (facoltativo) | Assicura che venga eliminato un numero minimo di token ogni volta che la strategia si attiva. Se l’API non riesce a cancellare almeno l’importo specificato, la strategia non verrà applicata. Ciò è utile per determinare se vale la pena interrompere la cache dei prompt per la cancellazione del contesto. |
| `exclude_tools` (facoltativo) | Elenco dei nomi degli strumenti i cui usi e risultati non devono mai essere cancellati. Utile per preservare un contesto importante. |
| `clear_tool_inputs` (False per impostazione predefinita, opzionale). | Controlla se i parametri di chiamata dello strumento vengono cancellati insieme ai risultati dello strumento. Per impostazione predefinita, vengono cancellati solo i risultati degli strumenti mantenendo visibili le chiamate agli strumenti originali di Claude, in modo che Claude possa vedere quali operazioni sono state eseguite anche dopo la rimozione dei risultati. |
**Nota**
La cancellazione degli strumenti invaliderà la cache se i prefissi contengono gli strumenti.
------
#### [ Request ]
```
response = client.beta.messages.create(
betas=["context-management-2025-06-27"],
model="claude-sonnet-4-20250514",
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
}
],
extra_body={
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
# The below parameters are OPTIONAL:
# Trigger clearing when threshold is exceeded
"trigger": {
"type": "input_tokens",
"value": 30000
},
# Number of tool uses to keep after clearing
"keep": {
"type": "tool_uses",
"value": 3
},
# Optional: Clear at least this many tokens
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
# Exclude these tools uses from being cleared
"exclude_tools": ["web_search"]
}
]
}
}
)
```
------
#### [ Response ]
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_456",
"name": "data_analyzer",
"input": {
"data": "sample data"
}
}
],
"context_management": {
"applied_edits": [
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8, # Number of tool use/result pairs that were cleared
"cleared_input_tokens": 50000 # Total number of input tokens removed from the prompt
}
]
}
"stop_reason": "tool_use",
"usage": {
"input_tokens": 150,
"output_tokens": 50
}
}
```
------
#### [ Streaming Response ]
```
data: {"type": "message_start", "message": {"id": "msg_123", "type": "message", "role": "assistant"}}
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "tool_use", "id": "toolu_456", "name": "data_analyzer", "input": {}}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": "{\"data\": \"sample"}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": " data\"}"}}
data: {"type": "content_block_stop", "index": 0}
data: {"type": "message_delta", "delta": {"stop_reason": "tool_use"}}
data: {"type": "message_stop"}
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null,
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [...],
}
}
```
------
**Nota**
Attualmente Bedrock non supporta la gestione del `clear_tool_uses_20250919` contesto sull' CountTokens API.
## Strumento di memoria (Beta)
**avvertimento**
Memory Tool è disponibile come «Servizio Beta» come definito nei Termini di AWS servizio.
Claude Sonnet 4.5 include un nuovo strumento di memoria che offre ai clienti un modo per gestire la memoria tra le conversazioni. Con questa funzionalità, i clienti possono consentire a Claude di recuperare informazioni al di fuori della finestra contestuale fornendo l’accesso a una directory locale. Questa funzionalità sarà disponibile come funzionalità beta. Per utilizzare questa funzionalità, è necessario utilizzare l’intestazione `context-management-2025-06-27` beta.
Definizione dello strumento:
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Richiesta di esempio:
```
{
"max_tokens": 2048,
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["context-management-2025-06-27"],
"tools": [{
"type": "memory_20250818",
"name": "memory"
}],
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Remember that my favorite color is blue and I work at Amazon?"}]
}
]
}
```
Risposta di esempio:
```
{
"id": "msg_vrtx_014mQ5ficCRB6PEa5k5sKqHd",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-20250514",
"content": [
{
"type": "text",
"text": "I'll start by checking your memory directory and then record this important information about you."
},
{
"type": "tool_use",
"id": "toolu_vrtx_01EU1UrCDigyPMRntr3VYvUB",
"name": "memory",
"input": {
"command": "view",
"path": "/memories"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 1403,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"output_tokens": 87
},
"context_management": {
"applied_edits": []
}
}
```
## Considerazioni sui costi per l’uso dello strumento
I prezzi delle richieste di utilizzo degli strumenti sono basati sui seguenti fattori:
1. Il numero totale di token di input inviati al modello (incluso nel parametro tools).
1. Il numero di token di output generati.
Gli strumenti hanno lo stesso prezzo di tutte le altre richieste API Claude, ma includono token aggiuntivi per richiesta. I token aggiuntivi derivanti dall’utilizzo degli strumenti provengono:
+ Dal parametro `tools` nelle richieste dell’API. Ad esempio, nomi, descrizioni e schemi degli strumenti.
+ Eventuali blocchi di contenuto `tool_use` nelle richieste e nelle risposte API.
+ Eventuali blocchi di contenuto `tool_result` nelle richieste API.
Quando si utilizzano gli strumenti, i modelli Anthropic includono automaticamente uno speciale prompt di sistema che consente l’utilizzo dello strumento. Il numero di token per l’utilizzo dello strumento richiesti per ogni modello è elencato nella tabella seguente. Questa tabella esclude i token aggiuntivi descritti in precedenza. Tieni presente che questa tabella presuppone che venga fornito almeno uno strumento. Se non vengono forniti strumenti, allora la scelta dello strumento “none” utilizza 0 token aggiuntivi nel prompt di sistema.
| Modello | Scelta dello strumento | Numero di token del prompt del sistema di utilizzo dello strumento |
| --- | --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | auto o none | 346 |
| Claude Opus4,5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | any o tool | 313 |
| Claude 3.5 Sonnet | auto o none | 294 |
| Claude 3.5 Sonnet | any o tool | 261 |
| Claude 3 Opus | auto o none | 530 |
| Claude 3 Opus | any o tool | 281 |
| Claude 3 Sonnet | auto o none | 159 |
| Claude 3 Sonnet | any o tool | 235 |
| Claude 3 Haiku | auto o none | 264 |
| Claude 3 Haiku | any o tool | 340 |
## Strumento di ricerca degli strumenti (beta)
Tool Search Tool Claude consente di lavorare con centinaia o addirittura migliaia di strumenti senza caricare in anticipo tutte le loro definizioni nella finestra contestuale. Invece di dichiarare immediatamente tutti gli strumenti, è possibile contrassegnarli con`defer_loading: true`, e Claude trovare e caricare solo gli strumenti necessari attraverso il meccanismo di ricerca degli strumenti.
Per accedere a questa funzionalità è necessario utilizzare l'`tool-search-tool-2025-10-19`intestazione beta. Tieni presente che questa funzionalità è attualmente disponibile solo tramite [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) APIs.
Definizione dello strumento:
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Esempio di richiesta:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"tool-search-tool-2025-10-19"
],
"max_tokens": 4096,
"tools": [{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_files",
"description": "Search through files in the workspace",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string"
},
"file_types": {
"type": "array",
"items": {
"type": "string"
}
}
},
"required": ["query"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather in Seattle?"
}]
}
```
Esempio di risposta
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with this task."
},
{
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex",
"input": {
"pattern": "weather"
}
},
{
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
},
{
"type": "text",
"text": "Now I can check the weather."
},
{
"type": "tool_use",
"id": "toolu_01XYZ789",
"name": "get_weather",
"input": {
"location": "Seattle",
"unit": "fahrenheit"
}
}
],
"stop_reason": "tool_use"
}
```
Esempio di streaming
```
# Event 1: content_block_start(with complete server_tool_use block) {
"type": "content_block_start",
"index": 0,
"content_block": {
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex"
}
}
# Event 2: content_block_delta(input JSON streamed) {
"type": "content_block_delta",
"index": 0,
"delta": {
"type": "input_json_delta",
"partial_json": "{\"regex\": \".*weather.*\"}"
}
}
# Event 3: content_block_stop(tool_use complete) {
"type": "content_block_stop",
"index": 0
}
# Event 4: content_block_start(COMPLETE result in single chunk) {
"type": "content_block_start",
"index": 1,
"content_block": {
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}
}
# Event 5: content_block_stop(result complete) {
"type": "content_block_stop",
"index": 1
}
```
**Strumenti di ricerca personalizzati**
È possibile implementare strumenti di ricerca di strumenti personalizzati (ad esempio, utilizzando gli incorporamenti) definendo uno strumento che restituisca `tool_reference` i blocchi. Lo strumento personalizzato deve avere `defer_loading: false` mentre altri strumenti dovrebbero avere`defer_loading: true`. Quando definite il vostro strumento di ricerca strumenti, questo dovrebbe restituire un risultato contenente blocchi di `tool_reference` contenuto che rimandano agli strumenti che desiderate Claude utilizzare.
Il formato di risposta ai risultati di Tool Search Tool previsto dal cliente:
```
{
"type": "tool_result",
"tool_use_id": "toolu_01ABC123",
"content": [{
"type": "tool_reference",
"tool_name": "get_weather"
},
{
"type": "tool_reference",
"tool_name": "weather_forecast"
}
]
}
```
`tool_name`Deve corrispondere a uno strumento definito nella richiesta con. `defer_loading: true` Claude avrà quindi accesso agli schemi completi di quegli strumenti.
**Strumenti di ricerca personalizzati - Esempio dettagliato**
È possibile implementare strumenti di ricerca di strumenti personalizzati (ad esempio, utilizzando incorporamenti o ricerca semantica) definendo uno strumento che `tool_reference` restituisca blocchi. Ciò consente sofisticati meccanismi di scoperta degli strumenti oltre alla corrispondenza con espressioni regolari.
Esempio di richiesta con TST personalizzato:
```
{
"model": "claude-sonnet-4-5-20250929",
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["tool-search-tool-2025-10-19"],
"max_tokens": 4096,
"tools": [{
"name": "semantic_tool_search",
"description": "Search for available tools using semantic similarity. Returns the most relevant tools for the given query.",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Natural language description of what kind of tool is needed"
},
"top_k": {
"type": "integer",
"description": "Number of tools to return (default: 5)"
}
},
"required": ["query"]
},
"defer_loading": false
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_flights",
"description": "Search for available flights between locations",
"input_schema": {
"type": "object",
"properties": {
"origin": {
"type": "string"
},
"destination": {
"type": "string"
},
"date": {
"type": "string"
}
},
"required": ["origin", "destination", "date"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather forecast in Seattle for the next 3 days?"
}]
}
```
Clauderisposta (chiamata al TST personalizzato):
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with weather information."
},
{
"type": "tool_use",
"id": "toolu_01ABC123",
"name": "semantic_tool_search",
"input": {
"query": "weather forecast multiple days",
"top_k": 3
}
}
],
"stop_reason": "tool_use"
}
```
**risultato dell'utensile fornito dal cliente**
Dopo aver eseguito la ricerca semantica nella libreria degli strumenti, il cliente restituisce i riferimenti agli strumenti corrispondenti:
```
{
"role": "user",
"content": [{
"type": "tool_search_tool_result",
"tool_use_id": "toolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}]
}
```
Claudeil follow-up (utilizzando lo strumento scoperto)
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I found the forecast tool. Let me get the weather forecast for Seattle."
},
{
"type": "tool_use",
"id": "toolu_01DEF456",
"name": "get_weather",
"input": {
"location": "Seattle, WA"
}
}
],
"stop_reason": "tool_use"
}
```
**Gestione degli errori**
+ L'impostazione `defer_loading: true` per tutti gli strumenti (incluso lo strumento di ricerca degli strumenti) genererà un errore 400.
+ Il passaggio di una definizione di utensile `tool_reference` senza una definizione di utensile corrispondente genererà un errore 400
## Esempi di utilizzo degli strumenti (beta)
Claude Opus4.5 supporta esempi forniti dall'utente nelle definizioni degli strumenti per aumentare le prestazioni Claude di utilizzo degli strumenti. È possibile fornire esempi come chiamate di funzioni complete, formattate esattamente come sarebbero i veri output LLM, senza bisogno di traduzione in un altro formato. Per utilizzare questa funzionalità è necessario passare l'intestazione beta. `tool-examples-2025-10-29`
Esempio di definizione dello strumento:
```
{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["location"]
},
"input_examples": [{
"location": "San Francisco, CA",
"unit": "fahrenheit"
},
{
"location": "Tokyo, Japan",
"unit": "celsius"
},
{
"location": "New York, NY"
}
]
}
```
**Regole di convalida**
+ Conformità allo schema: ogni esempio in `input_examples` deve essere valido in base allo strumento. `input_schema`
+ I campi obbligatori devono essere presenti in almeno un esempio.
+ I tipi di campo devono corrispondere allo schema.
+ I valori Enum devono appartenere al set consentito.
+ Se la convalida fallisce, restituisci un errore 400 con dettagli sull'esempio di convalida non riuscita.
+ Requisiti dell'array: `input_examples` deve essere un array (può essere vuoto).
+ `[]`L'array vuoto è valido ed equivale a omettere il campo.
+ Un singolo esempio deve essere ancora racchiuso in un array: `[{...}]`
+ Limite di lunghezza: iniziate con un limite di 20 esempi per definizione di utensile.
Esempi di errore:
```
// Invalid: Example doesn't match schema (missing required field)
{
"type": "invalid_request_error",
"message": "Tool 'get_weather' input_examples[0] is invalid: Missing required property 'location'"
}
// Invalid: Example has wrong type for field
{
"type": "invalid_request_error",
"message": "Tool 'search_products' input_examples[1] is invalid: Property 'filters.price_range.min' must be a number, got string"
}
// Invalid: input_examples on server-side tool
{
"type": "invalid_request_error",
"message": "input_examples is not supported for server-side tool"
}
```
# Pensiero esteso
Il pensiero esteso offre capacità di ragionamento Claude avanzate per compiti complessi, garantendo al contempo diversi livelli di trasparenza nel processo di step-by-step pensiero prima di fornire la risposta definitiva. Ogni volta che si abilita la modalità pensiero di Claude, è necessario impostare un budget per il numero massimo di token che Claude può utilizzare per il processo di ragionamento interno.
I modelli supportati sono i seguenti:
| Modello | ID modello |
| --- | --- |
| Claude Opus4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
| Claude Opus 4 | `anthropic.claude-opus-4-20250514-v1:0` |
| Claude Sonnet 4 | `anthropic.claude-sonnet-4-20250514-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-sonnet-4-5-20250929-v1:0` |
| Claude Haiku 4.5 | `anthropic.claude-haiku-4-5-20251001-v1:0` |
| Claude 3.7 Sonnet | `anthropic.claude-3-7-sonnet-20250219-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
**Nota**
Il comportamento delle API differisce tra i modelli Claude 3.7 e Claude 4. Per ulteriori informazioni, consulta [Differenze di pensiero tra le versioni del modello](claude-messages-thinking-differences.md).
**Topics**
+ [Best practice e considerazioni sul pensiero esteso](#claude-messages-extended-thinking-bps)
+ [Funzionamento del pensiero esteso](#claude-messages-how-extended-thinking-works)
+ [Come utilizzare il pensiero esteso](#claude-messages-use-extended-thinking)
+ [Pensiero esteso con uso di strumenti](#claude-messages-extended-thinking-tool-use)
+ [Thinking block clearing (beta)](#claude-messages-thinking-block-clearing)
+ [Pensiero esteso con caching dei prompt](#claude-messages-extended-thinking-prompt-caching)
+ [Informazioni sul comportamento del caching dei blocchi di pensiero](#claude-messages-extended-thinking-caching-behavior)
+ [Numero massimo di token e dimensione della finestra contestuale nell’ambito del pensiero esteso](#claude-messages-extended-thinking-max-tokens)
+ [Considerazioni sul costo dei token di pensiero esteso](#claude-messages-extended-thinking-cost)
## Best practice e considerazioni sul pensiero esteso
Linee guida per l'utilizzo
+ **Selezione dei compiti**: usa il pensiero esteso per attività particolarmente complesse che traggono vantaggio da step-by-step ragionamenti come matematica, programmazione e analisi.
+ **Gestione del contesto**: non è necessario rimuovere i blocchi di pensiero precedenti. L’API Anthropic ignora automaticamente i blocchi di pensiero dei turni precedenti che non vengono inclusi nel calcolo dell’utilizzo del contesto.
+ **Progettazione dei prompt**: consulta [suggerimenti per il pensiero esteso](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) di Anthropic se desideri ottimizzare le capacità di pensiero di Claude.
Considerazioni sulle prestazioni
+ **Tempi di risposta**: preparati a tempi di risposta potenzialmente più lunghi a causa dell’elaborazione aggiuntiva richiesta per il processo di ragionamento. Tieni presente che la generazione di blocchi di pensiero potrebbe aumentare il tempo di risposta complessivo.
+ **Requisiti di streaming**: lo streaming è necessario quando `max_tokens` è maggiore di 21.333. Durante lo streaming, preparati a gestire entrambi i blocchi contenuto `thinking` e `text` non appena arrivano.
Compatibilità delle funzionalità
+ La funzionalità di pensiero non è compatibile con le modifiche `temperature`, `top_p` o `top_k` né con l’[uso forzato dello strumento](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ Non è possibile precompilare le risposte quando il pensiero è abilitato.
+ Le modifiche al budget di pensiero invalidano i prefissi dei prompt memorizzati nella cache che includono messaggi. Tuttavia, i prompt di sistema e le definizioni degli strumenti memorizzati nella cache continuano a funzionare quando i parametri del pensiero cambiano.
Utilizzo dei budget di pensiero
+ **Ottimizzazioni del budget**: il budget minimo è pari a 1.024 token. Anthropic consiglia di iniziare dal valore minimo e di aumentare il budget di pensiero in modo incrementale per trovare l’intervallo ottimale per il proprio caso d’uso. Un numero maggiore di token potrebbe consentire un ragionamento più completo e sfumato, ma potrebbe anche comportare un rendimento decrescente a seconda dell’attività. Il budget di pensiero è un obiettivo piuttosto che un limite rigoroso: l’utilizzo effettivo dei token può variare in base all’attività.
+ **Impostazioni minime e ottimali**: il budget minimo è pari a 1.024 token. Si consiglia di iniziare dal valore minimo e di aumentare il budget di pensiero in modo incrementale per trovare l’intervallo ottimale in modo che Claude sia in grado di offrire le prestazioni migliori per il caso d’uso specifico. Un numero maggiore di token potrebbe consentire l’elaborazione di un ragionamento più completo e sfumato, ma potrebbe anche comportare un rendimento decrescente a seconda dell’attività. Il budget di pensiero è un obiettivo piuttosto che un limite rigoroso: l’utilizzo effettivo dei token può variare in base all’attività.
+ **Sperimentazione**: il modello potrebbe funzionare in modo diverso a seconda delle impostazioni differenti per il budget di pensiero massimo. L’aumento del budget di pensiero massimo può indurre il modello a pensare meglio o più intensamente, a scapito di una maggiore latenza. Per le attività critiche, prendi in considerazione la possibilità di testare diverse impostazioni di budget per trovare l’equilibrio ottimale tra qualità e prestazioni.
+ **Budget elevati**: per budget di pensiero superiori a 32.000, si consiglia di utilizzare l’elaborazione in batch per evitare problemi di rete. Le richieste che spingono il modello a superare i 32.000 token causano richieste di lunga durata che potrebbero provocare timeout di sistema e limiti alle connessioni aperte. Tieni presente che i limiti `max_tokens` variano in base ai modelli Claude. Per ulteriori informazioni, consulta [Numero massimo di token e dimensione della finestra contestuale nell’ambito del pensiero esteso](#claude-messages-extended-thinking-max-tokens).
+ **Monitoraggio dell’utilizzo dei token**: monitora l’utilizzo dei token di pensiero per ottimizzare costi e prestazioni.
## Funzionamento del pensiero esteso
Quando la funzionalità di pensiero esteso è attivata, Claude crea blocchi di contenuto `thinking` in cui produce il suo ragionamento interno. Claude incorpora le informazioni derivanti da questo ragionamento prima di formulare una risposta finale. La risposta dell’API includerà blocchi di contenuto `thinking`, seguiti da blocchi di contenuto `text`.
Ecco un esempio del formato di risposta predefinito:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Per ulteriori informazioni sul formato di risposta del pensiero esteso, consulta [Richiesta e risposta](model-parameters-anthropic-claude-messages-request-response.md) dell’API Messages di Anthropic.
## Come utilizzare il pensiero esteso
Per attivare il pensiero esteso, aggiungi un oggetto `thinking`, con il parametro `thinking` impostato su enabled e il parametro `budget_tokens` impostato su un budget di token specificato per il pensiero esteso.
Il parametro `budget_tokens` determina il numero massimo di token che Claude può utilizzare per il processo di ragionamento interno. Nel modelli Claude 4, questo limite si applica ai token di pensiero completo e non all’output riepilogato. Budget maggiori possono migliorare la qualità della risposta, consentendo un’analisi più approfondita per problemi complessi, anche se Claude può non utilizzare l’intero budget allocato, soprattutto per intervalli superiori a 32.000.
Il valore di `budget_tokens` deve essere impostato su un valore inferiore a `max_tokens`. Tuttavia, quando si utilizza [Pensiero interlacciato (beta)](#claude-messages-extended-thinking-tool-use-interleaved) con gli strumenti, è possibile superare questo limite perché il limite di token diventa l’intera finestra di contesto (200.000 token).
### Pensiero riepilogativo
Con la funzionalità di pensiero esteso abilitata, l’API Messages per i modelli Claude 4 restituisce un riepilogo del processo di pensiero completo di Claude. Il pensiero riepilogativo offre tutti i vantaggi in termini di intelligenza del pensiero esteso, prevenendone al contempo l’uso improprio.
Di seguito sono riportate alcune considerazioni importanti per il pensiero riepilogativo:
+ Vengono addebitati i token di pensiero completo generati dalla richiesta originale, non i token per il riepilogo.
+ Il numero dei token di output fatturati non corrisponde al numero di token visualizzati nella risposta.
+ Il prompt fornito al modello di riepilogo è soggetto a modifiche.
+ Le prime righe dell’output di pensiero sono più dettagliate e forniscono un ragionamento minuzioso particolarmente utile per scopi di progettazione dei prompt.
**Nota**
Claude 3.7 Sonnet restituisce comunque l’output del pensiero completo.
Per accedere all’output del pensiero completo nei modelli Claude 4, contatta il team del tuo account.
### Pensiero in streaming
Puoi trasmettere in streaming risposte di pensiero estese tramite eventi inviati dal server. Quando lo streaming è abilitato per il pensiero esteso, ricevi contenuti di pensiero tramite eventi `thinking_delta`. Non è garantito che gli eventi trasmessi in streaming vengano restituiti a una velocità costante. Potrebbero infatti verificarsi ritardi tra gli eventi. Per ulteriori informazioni sullo streaming tramite l’API Messages, consulta [Streaming dei messaggi](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
Ecco come gestire lo streaming con Thinking utilizzando: **InvokeModelWithResponseStream**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Risposta:
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
**Informazioni sul comportamento dello streaming nell’ambito del pensiero**
Quando utilizzi lo streaming con thinking abilitato, potresti notare che il testo a volte arriva in blocchi più grandi alternati a messaggi di testo più piccoli. token-by-token Si tratta di un comportamento previsto, soprattutto per quanto riguarda i contenuti di pensiero. Per ottenere prestazioni ottimali, il sistema di streaming deve elaborare i contenuti in batch, che può comportare questo modello di distribuzione.
## Pensiero esteso con uso di strumenti
Il pensiero esteso può essere utilizzato insieme a [Utilizzo degli strumenti](model-parameters-anthropic-claude-messages-tool-use.md), permettendo a Claude di ragionare tramite la selezione degli strumenti e l’elaborazione dei risultati. Quando utilizzi il pensiero esteso con gli strumenti, tieni presente le limitazioni seguenti:
+ **Limitazione della scelta degli strumenti**: l’uso degli strumenti con il pensiero supporta solo `tool_choice: any`. Non è supporta la fornitura di uno strumento specifico, di `auto` o di altri valori.
+ **Conservazione dei blocchi di pensiero**: quando si utilizza lo strumento, è necessario restituire i blocchi di pensiero all’API per l’ultimo messaggio dell’assistente. Includi il blocco completo non modificato nell’API per mantenere la continuità del ragionamento.
Ecco come funziona la gestione delle finestre contestuali con gli strumenti:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
}
]
}
```
La prima risposta è la seguente:
```
{
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`...",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
},
{
"type": "text",
"text": "I can help you get the current weather information for Paris. Let me check that for you"
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
}
```
La continuazione della conversazione con l’uso degli strumenti genererà un’altra risposta. Si noti che vengono passati sia `thinking_block` sia `tool_use_block`. Se il passaggio non avviene, si verifica un errore.
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`…",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxY",
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"content": "Current temperature: 88°F"
}
]
}
]
}
```
La risposta dell’API ora include solo testo
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Conservazione dei blocchi di pensiero
Quando si utilizza lo strumento, è necessario restituire i blocchi di pensiero all’API e includere nuovamente il blocco completo non modificato nell’API. Ciò è fondamentale per mantenere il flusso di ragionamento del modello e l’integrità della conversazione.
**Suggerimento**
Sebbene sia possibile omettere i blocchi `thinking` dai turni del ruolo `assistant` precedenti, si consiglia di restituire sempre tutti i blocchi di pensiero all’API per qualsiasi conversazione multi-turno. L’API eseguirà queste operazioni:
Filtro automatico dei blocchi di pensiero forniti
Uso dei blocchi di pensiero pertinenti necessari per preservare il ragionamento del modello
Fatturazione dei soli token di input per i blocchi mostrati a Claude
Quando Claude invoca gli strumenti, sospende la creazione di una risposta in attesa di informazioni esterne. Quando i risultati dello strumento vengono restituiti, Claude continua a creare la risposta esistente. Ciò richiede la conservazione dei blocchi di pensiero durante l’uso dello strumento per i seguenti motivi:
+ **Continuità del ragionamento**: il pensiero blocca il step-by-step ragionamento Claude di Capture che ha portato alla richiesta di strumenti. Quando si pubblicano i risultati dello strumento, l’inclusione del pensiero originale assicura che Claude sia in grado di continuare il ragionamento dal punto in cui l’aveva interrotto.
+ **Mantenimento del contesto**: sebbene i risultati degli strumenti siano visualizzati come messaggi utente nella struttura dell’API, in realtà fanno parte di un flusso di ragionamento continuo. La conservazione dei blocchi di pensiero consente di mantenere questo flusso concettuale tra più chiamate API.
**Importante**
Quando si forniscono blocchi di pensiero, l’intera sequenza di blocchi consecutivi deve corrispondere agli output generati dal modello durante la richiesta originale e non è possibile riorganizzare né modificare la sequenza dei blocchi.
### Pensiero interlacciato (beta)
**avvertimento**
Interleaved thinking è reso disponibile all'utente come «Servizio Beta», come definito nei Termini di servizio. AWS È soggetto al Contratto e ai Termini di AWS servizio dell'utente AWS e al modello di EULA applicabile.
I modelli Claude 4 supportano il pensiero interlacciato, una funzionalità che consente a Claude di pensare tra le chiamate agli strumenti e di eseguire ragionamenti più sofisticati dopo aver ricevuto i risultati dello strumento. Ciò consente interazioni di agenti più complesse in cui Claude può:
+ Valutare i risultati di una chiamata allo strumento prima di decidere l’operazione successiva
+ Concatenare più chiamate allo strumento con passaggi di ragionamento intermedi
+ Prendere decisioni più sfumate sulla base di risultati intermedi
Per abilitare il pensiero interlacciato, aggiungi l’intestazione beta `interleaved-thinking-2025-05-14` alla richiesta API.
**Nota**
Con il pensiero interlacciato, il valore di `budget_tokens` può superare quello del parametro `max_tokens`, in quanto rappresenta il budget totale di tutti i blocchi di pensiero all’interno di un turno dell’assistente.
## Thinking block clearing (beta)
**avvertimento**
Thinking block clearing è reso disponibile come «Servizio Beta» come definito nei Termini di AWS servizio.
**Nota**
Questa funzionalità è attualmente supportata su Claude Sonnet 4/4.5, Claude Haiku 4.5 e Claude Opus 4/4.1/4.5.
Thinking block clearing è una funzionalità del modello Anthropic Claude (in versione beta). Con questa funzione, Claude può eliminare automaticamente i blocchi di pensiero più vecchi dei turni precedenti. Per utilizzare Thinking block clearing, devi aggiungere `context-management-2025-06-27` all'elenco delle intestazioni beta il parametro di richiesta anthropic\$1beta. Dovrete inoltre specificare l'uso `clear_thinking_20251015` e scegliere tra le seguenti opzioni di configurazione.
Questi sono i controlli disponibili per la strategia di gestione del contesto `clear_thinking_20251015`. Sono tutti opzionali o hanno dei valori predefiniti:
| **Opzione di configurazione** | **Descrizione** |
| --- | --- |
| `keep` impostazione predefinita: 1 turno di pensiero | Definisce il numero di turni recenti dell'assistente con blocchi di pensiero da conservare. Usa `{"type": "thinking_turns", "value": N}` dove N deve essere > 0 per mantenere gli ultimi N turni o `{"type": "all"}` per mantenere tutti i blocchi di pensiero. |
------
#### [ Request ]
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"anthropic_beta": [
"context-management-2025-06-27"
],
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user is asking for the weather in Paris. I have access to a get_weather function that takes a location as a parameter. I have all the information I need to make this call - the location is \"Paris\".\n\nLet me call the get_weather function with \"Paris\" as the location.",
"signature": "ErgDCkgIChABGAIqQC/Ccv8GC+5VfcMEiq78XmpU2Ef2cT+96pHKMedKcRNuPz1x0kFlo5HBpW0r1NcQFVQUPuj6PDmP7jdHY7GsrUwSDKNBMogjaM7wYkwfPhoMswjlmfF09JLjZfFlIjB03NkghGOxLbr3VCQHIY0lMaV9UBvt7ZwTpJKzlz+mulBysfvAmDfcnvdJ/6CZre4qnQJsTZaiXdEgASwPIc5jOExBguerrtYSWVC/oPjSi7KZM8PfhP/SPXupyLi8hwYxeqomqkeG7AQhD+3487ecerZJcpJSOSsf0I1OaMpmQEE/b7ehnvTV/A4nLhxIjP4msyIBW+dVwHNFRFlpJLBHUJvN99b4run6YmqBSf4y9TyNMfOr+FtfxedGE0HfJMBd4FHXmUFyW5y91jAHMWqwNxDgacaKkFCAMaqce5rm0ShOxXn1uwDUAS3jeRP26Pynihq8fw5DQwlqOpo7vvXtqb5jjiCmqfOe6un5xeIdhhbzWddhEk1Vmtg7I817pM4MZjVaeQN02drPs8QgDxihnP6ZooGhd6FCBP2X3Ymdlj5zMlbVHxmSkA4wcNtg4IAYAQ=="
},
{
"type": "tool_use",
"id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"content": "Current temperature: 88°F"
}
]
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 1
}
}
]
}
}
```
------
#### [ Response ]
```
{
"model": "claude-haiku-4-5-20251001",
"id": "msg_bdrk_01KyTbyFbdG2kzPwWMJY1kum",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "The current weather in Paris is **88°F** (approximately 31°C). It's quite warm! If you need more detailed information like humidity, wind conditions, or a forecast, please let me know."
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 736,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"cache_creation": {
"ephemeral_5m_input_tokens": 0,
"ephemeral_1h_input_tokens": 0
},
"output_tokens": 47
},
"context_management": {
"applied_edits": [...]
}
}
```
------
## Pensiero esteso con caching dei prompt
L’uso del [caching dei prompt](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) con il pensiero si presta a diverse importanti considerazioni:
**Rimozione del contesto dei blocchi di pensiero**
+ I blocchi di pensiero dei turni precedenti vengono rimossi dal contesto e ciò può influire sui punti di interruzione della cache.
+ Se si continuano conversazioni con l’uso di strumenti, i blocchi di pensiero vengono memorizzati nella cache e sono considerati token di input quando vengono letti dalla cache. Ciò crea un compromesso in base al quale i blocchi di pensiero non occupano visivamente lo spazio della finestra contestuale, ma vengono comunque conteggiati ai fini dell’utilizzo dei token di input quando sono memorizzati nella cache.
+ Se la funzionalità di pensiero viene disabilitata, le richieste avranno esito negativo qualora si passi il contenuto di pensiero nel turno corrente di utilizzo dello strumento. In altri contesti, i contenuti di pensiero passati all’API vengono semplicemente ignorati.
**Modelli di invalidazione della cache**
+ Le modifiche ai parametri di pensiero, ad esempio l’abilitazione, la disabilitazione o la modifica dell’allocazione del budget, invalidano i punti di interruzione della cache dei messaggi.
+ [Pensiero interlacciato (beta)](#claude-messages-extended-thinking-tool-use-interleaved) amplifica l’invalidazione della cache, poiché blocchi di pensiero possono verificarsi tra più chiamate allo strumento.
+ I prompt e gli strumenti di sistema rimangono memorizzati nella cache nonostante le modifiche apportate ai parametri di pensiero o la rimozione dei blocchi.
**Nota**
Sebbene i blocchi di pensiero vengano rimossi per il caching e i calcoli del contesto, devono essere preservati quando si continuano le conversazioni con l’uso degli strumenti, in particolare con il pensiero interlacciato.
## Informazioni sul comportamento del caching dei blocchi di pensiero
Quando si utilizza il pensiero esteso con gli strumenti, i blocchi di pensiero mostrano un comportamento di caching specifico che influisce sul conteggio dei token. La sequenza seguente illustra questo funzionamento.
1. Il caching si verifica solo quando si effettua una richiesta successiva che includa i risultati dello strumento.
1. Quando viene effettuata la richiesta successiva, la cronologia delle conversazioni precedenti (inclusi i blocchi di pensiero) può essere memorizzata nella cache.
1. Quando sono letti dalla cache, i blocchi memorizzati nella cache contano come token di input nei parametri di utilizzo.
1. Quando viene incluso un blocco non-tool-result utente, tutti i blocchi di pensiero precedenti vengono ignorati e rimossi dal contesto.
Ecco un esempio dettagliato di flusso:
Richiesta 1
```
User: "What's the weather in Paris?"
```
Risposta 1
```
[thinking_block 1] + [tool_use block 1]
```
Richiesta 2
```
User: "What's the weather in Paris?",
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
```
Risposta 2
```
[thinking_block 2] + [text block 2]
```
La richiesta 2 scrive nella cache il contenuto della richiesta (non della risposta). La cache include il messaggio utente originale, il primo blocco di pensiero, il blocco di utilizzo dello strumento e il risultato dello strumento.
Richiesta 3
```
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]
```
Poiché è stato incluso un blocco non-tool-result utente, tutti i blocchi di pensiero precedenti vengono ignorati. Questa richiesta viene elaborata in modo analogo alla richiesta seguente:
Richiesta 3 alternativa
```
User: ["What's the weather in Paris?"]
Assistant: [tool_use block 1]
User: [tool_result_1, cache=True]
Assistant: [text block 2]
User: [Text response, cache=True]
```
Questo comportamento è coerente sia che si utilizzi il pensiero regolare che il pensiero interlacciato.
## Numero massimo di token e dimensione della finestra contestuale nell’ambito del pensiero esteso
Nei modelli Claude meno recenti (precedenti a Claude 3.7 Sonnet), se la somma dei token di prompt e di max\$1tokens superava la finestra contestuale del modello, il sistema regolava automaticamente il valore max\$1tokens per adeguarlo al limite previsto per il contesto. In tal modo era possibile impostare un valore max\$1tokens elevato e il sistema lo riduceva automaticamente in base alle esigenze. Nei modelli Claude 3.7 e 4, il valore `max_tokens`, che include il budget di pensiero quando la funzionalità è abilitata, viene applicato come limite rigoroso. Il sistema ora restituisce un errore di convalida se la somma dei token di prompt e di max\$1tokens supera la dimensione della finestra contestuale.
### Finestra contestuale nell’ambito del pensiero esteso
Quando si calcola l’utilizzo della finestra contestuale con la funzionalità di pensiero abilitata, è necessario considerare gli aspetti seguenti:
+ I blocchi di pensiero dei turni precedenti vengono rimossi e non vengono conteggiati ai fini della finestra contestuale.
+ Il pensiero del turno attuale conta ai fini del limite `max_tokens` per il turno specifico.
La finestra contestuale effettiva viene calcolata come: finestra contestuale = (token di input correnti - token di pensiero precedenti) \$1 (token di pensiero \$1 token di pensiero criptati \$1 token di output di testo).
### Gestione dei token nell’ambito del pensiero esteso e dell’uso degli strumenti
Quando si utilizza il pensiero esteso con gli strumenti, i blocchi di pensiero devono essere preservati in modo esplicito e restituiti con i risultati dello strumento. Il calcolo efficace della finestra contestuale per il pensiero esteso con l’uso degli strumenti diventa il seguente:
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Gestione dei token nell’ambito del pensiero esteso
In base alla finestra contestuale e al comportamento di `max_tokens` con i modelli Claude 3.7 e 4 con pensiero esteso, potrebbe essere necessario eseguire una di queste azioni:
+ Monitorare e gestire più attivamente l’uso dei token.
+ Modificare i valori `max_tokens` in base al cambiamento della lunghezza dei prompt.
+ Tenere presente che i blocchi di pensiero precedenti non si accumulano nella finestra contestuale. Questa modifica è stata apportata per fornire un comportamento più prevedibile e trasparente, soprattutto perché i limiti massimi dei token sono aumentati in modo significativo.
## Considerazioni sul costo dei token di pensiero esteso
Il processo di pensiero prevede costi per gli elementi seguenti:
+ Token utilizzati durante il processo di pensiero (token di output)
+ I blocchi di pensiero dell’ultimo turno dell’assistente vengono inclusi nelle richieste successive (token di input)
+ Token standard di output di testo
**Suggerimento**
Quando la funzionalità di pensiero esteso è abilitata, viene automaticamente incluso un prompt di sistema specializzato con 28 o 29 token per supportare la funzionalità stessa.
Il parametro `budget_tokens` determina il numero massimo di token che Claude può utilizzare per il processo di ragionamento interno. Budget maggiori possono migliorare la qualità della risposta, consentendo un’analisi più approfondita per problemi complessi, anche se Claude può non utilizzare l’intero budget allocato, soprattutto per intervalli superiori a 32.000.
Con il pensiero interlacciato, il valore di `budget_tokens` può superare quello del parametro `max_tokens`, in quanto rappresenta il budget totale di tutti i blocchi di pensiero all’interno di un turno dell’assistente.
Quando si utilizza un pensiero riepilogativo, tenere presente le seguenti informazioni:
+ **Token di input**: token nella richiesta originale
+ **Token di output (fatturati)**: token di pensiero originali che Claude ha generato internamente
+ **Token di output (visibili)**: token di pensiero riepilogati visibili nella risposta
+ **Nessun costo**: token utilizzati per generare il riepilogo
+ Il campo `summary_status` può indicare se i limiti del token hanno influito sul riepilogo
+ Il numero dei token di output fatturati non corrisponde al numero di token visibili nella risposta e viene fatturato il processo di pensiero completo e non il riepilogo visualizzato.
# Pensiero adattivo
Il pensiero adattivo è il metodo consigliato da utilizzare [Pensiero esteso](claude-messages-extended-thinking.md) con Claude Opus 4.6. Invece di impostare manualmente un budget basato su Thinking Token, Adaptive Thinking consente di decidere Claude dinamicamente quando e quanto pensare in base alla complessità di ogni richiesta. Il pensiero adattivo offre prestazioni migliori in modo affidabile rispetto al pensiero esteso con un approccio fisso`budget_tokens`, e consigliamo di passare al pensiero adattivo per ottenere le risposte più intelligenti della versione 4.6. Claude Opus Non è richiesto alcun header beta.
I modelli supportati sono i seguenti:
| Modello | ID modello |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
**Nota**
`thinking.type: "enabled"`e `budget_tokens` sono obsoleti nella versione Claude Opus 4.6 e verranno rimossi in una versione futura del modello. Utilizzare invece `thinking.type: "adaptive"` con il parametro effort.
I modelli precedenti (Claude Opus4.5Claude Sonnet 4.5, ecc.) non supportano il pensiero adattivo e richiedono `thinking.type: "enabled"` con`budget_tokens`.
## Come funziona il pensiero adattivo
In modalità adattiva, Claude valuta la complessità di ogni richiesta e decide se e quanto pensare. Al livello di sforzo predefinito (`high`), Claude penserà quasi sempre. A livelli di sforzo inferiori, Claude può evitare di pensare a problemi più semplici.
Il pensiero adattivo abilita anche automaticamente. [Pensiero interlacciato (beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved) Ciò significa Claude poter pensare tra un intervento e l'altro, il che lo rende particolarmente efficace per i flussi di lavoro agentici.
Imposta su `thinking.type` `"adaptive"` nella tua richiesta API:
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(
service_name='bedrock-runtime',
region_name='us-east-2'
)
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [{
"role": "user",
"content": "Explain why the sum of two even numbers is always even."
}]
})
)
response_body = json.loads(response["body"].read())
for block in response_body["content"]:
if block["type"] == "thinking":
print(f"\nThinking: {block['thinking']}")
elif block["type"] == "text":
print(f"\nResponse: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [{
role: "user",
content: "Explain why the sum of two even numbers is always even."
}]
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
for (const block of responseBody.content) {
if (block.type === "thinking") {
console.log(`\nThinking: ${block.thinking}`);
} else if (block.type === "text") {
console.log(`\nResponse: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Pensiero adattivo con il parametro effort
Puoi combinare il pensiero adattivo con il parametro dello sforzo per determinare la portata del pensieroClaude. Il livello di impegno funge da guida morbida per l'allocazione Claude del pensiero:
| Livello di impegno | Comportamento di pensiero |
| --- | --- |
| max | Claudepensa sempre senza limiti alla profondità del pensiero. Claude Opussolo 4.6: le richieste utilizzate max su altri modelli restituiranno un errore. |
| high (predefinito) | Claudepensa sempre. Fornisce un ragionamento approfondito su compiti complessi. |
| medium | Claudeusa un pensiero moderato. Può saltare il pensiero per domande molto semplici. |
| low | Claudeminimizza il pensiero. Evita di pensare a compiti semplici in cui la velocità conta di più. |
## Caching dei prompt
Richieste consecutive che utilizzano `adaptive` thinking preserve prompt cache breakpoints. Tuttavia, il passaggio tra le modalità `adaptive` e`enabled`/`disabled`thinking interrompe i punti di interruzione della cache per i messaggi. Le istruzioni di sistema e le definizioni degli strumenti rimangono memorizzate nella cache indipendentemente dai cambiamenti di modalità.
## Ottimizzazione del comportamento di pensiero
Se Claude pensi più o meno spesso di quanto desideri, puoi aggiungere una guida al prompt del sistema:
```
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.
```
**avvertimento**
ClaudeOrientarsi a pensare meno spesso può ridurre la qualità delle attività che traggono vantaggio dal ragionamento. Misura l'impatto sui tuoi carichi di lavoro specifici prima di implementare l'ottimizzazione tempestiva per la produzione. Valuta innanzitutto la possibilità di eseguire test con livelli di sforzo inferiori.
# Crittografia Thinking
Il contenuto completo di Thinking viene crittografato e restituito nel campo della firma. Questo campo viene utilizzato per verificare che i blocchi di Thinking siano stati generati da Claude quando sono stati restituiti all’API. Durante lo streaming delle risposte, la firma viene aggiunta tramite `signature_delta` all’interno di un evento `content_block_delta` appena prima dell’evento `content_block_stop`.
**Nota**
È strettamente necessario restituire blocchi di Thinking solo durante l’utilizzo di strumenti che prevedono un pensiero esteso. Altrimenti, puoi omettere i blocchi di Thinking presenti nei turni precedenti oppure lasciare che l’API li rimuova automaticamente, quando li restituisci.
Se restituisci i blocchi di Thinking, ti consigliamo di restituirli tutti così come li hai ricevuti, per motivi di coerenza e per evitare potenziali problemi.
## Redazione di Thinking in Claude 3.7 Sonnet
**Nota**
Le seguenti informazioni si applicano specificamente a Claude 3.7 Sonnet. 4 modelli di Claude gestiscono il Thinking in modo diverso e non generano blocchi di Thinking redatti.
In Claude 3.7 Sonnet, vale quanto segue:
+ Occasionalmente, il ragionamento interno di Claude verrà segnalato dai nostri sistemi di sicurezza. Quando si verifica questa situazione, una parte o l’intero blocco Thinking viene crittografato e restituito come blocco redacted\$1thinking. I blocchi redacted\$1thinking vengono decrittografati quando vengono restituiti all’API, consentendo a Claude di continuare la risposta senza perdere il contesto.
+ I blocchi `thinking` e `redacted_thinking` vengono restituiti prima dei blocchi di testo nella risposta.
Quando crei applicazioni rivolte ai clienti che utilizzano il Thinking esteso con Claude 3.7 Sonnet, considera quanto segue:
+ Tieni presente che i blocchi di Thinking redatti contengono contenuto crittografato che non è leggibile da persone.
+ Potresti fornire una spiegazione semplice come: “Alcuni ragionamenti interni di Claude sono stati crittografati automaticamente per motivi di sicurezza. Ciò non influisce sulla qualità delle risposte”.
+ Se mostri blocchi di Thinking agli utenti, puoi filtrare i blocchi redatti preservando i normali blocchi di Thinking.
+ Sii trasparente sul fatto che l’utilizzo di funzionalità di Thinking esteso può occasionalmente comportare la crittografia di alcuni ragionamenti.
+ Implementa una gestione degli errori appropriata per gestire correttamente il Thinking redatto senza compromettere l’interfaccia utente.
Ecco un esempio che mostra blocchi di Thinking normali e redatti:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature":"WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...." },
{
"type": "redacted_thinking",
"data":"EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpP..."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
**Suggerimento**
La visualizzazione di blocchi di Thinking redatti nei risultati è un comportamento previsto. Il modello può ancora utilizzare questo ragionamento redatto per orientare le proprie risposte, mantenendo al contempo i guardrail di sicurezza.
Se hai bisogno di testare la gestione del Thinking redatto nella tua applicazione, puoi usare questa speciale stringa di test come prompt: `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`
Quando passi i blocchi `thinking` e `redacted_thinking` all’API in una conversazione a più turni, devi includere il blocco completo e non modificato nell’ultima richiesta dell’assistente. Ciò è fondamentale per mantenere il flusso di ragionamento del modello. Consigliamo di restituire sempre tutti i blocchi di Thinking all’API. Per ulteriori dettagli, consulta [Pensiero esteso con uso di strumentiConservazione dei blocchi di pensiero](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
L'esempio seguente utilizza l'**InvokeModelWithResponseStream**API per dimostrare la struttura di richiesta e risposta quando si utilizzano i thinking token con redazioni.
Quando lo streaming è abilitato, riceverai contenuti di Thinking dagli eventi thinking\$1delta. Ecco come gestire lo streaming con il Thinking:
**Richiesta**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Risposta**
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
# Differenze di pensiero tra le versioni del modello
L’API Messaggi gestisce il modo di pensare in modo diverso tra i modelli Claude 3.7 Sonnet e Claude 4, principalmente nel comportamento di redazione e riepilogo. Nella seguente tabella sono riepilogate le varie differenze.
| Funzionalità | Claude 3.7 Sonnet | Modelli Claude 4 |
| --- | --- | --- |
| Risultato del pensiero | Restituisce l’intero risultato del pensiero | Restituisce il pensiero riepilogativo |
| Gestione della redazione | Utilizza blocchi `redacted_thinking` | Rimuove e crittografa il pensiero completo, restituito in un campo `signature` |
| Pensiero interlacciato | Non supportata | Supportato con un’intestazione beta |
# Compattazione
**Suggerimento**
La compattazione lato server è consigliata per la gestione del contesto nelle conversazioni di lunga durata e nei flussi di lavoro agentici, poiché gestisce automaticamente la gestione del contesto con un lavoro di integrazione minimo.
**Nota**
La compattazione è attualmente in versione beta. Includi l'intestazione beta `compact-2026-01-12` nelle tue richieste API per utilizzare questa funzionalità. La compattazione non è attualmente supportata dall'ConverseAPI, tuttavia è supportata con. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
La compattazione estende la lunghezza effettiva del contesto per conversazioni e attività di lunga durata riassumendo automaticamente il contesto precedente quando ci si avvicina al limite della finestra di contesto. È ideale per:
+ Conversazioni basate su chat a turni in cui si desidera che gli utenti utilizzino una chat per un lungo periodo di tempo
+ Prompt orientati alle attività che richiedono molto lavoro di follow-up (spesso l'uso di strumenti) e che possono superare la finestra contestuale di 200.000
La compattazione è supportata sui seguenti modelli:
| Modello | ID modello |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**Nota**
Il livello superiore `input_tokens` e `output_tokens` quello `usage` sul campo non includono l'utilizzo delle iterazioni di compattazione e riflettono la somma di tutte le iterazioni non di compattazione. Per calcolare il totale dei token consumati e fatturati per una richiesta, sommate tutte le voci dell'array. `usage.iterations`
Se in precedenza facevi affidamento su `usage.input_tokens` e `usage.output_tokens` per il monitoraggio o il controllo dei costi, dovrai aggiornare la logica di tracciamento per aggregarla quando la compattazione è abilitata. `usage.iterations` L'`iterations`array è presente solo quando viene attivata una nuova compattazione durante la richiesta. La riapplicazione di un `compaction` blocco precedente non comporta costi di compattazione aggiuntivi e in tal caso i campi di utilizzo di primo livello rimangono accurati.
## Come funziona la compattazione
Quando la compattazione è abilitata, riassume Claude automaticamente la conversazione quando si avvicina alla soglia del token configurata. L'API:
1. Rileva quando i token di input superano la soglia di attivazione specificata.
1. Genera un riepilogo della conversazione corrente.
1. Crea un `compaction` blocco contenente il riepilogo.
1. Continua la risposta con il contesto compatto.
Nelle richieste successive, aggiungi la risposta ai tuoi messaggi. L'API elimina automaticamente tutti i blocchi di messaggi precedenti al `compaction` blocco, continuando la conversazione dal riepilogo.
## Utilizzo di base
Abilita la compattazione aggiungendo la `compact_20260112` strategia `context_management.edits` nella tua richiesta API Messages.
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}' \
--cli-binary-format raw-in-base64-out \
/tmp/response.json
echo "Response:"
cat /tmp/response.json | jq '.content[] | {type, text: .text[0:500]}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Append the response (including any compaction block) to continue the conversation
messages.append({"role": "assistant", "content": response_body["content"]})
for block in response_body["content"]:
if block.get("type") == "compaction":
print(f"[COMPACTION]: {block['content'][:200]}...")
elif block.get("type") == "text":
print(f"[RESPONSE]: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const messages: Array<{role: string, content: string | object[]}> = [
{ role: "user", content: "Help me build a website" }
];
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
anthropic_beta: ["compact-2026-01-12"],
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
// Append response to continue conversation
messages.push({ role: "assistant", content: responseBody.content });
for (const block of responseBody.content) {
if (block.type === "compaction") {
console.log(`[COMPACTION]: ${block.content.substring(0, 200)}...`);
} else if (block.type === "text") {
console.log(`[RESPONSE]: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Parameters
| Parametro | Tipo | Predefinita | Description |
| --- | --- | --- | --- |
| type | stringa | Richiesto | Deve essere "compact\$120260112" |
| trigger | oggetto | 150.000 token | Quando attivare la compattazione. Devono essere almeno 50.000 gettoni. |
| pause\$1after\$1compaction | booleano | false | Se mettere in pausa dopo aver generato il riepilogo della compattazione |
| instructions | stringa | null | Richiesta di riepilogo personalizzata. Sostituisce completamente il prompt predefinito quando fornito. |
## Configurazione del trigger
Configura quando si attiva la compattazione utilizzando il `trigger` parametro:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Istruzioni di riepilogo personalizzate
Per impostazione predefinita, la compattazione utilizza la seguente richiesta di riepilogo:
```
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.
```
È possibile fornire istruzioni personalizzate tramite il `instructions` parametro per sostituire completamente questo prompt. Le istruzioni personalizzate non integrano quelle predefinite, ma le sostituiscono completamente:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Pausa dopo la compattazione
Consente `pause_after_compaction` di mettere in pausa l'API dopo aver generato il riepilogo della compattazione. Ciò consente di aggiungere blocchi di contenuto aggiuntivi (ad esempio la conservazione dei messaggi recenti o di messaggi specifici orientati alle istruzioni) prima che l'API continui con la risposta.
Se abilitata, l'API restituisce un messaggio con il motivo dell'`compaction`interruzione dopo aver generato il blocco di compattazione:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": True
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Check if compaction triggered a pause
if response_body.get("stop_reason") == "compaction":
# Response contains only the compaction block
messages.append({"role": "assistant", "content": response_body["content"]})
# Continue the request
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [{"type": "compact_20260112"}]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Lavorare con blocchi di compattazione
Quando viene attivata la compattazione, l'API restituisce un `compaction` blocco all'inizio della risposta dell'assistente.
Una conversazione di lunga durata può comportare compattazioni multiple. L'ultimo blocco di compattazione riflette lo stato finale del prompt e sostituisce il contenuto precedente con il riepilogo generato.
```
{
"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..."
}
]
}
```
## Streaming
Quando trasmetti risposte in streaming con la compattazione abilitata, riceverai un `content_block_start` evento all'inizio della compattazione. Lo streaming del blocco di compattazione è diverso dai blocchi di testo. Riceverai un `content_block_start` evento, seguito da un singolo `content_block_delta` con il contenuto di riepilogo completo (senza streaming intermedio) e poi da un evento. `content_block_stop`
## Caching dei prompt
Puoi aggiungere un `cache_control` breakpoint sui blocchi di compattazione, che memorizza nella cache l'intero prompt del sistema insieme al contenuto riepilogato. Il contenuto compattato originale viene ignorato. Tieni presente che quando viene attivata la compattazione, può causare la perdita della cache nella richiesta successiva.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Comprendere l'utilizzo
La compattazione richiede una fase di campionamento aggiuntiva, che contribuisce ai limiti tariffari e alla fatturazione. L'API restituisce informazioni dettagliate sull'utilizzo nella risposta:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
L'`iterations`array mostra l'utilizzo per ogni iterazione di campionamento. Quando si verifica la compattazione, vedrai un'`compaction`iterazione seguita dall'iterazione principale. `message` Il numero di token dell'iterazione finale riflette la dimensione effettiva del contesto dopo la compattazione.
# Ottieni risultati JSON convalidati dai modelli
È possibile utilizzare output strutturati conClaude Sonnet 4.5,Claude Haiku 4.5, Claude Opus 4.5 e. Claude Opus 4.6 Per ulteriori informazioni, consulta [Ottieni risultati JSON convalidati dai modelli](structured-output.md).
# Richiesta e risposta
Il corpo della richiesta viene passato nel `body` campo di una richiesta a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**Nota**
Le restrizioni si applicano alle seguenti operazioni: `InvokeModel``InvokeModelWithResponseStream`,`Converse`, e`ConverseStream`. Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
**avvertimento**
Claude Sonnet 4.5e Claude Haiku 4.5 supporta la specificazione del `top_p` parametro `temperature` o, ma non di entrambi. Questa condizione non si applica ai modelli precedenti.
------
#### [ Request ]
Anthropic Claude include i parametri di inferenza seguenti per effettuare una chiamata di inferenza ai messaggi.
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["computer-use-2024-10-22"]
"max_tokens": int,
"system": string,
"messages": [
{
"role": string,
"content": [
{ "type": "image", "source": { "type": "base64", "media_type": "image/jpeg", "data": "content image bytes" } },
{ "type": "text", "text": "content text" }
]
}
],
"temperature": float,
"top_p": float,
"top_k": int,
"tools": [
{
"type": "custom",
"name": string,
"description": string,
"input_schema": json
},
{
"type": "computer_20241022",
"name": "computer",
"display_height_px": int,
"display_width_px": int,
"display_number": 0 int
},
{
"type": "bash_20241022",
"name": "bash"
},
{
"type": "text_editor_20241022",
"name": "str_replace_editor"
}
],
"tool_choice": {
"type" : string,
"name" : string,
},
"stop_sequences": [string]
}
```
I seguenti parametri sono obbligatori.
+ **anthropic\$1version** (obbligatorio): versione di Anthropic. Il valore deve essere `bedrock-2023-05-31`.
+ **max\$1Tokens** (obbligatorio): numero massimo di token da generare prima dell’interruzione.
Tenere presente che i modelli Anthropic Claude potrebbero interrompere la generazione di token prima di raggiungere il valore di `max_tokens`. In modelli Anthropic Claude diversi i valori massimi per questo parametro sono differenti. Per ulteriori informazioni, consulta [Confronto dei modelli](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages** (obbligatorio): messaggi di input.
+ **role**: ruolo del turno di conversazione. I valori validi sono `user` e `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content** (obbligatorio): contenuto del turno di conversazione, come array di oggetti. Ogni oggetto contiene un campo **type**, in cui è possibile specificare uno dei seguenti valori:
+ `text`: se si specifica questo tipo, è necessario includere un campo di testo e indicare il prompt di testo come valore. Se un altro oggetto dell’array è un’immagine, questo prompt di testo si applica alle immagini.
+ `image`: se si specifica questo tipo, è necessario includere un campo **source** mappato a un oggetto con i seguenti campi:
+ **type** (obbligatorio): tipo di codifica dell’immagine. È possibile specificare `base64`.
+ **media\$1type** (obbligatorio): tipo di immagine. È possibile specificare i seguenti formati di immagine:
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data** (obbligatorio): byte dell’immagine con codifica base64 per l’immagine. La dimensione massima è 3,75 MB. L’altezza e la larghezza massime di un’immagine corrispondono a 8.000 pixel.
I seguenti parametri sono facoltativi.
+ **system** (facoltativo): prompt di sistema per la richiesta.
Un prompt di sistema è un modo per fornire contesto e istruzioni ad Anthropic Claude, ad esempio specificando un obiettivo o un ruolo particolare. Per ulteriori informazioni, consulta [Dare un ruolo a Claude con un system prompt](https://docs.anthropic.com/en/docs/system-prompts) nella documentazione di Anthropic.
**Nota**
È possibile utilizzare i prompt di sistema con Anthropic Claude versione 2.1 o successiva.
+ **anthropic\$1beta** (facoltativo): il parametro anthropic\$1beta è un elenco di stringhe di intestazioni beta utilizzate per indicare l’accettazione a un particolare set di funzionalità beta.
**Nota**
La variante con lunghezza contestuale di 1 milione di token Claude Sonnet 4 è disponibile in alcune AWS regioni come «Servizio beta», come definito nei Termini di AWS servizio. È soggetto al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello di EULA applicabile. Per ulteriori informazioni sui prezzi per le richieste contestuali più lunghe, consulta la pagina [Prezzi di Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/). Si applicano quote di servizio separate (per ulteriori informazioni, vedere **Service** Quotas in Console di gestione AWS).
Altre intestazioni beta disponibili sono le seguenti:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequences** (facoltativo): sequenze di testo personalizzate che inducono il modello a interrompere la generazione. I modelli Anthropic Claude in genere interrompono la generazione quando hanno completato naturalmente il proprio turno e in questo caso il valore della campo di risposta `stop_reason` è `end_turn`. Se si desidera che il modello interrompa la generazione quando incontra stringhe di testo personalizzate, usare il parametro `stop_sequences`. Se il modello incontra una delle stringhe di testo personalizzate, il valore del campo di risposta `stop_reason` è `stop_sequence` e il valore di `stop_sequence` contiene la sequenza di arresto corrispondente.
Il numero massimo di voci è 8191.
+ **temperature** (facoltativo): quantità di randomizzazione inserita nella risposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p** (facoltativo): utilizza il metodo “nucleus sampling”.
Nel metodo “nucleus sampling”, Anthropic Claude calcola la distribuzione cumulativa di tutte le opzioni per ogni token successivo in ordine di probabilità decrescente e la interrompe quando raggiunge un particolare valore specificato da `top_p`. Quando si regolano i parametri di campionamento, modificare `temperature` oppure `top_p`. Non modificare entrambi i parametri contemporaneamente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k** (facoltativo): campionamento eseguito solo dalle opzioni top K per ogni token successivo.
Utilizza `top_k` per rimuovere le risposte long tail a bassa probabilità.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools** (facoltativo): definizioni di strumenti che il modello può utilizzare.
**Nota**
Richiede un modello Anthropic Claude 3.
Se si include `tools` nella richiesta, il modello può restituire blocchi di contenuto `tool_use` che rappresentano l’utilizzo di tali strumenti da parte del modello. È quindi possibile eseguire tali strumenti utilizzando l’input dello strumento generato dal modello e quindi, facoltativamente, restituire i risultati al modello utilizzando blocchi di contenuto `tool_result`.
È possibile passare i seguenti tipi di strumenti:
**Personalizzato**
Definizione di uno strumento personalizzato.
+ **type** (facoltativo): tipo di strumento. Se definito, utilizzare il valore `custom`.
+ **name**: nome dello strumento.
+ **descrizione** (facoltativa, ma fortemente consigliata): descrizione dello strumento.
+ **input\$1schema**: schema JSON per lo strumento.
**Computer**
Definizione del computer utilizzato con l’API per l’utilizzo del computer.
+ **type**: il valore deve essere `computer_20241022`.
+ **name**: il valore deve essere `computer`.
+ **display\$1height\$1px** (obbligatorio): altezza del display controllato dal modello, in pixel.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **display\$1width\$1px** (obbligatorio): larghezza del display controllato dal modello, in pixel.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **display\$1number** (facoltativo): numero di display da controllare (rilevante solo per gli ambienti X11). Se specificato, allo strumento verrà fornito un numero di display nella definizione dello strumento.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Definizione dello strumento bash utilizzato con l’API per l’utilizzo del computer.
+ **type** (facoltativo): il valore deve essere `bash_20241022`.
+ **name**: il valore deve essere lo strumento `bash`.
**editor di testo**
Definizione dello strumento editor di testo utilizzato con l’API per l’utilizzo del computer.
+ **type** (facoltativo): il valore deve essere `text_editor_20241022`.
+ **name**: il valore deve essere lo strumento `str_replace_editor`.
+ **tool\$1choice** (facoltativo): specifica la modalità di utilizzo degli strumenti forniti da parte del modello. Il modello può utilizzare uno strumento specifico, qualsiasi strumento disponibile o decidere in modo autonomo.
**Nota**
Richiede un modello Anthropic Claude 3.
+ **tipo**: tipo dello strumento scelto. I valori possibili sono `any` (qualsiasi strumento disponibile), `auto` (decide il modello) e `tool` (strumento specificato).
+ **name** (facoltativo): nome dello strumento da utilizzare. Obbligatorio se si specifica `tool` nel campo `type`.
------
#### [ Response ]
I modelli Anthropic Claude restituiscono i campi seguenti per una chiamata di inferenza ai messaggi.
```
{
"id": string,
"model": string,
"type" : "message",
"role" : "assistant",
"content": [
{
"type": string,
"text": string,
"image" :json,
"id": string,
"name":string,
"input": json
}
],
"stop_reason": string,
"stop_sequence": string,
"usage": {
"input_tokens": integer,
"output_tokens": integer
}
}
```
Risposte di esempio con nuovi valori stop\$1reason:
```
// Example with refusal
{
"stop_reason": "refusal",
"content": [
{
"type": "text",
"text": "I can't help with that request."
}
]
}
// Example with tool_use
{
"stop_reason": "tool_use",
"content": [
{
"type": "tool_use",
"id": "toolu_123",
"name": "calculator",
"input": {"expression": "2+2"}
}
]
}
// Example with model_context_window_exceeded (Claude Sonnet 4.5)
{
"stop_reason": "model_context_window_exceeded",
"content": [
{
"type": "text",
"text": "The response was truncated due to context window limits..."
}
]
}
```
+ **id**: identificatore univoco per la risposta. Il formato e la lunghezza dell’ID potrebbero cambiare nel tempo.
+ **model**: ID modello Anthropic Claude che ha effettuato la richiesta.
+ **stop\$1reason**: motivo per cui Anthropic Claude ha interrotto la generazione della risposta.
+ **end\$1turn**: il modello ha raggiunto un punto d interruzione naturale.
+ **max\$1tokens**: il testo generato ha superato il valore del campo di input `max_tokens` o ha superato il numero massimo di token supportati dal modello.
+ **stop\$1sequence**: il modello ha generato una delle sequenze di arresto specificate nel campo di input `stop_sequences`.
+ **refusal**: Claude si rifiuta di generare una risposta per motivi di sicurezza.
+ **tool\$1use**: Claude sta chiamando uno strumento e si aspetta che l’utente lo esegua.
+ **model\$1context\$1window\$1exceeded**: il modello ha interrotto la generazione perché ha raggiunto il limite della finestra contestuale.
+ Nuovo in Claude Sonnet 4.5
+ **stop\$1sequence**: sequenza di arresto che ha terminato la generazione.
+ **type**: tipo della risposta. Il valore è sempre `message`.
+ **role**: ruolo conversazionale del messaggio generato. Il valore è sempre `assistant`.
+ **content**: contenuto generato dal modello. Restituito in forma di array. Esistono tre tipi di contenuto, *text*, *tool\$1use* e *image*.
+ *text*: risposta in formato testo.
+ **type**: tipo del contenuto. Il valore è `text`.
+ **text**: se il valore di `type` è di tipo testo, contiene il testo del contenuto.
+ *tool use*: richiesta da parte del modello di utilizzare uno strumento.
+ **type**: tipo del contenuto. Il valore è `tool_use`.
+ **id**: ID dello strumento di cui il modello richiede l’utilizzo.
+ **name**: nome dello strumento richiesto.
+ **input**: parametri di input da passare allo strumento.
+ *Image*: richiesta da parte del modello di utilizzare uno strumento.
+ **type**: tipo del contenuto. Il valore è `image`.
+ **source**: contiene l’immagine. Per ulteriori informazioni, consulta [Prompt multimodali](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage**: container per il numero di token forniti nella richiesta e per quello di token generati dal modello nella risposta.
+ **input\$1tokens**: numero di token di input nella richiesta.
+ **output\$1tokens**: numero di token generati dal modello nella risposta.
+ **stop\$1sequence**: il modello ha generato una delle sequenze di arresto specificate nel campo di input `stop_sequences`.
------
## Parametro di sforzo (beta)
Il `effort` parametro è un'alternativa a Thinking Token Budgets for Claude Opus 4.5. Questo parametro indica con Claude quanta generosità dovrebbe spendere i token per ottenere i migliori risultati, adattando l'utilizzo dei token in base al pensiero, alle chiamate agli strumenti e alla comunicazione con l'utente. Può essere usato con o senza la modalità di pensiero estesa.
Il parametro di sforzo può essere impostato su:
+ `high`(impostazione predefinita): Claude spende tutti i token necessari per ottenere il miglior risultato
+ `medium`— Utilizzo bilanciato dei token
+ `low`— Utilizzo conservativo dei token
Per utilizzare questa funzionalità è necessario superare l'intestazione `effort-2025-11-24` beta.
Esempio di richiesta:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"effort-2025-11-24"
],
"max_tokens": 4096,
"output_config": {
"effort": "medium"
},
"messages": [{
"role": "user",
"content": "Analyze this complex dataset and provide insights"
}]
}
```
# Esempi di codice
Gli esempi di codice seguenti mostrano come utilizzare l’API Messages.
**Topics**
+ [Esempio di codice di messaggio](#api-inference-examples-claude-messages-code-example)
+ [Esempi di codice multimodale](#api-inference-examples-claude-multimodal-code-example)
## Esempio di codice di messaggio
Questo esempio mostra come inviare un messaggio di solo turno utente e un messaggio di turno utente con risposta assistente precompilata a un modello Anthropic Claude 3 Sonnet.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate a message with Anthropic Claude (on demand).
"""
import boto3
import json
import logging
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):
body=json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"system": system_prompt,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude message example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
system_prompt = "Please respond only with emoji."
max_tokens = 1000
# Prompt with user turn only.
user_message = {"role": "user", "content": "Hello World"}
messages = [user_message]
response = generate_message (bedrock_runtime, model_id, system_prompt, messages, max_tokens)
print("User turn only.")
print(json.dumps(response, indent=4))
# Prompt with both user turn and prefilled assistant response.
#Anthropic Claude continues by using the prefilled assistant text.
assistant_message = {"role": "assistant", "content": ""}
messages = [user_message, assistant_message]
response = generate_message(bedrock_runtime, model_id,system_prompt, messages, max_tokens)
print("User turn and prefilled assistant response.")
print(json.dumps(response, indent=4))
except ClientError as err:
message=err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
## Esempi di codice multimodale
Gli esempi seguenti mostrano come passare un’immagine e il testo di un prompt in un messaggio multimodale a un modello Anthropic Claude 3 Sonnet.
**Topics**
+ [Richiesta multimodale con InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Streaming di prompt multimodale con InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Richiesta multimodale con InvokeModel
L'esempio seguente mostra come inviare un prompt multimodale a with. Anthropic Claude 3 Sonnet [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
### Streaming di prompt multimodale con InvokeModelWithResponseStream
L'esempio seguente mostra come trasmettere in streaming la risposta da un prompt multimodale inviato a with. Anthropic Claude 3 Sonnet [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to stream the response from Anthropic Claude Sonnet (on demand) for a
multimodal request.
"""
import json
import base64
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_multi_modal_prompt(bedrock_runtime, model_id, input_text, image, max_tokens):
"""
Streams the response from a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
input_text (str) : The prompt text
image (str) : The path to an image that you want in the prompt.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
with open(image, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": input_text},
{"type": "image", "source": {"type": "base64",
"media_type": "image/jpeg", "data": encoded_string.decode('utf-8')}}
]
}
]
})
response = bedrock_runtime.invoke_model_with_response_stream(
body=body, modelId=model_id)
for event in response.get("body"):
chunk = json.loads(event["chunk"]["bytes"])
if chunk['type'] == 'message_delta':
print(f"\nStop reason: {chunk['delta']['stop_reason']}")
print(f"Stop sequence: {chunk['delta']['stop_sequence']}")
print(f"Output tokens: {chunk['usage']['output_tokens']}")
if chunk['type'] == 'content_block_delta':
if chunk['delta']['type'] == 'text_delta':
print(chunk['delta']['text'], end="")
def main():
"""
Entrypoint for Anthropic Claude Sonnet multimodal prompt example.
"""
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What can you tell me about this image?"
image = "/path/to/image"
max_tokens = 100
try:
bedrock_runtime = boto3.client('bedrock-runtime')
stream_multi_modal_prompt(
bedrock_runtime, model_id, input_text, image, max_tokens)
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
# Modelli supportati
Puoi utilizzare l’API Messages con i seguenti modelli Anthropic Claude.
+ AnthropicClaude Opus4.5
+ AnthropicClaude Opus4.1
+ AnthropicClaude Opus4
+ Anthropic Claude Sonnet 4.5
+ Anthropic Claude Haiku 4.5
+ Anthropic Claude Sonnet 4
+ Anthropic Claude 3.7 Sonnet
+ Anthropic Claude 3.5 Sonnet v2
+ Anthropic Claude 3.5 Sonnet
+ Anthropic Claude 3 Opus
+ Anthropic Claude 3 Sonnet
+ Anthropic Claude 3 Haiku
+ Anthropic Claude 2 v2.1
+ Anthropic Claude 2 v2
+ Anthropic Claude Instant v1.2