Cara Menggunakan API Claude Sonnet 4.6: Panduan Lengkap

TL;DR / Jawaban Cepat

Claude Sonnet 4.6 adalah model kelas menengah terbaru dari Anthropic, menggabungkan kinerja pengkodean tingkat terdepan dengan jendela konteks 1M token (beta) hanya dengan $3/$15 per juta token input/output. Untuk mulai menggunakan API:

1. Dapatkan kunci API dari console.anthropic.com
2. Instal SDK (pip install anthropic)
3. Gunakan ID model claude-sonnet-4-6
4. Beralih ke pemikiran adaptif (thinking: {type: "adaptive"}) untuk hasil terbaik.

Penguji awal lebih menyukai model ini dibandingkan Sonnet 4.5 sebesar 70% dan bahkan dibandingkan Opus 4.5 sebesar 59%.

Pendahuluan

Anthropic merilis Claude Sonnet 4.6, dan segera mengubah kategori model AI kelas menengah. Ini bukan pembaruan inkremental—ini adalah model yang mengalahkan model kelas premium sebelumnya, Opus 4.5, dalam pengujian langsung sebesar 59% menurut pengadopsi awal, sambil tetap mempertahankan harga Sonnet.

Perubahan utama: jendela konteks 1M token yang memasuki beta, mode pemikiran adaptif baru yang menggantikan pendekatan pemikiran diperluas biner lama, dan seperangkat alat—pencarian web, eksekusi kode, memori, dan pencarian alat—yang beralih ke ketersediaan umum. Bagi pengembang yang membangun aplikasi agen, Sonnet 4.6 memberikan kemampuan yang sebelumnya hanya diperuntukkan bagi model terdepan yang mahal dengan biaya sekitar sepertiga.

Peningkatan pengkodean sangat nyata. Pengguna melaporkan kepatuhan instruksi yang lebih baik dalam pembuatan kode, pemahaman konteks yang lebih cerdas sebelum melakukan modifikasi, dan pengurangan duplikasi kode melalui konsolidasi logika otomatis. Penggunaan komputer mencapai akurasi 94% pada alur kerja asuransi yang kompleks. Skor SWE-bench Verified mencapai 79.6%.

Panduan ini mencakup semua yang Anda butuhkan untuk mulai membangun dengan API Claude Sonnet 4.6 hari ini: otentikasi, contoh kode praktis dalam Python dan JavaScript, parameter pemikiran adaptif baru, cara membuka jendela konteks 1M, dan cara menguji integrasi Anda dengan klien API visual Apidog.

Apa yang Baru di Claude Sonnet 4.6

Mode Pemikiran Adaptif

Pola lama thinking: {type: "enabled", budget_tokens: N} sudah tidak digunakan lagi di Sonnet 4.6. Penggantinya adalah pemikiran adaptif: thinking: {type: "adaptive"}. Claude kini memutuskan secara dinamis seberapa banyak penalaran yang dibutuhkan suatu tugas.

Pasangkan pemikiran adaptif dengan parameter effort (tersedia di GA sekarang) untuk menyetel biaya versus kinerja:

• effort: "high" (default) — Claude hampir selalu berpikir, terbaik untuk masalah kompleks
• effort: "medium" — direkomendasikan untuk sebagian besar kasus penggunaan Sonnet 4.6, menyeimbangkan kecepatan dan kualitas
• effort: "low" — pemikiran minimal, respons tercepat untuk tugas sederhana

Peningkatan Kinerja Pengkodean

Sonnet 4.6 membawa tiga peningkatan konkret pada pembuatan kode:

1. Kepatuhan instruksi yang lebih baik — menghasilkan kode yang lebih akurat sesuai spesifikasi
2. Pemahaman konteks — membaca dan memahami kode yang ada sebelum memodifikasinya, mengurangi regresi
3. Konsolidasi logika — mengidentifikasi pola duplikat dan menyarankan abstraksi bersama

Penguji awal yang menjalankan benchmark pengkodean melaporkan lebih menyukai output Sonnet 4.6 daripada Sonnet 4.5 dalam 70% kasus dan daripada Opus 4.5 dalam 59% kasus.

Peningkatan Penggunaan Komputer

Akurasi penggunaan komputer mencapai 72.5% pada OSWorld-Verified (dalam 0.2% dari Opus 4.6), meningkat secara signifikan dari Sonnet 4.5. Model ini menunjukkan akurasi 94% pada alur kerja asuransi yang membutuhkan navigasi UI, manipulasi spreadsheet, dan penyelesaian formulir multi-langkah. Ini juga lebih tahan terhadap serangan injeksi prompt selama tugas otomatis.

