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à.
# 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.