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 o Raciocínio estendido Claude Opus 4.6. Em vez de definir manualmente um orçamento simbólico inteligente, 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 fixobudget_tokens, e recomendamos mudar para o pensamento adaptativo para obter as respostas mais inteligentes a partir da versão 4.6. Claude Opus Nenhum cabeçalho beta é necessário.

Os modelos compatíveis são os seguintes:

Como funciona o pensamento adaptativo

No modo adaptativo, Claude avalia a complexidade de cada solicitação e decide se e 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 ativa Raciocínio intercalado (beta) automaticamente. Isso significa que é Claude capaz de pensar entre as chamadas de ferramentas, o que a torna especialmente eficaz para fluxos de trabalho de agentes.

thinking.typeDefina como "adaptive" em 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 esforço

Você pode combinar o pensamento adaptativo com o parâmetro esforço para orientar o quanto Claude o pensamento funciona. O nível de esforço atua como uma orientação suave para a alocação Claude de pensamento:

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, passe os effort parâmetros thinking e para dentro delaadditionalModelRequestFields. 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 emadditionalModelRequestFields:

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 pensamento preservam os pontos de interrupção imediatos do cache. No entanto, alternar entre os modos de disabled pensamento adaptive eenabled/quebra os pontos de interrupção do cache para 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ção 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.

Resumo do texto do conector (beta)

No 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 o 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:

Esse recurso é ativado no lado do servidor para Claude Fable 5. Não há aceitação ou exclusão do cliente.