Terobosan ARC-AGI-2

Angka benchmark yang paling mencolok: kinerja ARC-AGI-2 melonjak dari 13.6% menjadi 58.3% — peningkatan 4.3x. Ini mengukur pemecahan masalah baru pada tugas-tugas yang belum pernah dilihat polanya oleh model, menunjukkan peningkatan penalaran yang asli daripada hafalan.

Spesifikasi dan Harga API

Opsi pengurangan biaya:

• Caching prompt: Cache bagian statis dari prompt sistem Anda dan hemat hingga 90%
• API Batch: Proses permintaan secara asinkron untuk diskon 50%
• Harga konteks panjang: Permintaan yang melebihi 200K token menggunakan tarif konteks panjang terpisah

Untuk anggaran produksi: percakapan jutaan token dalam mode pemikiran adaptif pada effort: "medium" berharga sekitar $3 dalam token input. Sebagian besar panggilan API tunggal jauh di bawah satu sen.

Memulai dengan API Claude Sonnet 4.6

Langkah 1: Dapatkan Kunci API Anda

1. Masuk ke platform.anthropic.com
2. Navigasikan ke API Keys di pengaturan
3. Klik Create Key dan salin nilainya segera (hanya ditampilkan sekali)

Simpan kunci Anda sebagai variabel lingkungan—jangan pernah mengodekannya secara langsung:

export ANTHROPIC_API_KEY="sk-ant-..."

Langkah 2: Instal SDK

Python:

pip install anthropic

JavaScript/Node.js:

npm install @anthropic-ai/sdk

Langkah 3: Buat Permintaan Pertama Anda

import anthropic

client = anthropic.Anthropic()  # membaca ANTHROPIC_API_KEY dari lingkungan

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Jelaskan perbedaan antara async/await dan promises di JavaScript."}
    ]
)

print(response.content[0].text)

Itu adalah panggilan minimum yang layak. Objek respons mencakup statistik penggunaan (token input, token output), alasan berhenti, dan versi model.

Contoh Kode Python

Generasi Teks Dasar

import anthropic

client = anthropic.Anthropic()

def ask_claude(question: str, system: str = None) -> str:
    """Pembungkus sederhana untuk generasi teks Claude Sonnet 4.6."""
    messages = [{"role": "user", "content": question}]

    kwargs = {
        "model": "claude-sonnet-4-6",
        "max_tokens": 2048,
        "messages": messages,
    }
    if system:
        kwargs["system"] = system

    response = client.messages.create(**kwargs)
    return response.content[0].text

# Contoh penggunaan
answer = ask_claude(
    "Tinjau fungsi Python ini untuk masalah kinerja:\n\ndef find_duplicates(lst):\n    return [x for x in lst if lst.count(x) > 1]",
    system="Anda adalah insinyur Python senior. Bersikaplah spesifik dan berikan kode yang sudah diperbaiki."
)
print(answer)

Respons Streaming

Untuk output panjang atau UX real-time, gunakan streaming:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": "Tulis handler REST API lengkap di FastAPI untuk otentikasi pengguna dengan JWT."
    }]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Dapatkan pesan akhir dengan statistik penggunaan setelah streaming selesai
message = stream.get_final_message()
print(f"\n\nToken yang digunakan: {message.usage.input_tokens} masuk, {message.usage.output_tokens} keluar")

Pemanggilan Alat / Penggunaan Fungsi

import anthropic
import json

client = anthropic.Anthropic()

