Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Pemikiran adaptif

Pemikiran adaptif adalah cara yang disarankan untuk digunakan Pemikiran yang diperluas dengan Claude Opus 4.6. Alih-alih menetapkan anggaran token pemikiran secara manual, pemikiran adaptif memungkinkan Claude secara dinamis memutuskan kapan dan berapa banyak yang harus dipikirkan berdasarkan kompleksitas setiap permintaan. Pemikiran adaptif secara andal mendorong kinerja yang lebih baik daripada pemikiran yang diperluas dengan pemikiran yang tetapbudget_tokens, dan kami merekomendasikan beralih ke pemikiran adaptif untuk mendapatkan respons paling cerdas dari 4.6. Claude Opus Tidak diperlukan header beta.

Model yang didukung adalah sebagai berikut:

Cara kerja pemikiran adaptif

Dalam mode adaptif, Claude mengevaluasi kompleksitas setiap permintaan dan memutuskan apakah dan berapa banyak yang harus dipikirkan. Pada tingkat upaya default (high), hampir selalu Claude akan berpikir. Pada tingkat usaha yang lebih rendah, Claude mungkin melewatkan pemikiran untuk masalah yang lebih sederhana.

Pemikiran adaptif juga secara otomatis memungkinkanPemikiran yang disisipkan (beta). Ini berarti Claude dapat berpikir di antara panggilan alat, membuatnya sangat efektif untuk alur kerja agen.

Setel thinking.type ke "adaptive" dalam permintaan API Anda:

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

Berpikir adaptif dengan parameter usaha

Anda dapat menggabungkan pemikiran adaptif dengan parameter upaya untuk memandu seberapa banyak pemikiran yang Claude dilakukan. Tingkat upaya bertindak sebagai panduan lunak untuk Claude alokasi pemikiran:

Contoh berikut menunjukkan cara mengatur level usaha saat menggunakan 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"
    }]
}

Menggunakan pemikiran adaptif dengan Converse API

Saat menggunakan Converse API, teruskan effort parameter thinking dan di dalamnyaadditionalModelRequestFields. Contoh berikut menunjukkan pemikiran adaptif dengan tingkat upaya default:

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

Untuk menentukan tingkat usaha, tambahkan effort bidang di dalam output_config objek terpisah diadditionalModelRequestFields:

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 cepat

Permintaan berturut-turut menggunakan adaptive pemikiran mempertahankan breakpoint cache yang cepat. Namun, beralih antara adaptive danenabled/mode disabled berpikir memecah breakpoint cache untuk pesan. Permintaan sistem dan definisi alat tetap di-cache terlepas dari perubahan mode.

Menyetel perilaku berpikir

Jika berpikir Claude lebih atau kurang sering dari yang Anda inginkan, Anda dapat menambahkan panduan ke prompt sistem Anda:

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.

Ringkasan teks konektor (beta)

Pada Claude Fable 5, teks yang dipancarkan model di antara panggilan alat (kadang-kadang disebut “teks konektor” - misalnya, “Biarkan saya memeriksa file itu berikutnya...”) diringkas sisi server dan dikembalikan sebagai blok pemikiran daripada blok konten teks biasa. Blok berpikir menggunakan bentuk yang sama seperti blok berpikir lainnya (teks kosong dengan tanda tangan di bawah omitted tampilan default).

Dampak pelanggan:

Fitur ini diaktifkan sisi server untuk Claude Fable 5. Tidak ada opt-in atau opt-out pelanggan.