Tutorial Lengkap Anthropic Claude API: Dari Dasar hingga Fitur Lanjutan

# 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 yan...

By Ruby Abdullah · · tutorial
Claude APIAnthropicLLMAI AgentPython

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

  • Gunakan model yang tepat: claude-sonnet-4-6 untuk tugas umum, claude-opus-4-6 untuk tugas kompleks, claude-haiku-4-5 untuk tugas ringan dan cepat.
  • Set maxtokens dengan tepat: Jangan terlalu besar jika tidak perlu, ini mempengaruhi latensi.
  • Manfaatkan prompt caching: Untuk system prompt atau dokumen referensi yang digunakan berulang, selalu gunakan cachecontrol.
  • Gunakan streaming untuk UX yang baik: Pengguna lebih suka melihat respons yang muncul bertahap daripada menunggu lama.
  • Implementasi retry logic: API bisa mengalami rate limit atau error sementara, SDK secara default sudah menangani retry.
  • Gunakan async untuk throughput tinggi: Jika memproses banyak request secara paralel, gunakan AsyncAnthropic.
  • Monitor usage: Periksa 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.

    Artikel Terkait

    Tutorial Browser-Use: Automasi Browser dengan AI Agent

    Tutorial Browser-Use: Automasi Browser dengan AI Agent Pendahuluan Browser-Use adalah library Python open-source yang me...

    Tutorial Phidata (Agno): Framework AI Agent yang Simpel dan Powerful

    Tutorial Phidata (Agno): Framework AI Agent yang Simpel dan Powerful Membangun AI agent yang cerdas dan otonom kini sema...

    Tutorial CrewAI: Membangun Multi-Agent AI Framework

    CrewAI - Framework AI Multi-Agen Daftar Isi Pendahuluan Prasyarat Instalasi dan Pengaturan Konsep Dasar 5...

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng Apa itu Aisuite? Aisuite adalah library Python open...