# Definisikan alat
tools = [
    {
        "name": "get_repository_info",
        "description": "Ambil informasi tentang repositori GitHub termasuk bintang, fork, dan commit terbaru.",
        "input_schema": {
            "type": "object",
            "properties": {
                "owner": {
                    "type": "string",
                    "description": "Nama pemilik repositori atau organisasi"
                },
                "repo": {
                    "type": "string",
                    "description": "Nama repositori"
                }
            },
            "required": ["owner", "repo"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "Apa yang bisa Anda ceritakan tentang repositori anthropics/anthropic-sdk-python?"
    }]
)

# Tangani respons penggunaan alat
for block in response.content:
    if block.type == "tool_use":
        print(f"Alat dipanggil: {block.name}")
        print(f"Argumen: {json.dumps(block.input, indent=2)}")
        # Dalam produksi, panggil implementasi aktual Anda di sini
        # result = get_repository_info(block.input["owner"], block.input["repo"])

Visi dan Analisis Gambar

import anthropic
import base64
from pathlib import Path

client = anthropic.Anthropic()

def analyze_image(image_path: str, question: str) -> str:
    """Analisis gambar dengan Claude Sonnet 4.6."""
    image_data = base64.standard_b64encode(Path(image_path).read_bytes()).decode("utf-8")

    # Deteksi tipe media dari ekstensi
    ext = Path(image_path).suffix.lower()
    media_type_map = {
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".png": "image/png",
        ".gif": "image/gif",
        ".webp": "image/webp"
    }
    media_type = media_type_map.get(ext, "image/jpeg")

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": media_type,
                        "data": image_data,
                    },
                },
                {
                    "type": "text",
                    "text": question
                }
            ],
        }]
    )
    return response.content[0].text

# Contoh: analisis tangkapan layar UI untuk masalah aksesibilitas
result = analyze_image(
    "screenshot.png",
    "Identifikasi masalah aksesibilitas apa pun dalam desain UI ini. Periksa rasio kontras, indikator teks alt yang hilang, dan masalah navigasi keyboard."
)
print(result)

Contoh JavaScript/Node.js

Pengaturan dan Permintaan Dasar

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY, // default, ditampilkan secara eksplisit untuk kejelasan
});

async function askClaude(userMessage, systemPrompt = null) {
  const params = {
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    messages: [{ role: "user", content: userMessage }],
  };

  if (systemPrompt) {
    params.system = systemPrompt;
  }

  const response = await client.messages.create(params);
  return response.content[0].text;
}

// Penggunaan
const answer = await askClaude(
  "Refactor rute Express ini untuk menggunakan async/await:\n\napp.get('/users', (req, res) => {\n  User.find({}, (err, users) => {\n    if (err) return res.status(500).send(err);\n    res.json(users);\n  });\n});",
  "Anda adalah pengembang Node.js senior. Kembalikan hanya kode yang sudah direfaktor dengan penjelasan singkat."
);

console.log(answer);

Streaming dengan TypeScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function streamCodeReview(codeSnippet: string): Promise<void> {
  const stream = await client.messages.stream({
    model: "claude-sonnet-4-6",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: `Lakukan tinjauan kode menyeluruh terhadap fungsi TypeScript ini:\n\n\`\`\`typescript\n${codeSnippet}\n\`\`\`\n\nFokus pada: keamanan tipe, kasus tepi, kinerja, dan keamanan.`,
      },
    ],
  });

  // Streaming teks saat tiba
  stream.on("text", (text) => {
    process.stdout.write(text);
  });

  // Dapatkan statistik akhir
  const finalMessage = await stream.finalMessage();
  console.log(
    `\n\n---\nTotal token: ${finalMessage.usage.input_tokens + finalMessage.usage.output_tokens}`
  );
}

Percakapan Multi-Belok

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

class ConversationManager {
  constructor(systemPrompt = null) {
    this.messages = [];
    this.systemPrompt = systemPrompt;
  }

  async chat(userMessage) {
    this.messages.push({ role: "user", content: userMessage });

    const params = {
      model: "claude-sonnet-4-6",
      max_tokens: 2048,
      messages: this.messages,
    };

    if (this.systemPrompt) {
      params.system = this.systemPrompt;
    }

    const response = await client.messages.create(params);
    const assistantMessage = response.content[0].text;

    // Pertahankan riwayat percakapan
    this.messages.push({ role: "assistant", content: assistantMessage });

    return assistantMessage;
  }
}

// Contoh: sesi debugging multi-belok
const debugSession = new ConversationManager(
  "Anda adalah debugger ahli. Ajukan pertanyaan klarifikasi dan telusuri masalah langkah demi langkah."
);

console.log(await debugSession.chat("API saya terus mengembalikan error 401."));
console.log(await debugSession.chat("Saya menyertakan header Otorisasi."));
console.log(
  await debugSession.chat("Token berasal dari localStorage setelah login.")
);

Pemikiran Adaptif: Pemikiran Diperluas yang Baru

Pemikiran adaptif menggantikan model pemikiran diperluas lama pada Sonnet 4.6. Perbedaan utamanya: alih-alih menetapkan anggaran token tetap untuk berpikir, Anda menetapkan tingkat effort dan Claude menentukan seberapa banyak penalaran yang sebenarnya dibutuhkan masalah tersebut.

