Membangun dengan pemikiran yang diperluas

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

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

# Ekstrak blok pemikiran dan blok penggunaan alat
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 pura-pura ini adalah apa yang kami dapatkan kembali
weather_data = {"temperature": 88}

# Permintaan kedua - Sertakan blok pemikiran dan hasil alat
# Tidak ada blok pemikiran baru yang akan dihasilkan dalam respons
continuation = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Bagaimana cuaca di Paris?"},
        # perhatikan bahwa thinking_block dilewatkan bersama dengan tool_use_block
        # jika ini tidak dilewatkan, kesalahan akan dimunculkan
        {"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"
        }]}
    ]
)

import anthropic

client = anthropic.Anthropic()

# Tentukan alat
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": "Kueri basis data produk",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Kueri SQL untuk dieksekusi"
            }
        },
        "required": ["query"]
    }
}

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

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

# Anda akan menjalankan alat dan mengembalikan hasil...
# Setelah mendapatkan kedua hasil alat kembali, Claude langsung merespons tanpa pemikiran tambahan

import anthropic

client = anthropic.Anthropic()

# Definisi alat 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": "Kueri basis data produk",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Kueri SQL untuk dieksekusi"
            }
        },
        "required": ["query"]
    }
}

# Permintaan pertama dengan pemikiran yang disisipi diaktifkan
response = client.beta.messages.create(
    model="claude-sonnet-4-5",
    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 kami menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kami dari basis data?"
    }]
)

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

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

# Hasil alat pertama (kalkulator)
calculator_result = "7500"  # 150 * 50

# Lanjutkan dengan hasil alat pertama
response2 = client.beta.messages.create(
    model="claude-sonnet-4-5",
    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 kami menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kami dari basis data?"
        },
        {
            "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 kalkulator:")
# Dengan pemikiran yang disisipi, Claude dapat berpikir tentang hasil kalkulator
# sebelum memutuskan untuk menanyakan basis data
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Pemikiran yang disisipi: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Penggunaan alat: {block.name} dengan input {block.input}")

# Hasil alat kedua (basis data)
database_result = "5200"  # Contoh pendapatan bulanan rata-rata

# Lanjutkan dengan hasil alat kedua
response3 = client.beta.messages.create(
    model="claude-sonnet-4-5",
    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 kami menjual 150 unit produk A dengan harga $50 masing-masing, dan bagaimana ini dibandingkan dengan pendapatan bulanan rata-rata kami dari basis data?"
        },
        {
            "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 basis data:")
# Dengan pemikiran yang disisipi, Claude dapat berpikir tentang kedua hasil
# sebelum merumuskan respons akhir
for block in response3.content:
    if block.type == "thinking":
        print(f"Pemikiran akhir: {block.thinking}")
    elif block.type == "text":
        print(f"Respons akhir: {block.text}")

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 setiap baris
    lines = (line.strip() for line in text.splitlines())
    # Pecah headline multi menjadi satu baris masing-masing
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Hapus 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 cukup teks untuk penyimpanan (beberapa bab pertama)
LARGE_TEXT = book_content[:5000]

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

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

# Permintaan pertama - tetapkan cache
print("Permintaan pertama - menetapkan cache")
response1 = client.messages.create(
    model="claude-sonnet-4-5",
    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 pemikiran yang sama (cache hit diharapkan)
print("\nPermintaan kedua - parameter pemikiran yang sama (cache hit diharapkan)")
response2 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

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

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

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

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 setiap baris
    lines = (line.strip() for line in text.splitlines())
    # Pecah headline multi menjadi satu baris masing-masing
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Hapus 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 cukup teks untuk penyimpanan (beberapa bab pertama)
LARGE_TEXT = book_content[:5000]

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

# Permintaan pertama - tetapkan cache
print("Permintaan pertama - menetapkan cache")
response1 = client.messages.create(
    model="claude-sonnet-4-5",
    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 pemikiran yang sama (cache hit diharapkan)
print("\nPermintaan kedua - parameter pemikiran yang sama (cache hit diharapkan)")
response2 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Anggaran pemikiran yang sama
    },
    messages=MESSAGES
)

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

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

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

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

import anthropic

client = anthropic.Anthropic()

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

# Identifikasi blok pemikiran yang diredaksi
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("Respons berisi blok pemikiran yang diredaksi")
    # Blok ini masih dapat digunakan dalam permintaan berikutnya

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

    # Saat melewatkan ke permintaan berikutnya, sertakan semua blok tanpa modifikasi
    # Ini mempertahankan integritas penalaran Claude

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