Claude Sonnet 4: Panduan Praktis untuk Pengembang

Anthropic baru-baru ini meluncurkan pembaruan Claude Sonnet 4.5, Claude Agents SDK, dan Imagine with Claude.

Dengan rilis Claude Sonnet 4, pengembang kini memiliki akses ke kapabilitas baru yang kuat—termasuk eksekusi kode native, Files API yang fleksibel, dan penggunaan tool dinamis. Fitur-fitur ini membuka peluang menarik untuk membangun aplikasi bertenaga AI yang melampaui interaksi teks sederhana.

Dalam tutorial ini, saya akan memandu Anda melalui fitur-fitur baru tersebut dengan membangun agen berbasis Python yang dapat menyelesaikan soal matematika tingkat lanjut langsung dari terminal Anda. Anda akan belajar menggunakan alat eksekusi kode native yang baru diperkenalkan dan files API.

Di akhir, Anda akan memiliki agen yang berfungsi dengan dukungan Claude Sonnet 4 untuk menganalisis masalah, menulis dan menjalankan kode Python, serta membuat visual seperti di bawah ini.

Lihat repositori GitHub untuk proyek ini untuk melihat seluruh kode pembuatan aplikasinya.

Jika Anda baru memulai perjalanan membangun dengan LLM seperti Claude, roadmap pengembang AI ini menjelaskan tool, keterampilan, dan jalur belajar penting untuk memulai.

Apa yang Baru di Anthropic API

Sebelum masuk ke tutorial, mari kita lihat semua fitur baru yang baru-baru ini dirilis melalui Anthropic API. Silakan lewati jika Anda sudah mengetahuinya.

Menurut saya, seluruh pengumuman Claude 4 dapat diringkas dalam satu gambar ini:

Model Claude 4 (Opus dan Sonnet 4) mengungguli kompetitor pada tugas rekayasa perangkat lunak terverifikasi dengan selisih signifikan. Anthropic mencapai hal ini dengan memperkenalkan beberapa perubahan penting pada perilaku model:

1. Runtime panjang: Kedua model mendukung eksekusi tugas berkelanjutan selama beberapa jam untuk menyelesaikan masalah dengan ribuan langkah.
2. Pemikiran diperpanjang dengan penggunaan tool: Kedua model kini dapat menggunakan tool seperti pencarian web selama fase berpikir yang diperpanjang, memungkinkan Claude bergantian antara penalaran dan penggunaan tool untuk meningkatkan respons.
3. Eksekusi tool paralel: Model kini dapat menggunakan banyak tool secara simultan, bukan berurutan.
4. Kepatuhan instruksi yang lebih presisi: Steerability yang ditingkatkan memberi pengguna kontrol lebih besar atas implementasi dan bagaimana Claude merespons instruksi.
5. Kemampuan memori yang ditingkatkan: Saat diberi akses ke file lokal, model dapat mengekstrak dan menyimpan fakta kunci untuk menjaga kesinambungan dan membangun pengetahuan tacit dari waktu ke waktu.
6. Perilaku jalan pintas berkurang: Dibandingkan versi sebelumnya, kedua model 65% lebih kecil kemungkinannya menggunakan jalan pintas atau celah untuk menyelesaikan tugas (lihat pos pengumuman lengkap untuk detail lebih lanjut).

Selain itu, sebagai bagian dari pengumuman keluarga model Claude 4, Anthropic menambahkan empat fitur baru untuk membangun agen AI: alat eksekusi kode, Files API, konektor MCP, dan cache prompt yang diperluas. Tool ini mengubah cara pengembang dapat membangun aplikasi AI.

Alat eksekusi kode: Jalankan kode Python secara aman

Alat eksekusi kode memungkinkan Claude menjalankan kode Python dalam lingkungan sandbox yang aman. Alih-alih hanya menulis saran kode, Claude kini dapat mengeksekusi kode, menganalisis hasil, dan mengiterasi solusi.

Untuk menggunakan alat eksekusi kode, tambahkan ke array tools dan sertakan header beta yang diperlukan:

from anthropic import Anthropic

# Initialize client with the code execution beta header
client = Anthropic(
   default_headers={
       "anthropic-beta": "code-execution-2025-05-22"
   }
)

# Send a request that triggers code execution
response = client.messages.create(
   model="claude-sonnet-4-20250514",
   max_tokens=4096,
   messages=[{
       "role": "user",
       "content": "Solve the quadratic equation 2x² + 5x - 3 = 0 and plot the parabola"
   }],
   tools=[{
       "type": "code_execution_20250522",
       "name": "code_execution"
   }]
)

Saat Claude mengeksekusi kode, respons berisi kode yang dihasilkan dan hasil eksekusinya. Berikut cara mengurai berbagai komponennya:

# Parse the response to extract code and results
for item in response.content:
   if item.type == "server_tool_use":
       # This contains the actual Python code Claude wrote
       print(f"Code executed:\n{item.input['code']}")
   elif item.type == "code_execution_tool_result":
       # This contains the output from running the code
       print(f"Output:\n{item.content['stdout']}")
       if item.content.get('stderr'):
           print(f"Errors:\n{item.content['stderr']}")

Pembatasan sandbox: Lingkungan eksekusi kode memiliki beberapa batasan keamanan bawaan. Claude berjalan dalam container terisolasi tanpa akses internet, sumber daya komputasi terbatas (RAM 1 GB, ruang disk 5 GB, dan 1 CPU), serta tidak dapat mengakses sistem file lokal Anda. Lingkungan ini sudah terpasang pustaka populer seperti numpy, pandas, matplotlib, dan scipy, tetapi Anda tidak dapat memasang paket tambahan saat eksekusi.

Files API: Konteks file persisten untuk tugas kompleks

Files API memungkinkan Anda mengunggah dokumen sekali dan mereferensikannya di banyak percakapan. Ini menghilangkan kebutuhan untuk menyertakan dokumen besar di setiap permintaan API.

Pertama, unggah file Anda ke server Anthropic:

# Upload a file once - this stores it on Anthropic's servers
uploaded_file = client.beta.files.upload(
   file=open("sales_data.csv", "rb"),
   purpose="user_upload"
)
# The uploaded_file.id can now be referenced in multiple conversations

Setelah diunggah, referensikan file tersebut dalam panggilan API Anda menggunakan jenis konten container_upload:

# Reference the uploaded file in a conversation
response = client.messages.create(
   model="claude-sonnet-4-20250514",
   max_tokens=4096,
   messages=[{
       "role": "user",
       "content": [
           {"type": "text", "text": "Create a quarterly sales report from this data"},
           {"type": "container_upload", "file_id": uploaded_file.id}
       ]
   }],
   tools=[{
       "type": "code_execution_20250522",
       "name": "code_execution"
   }]
)

Saat Claude membuat file selama eksekusi kode (seperti plot atau data yang diproses), Anda dapat mengekstrak dan mengunduhnya:

# Extract file IDs of any files Claude created during execution
def extract_created_files(response):
   file_ids = []
   for item in response.content:
       if item.type == 'code_execution_tool_result':
           content = item.content
           if content.get('type') == 'code_execution_result':
               # Look for file objects in the execution results
               for file_obj in content.get('content', []):
                   if 'file_id' in file_obj:
                       file_ids.append(file_obj['file_id'])
   return file_ids

# Download any files Claude created
created_files = extract_created_files(response)
for file_id in created_files:
   file_content = client.beta.files.download(file_id)
   file_content.write_to_file(f"output_{file_id}.png")

Konektor MCP: Sambungkan Claude ke alur kerja apa pun

Konektor MCP menghadirkan dukungan Model Context Protocol langsung ke API. MCP memungkinkan Claude terhubung ke layanan eksternal seperti database, API, dan tool produktivitas tanpa kode integrasi khusus.

Sebelumnya, menyambungkan ke server MCP memerlukan pembuatan infrastruktur klien. Kini, Anda cukup menyediakan URL server MCP jarak jauh dalam permintaan API Anda, dan Claude secara otomatis menemukan tool yang tersedia, mengelola koneksi, serta menangani autentikasi.

Ini membuka akses ke ekosistem server MCP yang terus berkembang dari perusahaan seperti Zapier dan Asana, memungkinkan Anda membangun agen yang dapat membaca kalender Anda, memperbarui tool manajemen proyek, atau terintegrasi dengan ratusan layanan lainnya.

Mulai dengan Claude Sonnet 4: Ikhtisar Proyek dan Penyiapan

Sekarang kita memahami fitur API baru, mari kita bangun pemecah masalah matematika interaktif. Ini akan menggabungkan kapabilitas eksekusi kode Claude dengan penanganan file untuk membuat asisten matematika yang lengkap.

Aplikasi kita akan menerima pertanyaan matematika dalam bahasa natural, mengeksekusi kode Python untuk menyelesaikannya, membuat visualisasi, dan menyimpan laporan komprehensif.

Untuk pendekatan terstruktur membangun proyek seperti ini, lihat track Developing AI Applications.

> Catatan: Karena kita akan memecah blok kode panjang dengan penjelasan, indentasi kode mungkin tidak sepenuhnya akurat di cuplikan. Untuk itu, kami menyarankan membuka repo GitHub untuk proyek ini di tab terpisah saat mengikuti.

Langkah 0: Siapkan lingkungan proyek Claude Sonnet 4 Anda

Sebelum menulis kode, mari siapkan lingkungan pengembangan dan dependensi.

Buat direktori baru untuk proyek Anda dan siapkan file yang diperlukan:

mkdir math-solver
cd math-solver
touch math_solver.py demo_problems.py requirements.txt README.md

Buat file requirements.txt dengan dependensi yang diperlukan:

anthropic>=0.42.0

Instal dependensi:

pip install -r requirements.txt

Setel kunci Anthropic API Anda sebagai variabel lingkungan:

export ANTHROPIC_API_KEY="your-api-key-here"

Langkah 1: Rancang struktur aplikasi

Mari mulai dengan membuat struktur dasar kelas MathSolver. Kelas ini akan menangani seluruh fungsi utama: komunikasi API, manajemen file, dan interaksi pengguna.

Pertama, mari atur impor dan struktur dasar:

#!/usr/bin/env python3
"""
Interactive Math Problem Solver using Claude 4 Code Execution Tool

This application allows users to ask math questions in natural language,
gets solutions using Claude's code execution capabilities, and saves
both visualizations and detailed markdown reports.
"""

import os
import json
import datetime
from pathlib import Path
from typing import List, Dict, Any
from anthropic import Anthropic

Sekarang mari kita definisikan struktur kelas utama:

class MathSolver:
   def __init__(self, api_key: str = None):
       """Initialize the Math Solver with Anthropic client."""
       # API setup and directory creation will go here
       pass

   def solve_problem(self, question: str) -> Dict[str, Any]:
       """Send a math question to Claude and get solution with code execution."""
       pass
Here are the methods for file and report handling:
def extract_files_from_response(self, response) -> List[str]:
       """Extract file IDs from Claude's response."""
       pass

   def download_files(self, file_ids: List[str]) -> List[str]:
       """Download files created by code execution to local storage."""
       pass

   def extract_code_blocks(self, response) -> List[str]:
       """Extract all code blocks from the response."""
       Pass

Terakhir, kita tambahkan manajemen sesi dan entry point:

def generate_markdown_report(self, result: Dict[str, Any], downloaded_files: List[str]) -> str:
       """Generate a comprehensive markdown report of the solution."""
       pass

   def run_interactive_session(self):
       """Run the main interactive session loop."""
       pass


def main():
   """Main entry point for the application."""
   pass

Struktur ini memberi kita peta jalan yang jelas: inisialisasi, pemecahan masalah, penanganan file, pembuatan laporan, dan interaksi pengguna. Setiap metode memiliki tanggung jawab khusus dalam pipeline pemecahan matematika kita.

Membangun Pemecah Matematika dengan Eksekusi Kode Claude Sonnet 4

Sekarang, mari implementasikan fungsi inti menggunakan alat eksekusi kode Claude dan respons streaming.

Langkah 2: Inisialisasi Claude dengan header API yang aman

Mari implementasikan metode __init__() untuk menangani penyiapan klien API dan pembuatan direktori.

Pertama, kita tangani manajemen kunci API:

def __init__(self, api_key: str = None):
   """Initialize the Math Solver with Anthropic client."""
   if not api_key:
       api_key = os.getenv("ANTHROPIC_API_KEY")
       if not api_key:
           raise ValueError(
               "Please set ANTHROPIC_API_KEY environment variable or provide api_key"
           )

Selanjutnya, kita siapkan klien Anthropic dengan header beta yang diperlukan:

# Initialize client with both code execution and files API headers
   self.client = Anthropic(
       api_key=api_key,
       default_headers={
           "anthropic-beta": "code-execution-2025-05-22,files-api-2025-04-14"
       },
   )

Terakhir, kita buat struktur direktori output:

# Create organized output directories
   self.output_dir = Path("math_solver_output")
   self.images_dir = self.output_dir / "images"
   self.reports_dir = self.output_dir / "reports"

   self.output_dir.mkdir(exist_ok=True)
   self.images_dir.mkdir(exist_ok=True)
   self.reports_dir.mkdir(exist_ok=True)

   print(f"📁 Output directories created:")
   print(f"   • Images: {self.images_dir}")
   print(f"   • Reports: {self.reports_dir}")

Inisialisasi ini melakukan tiga hal penting:

1. Manajemen kunci API: Memeriksa kunci di variabel lingkungan terlebih dahulu, lalu kembali ke parameter.
2. Penyiapan klien: Membuat klien Anthropic dengan kedua header beta untuk eksekusi kode dan Files API.
3. Struktur direktori: Membuat folder terorganisasi untuk menyimpan gambar dan laporan.

Langkah 3: Tulis fungsi pemecah inti

Metode solve_problem() adalah inti aplikasi kita. Ini mengirim permintaan ke Claude dengan dukungan streaming.

Mari mulai dengan tanda tangan fungsi dan penyiapan awal:

def solve_problem(self, question: str) -> Dict[str, Any]:
   """
   Send a math question to Claude and get solution with code execution.
   """
   print(f"\n🤔 Thinking about: {question}")

   try:
       # Use streaming to show real-time progress
       with self.client.messages.stream(
           model="claude-sonnet-4-20250514",
           max_tokens=4096,
Now we configure the message and tool specification:
messages=[
               {
                   "role": "user",
                   "content": f"""Solve this math problem using code execution:

Problem: {question}

Please:
1. Solve the problem with actual Python code
2. Create visualizations using matplotlib if helpful
3. Save any plots as PNG files using plt.savefig()
4. Show your calculations step by step
5. Use descriptive filenames for saved plots

Execute Python code to solve this problem.""",
               }
           ],
           tools=[{"type": "code_execution_20250522", "name": "code_execution"}],
       ) as stream:
The streaming event processing handles real-time updates:
print("\n💭 Claude is working...")

           # Process streaming events and show progress
           for event in stream:
               if event.type == "content_block_start":
                   if hasattr(event.content_block, "type"):
                       if event.content_block.type == "text":
                           print("\n📝 Response:", end=" ", flush=True)
                       elif event.content_block.type == "server_tool_use":
                           print(f"\n🔧 Using tool: {event.content_block.name}")

Kita menangani berbagai jenis peristiwa streaming:

	elif event.type == "content_block_delta":
                   if hasattr(event.delta, "text"):
                       print(event.delta.text, end="", flush=True)

               elif event.type == "content_block_stop":
                   print("", flush=True)  # New line

               elif event.type == "message_delta":
                   if hasattr(event.delta, "stop_reason"):
                       print(f"\n✅ Completed: {event.delta.stop_reason}")

Terakhir, kita mengembalikan hasil atau menangani error:

	# Get the final message
           final_message = stream.get_final_message()

           return {
               "response": final_message,
               "question": question,
               "timestamp": datetime.datetime.now().isoformat(),
           }

   except Exception as e:
       print(f"❌ Error solving problem: {e}")
       return None

Fungsi ini menunjukkan beberapa konsep penting:

• Dukungan streaming: Kita menggunakan client.messages.stream() alih-alih client.messages.create() untuk mendapatkan umpan balik waktu nyata saat Claude mengerjakan masalah.
• Penanganan event: API streaming mengirim berbagai tipe event:
• content_block_start: Saat Claude mulai menulis teks atau menggunakan tool
• content_block_delta: Saat konten sedang dihasilkan
• content_block_stop: Saat satu blok konten selesai
• message_delta: Saat seluruh pesan selesai
• Spesifikasi tool: Kita menyertakan alat eksekusi kode dalam array tools dengan tipe tepat "code_execution_20250522".
• Prompt terstruktur: Prompt kita dengan jelas menginstruksikan Claude untuk menggunakan eksekusi kode dan menyimpan visualisasi apa pun.

Langkah 4: Selesaikan masalah matematika dengan eksekusi kode streaming

Saat Claude membuat file selama eksekusi kode (seperti plot matplotlib), kita perlu mengekstrak ID file dan mengunduhnya secara lokal.

Metode ekstraksi file menelusuri struktur respons:

def extract_files_from_response(self, response) -> List[str]:
   """Extract file IDs from Claude's response."""
   file_ids = []

   for item in response.content:
       if item.type == "code_execution_tool_result":
           content_item = item.content
          
           if isinstance(content_item, dict):
               if content_item.get("type") == "code_execution_result":
                   content_list = content_item.get("content", [])

Lalu kita mencari ID file di konten:

  for file_item in content_list:
                       if isinstance(file_item, dict) and "file_id" in file_item:
                           file_ids.append(file_item["file_id"])

   return file_ids

Proses pengunduhan mengambil file dan menyimpannya secara lokal:

def download_files(self, file_ids: List[str]) -> List[str]:
   """Download files created by code execution to local storage."""
   downloaded_files = []

   for file_id in file_ids:
       try:
           # Get file metadata and download content
           file_metadata = self.client.beta.files.retrieve_metadata(file_id)
           filename = file_metadata.filename
          
           file_content = self.client.beta.files.download(file_id)
           local_path = self.images_dir / filename
           file_content.write_to_file(str(local_path))

Kita melacak file yang diunduh dan menangani error:

downloaded_files.append(str(local_path))
           print(f"✅ Downloaded: {filename}")

       except Exception as e:
           print(f"❌ Error downloading file {file_id}: {e}")

   return downloaded_files

• Logika ekstraksi file: Metode extract_files_from_response() menelusuri struktur respons untuk menemukan ID file. Hasil eksekusi kode berada dalam format spesifik di mana file muncul dalam array content.
• Proses pengunduhan file: Metode download_files():
• Mengambil metadata untuk setiap file (termasuk nama file asli)
• Mengunduh konten file menggunakan Files API
• Menyimpan file ke struktur direktori terorganisasi kita
• Mengembalikan daftar path file lokal untuk digunakan kemudian