Cara Menggunakan Pemikiran Adaptif

import anthropic

client = anthropic.Anthropic()

# Direkomendasikan: pemikiran adaptif dengan upaya sedang untuk sebagian besar kasus penggunaan
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    effort="medium",  # pilihan: "low", "medium", "high" (default: high)
    messages=[{
        "role": "user",
        "content": """
        Rancang skema database untuk platform analitik SaaS yang perlu:
        - Melacak peristiwa dari jutaan pengguna
        - Mendukung kueri real-time selama 24 jam terakhir
        - Mengarsipkan data historis secara hemat biaya
        - Menangani isolasi penyewa untuk pelanggan enterprise
        """
    }]
)

# Blok berpikir muncul sebelum respons teks
for block in response.content:
    if block.type == "thinking":
        print(f"[Penalaran Claude - {len(block.thinking)} karakter]")
    elif block.type == "text":
        print(block.text)

Tingkat Upaya dalam Praktik

Catatan Migrasi:thinking: {type: "enabled", budget_tokens: N}thinking: {type: "adaptive"}effort

Jendela Konteks 1M Token

Jendela konteks 1M token memungkinkan Anda memberi Claude seluruh basis kode, set dokumen ekstensif, atau riwayat percakapan berbulan-bulan. Itu sekitar 750.000 kata atau setara dengan 5–10 basis kode lengkap dalam satu permintaan.

Cara Mengaktifkan Konteks 1M

Lewati header beta context-1m-2025-08-07 dalam permintaan Anda:

import anthropic

client = anthropic.Anthropic()

# Baca seluruh basis kode besar
with open("large_codebase.txt", "r") as f:
    codebase_content = f.read()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["context-1m-2025-08-07"],
    messages=[{
        "role": "user",
        "content": f"""
        Berikut adalah seluruh basis kode backend kami:\n\n{codebase_content}\n\n
        Temukan semua kueri database yang dapat menyebabkan masalah N+1 dan sarankan perbaikannya.
        """
    }]
)

print(response.content[0].text)

// JavaScript equivalent
const response = await client.beta.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 4096,
  betas: ["context-1m-2025-08-07"],
  messages: [
    {
      role: "user",
      content: `Tinjau seluruh basis kode ini untuk kerentanan keamanan:\n\n${codebaseContent}`,
    },
  ],
});

Apa yang Dimungkinkan oleh 1M Token

• Analisis basis kode lengkap: Kirim seluruh repositori Anda dan minta Claude untuk menemukan bug, menyarankan refactor, atau menghasilkan pengujian
• Pemrosesan dokumen panjang: Analisis kontrak hukum lengkap, laporan keuangan, atau makalah penelitian
• Sesi agen yang diperluas: Pertahankan riwayat lengkap tugas multi-langkah yang panjang tanpa kehilangan konteks
• Pelacakan ketergantungan lintas file: Temukan semua penggunaan fungsi atau kelas di seluruh proyek besar

Catatan harga: Permintaan yang melebihi 200K token menggunakan harga konteks panjang. Rencanakan dengan tepat untuk penggunaan bervolume tinggi.

Pencarian Web dan Pemfilteran Dinamis

Pencarian web dan alat pengambilan web kini mendukung pemfilteran dinamis dalam beta publik di Sonnet 4.6. Claude menulis dan mengeksekusi kode untuk memfilter hasil pencarian sebelum masuk ke jendela konteks—hanya menyimpan informasi yang relevan dan secara signifikan mengurangi penggunaan token.

Eksekusi kode gratis saat digunakan bersama dengan pencarian web atau alat pengambilan web (tidak ada tagihan terpisah).

Menyiapkan Pencarian Web Dinamis

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[
        {
            "type": "web_search_20260209",  # Gunakan versi ini untuk pemfilteran dinamis
            "name": "web_search",
        }
    ],
    messages=[{
        "role": "user",
        "content": "Temukan CVE terbaru untuk Apache Log4j yang diterbitkan dalam 30 hari terakhir dan rangkum tingkat keparahannya."
    }]
)

for block in response.content:
    if hasattr(block, "text"):
        print(block.text)

Pengambilan Web dengan Pemfilteran Dinamis

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[
        {
            "type": "web_fetch_20260209",  # Versi baru dengan pemfilteran dinamis
            "name": "web_fetch",
        }
    ],
    messages=[{
        "role": "user",
        "content": "Ambil halaman harga Anthropic dan ekstrak hanya baris harga Claude Sonnet."
    }]
)

