Membangun dengan extended thinking

Extended thinking memberikan Claude kemampuan penalaran yang ditingkatkan untuk tugas-tugas kompleks, sambil menyediakan berbagai tingkat transparansi ke dalam proses pemikiran langkah demi langkah sebelum memberikan jawaban akhir.

Model yang didukung

Extended thinking didukung dalam model-model berikut:

Claude Opus 4 (claude-opus-4-20250514)
Claude Sonnet 4 (claude-sonnet-4-20250514)
Claude Sonnet 3.7 (claude-3-7-sonnet-20250219)

Perilaku API berbeda di antara model Claude 3.7 dan Claude 4, tetapi bentuk API tetap sama persis.

Untuk informasi lebih lanjut, lihat Perbedaan dalam thinking di berbagai versi model.

Cara kerja extended thinking

Ketika extended thinking diaktifkan, Claude membuat blok konten thinking di mana ia mengeluarkan penalaran internalnya. Claude menggabungkan wawasan dari penalaran ini sebelum menyusun respons akhir.

Respons API akan mencakup blok konten thinking, diikuti oleh blok konten text.

Berikut adalah contoh format respons default:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Mari saya analisis ini langkah demi langkah...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "Berdasarkan analisis saya..."
    }
  ]
}

Untuk informasi lebih lanjut tentang format respons extended thinking, lihat Referensi API Messages.

Cara menggunakan extended thinking

Berikut adalah contoh penggunaan extended thinking dalam Messages API:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Apakah ada jumlah tak terbatas bilangan prima sedemikian rupa sehingga n mod 4 == 3?"
        }
    ]
}'

Untuk mengaktifkan extended thinking, tambahkan objek thinking, dengan parameter type diatur ke enabled dan budget_tokens ke anggaran token yang ditentukan untuk extended thinking.

Parameter budget_tokens menentukan jumlah maksimum token yang diizinkan Claude gunakan untuk proses penalaran internalnya. Dalam model Claude 4, batas ini berlaku untuk token thinking penuh, dan bukan untuk output yang dirangkum. Anggaran yang lebih besar dapat meningkatkan kualitas respons dengan memungkinkan analisis yang lebih menyeluruh untuk masalah kompleks, meskipun Claude mungkin tidak menggunakan seluruh anggaran yang dialokasikan, terutama pada rentang di atas 32k.

budget_tokens harus diatur ke nilai yang kurang dari max_tokens. Namun, ketika menggunakan interleaved thinking dengan tools, Anda dapat melebihi batas ini karena batas token menjadi seluruh jendela konteks Anda (200k token).

Summarized thinking

Dengan extended thinking diaktifkan, Messages API untuk model Claude 4 mengembalikan ringkasan dari proses thinking penuh Claude. Summarized thinking memberikan manfaat kecerdasan penuh dari extended thinking, sambil mencegah penyalahgunaan.

Berikut adalah beberapa pertimbangan penting untuk summarized thinking:

Anda ditagih untuk token thinking penuh yang dihasilkan oleh permintaan asli, bukan token ringkasan.
Jumlah token output yang ditagih tidak akan cocok dengan jumlah token yang Anda lihat dalam respons.
Beberapa baris pertama output thinking lebih verbose, memberikan penalaran detail yang sangat membantu untuk tujuan prompt engineering.
Karena Anthropic berusaha meningkatkan fitur extended thinking, perilaku peringkasan dapat berubah.
Peringkasan mempertahankan ide-ide kunci dari proses thinking Claude dengan latensi tambahan minimal, memungkinkan pengalaman pengguna yang dapat di-stream dan migrasi mudah dari model Claude 3.7 ke model Claude 4.
Peringkasan diproses oleh model yang berbeda dari yang Anda targetkan dalam permintaan Anda. Model thinking tidak melihat output yang dirangkum.

Claude Sonnet 3.7 terus mengembalikan output thinking penuh.

Dalam kasus langka di mana Anda memerlukan akses ke output thinking penuh untuk model Claude 4, hubungi tim penjualan kami.

Streaming thinking

Anda dapat melakukan stream respons extended thinking menggunakan server-sent events (SSE).

Ketika streaming diaktifkan untuk extended thinking, Anda menerima konten thinking melalui event thinking_delta.

Untuk dokumentasi lebih lanjut tentang streaming melalui Messages API, lihat Streaming Messages.

Berikut cara menangani streaming dengan thinking:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "stream": true,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Berapa 27 * 453?"
        }
    ]
}'

Contoh output streaming:

event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-sonnet-4-20250514", "stop_reason": null, "stop_sequence": null}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Mari saya selesaikan ini langkah demi langkah:\n\n1. Pertama uraikan 27 * 453"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}

// Delta thinking tambahan...

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}

event: content_block_stop
data: {"type": "content_block_stop", "index": 0}

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}

// Delta text tambahan...

event: content_block_stop
data: {"type": "content_block_stop", "index": 1}

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

event: message_stop
data: {"type": "message_stop"}

Ketika menggunakan streaming dengan thinking diaktifkan, Anda mungkin memperhatikan bahwa teks terkadang tiba dalam potongan yang lebih besar bergantian dengan pengiriman yang lebih kecil, token demi token. Ini adalah perilaku yang diharapkan, terutama untuk konten thinking.

