As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Pensamento adaptativo
O pensamento adaptativo é a forma recomendada de usar [Raciocínio estendido](claude-messages-extended-thinking.md) com o Claude Opus 4.6. Em vez de definir manualmente um orçamento simbólico, o pensamento adaptativo permite decidir Claude dinamicamente quando e quanto pensar com base na complexidade de cada solicitação. O pensamento adaptativo gera um desempenho melhor de forma confiável do que o pensamento estendido com um pensamento fixo`budget_tokens`, e recomendamos mudar para o pensamento adaptativo para obter as respostas mais inteligentes do 4.6. Claude Opus Nenhum cabeçalho beta é necessário.
Os modelos compatíveis são os seguintes:
| Modelo | ID do modelo |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Soneto de Claude 4.6 | `anthropic.claude-sonnet-4-6` |
**nota**
`thinking.type: "enabled"`e `budget_tokens` estão obsoletos na versão Claude Opus 4.6 e serão removidos em uma versão futura do modelo. Em vez disso, use `thinking.type: "adaptive"` com o parâmetro de esforço.
Modelos mais antigos (Claude Sonnet 4.5, Claude Opus 4.5, etc.) não suportam o pensamento adaptativo e exigem`thinking.type: "enabled"`. `budget_tokens`
## Como funciona o pensamento adaptativo
No modo adaptativo, Claude avalia a complexidade de cada solicitação e decide se e em quanto pensar. No nível de esforço padrão (`high`), quase sempre Claude pensará. Em níveis mais baixos de esforço, Claude pode deixar de pensar em problemas mais simples.
O pensamento adaptativo também é ativado automaticamente. [Raciocínio intercalado (beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved) Isso significa que Claude pode pensar entre chamadas de ferramentas, tornando-a especialmente eficaz para fluxos de trabalho agentes.
`thinking.type`Defina como `"adaptive"` na sua solicitação de 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);
```
------
## Pensamento adaptativo com o parâmetro de esforço
Você pode combinar o pensamento adaptativo com o parâmetro de esforço para orientar o quanto Claude o pensamento faz. O nível de esforço atua como uma orientação suave para a alocação Claude do pensamento:
| Nível de esforço | Comportamento de pensamento |
| --- | --- |
| max | Claudesempre pensa sem restrições na profundidade do pensamento. Claude OpusSomente 4.6 — solicitações usadas max em outros modelos retornarão um erro. |
| high (padrão) | Claudesempre pensa. Fornece um raciocínio profundo sobre tarefas complexas. |
| medium | Claudeusa pensamento moderado. Pode deixar de pensar em perguntas muito simples. |
| low | Claudeminimiza o pensamento. Pare de pensar em tarefas simples, nas quais a velocidade é mais importante. |
## Usando o pensamento adaptativo com a API Converse
Ao usar a [API Converse](conversation-inference.md), passe os `effort` parâmetros `thinking` e para dentro`additionalModelRequestFields`. O exemplo a seguir mostra o pensamento adaptativo com o nível de esforço padrão:
```
import boto3, json
bedrock_runtime = boto3.client(service_name='bedrock-runtime', region_name='us-east-2')
response = bedrock_runtime.converse(
modelId="us.anthropic.claude-opus-4-6-v1",
messages=[{
"role": "user",
"content": [{"text": "Explain why the sum of two even numbers is always even."}]
}],
additionalModelRequestFields={
"thinking": {
"type": "adaptive"
}
}
)
print(json.dumps(response["output"], indent=2, default=str))
```
Para especificar um nível de esforço, adicione o `effort` campo dentro do `thinking` objeto:
```
response = bedrock_runtime.converse(
modelId="us.anthropic.claude-opus-4-6-v1",
messages=[{
"role": "user",
"content": [{"text": "What is 2 + 2?"}]
}],
additionalModelRequestFields={
"thinking": {
"type": "adaptive",
"effort": "low"
}
}
)
```
## Armazenamento em cache de prompts
Solicitações consecutivas usando o `adaptive` thinking preservam pontos de interrupção imediatos do cache. No entanto, alternar entre `adaptive` os modos `enabled` `disabled` e/thinking interrompe os pontos de interrupção do cache das mensagens. Os prompts do sistema e as definições de ferramentas permanecem em cache, independentemente das alterações de modo.
## Ajustando o comportamento de pensamento
Se Claude estiver pensando com mais ou menos frequência do que gostaria, você pode adicionar orientações ao prompt do 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.
```
**Atenção**
ClaudePassar a pensar com menos frequência pode reduzir a qualidade das tarefas que se beneficiam do raciocínio. Meça o impacto em suas cargas de trabalho específicas antes de implantar o ajuste baseado em solicitações na produção. Considere testar primeiro com níveis de esforço mais baixos.