print(response.content[-1].text)

Mengapa pemfilteran dinamis itu penting: Tanpa pemfilteran, mengambil halaman web penuh mungkin mengonsumsi 100K token untuk halaman di mana Anda hanya membutuhkan 2K token konten yang relevan. Pemfilteran dinamis memungkinkan Claude mengurai halaman dalam kode dan mengembalikan hanya apa yang dibutuhkan, mengurangi biaya hingga 90%+ pada halaman yang kaya konten.

API Pemadatan Konteks

Pemadatan konteks menangani sesi agen yang berjalan lama di mana konteks menumpuk melebihi batas jendela. API secara otomatis merangkum bagian percakapan yang lebih lama di sisi server ketika mendekati batas, memungkinkan panjang percakapan yang efektif tidak terbatas.

import anthropic

client = anthropic.Anthropic()

# Aktifkan pemadatan konteks melalui header beta
response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["interleaved-thinking-2025-05-14"],  # Mengaktifkan pemadatan dalam beta
    system="Anda adalah agen pengembangan perangkat lunak jangka panjang. Pertahankan konteks tentang perubahan basis kode yang dibuat selama sesi ini.",
    messages=[
        {"role": "user", "content": "Mulai sesi refactoring untuk modul otentikasi kami."},
        # ... banyak giliran lagi akan masuk di sini dalam sesi nyata
    ]
)

# Bidang compaction_details menunjukkan kapan rangkuman terjadi
if hasattr(response, "usage") and hasattr(response.usage, "cache_read_input_tokens"):
    print(f"Token konteks disimpan melalui caching: {response.usage.cache_read_input_tokens}")

Kapan menggunakan pemadatan: Alur kerja agen apa pun yang berjalan lebih dari beberapa menit dan mengumpulkan riwayat—agen CI/CD, sesi pengkodean panjang, utas dukungan pelanggan, atau tugas penelitian multi-langkah.

Menguji Claude Sonnet 4.6 dengan Apidog

Sebelum menulis kode SDK, gunakan Apidog untuk menjelajahi API Claude Sonnet 4.6 secara visual. Apidog mempercepat pengembangan dengan memungkinkan Anda mengonfigurasi header, membangun badan permintaan, dan memeriksa respons streaming tanpa boilerplate.

Menyiapkan API Anthropic di Apidog

1. Buka Apidog dan buat permintaan HTTP baru
2. Atur metode ke POST dan URL ke https://api.anthropic.com/v1/messages
3. Tambahkan header ini:

1. Atur badan permintaan ke JSON:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Apa saja peningkatan utama di Claude Sonnet 4.6?"
    }
  ]
}

Menguji Pemikiran Adaptif

Untuk menguji mode pemikiran adaptif di Apidog, tambahkan bidang thinking dan effort ke badan permintaan Anda:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 8192,
  "thinking": {
    "type": "adaptive"
  },
  "effort": "medium",
  "messages": [
    {
      "role": "user",
      "content": "Rancang strategi pembatasan kecepatan untuk API publik yang melayani 10 juta permintaan per hari."
    }
  ]
}

Menguji Fitur Beta di Apidog

Untuk fitur beta (konteks 1M, pencarian web dinamis, pemadatan konteks), tambahkan header beta:

Atau untuk pemfilteran dinamis pencarian web:

Apidog memungkinkan Anda menyimpan konfigurasi ini sebagai preset dan membagikannya dengan tim Anda, sehingga setiap orang memiliki lingkungan pengujian API yang konsisten.

Alat Baru Sekarang di GA

Beberapa alat yang sebelumnya dalam beta sekarang tersedia secara umum di Sonnet 4.6, yang berarti tidak memerlukan header beta khusus:

Alat Eksekusi Kode

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{"type": "code_execution_20250522", "name": "code_execution"}],
    messages=[{
        "role": "user",
        "content": "Hitung bunga majemuk sebesar $10.000 dengan tingkat bunga tahunan 5% selama 10 tahun, dengan perhitungan bulanan. Tampilkan rincian tahun-ke-tahun."
    }]
)

for block in response.content:
    if block.type == "tool_result":
        print("Output eksekusi:", block.content)
    elif hasattr(block, "text"):
        print(block.text)

Alat Memori

Alat memori memungkinkan Claude untuk mempertahankan informasi di seluruh sesi percakapan, berguna untuk membangun asisten yang stateful:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    tools=[{"type": "memory_20250416", "name": "memory"}],
    messages=[{
        "role": "user",
        "content": "Ingat bahwa URL dasar API kami adalah https://api.company.com/v2 dan kami memerlukan otentikasi token Bearer di semua endpoint."
    }]
)