Sistem streaming perlu memproses konten dalam batch untuk kinerja optimal, yang dapat menghasilkan pola pengiriman “chunky” ini, dengan kemungkinan penundaan antara event streaming. Kami terus bekerja untuk meningkatkan pengalaman ini, dengan pembaruan masa depan yang berfokus pada membuat konten thinking streaming lebih lancar.

Extended thinking dengan penggunaan tool

Extended thinking dapat digunakan bersama dengan penggunaan tool, memungkinkan Claude untuk bernalar melalui pemilihan tool dan pemrosesan hasil.

Ketika menggunakan extended thinking dengan penggunaan tool, waspadai keterbatasan berikut:

Keterbatasan pilihan tool: Penggunaan tool dengan thinking hanya mendukung tool_choice: {"type": "auto"} (default) atau tool_choice: {"type": "none"}. Menggunakan tool_choice: {"type": "any"} atau tool_choice: {"type": "tool", "name": "..."} akan menghasilkan error karena opsi ini memaksa penggunaan tool, yang tidak kompatibel dengan extended thinking.
Mempertahankan blok thinking: Selama penggunaan tool, Anda harus mengirimkan blok thinking kembali ke API untuk pesan assistant terakhir. Sertakan blok yang lengkap dan tidak dimodifikasi kembali ke API untuk mempertahankan kontinuitas penalaran.

Contoh: Mengirimkan blok thinking dengan hasil tool

Berikut adalah contoh praktis yang menunjukkan cara mempertahankan blok thinking ketika memberikan hasil tool:

weather_tool = {
    "name": "get_weather",
    "description": "Dapatkan cuaca saat ini untuk suatu lokasi",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

# Permintaan pertama - Claude merespons dengan thinking dan permintaan tool
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Bagaimana cuaca di Paris?"}
    ]
)

Respons API akan mencakup blok thinking, text, dan tool_use:

{
    "content": [
        {
            "type": "thinking",
            "thinking": "Pengguna ingin mengetahui cuaca saat ini di Paris. Saya memiliki akses ke fungsi `get_weather`...",
            "signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
        },
        {
            "type": "text",
            "text": "Saya dapat membantu Anda mendapatkan informasi cuaca saat ini untuk Paris. Mari saya periksa itu untuk Anda"
        },
        {
            "type": "tool_use",
            "id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
            "name": "get_weather",
            "input": {
                "location": "Paris"
            }
        }
    ]
}

Sekarang mari kita lanjutkan percakapan dan gunakan tool

# Ekstrak blok thinking dan blok tool use
thinking_block = next((block for block in response.content
                      if block.type == 'thinking'), None)
tool_use_block = next((block for block in response.content
                      if block.type == 'tool_use'), None)

# Panggil API cuaca aktual Anda, di sini adalah tempat panggilan API aktual Anda akan dilakukan
# mari kita anggap ini yang kita dapatkan kembali
weather_data = {"temperature": 88}

# Permintaan kedua - Sertakan blok thinking dan hasil tool
# Tidak ada blok thinking baru yang akan dihasilkan dalam respons
continuation = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Bagaimana cuaca di Paris?"},
        # perhatikan bahwa thinking_block dikirimkan juga sebagai tool_use_block
        # jika ini tidak dikirimkan, error akan muncul
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Suhu saat ini: {weather_data['temperature']}°F"
        }]}
    ]
)

Respons API sekarang hanya akan mencakup text

{
    "content": [
        {
            "type": "text",
            "text": "Saat ini di Paris, suhunya adalah 88°F (31°C)"
        }
    ]
}

Mempertahankan blok thinking

Selama penggunaan tool, Anda harus mengirimkan blok thinking kembali ke API, dan Anda harus menyertakan blok yang lengkap dan tidak dimodifikasi kembali ke API. Ini sangat penting untuk mempertahankan alur penalaran model dan integritas percakapan.

Meskipun Anda dapat menghilangkan blok thinking dari giliran assistant sebelumnya, kami menyarankan untuk selalu mengirimkan kembali semua blok thinking ke API untuk percakapan multi-turn apa pun. API akan:

Secara otomatis memfilter blok thinking yang disediakan
Menggunakan blok thinking yang relevan yang diperlukan untuk mempertahankan penalaran model
Hanya menagih token input untuk blok yang ditunjukkan kepada Claude

Ketika Claude memanggil tools, ia menghentikan konstruksi respons untuk menunggu informasi eksternal. Ketika hasil tool dikembalikan, Claude akan melanjutkan membangun respons yang ada. Ini mengharuskan mempertahankan blok thinking selama penggunaan tool, untuk beberapa alasan:

Kontinuitas penalaran: Blok thinking menangkap penalaran langkah demi langkah Claude yang mengarah ke permintaan tool. Ketika Anda mengirimkan hasil tool, menyertakan thinking asli memastikan Claude dapat melanjutkan penalarannya dari tempat ia berhenti.
Pemeliharaan konteks: Meskipun hasil tool muncul sebagai pesan pengguna dalam struktur API, mereka adalah bagian dari alur penalaran yang berkelanjutan. Mempertahankan blok thinking mempertahankan alur konseptual ini di seluruh beberapa panggilan API. Untuk informasi lebih lanjut tentang manajemen konteks, lihat panduan kami tentang jendela konteks.

