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 modo consigliato di utilizzare Pensiero esteso con Claude Opus 4.6. Invece di impostare manualmente un budget di Thinking Token, il pensiero adattivo consente di decidere Claude dinamicamente quando e quanto pensare in base alla complessità di ogni richiesta. Il pensiero adattivo migliora in modo affidabile le prestazioni rispetto al pensiero esteso con un approccio fisso budget_tokens e consigliamo di passare al pensiero adattivo per ottenere le risposte più intelligenti a partire dalla versione 4.6. Claude Opus Non è richiesta alcuna intestazione beta.

I modelli supportati sono i seguenti:

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.

Anche il pensiero adattivo lo abilita automaticamente. Pensiero interlacciato (beta) Ciò significa che è in Claude grado di pensare tra una chiamata all'altra degli strumenti, 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 l'effetto del pensieroClaude. Il livello di impegno funge da guida morbida per l'allocazione Claude del pensiero:

L'esempio seguente mostra come impostare il livello di impegno quando si utilizza l' 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"
    }]
}

Usare il pensiero adattivo con l'API Converse

Quando usi l'API Converse, passa i parametri thinking and effort all'interno. additionalModelRequestFields L'esempio seguente mostra il pensiero adattivo con il livello di impegno predefinito:

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

Per specificare un livello di impegno, aggiungi il effort campo all'interno di un output_config oggetto separato inadditionalModelRequestFields:

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

Caching dei prompt

Le richieste consecutive che utilizzano adaptive thinking preservano i breakpoint della cache dei prompt. Tuttavia, il passaggio tra le modalità adaptive eenabled/disabledthinking interrompe i punti di interruzione della cache per i messaggi. I prompt di sistema e le definizioni degli strumenti rimangono memorizzati nella cache indipendentemente dalle modifiche alla modalità.

Ottimizzazione del comportamento mentale

Se Claude sta pensando più o meno spesso di quanto vorresti, puoi aggiungere una guida al prompt del tuo 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.

Riepilogo del testo del connettore (beta)

In Claude Fable 5, il testo che il modello emette tra una chiamata allo strumento e l'altra (a volte chiamato «testo del connettore», ad esempio «Fammi controllare il file successivo...») viene riepilogato sul lato server e restituito come blocco di pensiero anziché come blocco di contenuto di testo semplice. Il blocco di pensiero utilizza la stessa forma di qualsiasi altro blocco di pensiero (testo vuoto con una firma nella visualizzazione predefinita). omitted

Impatto sul cliente:

Questa funzionalità è abilitata lato server per Claude Fable 5. Non è previsto alcun opt-in o opt-out da parte del cliente.