Pemanggilan Alat Programatis

Pemanggilan alat programatis memungkinkan Claude menghasilkan panggilan API terstruktur secara langsung:

import anthropic

client = anthropic.Anthropic()

# Claude sekarang dapat memanggil alat secara programatis tanpa campur tangan manusia
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    tools=[
        {
            "name": "execute_sql",
            "description": "Jalankan kueri SQL dan kembalikan hasilnya",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Kueri SQL yang akan dijalankan"},
                    "database": {"type": "string", "description": "Nama database"}
                },
                "required": ["query", "database"]
            }
        }
    ],
    messages=[{
        "role": "user",
        "content": "Temukan semua pengguna yang mendaftar pada Januari 2026 dan belum melakukan pembelian."
    }]
)

Sonnet 4.6 vs Model Sebelumnya

Intinya: Jika Anda menggunakan Sonnet 4.5, memutakhirkan ke Sonnet 4.6 adalah hal yang tidak perlu dipikirkan—harga yang sama, kinerja pengkodean yang jauh lebih baik, dan pemikiran adaptif. Jika Anda menggunakan Opus 4.5, Sonnet 4.6 sekarang cocok atau mengalahkannya di sebagian besar kasus penggunaan dengan 60% dari biaya.

Praktik Terbaik dan Tip

1. Gunakan Pemikiran Adaptif dengan Upaya Sedang secara Default

Untuk sebagian besar kasus penggunaan Sonnet 4.6, effort: "medium" memberikan keseimbangan biaya-kinerja terbaik. Cadangkan effort: "high" untuk tugas yang benar-benar kompleks seperti desain arsitektur, rantai penalaran multi-langkah, atau bukti matematis.

# Pola default yang baik untuk Sonnet 4.6
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    effort="medium",  # Titik tengah yang tepat untuk sebagian besar tugas
    messages=[...]
)

2. Gunakan Streaming untuk Output Lebih dari 1K Token

Respons besar mendapat manfaat dari streaming untuk menghindari waktu habis HTTP dan memberikan waktu respons yang dirasakan lebih cepat kepada pengguna:

# Untuk respons apa pun yang diperkirakan panjang
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    messages=[...]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

3. Aktifkan Caching Prompt untuk Prompt Sistem Berulang

Jika Anda menggunakan prompt sistem yang sama di banyak panggilan, cache untuk menghemat hingga 90%:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Prompt sistem Anda yang panjang di sini...",
            "cache_control": {"type": "ephemeral"}  # Cache blok ini
        }
    ],
    messages=[{"role": "user", "content": user_input}]
)

4. Tangani Batas Kecepatan dengan Baik

Sonnet 4.6 memiliki batas kecepatan yang murah hati, tetapi sistem produksi harus menerapkan backoff eksponensial:

import anthropic
import time

def create_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.messages.create(**kwargs)
        except anthropic.RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait_time = (2 ** attempt) + 1  # 2s, 3s, 5s
            time.sleep(wait_time)

5. Migrasi dari Prefill di Sonnet 4.6

Mengisi pesan asisten terlebih dahulu (prefill giliran terakhir) tidak didukung pada model Claude 4.6. Gunakan output terstruktur sebagai gantinya:

# Pendekatan lama (rusak di Claude 4.6):
# messages = [
#     {"role": "user", "content": "Beri saya JSON..."},
#     {"role": "assistant", "content": "{"}  # Prefill
# ]

# Pendekatan baru: gunakan output terstruktur
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    output_config={
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "score": {"type": "number"}
                }
            }
        }
    },
    messages=[{"role": "user", "content": "Hasilkan objek pengguna sampel."}]
)

6. Tentukan AWS atau GCP untuk Residensi Data

Jika persyaratan kepatuhan Anda membutuhkan inferensi hanya di AS, gunakan parameter inference_geo:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    inference_geo="us",  # Memastikan inferensi berjalan di pusat data AS
    messages=[...]
)

Inferensi hanya di AS dihargai 1.1x tarif standar di Sonnet 4.6.

Siap membangun dengan Claude Sonnet 4.6? Unduh Apidog gratis untuk menguji panggilan API Anda secara visual, berkolaborasi dengan tim Anda pada konfigurasi permintaan, dan menghasilkan kode SDK secara otomatis—tidak diperlukan kartu kredit.