Penting: Ketika menyediakan blok thinking, seluruh urutan blok thinking berturut-turut harus cocok dengan output yang dihasilkan oleh model selama permintaan asli; Anda tidak dapat mengatur ulang atau memodifikasi urutan blok ini.

Interleaved thinking

Extended thinking dengan penggunaan tool dalam model Claude 4 mendukung interleaved thinking, yang memungkinkan Claude untuk berpikir di antara panggilan tool dan membuat penalaran yang lebih canggih setelah menerima hasil tool.

Dengan interleaved thinking, Claude dapat:

Bernalar tentang hasil panggilan tool sebelum memutuskan apa yang harus dilakukan selanjutnya
Menghubungkan beberapa panggilan tool dengan langkah penalaran di antaranya
Membuat keputusan yang lebih bernuansa berdasarkan hasil perantara

Untuk mengaktifkan interleaved thinking, tambahkan header beta interleaved-thinking-2025-05-14 ke permintaan API Anda.

Berikut adalah beberapa pertimbangan penting untuk interleaved thinking:

Dengan interleaved thinking, budget_tokens dapat melebihi parameter max_tokens, karena ini mewakili total anggaran di semua blok thinking dalam satu giliran assistant.
Interleaved thinking hanya didukung untuk tools yang digunakan melalui Messages API.
Interleaved thinking didukung untuk model Claude 4 saja, dengan header beta interleaved-thinking-2025-05-14.
Panggilan langsung ke API Anthropic memungkinkan Anda mengirimkan interleaved-thinking-2025-05-14 dalam permintaan ke model apa pun, tanpa efek.
Pada platform pihak ketiga (misalnya, Amazon Bedrock dan Vertex AI), jika Anda mengirimkan interleaved-thinking-2025-05-14 ke model apa pun selain Claude Opus 4 atau Sonnet 4, permintaan Anda akan gagal.

Penggunaan tool tanpa interleaved thinking

import anthropic

client = anthropic.Anthropic()

# Definisikan tools
calculator_tool = {
    "name": "calculator",
    "description": "Lakukan perhitungan matematika",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Ekspresi matematika untuk dievaluasi"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Query database produk",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Query SQL untuk dieksekusi"
            }
        },
        "required": ["query"]
    }
}

# Permintaan pertama - Claude berpikir sekali sebelum semua panggilan tool
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    messages=[{
        "role": "user",
        "content": "Berapa total pendapatan jika kita menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kita dari database?"
    }]
)

# Respons mencakup thinking diikuti oleh penggunaan tool
# Catatan: Claude berpikir sekali di awal, kemudian membuat semua keputusan tool
print("Respons pertama:")
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking (dirangkum): {block.thinking}")
    elif block.type == "tool_use":
        print(f"Penggunaan tool: {block.name} dengan input {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# Anda akan mengeksekusi tools dan mengembalikan hasil...
# Setelah mendapatkan kedua hasil tool kembali, Claude langsung merespons tanpa thinking tambahan

Dalam contoh ini tanpa interleaved thinking:

Claude berpikir sekali di awal untuk memahami tugas
Membuat semua keputusan penggunaan tool di muka
Ketika hasil tool dikembalikan, Claude segera memberikan respons tanpa thinking tambahan

Penggunaan tool dengan interleaved thinking

import anthropic

client = anthropic.Anthropic()

# Definisi tool yang sama seperti sebelumnya
calculator_tool = {
    "name": "calculator",
    "description": "Lakukan perhitungan matematika",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Ekspresi matematika untuk dievaluasi"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Query database produk",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Query SQL untuk dieksekusi"
            }
        },
        "required": ["query"]
    }
}

# Permintaan pertama dengan interleaved thinking diaktifkan
response = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[{
        "role": "user",
        "content": "Berapa total pendapatan jika kita menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kita dari database?"
    }]
)

print("Respons awal:")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Thinking: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Penggunaan tool: {block.name} dengan input {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# Hasil tool pertama (calculator)
calculator_result = "7500"  # 150 * 50

# Lanjutkan dengan hasil tool pertama
response2 = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "Berapa total pendapatan jika kita menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kita dari database?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        }
    ]
)

print("\nSetelah hasil calculator:")
# Dengan interleaved thinking, Claude dapat berpikir tentang hasil calculator
# sebelum memutuskan untuk query database
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Interleaved thinking: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Penggunaan tool: {block.name} dengan input {block.input}")

# Hasil tool kedua (database)
database_result = "5200"  # Contoh pendapatan bulanan rata-rata

# Lanjutkan dengan hasil tool kedua
response3 = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "Berapa total pendapatan jika kita menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kita dari database?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        },
        {
            "role": "assistant",
            "content": thinking_blocks[1:] + tool_use_blocks[1:]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[1].id,
                "content": database_result
            }]
        }
    ]
)

print("\nSetelah hasil database:")
# Dengan interleaved thinking, Claude dapat berpikir tentang kedua hasil
# sebelum merumuskan respons akhir
for block in response3.content:
    if block.type == "thinking":
        print(f"Thinking akhir: {block.thinking}")
    elif block.type == "text":
        print(f"Respons akhir: {block.text}")

