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 Mythos 5 | `anthropic.claude-mythos-5` | | Claude Fable 5 | `anthropic.claude-fable-5` | | Claude Opus4.7 | `anthropic.claude-opus-4-7` | | Prévia de Claude Mythos | `anthropic.claude-mythos-preview` | | Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` | | Soneto de Claude 4.6 | `anthropic.claude-sonnet-4-6` | **nota** *Claude Mythos 5, Claude Fable 5, Claude Opus 4.7 e Claude Mythos Preview suportam apenas o pensamento adaptativo.* O pensamento manual estendido (`thinking.type: "enabled"`com`budget_tokens`) e o pensamento desativado (`thinking.type: "disabled"`) não são suportados nesses modelos e retornarão um erro 400. Use `thinking.type: "adaptive"` com `output_config.effort` para controlar o comportamento de pensamento. `thinking.type: "enabled"`e `budget_tokens` estão obsoletos na versão Claude Opus 4.6 e no Claude Sonnet 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 de 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. | **Importante** O `effort` parâmetro deve ser colocado dentro de um `output_config` objeto separado no corpo da solicitação, não dentro do `thinking` objeto. Colocar `effort` dentro `thinking` resultará em um`ValidationException`. O exemplo a seguir mostra como definir o nível de esforço ao usar a InvokeModel API: ``` { "anthropic_version": "bedrock-2023-05-31", "max_tokens": 16000, "thinking": { "type": "adaptive" }, "output_config": { "effort": "high" }, "messages": [{ "role": "user", "content": "Your prompt here" }] } ``` ## 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 de um `output_config` objeto separado em`additionalModelRequestFields`: ``` 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" }, "output_config": { "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. ## Resumo do texto do conector (beta) Em Claude Fable 5, o texto que o modelo emite entre as chamadas da ferramenta (às vezes chamado de “texto do conector” — por exemplo, “Deixe-me verificar esse arquivo a seguir...”) é resumido no lado do servidor e retornado como um bloco de pensamento em vez de um bloco de conteúdo de texto simples. O bloco de pensamento usa a mesma forma de qualquer outro bloco de pensamento (texto vazio com uma assinatura na `omitted` tela padrão). **Impacto no cliente:** + **Forma de resposta:** Tool-use as respostas de Claude Fable 5 podem conter blocos de pensamento adicionais em que os modelos anteriores emitiam texto simples entre os blocos. `tool_use` Não há nenhum novo tipo de bloco de conteúdo. As respostas finais do assistente (após a conclusão de todo o uso da ferramenta) não são afetadas e permanecem em texto simples. + **Multi-turn manipulação:** devolva esses blocos de pensamento inalterados em conversas de vários turnos — o mesmo tratamento do pensamento protegido (assinatura validada no repasse; removida silenciosamente se enviada para um modelo diferente). + **Escopo:** o resumo do conector se aplica somente após a `tool_result` existência de um na conversa. A narração antes da primeira chamada de ferramenta em uma nova conversa permanece em texto simples. Segmentos de texto curto podem passar como texto simples sem resumo. Esse recurso está habilitado no lado do servidor para Claude Fable 5. Não há aceitação ou exclusão do cliente.