Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Pensamiento adaptativo

El pensamiento adaptativo es la forma recomendada de usar Pensamiento extendido con la Claude Opus versión 4.6. En lugar de establecer manualmente un presupuesto de fichas de pensamiento, el pensamiento adaptativo permite decidir de Claude forma dinámica cuándo y cuánto pensar en función de la complejidad de cada solicitud. El pensamiento adaptativo genera un mejor rendimiento de forma fiable que el pensamiento extendido con un budget_tokens enfoque fijo, y recomendamos pasar al pensamiento adaptativo para obtener las respuestas más inteligentes a partir de la Claude Opus versión 4.6. No se requiere ningún encabezado beta.

Los modelos admitidos son los siguientes:

Cómo funciona el pensamiento adaptativo

En el modo adaptativo, Claude evalúa la complejidad de cada solicitud y decide si hay que pensar y en qué medida. En el nivel de esfuerzo predeterminado (high), casi siempre Claude pensará. En niveles de esfuerzo más bajos, Claude puede dejar de pensar en problemas más simples.

El pensamiento adaptativo también posibilita automáticamentePensamiento intercalado (beta). Esto significa que Claude puede pensar entre llamadas de herramientas, lo que lo hace especialmente efectivo para los flujos de trabajo de las agencias.

thinking.typeConfigúralo como "adaptive" en tu solicitud 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);

Pensamiento adaptativo con el parámetro de esfuerzo

Puedes combinar el pensamiento adaptativo con el parámetro de esfuerzo para determinar cuánto Claude se piensa. El nivel de esfuerzo actúa como una guía básica para Claude la asignación del pensamiento:

El siguiente ejemplo muestra cómo establecer el nivel de esfuerzo al usar la 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"
    }]
}

Uso del pensamiento adaptativo con la API de Converse

Cuando utilices la API de Converse, introduce los effort parámetros thinking y. additionalModelRequestFields El siguiente ejemplo muestra el pensamiento adaptativo con el nivel de esfuerzo predeterminado:

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 un nivel de esfuerzo, añada el effort campo dentro de un output_config objeto independiente enadditionalModelRequestFields:

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"
        }
    }
)

Almacenamiento en caché de peticiones

Las solicitudes consecutivas que utilizan el adaptive pensamiento preservan rápidamente los puntos de interrupción de la caché. Sin embargo, al cambiar entre los modos de disabled pensamiento adaptive yenabled/se rompen los puntos de interrupción de la caché de los mensajes. Las instrucciones del sistema y las definiciones de las herramientas permanecen en caché independientemente de los cambios de modo.

Ajustar el comportamiento del pensamiento

Si Claude piensas con más o menos frecuencia de la que te gustaría, puedes añadir instrucciones al mensaje 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.

Resumen del texto del conector (beta)

En Claude Fable 5, el texto que el modelo emite entre las llamadas a las herramientas (a veces denominado «texto del conector», por ejemplo, «Déjame comprobar ese archivo a continuación...») se resume en el servidor y se devuelve como un bloque de pensamiento en lugar de como un bloque de contenido de texto sin formato. El bloque de pensamiento usa la misma forma que cualquier otro bloque de pensamiento (texto vacío con una firma en la pantalla predeterminada). omitted

Impacto en los clientes:

Esta función está habilitada en el lado del servidor para Claude Fable 5. El cliente no acepta ni se excluye.