Dalam contoh ini dengan interleaved thinking:

Claude berpikir tentang tugas awalnya
Setelah menerima hasil calculator, Claude dapat berpikir lagi tentang apa arti hasil tersebut
Claude kemudian memutuskan bagaimana melakukan query database berdasarkan hasil pertama
Setelah menerima hasil database, Claude berpikir sekali lagi tentang kedua hasil sebelum merumuskan respons akhir
Anggaran thinking didistribusikan di semua blok thinking dalam giliran

Pola ini memungkinkan rantai penalaran yang lebih canggih di mana output setiap tool menginformasikan keputusan berikutnya.

Extended thinking dengan prompt caching

Prompt caching dengan thinking memiliki beberapa pertimbangan penting:

Tugas extended thinking sering memakan waktu lebih dari 5 menit untuk diselesaikan. Pertimbangkan menggunakan durasi cache 1 jam untuk mempertahankan cache hit di seluruh sesi thinking yang lebih lama dan alur kerja multi-langkah.

Penghapusan konteks blok thinking

Blok thinking dari giliran sebelumnya dihapus dari konteks, yang dapat mempengaruhi breakpoint cache
Ketika melanjutkan percakapan dengan penggunaan tool, blok thinking di-cache dan dihitung sebagai token input ketika dibaca dari cache
Ini menciptakan trade-off: meskipun blok thinking tidak mengonsumsi ruang jendela konteks secara visual, mereka masih dihitung terhadap penggun aan token input Anda ketika di-cache
Jika thinking menjadi dinonaktifkan, permintaan akan gagal jika Anda mengirimkan konten thinking dalam giliran penggunaan tool saat ini. Dalam konteks lain, konten thinking yang dikirimkan ke API hanya diabaikan

Pola invalidasi cache

Perubahan pada parameter thinking (diaktifkan/dinonaktifkan atau alokasi anggaran) membatalkan breakpoint cache pesan
Interleaved thinking memperkuat invalidasi cache, karena blok thinking dapat terjadi di antara beberapa panggilan tool
Prompt sistem dan tools tetap di-cache meskipun parameter thinking berubah atau blok dihapus

Meskipun blok thinking dihapus untuk caching dan perhitungan konteks, mereka harus dipertahankan ketika melanjutkan percakapan dengan penggunaan tool, terutama dengan interleaved thinking.

Memahami perilaku caching blok thinking

Ketika menggunakan extended thinking dengan penggunaan tool, blok thinking menunjukkan perilaku caching spesifik yang mempengaruhi penghitungan token:

Cara kerjanya:

Caching hanya terjadi ketika Anda membuat permintaan berikutnya yang mencakup hasil tool
Ketika permintaan berikutnya dibuat, riwayat percakapan sebelumnya (termasuk blok thinking) dapat di-cache
Blok thinking yang di-cache ini dihitung sebagai token input dalam metrik penggunaan Anda ketika dibaca dari cache
Ketika blok pengguna non-tool-result disertakan, semua blok thinking sebelumnya diabaikan dan dihapus dari konteks

Contoh alur detail:

Permintaan 1:

User: "Bagaimana cuaca di Paris?"

Respons 1:

[thinking_block_1] + [tool_use block 1]

Permintaan 2:

User: ["Bagaimana cuaca di Paris?"], 
Assistant: [thinking_block_1] + [tool_use block 1], 
User: [tool_result_1, cache=True]

Respons 2:

[thinking_block_2] + [text block 2]

Permintaan 2 menulis cache dari konten permintaan (bukan respons). Cache mencakup pesan pengguna asli, blok thinking pertama, blok penggunaan tool, dan hasil tool.

Permintaan 3:

User: ["Bagaimana cuaca di Paris?"], 
Assistant: [thinking_block_1] + [tool_use block 1], 
User: [tool_result_1, cache=True], 
Assistant: [thinking_block_2] + [text block 2], 
User: [Text response, cache=True]

Karena blok pengguna non-tool-result disertakan, semua blok thinking sebelumnya diabaikan. Permintaan ini akan diproses sama seperti:

User: ["Bagaimana cuaca di Paris?"], 
Assistant: [tool_use block 1], 
User: [tool_result_1, cache=True], 
Assistant: [text block 2], 
User: [Text response, cache=True]

Poin kunci:

Perilaku caching ini terjadi secara otomatis, bahkan tanpa penanda cache_control eksplisit
Perilaku ini konsisten baik menggunakan thinking reguler atau interleaved thinking

Caching prompt sistem (dipertahankan ketika thinking berubah)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Hapus elemen script dan style
    for script in soup(["script", "style"]):
        script.decompose()

    # Dapatkan teks
    text = soup.get_text()

    # Pecah menjadi baris dan hapus spasi di awal dan akhir pada setiap baris
    lines = (line.strip() for line in text.splitlines())
    # Pecah multi-headline menjadi satu baris masing-masing
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Buang baris kosong
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Ambil konten artikel
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Gunakan teks yang cukup untuk caching (beberapa bab pertama)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "Anda adalah asisten AI yang bertugas melakukan analisis sastra. Analisis teks berikut dengan hati-hati.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Analisis nada dari bagian ini."
    }
]

