Tutorial Lengkap Anthropic Claude API: Dari Dasar hingga Fitur Lanjutan
Anthropic Claude adalah salah satu Large Language Model (LLM) paling canggih saat ini, dikenal dengan kemampuan reasoning yang kuat, konteks window yang besar (hingga 200K token), dan fitur safety yang unggul. Dalam tutorial ini, kita akan mempelajari cara menggunakan Claude API melalui Anthropic Python SDK secara lengkap, mulai dari setup awal, chat sederhana, streaming, vision (analisis gambar), tool use (function calling), hingga prompt caching untuk optimasi biaya.
Mengapa Claude API?
Sebelum kita mulai coding, berikut beberapa alasan mengapa Claude API layak dipertimbangkan untuk proyek AI Anda:
- Context Window Besar: Mendukung hingga 200K token, memungkinkan pemrosesan dokumen panjang dalam satu request.
- Reasoning Kuat: Extended thinking memungkinkan Claude berpikir langkah demi langkah sebelum menjawab.
- Tool Use Bawaan: Claude bisa memanggil fungsi/tools yang Anda definisikan, cocok untuk membangun AI agent.
- Vision: Mampu menganalisis gambar langsung dari API.
- Prompt Caching: Hemat biaya hingga 90% untuk prompt yang sering diulang.
- Streaming: Response real-time untuk pengalaman pengguna yang lebih baik.
Instalasi dan Setup
1. Install Anthropic Python SDK
pip install anthropic
2. Dapatkan API Key
Buat akun di console.anthropic.com, lalu buat API key di halaman Settings > API Keys.
3. Set Environment Variable
export ANTHROPICAPIKEY="sk-ant-api03-xxxxx"
Atau simpan dalam file .env:
ANTHROPICAPIKEY=sk-ant-api03-xxxxx
4. Verifikasi Instalasi
import anthropic
client = anthropic.Anthropic()
print("Anthropic SDK version:", anthropic.version)
Basic Usage: Chat Sederhana
Mari mulai dengan contoh paling dasar, mengirim pesan ke Claude dan mendapatkan respons:
import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{"role": "user", "content": "Jelaskan apa itu machine learning dalam 3 kalimat."}
]
)
print(message.content[0].text)
Menggunakan System Prompt
System prompt membantu mengatur perilaku dan persona Claude:
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
system="Kamu adalah asisten data science yang menjelaskan konsep kompleks dengan analogi sederhana. Jawab dalam bahasa Indonesia.",
messages=[
{"role": "user", "content": "Apa itu gradient descent?"}
]
)
print(message.content[0].text)
Multi-turn Conversation
Untuk percakapan multi-turn, kirimkan seluruh history percakapan:
messages = [
{"role": "user", "content": "Apa itu neural network?"},
{"role": "assistant", "content": "Neural network adalah model komputasi yang terinspirasi dari cara kerja otak manusia..."},
{"role": "user", "content": "Bagaimana cara melatihnya?"}
]
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=messages
)
print(message.content[0].text)
Streaming Response
Untuk aplikasi real-time seperti chatbot, streaming memungkinkan Anda menampilkan respons token per token:
import anthropic
client = anthropic.Anthropic()
with client.messages.stream(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{"role": "user", "content": "Tulis panduan singkat tentang cara deploy model ML ke production."}
]
) as stream:
for text in stream.textstream:
print(text, end="", flush=True)
print()
Streaming dengan Event Handling
Untuk kontrol lebih granular, Anda bisa menangani berbagai event:
with client.messages.stream(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{"role": "user", "content": "Jelaskan arsitektur transformer."}
]
) as stream:
for event in stream:
if event.type == "contentblockdelta":
if event.delta.type == "textdelta":
print(event.delta.text, end="", flush=True)
elif event.type == "messagestop":
print("\n[Selesai]")
Vision: Analisis Gambar
Claude dapat menganalisis gambar yang dikirim melalui API. Ini sangat berguna untuk OCR, analisis chart, atau deskripsi visual:
Dari URL
import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "url",
"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
}
},
{
"type": "text",
"text": "Deskripsikan gambar ini secara detail."
}
]
}
]
)
print(message.content[0].text)
Dari File Lokal (Base64)
import anthropic
import base64
client = anthropic.Anthropic()
with open("chart.png", "rb") as f:
imagedata = base64.standardb64encode(f.read()).decode("utf-8")
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"mediatype": "image/png",
"data": imagedata
}
},
{
"type": "text",
"text": "Analisis chart ini. Apa insight utama yang bisa diambil?"
}
]
}
]
)
print(message.content[0].text)
Tool Use (Function Calling)
Fitur tool use memungkinkan Claude memanggil fungsi yang Anda definisikan. Ini adalah fondasi untuk membangun AI agent:
import anthropic
import json
client = anthropic.Anthropic()
tools = [
{
"name": "getweather",
"description": "Mendapatkan informasi cuaca untuk kota tertentu",
"inputschema": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "Nama kota, misalnya Jakarta"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Satuan temperatur"
}
},
"required": ["city"]
}
},
{
"name": "calculate",
"description": "Melakukan kalkulasi matematika",
"inputschema": {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "Ekspresi matematika, misalnya 2+2"
}
},
"required": ["expression"]
}
}
]
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
tools=tools,
messages=[
{"role": "user", "content": "Berapa cuaca di Jakarta hari ini?"}
]
)
print("Stop reason:", message.stopreason)
for block in message.content:
if block.type == "tooluse":
print(f"Tool call: {block.name}")
print(f"Input: {json.dumps(block.input, indent=2)}")
Agentic Loop: Menjalankan Tool dan Melanjutkan Percakapan
Dalam skenario nyata, Anda perlu menjalankan tool yang diminta Claude, lalu mengirim hasilnya kembali:
import anthropic
import json
client = anthropic.Anthropic()
def getweather(city, unit="celsius"):
weatherdata = {
"Jakarta": {"temp": 32, "condition": "Cerah berawan"},
"Bandung": {"temp": 24, "condition": "Hujan ringan"},
}
data = weatherdata.get(city, {"temp": 25, "condition": "Tidak diketahui"})
return json.dumps(data)
def processtoolcall(toolname, toolinput):
if toolname == "getweather":
return getweather(toolinput["city"], toolinput.get("unit", "celsius"))
return json.dumps({"error": "Tool tidak ditemukan"})
tools = [
{
"name": "getweather",
"description": "Mendapatkan informasi cuaca untuk kota tertentu",
"inputschema": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "Nama kota"},
"unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
},
"required": ["city"]
}
}
]
messages = [{"role": "user", "content": "Bandingkan cuaca Jakarta dan Bandung hari ini."}]
while True:
response = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
tools=tools,
messages=messages
)
if response.stopreason == "endturn":
for block in response.content:
if hasattr(block, "text"):
print(block.text)
break
if response.stopreason == "tooluse":
messages.append({"role": "assistant", "content": response.content})
toolresults = []
for block in response.content:
if block.type == "tooluse":
result = processtoolcall(block.name, block.input)
toolresults.append({
"type": "toolresult",
"tooluseid": block.id,
"content": result
})
messages.append({"role": "user", "content": toolresults})
Prompt Caching
Prompt caching adalah fitur yang sangat berguna untuk menghemat biaya dan meningkatkan kecepatan. Ketika Anda mengirim prompt yang sama berulang kali (misalnya system prompt yang panjang atau dokumen referensi), Claude bisa meng-cache bagian tersebut:
import anthropic
client = anthropic.Anthropic()
longsystemprompt = """Kamu adalah asisten analisis data senior dengan keahlian di bidang:
Python, Pandas, NumPy, Scikit-learn
SQL dan database management
Statistik dan probabilitas
Machine learning dan deep learning
Data visualization dengan Matplotlib dan Seaborn
... (bayangkan ini adalah prompt yang sangat panjang dengan ratusan baris instruksi)
"""
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
system=[
{
"type": "text",
"text": longsystemprompt,
"cachecontrol": {"type": "ephemeral"}
}
],
messages=[
{"role": "user", "content": "Bagaimana cara handle missing values di dataset?"}
]
)
print(message.content[0].text)
print(f"Input tokens: {message.usage.inputtokens}")
print(f"Cache read tokens: {message.usage.cachereadinputtokens}")
print(f"Cache creation tokens: {message.usage.cachecreationinputtokens}")
Cache bertahan selama 5 menit. Request kedua dengan system prompt yang sama akan jauh lebih murah karena membaca dari cache.
Caching Dokumen Referensi
with open("companyhandbook.txt", "r") as f:
handbook = f.read()
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
system=[
{
"type": "text",
"text": "Kamu adalah HR assistant yang menjawab pertanyaan berdasarkan handbook perusahaan berikut.",
},
{
"type": "text",
"text": handbook,
"cachecontrol": {"type": "ephemeral"}
}
],
messages=[
{"role": "user", "content": "Berapa hari cuti tahunan yang didapat karyawan baru?"}
]
)
Extended Thinking
Extended thinking memungkinkan Claude menunjukkan proses berpikirnya sebelum memberikan jawaban akhir. Ini sangat berguna untuk masalah kompleks:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=16000,
thinking={
"type": "enabled",
"budgettokens": 10000
},
messages=[
{
"role": "user",
"content": "Sebuah perusahaan memiliki data penjualan 3 tahun. Tahun 1: Rp 500 juta, Tahun 2: Rp 650 juta, Tahun 3: Rp 780 juta. Prediksi penjualan tahun ke-4 menggunakan metode regresi linear. Tunjukkan langkah perhitungannya."
}
]
)
for block in response.content:
if block.type == "thinking":
print("=== Proses Berpikir ===")
print(block.thinking)
print()
elif block.type == "text":
print("=== Jawaban ===")
print(block.text)
Async Client
Untuk aplikasi yang membutuhkan concurrency tinggi, gunakan async client:
import anthropic
import asyncio
async def analyzedocument(doctext, question):
client = anthropic.AsyncAnthropic()
message = await client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{"role": "user", "content": f"Dokumen:\n{doctext}\n\nPertanyaan: {question}"}
]
)
return message.content[0].text
async def main():
documents = [
("Laporan Q1: Revenue naik 15%...", "Apa highlight utama?"),
("Laporan Q2: Ekspansi ke 3 kota baru...", "Apa rencana ekspansi?"),
("Laporan Q3: Cost optimization berhasil...", "Berapa penghematan?"),
]
tasks = [analyzedocument(doc, q) for doc, q in documents]
results = await asyncio.gather(tasks)
for i, result in enumerate(results):
print(f"\nDokumen {i+1}: {result[:200]}...")
asyncio.run(main())
Message Batches API
Untuk pemrosesan batch dalam volume besar dengan biaya 50% lebih murah:
import anthropic
client = anthropic.Anthropic()
batch = client.messages.batches.create(
requests=[
{
"customid": "review-1",
"params": {
"model": "claude-sonnet-4-6",
"maxtokens": 1024,
"messages": [
{"role": "user", "content": "Review kode berikut: def add(a,b): return a+b"}
]
}
},
{
"customid": "review-2",
"params": {
"model": "claude-sonnet-4-6",
"maxtokens": 1024,
"messages": [
{"role": "user", "content": "Review kode berikut: def multiply(x,y): return xy"}
]
}
}
]
)
print(f"Batch ID: {batch.id}")
print(f"Status: {batch.processingstatus}")
Error Handling dan Best Practices
Retry Logic
import anthropic
client = anthropic.Anthropic(maxretries=3)
try:
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
messages=[
{"role": "user", "content": "Hello!"}
]
)
print(message.content[0].text)
except anthropic.RateLimitError:
print("Rate limit tercapai. Coba lagi nanti.")
except anthropic.APIConnectionError:
print("Gagal terhubung ke API. Periksa koneksi internet.")
except anthropic.APIStatusError as e:
print(f"API error: {e.statuscode} - {e.message}")
Best Practices
claude-sonnet-4-6 untuk tugas umum, claude-opus-4-6 untuk tugas kompleks, claude-haiku-4-5 untuk tugas ringan dan cepat.message.usage untuk memantau konsumsi token dan biaya.print(f"Input tokens: {message.usage.inputtokens}")
print(f"Output tokens: {message.usage.outputtokens}")
Contoh Proyek: RAG Sederhana dengan Claude
Berikut contoh implementasi Retrieval-Augmented Generation sederhana:
import anthropic
client = anthropic.Anthropic()
knowledgebase = {
"produk": "Kami menjual 3 paket: Basic (Rp 100rb/bulan), Pro (Rp 500rb/bulan), Enterprise (custom).",
"refund": "Refund bisa diajukan dalam 30 hari setelah pembelian dengan menghubungi support.",
"support": "Support tersedia 24/7 melalui email support@example.com atau chat di website.",
}
def simpleretrieval(query):
querylower = query.lower()
relevantdocs = []
for key, value in knowledgebase.items():
if key in querylower or any(word in querylower for word in value.lower().split()[:5]):
relevantdocs.append(value)
return "\n".join(relevantdocs) if relevantdocs else "Tidak ada informasi yang relevan."
def raganswer(question):
context = simpleretrieval(question)
message = client.messages.create(
model="claude-sonnet-4-6",
maxtokens=1024,
system=[
{
"type": "text",
"text": "Kamu adalah customer support assistant. Jawab pertanyaan HANYA berdasarkan konteks yang diberikan. Jika informasi tidak tersedia di konteks, katakan bahwa kamu tidak memiliki informasi tersebut.",
},
{
"type": "text",
"text": f"Konteks:\n{context}",
"cachecontrol": {"type": "ephemeral"}
}
],
messages=[
{"role": "user", "content": question}
]
)
return message.content[0].text
print(raganswer("Berapa harga paket Pro?"))
print(rag_answer("Bagaimana cara refund?"))
Kesimpulan
Anthropic Claude API menawarkan kemampuan yang sangat lengkap untuk membangun aplikasi AI modern. Fitur-fitur utama yang perlu Anda kuasai:
- Messages API sebagai fondasi untuk semua interaksi dengan Claude
- Streaming untuk pengalaman pengguna yang responsif
- Vision untuk aplikasi multimodal yang menganalisis gambar
- Tool Use untuk membangun AI agent yang bisa berinteraksi dengan sistem eksternal
- Prompt Caching untuk optimasi biaya di production
- Extended Thinking untuk masalah yang membutuhkan reasoning mendalam
- Batches API untuk pemrosesan volume besar dengan biaya lebih rendah
Dengan memahami fitur-fitur ini, Anda siap membangun aplikasi AI yang powerful dan production-ready menggunakan Claude API. Mulailah dengan contoh-contoh sederhana di tutorial ini, lalu kembangkan sesuai kebutuhan proyek Anda.