# Permintaan pertama - buat cache
print("Permintaan pertama - membuat cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Penggunaan respons pertama: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analisis karakter dalam bagian ini."
})
# Permintaan kedua - parameter thinking sama (cache hit diharapkan)
print("\nPermintaan kedua - parameter thinking sama (cache hit diharapkan)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Penggunaan respons kedua: {response2.usage}")

# Permintaan ketiga - parameter thinking berbeda (cache miss untuk pesan)
print("\nPermintaan ketiga - parameter thinking berbeda (cache miss untuk pesan)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Anggaran thinking berubah
    },
    system=SYSTEM_PROMPT,  # Prompt sistem tetap di-cache
    messages=MESSAGES  # Cache pesan dibatalkan
)

print(f"Penggunaan respons ketiga: {response3.usage}")

Caching pesan (dibatalkan ketika thinking berubah)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Hapus elemen script dan style
    for script in soup(["script", "style"]):
        script.decompose()

    # Dapatkan teks
    text = soup.get_text()

    # Pecah menjadi baris dan hapus spasi di awal dan akhir pada setiap baris
    lines = (line.strip() for line in text.splitlines())
    # Pecah multi-headline menjadi satu baris masing-masing
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Buang baris kosong
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Ambil konten artikel
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Gunakan teks yang cukup untuk caching (beberapa bab pertama)
LARGE_TEXT = book_content[:5000]

# Tidak ada prompt sistem - caching di pesan sebagai gantinya
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Analisis nada dari bagian ini."
            }
        ]
    }
]

# Permintaan pertama - buat cache
print("Permintaan pertama - membuat cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"Penggunaan respons pertama: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analisis karakter dalam bagian ini."
})
# Permintaan kedua - parameter thinking sama (cache hit diharapkan)
print("\nPermintaan kedua - parameter thinking sama (cache hit diharapkan)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Anggaran thinking sama
    },
    messages=MESSAGES
)

print(f"Penggunaan respons kedua: {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analisis latar dalam bagian ini."
})

# Permintaan ketiga - anggaran thinking berbeda (cache miss diharapkan)
print("\nPermintaan ketiga - anggaran thinking berbeda (cache miss diharapkan)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Anggaran thinking berbeda merusak cache
    },
    messages=MESSAGES
)

print(f"Penggunaan respons ketiga: {response3.usage}")

Berikut adalah output dari script (Anda mungkin melihat angka yang sedikit berbeda)

Permintaan pertama - membuat cache
Penggunaan respons pertama: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Permintaan kedua - parameter thinking sama (cache hit diharapkan)

Penggunaan respons kedua: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Permintaan ketiga - anggaran thinking berbeda (cache miss diharapkan)
Penggunaan respons ketiga: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Contoh ini menunjukkan bahwa ketika caching diatur dalam array pesan, mengubah parameter thinking (budget_tokens ditingkatkan dari 4000 ke 8000) membatalkan cache. Permintaan ketiga menunjukkan tidak ada cache hit dengan cache_creation_input_tokens=1370 dan cache_read_input_tokens=0, membuktikan bahwa caching berbasis pesan dibatalkan ketika parameter thinking berubah.

Max tokens dan ukuran jendela konteks dengan extended thinking

Dalam model Claude yang lebih lama (sebelum Claude Sonnet 3.7), jika jumlah token prompt dan max_tokens melebihi jendela konteks model, sistem akan secara otomatis menyesuaikan max_tokens agar sesuai dengan batas konteks. Ini berarti Anda dapat mengatur nilai max_tokens yang besar dan sistem akan secara diam-diam menguranginya sesuai kebutuhan.

Dengan model Claude 3.7 dan 4, max_tokens (yang mencakup anggaran thinking Anda ketika thinking diaktifkan) diberlakukan sebagai batas yang ketat. Sistem sekarang akan mengembalikan error validasi jika token prompt + max_tokens melebihi ukuran jendela konteks.

Anda dapat membaca panduan kami tentang jendela konteks untuk pendalaman yang lebih menyeluruh.

Jendela konteks dengan extended thinking

Ketika menghitung penggunaan jendela konteks dengan thinking diaktifkan, ada beberapa pertimbangan yang perlu diketahui:

Blok thinking dari giliran sebelumnya dihapus dan tidak dihitung terhadap jendela konteks Anda
Thinking giliran saat ini dihitung terhadap batas max_tokens Anda untuk giliran tersebut

Diagram di bawah ini menunjukkan manajemen token khusus ketika extended thinking diaktifkan:

Jendela konteks efektif dihitung sebagai:

jendela konteks =
  (token input saat ini - token thinking sebelumnya) +
  (token thinking + token thinking terenkripsi + token output teks)

Kami merekomendasikan menggunakan API penghitungan token untuk mendapatkan jumlah token yang akurat untuk kasus penggunaan spesifik Anda, terutama ketika bekerja dengan percakapan multi-turn yang mencakup thinking.

Jendela konteks dengan extended thinking dan penggunaan tool

Ketika menggunakan extended thinking dengan penggunaan tool, blok thinking harus secara eksplisit dipertahankan dan dikembalikan dengan hasil tool.

Perhitungan jendela konteks efektif untuk extended thinking dengan penggunaan tool menjadi:

jendela konteks =
  (token input saat ini + token thinking sebelumnya + token penggunaan tool) +
  (token thinking + token thinking terenkripsi + token output teks)

Diagram di bawah ini mengilustrasikan manajemen token untuk extended thinking dengan penggunaan tool:

Mengelola token dengan extended thinking

Mengingat perilaku jendela konteks dan max_tokens dengan model extended thinking Claude 3.7 dan 4, Anda mungkin perlu:

Lebih aktif memantau dan mengelola penggunaan token Anda
Menyesuaikan nilai max_tokens saat panjang prompt Anda berubah
Berpotensi menggunakan endpoint penghitungan token lebih sering
Menyadari bahwa blok thinking sebelumnya tidak terakumulasi dalam jendela konteks Anda

Perubahan ini telah dibuat untuk memberikan perilaku yang lebih dapat diprediksi dan transparan, terutama karena batas token maksimum telah meningkat secara signifikan.

Enkripsi thinking

Konten thinking penuh dienkripsi dan dikembalikan dalam field signature. Field ini digunakan untuk memverifikasi bahwa blok thinking dihasilkan oleh Claude ketika dikirimkan kembali ke API.

Hanya benar-benar diperlukan untuk mengirimkan kembali blok thinking ketika menggunakan tools dengan extended thinking. Jika tidak, Anda dapat menghilangkan blok thinking dari giliran sebelumnya, atau membiarkan API menghapusnya untuk Anda jika Anda mengirimkannya kembali.

Jika mengirimkan kembali blok thinking, kami merekomendasikan mengirimkan semuanya kembali seperti yang Anda terima untuk konsistensi dan untuk menghindari masalah potensial.

Berikut adalah beberapa pertimbangan penting tentang enkripsi thinking:

Ketika streaming respons, signature ditambahkan melalui signature_delta di dalam event content_block_delta tepat sebelum event content_block_stop.
Nilai signature secara signifikan lebih panjang di Claude 4 daripada di model sebelumnya.
Field signature adalah field opaque dan tidak boleh diinterpretasikan atau di-parse - ia ada semata-mata untuk tujuan verifikasi.
Nilai signature kompatibel di seluruh platform (API Anthropic, Amazon Bedrock, dan Vertex AI). Nilai yang dihasilkan di satu platform akan kompatibel dengan platform lain.

Redaksi thinking

Kadang-kadang penalaran internal Claude akan ditandai oleh sistem keamanan kami. Ketika ini terjadi, kami mengenkripsi sebagian atau semua blok thinking dan mengembalikannya kepada Anda sebagai blok redacted_thinking. Blok redacted_thinking didekripsi ketika dikirimkan kembali ke API, memungkinkan Claude untuk melanjutkan responsnya tanpa kehilangan konteks.

Ketika membangun aplikasi yang menghadap pelanggan yang menggunakan extended thinking:

Waspadai bahwa blok redacted thinking berisi konten terenkripsi yang tidak dapat dibaca manusia
Pertimbangkan memberikan penjelasan sederhana seperti: “Beberapa penalaran internal Claude telah dienkripsi secara otomatis untuk alasan keamanan. Ini tidak mempengaruhi kualitas respons.”
Jika menampilkan blok thinking kepada pengguna, Anda dapat memfilter blok yang diredaksi sambil mempertahankan blok thinking normal
Bersikap transparan bahwa menggunakan fitur extended thinking mungkin kadang-kadang menghasilkan beberapa penalaran yang dienkripsi
Implementasikan penanganan error yang tepat untuk mengelola redacted thinking dengan baik tanpa merusak UI Anda

Berikut adalah contoh yang menunjukkan blok thinking normal dan yang diredaksi:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Mari saya analisis ini langkah demi langkah...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "redacted_thinking",
      "data": "EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpPkNRj2YfWXGmKDxH4mPnZ5sQ7vB9URj2pLmN3kF8/dW5hR7xJ0aP1oLs9yTcMnKVf2wRpEGjH9XZaBt4UvDcPrQ..."
    },
    {
      "type": "text",
      "text": "Berdasarkan analisis saya..."
    }
  ]
}

Melihat blok redacted thinking dalam output Anda adalah perilaku yang diharapkan. Model masih dapat menggunakan penalaran yang diredaksi ini untuk menginformasikan responsnya sambil mempertahankan pagar keamanan.

Jika Anda perlu menguji penanganan redacted thinking dalam aplikasi Anda, Anda dapat menggunakan string tes khusus ini sebagai prompt Anda: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

Ketika mengirimkan blok thinking dan redacted_thinking kembali ke API dalam percakapan multi-turn, Anda harus menyertakan blok yang lengkap dan tidak dimodifikasi kembali ke API untuk giliran assistant terakhir. Ini sangat penting untuk mempertahankan alur penalaran model. Kami menyarankan untuk selalu mengirimkan kembali semua blok thinking ke API. Untuk detail lebih lanjut, lihat bagian Mempertahankan blok thinking di atas.

Contoh: Bekerja dengan blok redacted thinking

Contoh ini menunjukkan cara menangani blok redacted_thinking yang mungkin muncul dalam respons ketika penalaran internal Claude berisi konten yang ditandai oleh sistem keamanan:

import anthropic

client = anthropic.Anthropic()

# Menggunakan prompt khusus yang memicu redacted thinking (hanya untuk tujuan demonstrasi)
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
    }]
)

# Identifikasi blok redacted thinking
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("Respons berisi blok redacted thinking")
    # Blok ini masih dapat digunakan dalam permintaan berikutnya

    # Ekstrak semua blok (baik yang diredaksi maupun tidak)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # Ketika mengirimkan ke permintaan berikutnya, sertakan semua blok tanpa modifikasi
    # Ini mempertahankan integritas penalaran Claude

    print(f"Ditemukan {len(all_thinking_blocks)} blok thinking total")
    print(f"Blok ini masih dapat ditagih sebagai token output")

Perbedaan dalam thinking di berbagai versi model

Messages API menangani thinking secara berbeda di antara model Claude Sonnet 3.7 dan Claude 4, terutama dalam perilaku redaksi dan peringkasan.

Lihat tabel di bawah ini untuk perbandingan yang diringkas:

Fitur	Claude Sonnet 3.7	Model Claude 4
Output Thinking	Mengembalikan output thinking penuh	Mengembalikan thinking yang dirangkum
Interleaved Thinking	Tidak didukung	Didukung dengan header beta `interleaved-thinking-2025-05-14`

Harga

Extended thinking menggunakan skema harga token standar:

Model	Token Input Dasar	Cache Writes	Cache Hits	Token Output
Claude Opus 4	$15 / MTok	$18.75 / MTok	$1.50 / MTok	$75 / MTok
Claude Sonnet 4	$3 / MTok	$3.75 / MTok	$0.30 / MTok	$15 / MTok
Claude Sonnet 3.7	$3 / MTok	$3.75 / MTok	$0.30 / MTok	$15 / MTok

Proses thinking menimbulkan biaya untuk:

Token yang digunakan selama thinking (token output)
Blok thinking dari giliran assistant terakhir yang disertakan dalam permintaan berikutnya (token input)
Token output teks standar

Ketika extended thinking diaktifkan, prompt sistem khusus secara otomatis disertakan untuk mendukung fitur ini.

Ketika menggunakan summarized thinking:

Token input: Token dalam permintaan asli Anda (tidak termasuk token thinking dari giliran sebelumnya)
Token output (ditagih): Token thinking asli yang dihasilkan Claude secara internal
Token output (terlihat): Token thinking yang dirangkum yang Anda lihat dalam respons
Tidak ada biaya: Token yang digunakan untuk menghasilkan ringkasan

Jumlah token output yang ditagih tidak akan cocok dengan jumlah token yang terlihat dalam respons. Anda ditagih untuk proses thinking penuh, bukan ringkasan yang Anda lihat.

Praktik terbaik dan pertimbangan untuk extended thinking

Bekerja dengan anggaran thinking

Optimisasi anggaran: Anggaran minimum adalah 1.024 token. Kami menyarankan untuk memulai dengan minimum dan meningkatkan anggaran thinking secara bertahap untuk menemukan rentang optimal untuk kasus penggunaan Anda. Jumlah token yang lebih tinggi memungkinkan penalaran yang lebih komprehensif tetapi dengan hasil yang semakin berkurang tergantung pada tugas. Meningkatkan anggaran dapat meningkatkan kualitas respons dengan trade-off peningkatan latensi. Untuk tugas kritis, uji pengaturan yang berbeda untuk menemukan keseimbangan optimal. Perhatikan bahwa anggaran thinking adalah target daripada batas yang ketat—penggunaan token aktual dapat bervariasi berdasarkan tugas.
Titik awal: Mulai dengan anggaran thinking yang lebih besar (16k+ token) untuk tugas kompleks dan sesuaikan berdasarkan kebutuhan Anda.
Anggaran besar: Untuk anggaran thinking di atas 32k, kami merekomendasikan menggunakan batch processing untuk menghindari masalah jaringan. Permintaan yang mendorong model untuk berpikir di atas 32k token menyebabkan permintaan yang berjalan lama yang mungkin bertabrakan dengan timeout sistem dan batas koneksi terbuka.
Pelacakan penggunaan token: Pantau penggunaan token thinking untuk mengoptimalkan biaya dan kinerja.

Pertimbangan kinerja

Waktu respons: Bersiaplah untuk waktu respons yang berpotensi lebih lama karena pemrosesan tambahan yang diperlukan untuk proses penalaran. Faktor bahwa menghasilkan blok thinking dapat meningkatkan waktu respons keseluruhan.
Persyaratan streaming: Streaming diperlukan ketika max_tokens lebih besar dari 21.333. Ketika streaming, bersiaplah untuk menangani blok konten thinking dan teks saat mereka tiba.

Kompatibilitas fitur

Thinking tidak kompatibel dengan modifikasi temperature atau top_k serta penggunaan tool paksa.
Ketika thinking diaktifkan, Anda dapat mengatur top_p ke nilai antara 1 dan 0,95.
Anda tidak dapat melakukan pre-fill respons ketika thinking diaktifkan.
Perubahan pada anggaran thinking membatalkan prefiks prompt yang di-cache yang mencakup pesan. Namun, prompt sistem dan definisi tool yang di-cache akan terus bekerja ketika parameter thinking berubah.

Panduan penggunaan

Pemilihan tugas: Gunakan extended thinking untuk tugas yang sangat kompleks yang mendapat manfaat dari penalaran langkah demi langkah seperti matematika, coding, dan analisis.
Penanganan konteks: Anda tidak perlu menghapus blok thinking sebelumnya sendiri. API Anthropic secara otomatis mengabaikan blok thinking dari giliran sebelumnya dan mereka tidak disertakan ketika menghitung penggunaan konteks.
Prompt engineering: Tinjau tips prompting extended thinking kami jika Anda ingin memaksimalkan kemampuan thinking Claude.

Langkah selanjutnya

Coba cookbook extended thinking

Jelajahi contoh praktis thinking dalam cookbook kami.

Tips prompting extended thinking

Pelajari praktik terbaik prompt engineering untuk extended thinking.

Prompt caching Streaming Messages

On this page

Model yang didukung
Cara kerja extended thinking
Cara menggunakan extended thinking
Summarized thinking
Streaming thinking
Extended thinking dengan penggunaan tool
Mempertahankan blok thinking
Interleaved thinking
Extended thinking dengan prompt caching
Memahami perilaku caching blok thinking
Max tokens dan ukuran jendela konteks dengan extended thinking
Jendela konteks dengan extended thinking
Jendela konteks dengan extended thinking dan penggunaan tool
Mengelola token dengan extended thinking
Enkripsi thinking
Redaksi thinking
Perbedaan dalam thinking di berbagai versi model
Harga
Praktik terbaik dan pertimbangan untuk extended thinking
Bekerja dengan anggaran thinking
Pertimbangan kinerja
Kompatibilitas fitur
Panduan penggunaan
Langkah selanjutnya

Langkah pertama

Model & harga

Pelajari tentang Claude

Kemampuan

Alat

Model Context Protocol (MCP)

Kasus penggunaan

Rekayasa prompt

Uji & evaluasi

Perkuat pagar pengaman

Pusat Hukum

Membangun dengan extended thinking

Model yang didukung

Cara kerja extended thinking

Cara menggunakan extended thinking

Summarized thinking

Streaming thinking

Extended thinking dengan penggunaan tool

Mempertahankan blok thinking

Interleaved thinking

Extended thinking dengan prompt caching

Memahami perilaku caching blok thinking

Max tokens dan ukuran jendela konteks dengan extended thinking

Jendela konteks dengan extended thinking

Jendela konteks dengan extended thinking dan penggunaan tool

Mengelola token dengan extended thinking

Enkripsi thinking

Redaksi thinking

Perbedaan dalam thinking di berbagai versi model

Harga

Praktik terbaik dan pertimbangan untuk extended thinking

Bekerja dengan anggaran thinking

Pertimbangan kinerja

Kompatibilitas fitur

Panduan penggunaan

Langkah selanjutnya

Coba cookbook extended thinking

Tips prompting extended thinking

Langkah pertama

Model & harga

Pelajari tentang Claude

Kemampuan

Alat

Model Context Protocol (MCP)

Kasus penggunaan

Rekayasa prompt

Uji & evaluasi

Perkuat pagar pengaman

Pusat Hukum

​Model yang didukung

​Cara kerja extended thinking

​Cara menggunakan extended thinking

​Summarized thinking

​Streaming thinking

​Extended thinking dengan penggunaan tool

​Mempertahankan blok thinking

​Interleaved thinking

​Extended thinking dengan prompt caching

​Memahami perilaku caching blok thinking

​Max tokens dan ukuran jendela konteks dengan extended thinking

​Jendela konteks dengan extended thinking

​Jendela konteks dengan extended thinking dan penggunaan tool

​Mengelola token dengan extended thinking

​Enkripsi thinking

​Redaksi thinking

​Perbedaan dalam thinking di berbagai versi model

​Harga

​Praktik terbaik dan pertimbangan untuk extended thinking

​Bekerja dengan anggaran thinking

​Pertimbangan kinerja

​Kompatibilitas fitur

​Panduan penggunaan

​Langkah selanjutnya

Coba cookbook extended thinking

Tips prompting extended thinking

Model yang didukung

Cara kerja extended thinking

Cara menggunakan extended thinking

Summarized thinking

Streaming thinking

Extended thinking dengan penggunaan tool

Mempertahankan blok thinking

Interleaved thinking

Extended thinking dengan prompt caching

Memahami perilaku caching blok thinking

Max tokens dan ukuran jendela konteks dengan extended thinking

Jendela konteks dengan extended thinking

Jendela konteks dengan extended thinking dan penggunaan tool

Mengelola token dengan extended thinking

Enkripsi thinking

Redaksi thinking

Perbedaan dalam thinking di berbagai versi model

Harga

Praktik terbaik dan pertimbangan untuk extended thinking

Bekerja dengan anggaran thinking

Pertimbangan kinerja

Kompatibilitas fitur

Panduan penggunaan

Langkah selanjutnya