Claude 18, Belajar Claude API: Panduan Lengkap Membangun Aplikasi AI dengan Python, Dari Hello World hingga Production

Tinggalkan Komentar / CLAUDE CODE AI / Oleh

Membangun aplikasi dengan Claude bukan sekadar memanggil API dan mendapatkan teks. Ekosistem Anthropic telah berkembang menjadi platform agentic yang lengkap — dengan model-model Claude 4.6 yang powerful, tool use, extended thinking, RAG, prompt caching, hingga sistem multi-agent dengan Model Context Protocol.

Panduan ini mencakup perjalanan penuh: dari panggilan API pertama hingga sistem production-ready — lengkap dengan kode nyata yang bisa langsung dijalankan.

Bab 1 — Memilih Model Claude yang Tepat

Memilih model yang tepat adalah keputusan arsitektur paling fundamental. Jangan pakai satu model untuk semua task.

Model API String Keunggulan Gunakan untuk
Claude Opus 4.6 claude-opus-4-6 Reasoning tertinggi Coding kompleks, analisis mendalam, orchestrator multi-agent
Claude Sonnet 4.6 claude-sonnet-4-6 Balance capability vs cost Default untuk mayoritas task: coding, writing, analysis, agents
Claude Haiku 4.5 claude-haiku-4-5-20251001 Tercepat, termurah Klasifikasi, routing, preprocessing, subagent sederhana

Strategi model routing yang matang bisa hemat 60-80% biaya: gunakan Haiku untuk task ringan (routing, klasifikasi), Sonnet untuk mayoritas pekerjaan, dan Opus hanya ketika benar-benar membutuhkan reasoning tertinggi.

Fitur utama Claude 4.6: Extended/Adaptive Thinking, 1 juta token context window (Sonnet 4.6 dan Opus 4.6), structured outputs (beta), parallel tool use, dan computer use.

Bab 2 — Messages API: Fondasi Semua Interaksi

Panggilan API Pertama

 
 
bash
pip install anthropic
 
 
python
import anthropic

client = anthropic.Anthropic()  # Pakai ANTHROPIC_API_KEY dari environment

message = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Jelaskan konsep RAG dalam 3 kalimat."}
    ]
)

print(message.content[0].text)

Multi-Turn Conversation

 
 
python
# Multi-turn: sertakan histori percakapan
messages = [
    {"role": "user", "content": "Apa itu transformer architecture?"},
    {"role": "assistant", "content": "Transformer adalah arsitektur neural network..."},
    {"role": "user", "content": "Bagaimana attention mechanism bekerja di dalamnya?"}
]

response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=2048,
    messages=messages
)

Streaming untuk UX yang Responsif

 
 
python
with client.messages.stream(
    model='claude-sonnet-4-6',
    max_tokens=1024,
    messages=[{'role': 'user', 'content': prompt}]
) as stream:
    for text in stream.text_stream:
        print(text, end='', flush=True)

Message Batches API — Hemat 50% untuk Volume Besar

 
 
python
from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request

batch = client.messages.batches.create(
    requests=[
        Request(
            custom_id=f"request_{i}",
            params=MessageCreateParamsNonStreaming(
                model='claude-haiku-4-5-20251001',
                max_tokens=500,
                messages=[{"role": "user", "content": prompts[i]}]
            )
        )
        for i, prompt in enumerate(prompts[:1000])  # Maks 10.000 per batch
    ]
)
print(f'Batch ID: {batch.id}')  # Poll status dengan batch.id

Files API — Upload Sekali, Gunakan Berulang

 
 
python
# Upload file sekali
with open('document.pdf', 'rb') as f:
    uploaded_file = client.beta.files.upload(
        file=('document.pdf', f, 'application/pdf')
    )
file_id = uploaded_file.id

# Gunakan di multiple requests tanpa re-upload
response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {"type": "document", "source": {"type": "file", "file_id": file_id}},
            {"type": "text", "text": "Ringkas dokumen ini"}
        ]
    }]
)

Bab 3 — Prompt Engineering yang Efektif

Teknik 1: XML Tags untuk Struktur yang Jelas

 
 
python
prompt = """
<system_context>
Anda adalah analis keuangan senior dengan keahlian di pasar Asia Tenggara.
Selalu berikan analisis berbasis data dengan asumsi yang eksplisit.
</system_context>

<task>
Analisis potensi ekspansi bisnis ke Vietnam untuk perusahaan SaaS B2B.
</task>

<output_format>
1. Executive Summary (100 kata)
2. Analisis Risiko (3-5 risiko utama dengan severity rating)
3. Rekomendasi (Go/No-Go dengan justifikasi)
</output_format>
"""

Teknik 2: Few-Shot Examples untuk Konsistensi Format

 
 
python
prompt = """
Klasifikasikan setiap tiket support. Format: [KATEGORI] | [PRIORITAS] | [RINGKASAN 10 KATA]

Contoh:
Input: 'Tidak bisa login sejak tadi pagi, urgent butuh akses'
Output: [AKSES] | [HIGH] | User tidak bisa login, berdampak operasional

Input: 'Tolong tambahkan fitur dark mode'
Output: [FEATURE_REQUEST] | [LOW] | Permintaan dark mode interface

Sekarang klasifikasikan:
Input: {tiket_baru}
"""

Teknik 3: Chain-of-Thought

 
 
python
prompt = """
Sebelum memberikan jawaban akhir, pikirkan langkah demi langkah:
1. Identifikasi semua asumsi yang perlu dibuat
2. Uraikan masalah menjadi sub-masalah yang lebih kecil
3. Selesaikan setiap sub-masalah
4. Verifikasi konsistensi jawabanmu
5. Baru berikan kesimpulan akhir

Masalah: {masalah_kompleks}
"""

Teknik 4: System Prompt yang Efektif

 
 
python
response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=1024,
    system="""
# Identitas dan Peran
Anda adalah asisten AI untuk [nama produk], platform manajemen inventori.

# Kemampuan dan Scope
Anda membantu pengguna dengan:
- Pertanyaan tentang fitur platform
- Troubleshooting masalah teknis
- Best practices manajemen inventori

# Batasan
- Jangan membahas produk kompetitor secara spesifik
- Untuk isu billing, arahkan ke: billing@company.com
- Jika tidak yakin, akui dan tawarkan untuk eskalasi ke human agent

# Format Respons
- Gunakan bahasa Indonesia yang profesional tapi tidak kaku
- Respons maks 3 paragraf untuk pertanyaan umum
- Untuk langkah teknis, gunakan numbered list
    """,
    messages=[{"role": "user", "content": user_message}]
)

Teknik 5: Prefill untuk Kontrol Output

 
 
python
# Prefill memaksa Claude melanjutkan dari titik tertentu
messages = [
    {'role': 'user', 'content': 'Ekstrak informasi produk dari teks berikut: {teks}'},
    {'role': 'assistant', 'content': '{'}  # Prefill — Claude melanjutkan JSON
]
# Hasilnya: Claude output JSON valid tanpa pembukaan atau penjelasan

Bab 4 — Tool Use: Menghubungkan Claude ke Sistem Eksternal

Tool use memungkinkan Claude berinteraksi dengan API, database, filesystem, dan web. Claude memutuskan kapan menggunakan tool mana berdasarkan pemahaman konteks.

Mendefinisikan Tools

 
 
python
tools = [
    {
        "name": "get_product_info",
        "description": """
Ambil informasi lengkap tentang produk dari database.
Gunakan ketika user bertanya tentang detail, harga, atau stok produk.
JANGAN gunakan untuk pencarian produk — gunakan search_products untuk itu.
        """,
        "input_schema": {
            "type": "object",
            "properties": {
                "product_id": {
                    "type": "string",
                    "description": "ID produk unik (format: PROD-XXXX)"
                }
            },
            "required": ["product_id"]
        }
    }
]

Agentic Loop — Handle Tool Calls

 
 
python
def run_agent_with_tools(user_message, tools, max_iterations=10):
    messages = [{'role': 'user', 'content': user_message}]

    for i in range(max_iterations):
        response = client.messages.create(
            model='claude-sonnet-4-6',
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        messages.append({'role': 'assistant', 'content': response.content})

        if response.stop_reason == 'tool_use':
            tool_results = []
            for block in response.content:
                if block.type == 'tool_use':
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        'type': 'tool_result',
                        'tool_use_id': block.id,
                        'content': str(result)
                    })
            messages.append({'role': 'user', 'content': tool_results})

        else:  # stop_reason == 'end_turn'
            return response.content[0].text

    return 'Max iterations reached'

Server tools bawaan Claude yang bisa langsung digunakan: web_search (pencarian web real-time), web_fetch (ambil konten dari URL), computer (eksekusi kode Python), text_editor (edit file teks), dan bash (shell commands).

Kunci penulisan tool yang baik: deskripsi seperti docstring untuk junior developer — eksplisit, jelas, termasuk kapan TIDAK menggunakan tool. Parallel tool use memungkinkan multiple tool calls dalam satu turn untuk efisiensi.

Bab 5 — Extended Thinking dan Vision

Adaptive Thinking untuk Reasoning Mendalam

 
 
python
# Adaptive thinking — DIREKOMENDASIKAN untuk Claude 4.6
response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=8000,
    thinking={
        "type": "adaptive",    # Model putuskan sendiri kapan perlu berpikir
        "budget_tokens": 5000  # Maks token untuk thinking
    },
    messages=[{'role': 'user', 'content': complex_problem}]
)

for block in response.content:
    if block.type == 'thinking':
        print('THINKING:', block.thinking[:500])
    elif block.type == 'text':
        print('ANSWER:', block.text)
 
 
python
# Interleaved thinking untuk tool use
response = client.messages.create(
    model='claude-opus-4-6',
    max_tokens=8000,
    extra_headers={'anthropic-beta': 'interleaved-thinking-2025-05-14'},
    thinking={'type': 'enabled', 'budget_tokens': 5000},
    tools=tools,
    messages=messages
)

Mode thinking: Standard (cepat, hemat), Extended (latency tinggi, masalah sangat kompleks), Adaptive (balance terbaik — rekomendasi untuk Claude 4.6), Interleaved (thinking antara tool calls).

Vision: Analisis Gambar dan PDF

 
 
python
import base64

# Kirim gambar
with open('chart.png', 'rb') as f:
    image_data = base64.standard_b64encode(f.read()).decode('utf-8')

response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=1024,
    messages=[{
        'role': 'user',
        'content': [
            {'type': 'image', 'source': {'type': 'base64',
             'media_type': 'image/png', 'data': image_data}},
            {'type': 'text', 'text': 'Analisis chart ini dan berikan insight utama'}
        ]
    }]
)
 
 
python
# Analisis PDF
with open('report.pdf', 'rb') as f:
    pdf_data = base64.standard_b64encode(f.read()).decode('utf-8')

response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=4096,
    messages=[{
        'role': 'user',
        'content': [
            {'type': 'document', 'source': {'type': 'base64',
             'media_type': 'application/pdf', 'data': pdf_data}},
            {'type': 'text', 'text': 'Ekstrak semua data keuangan dan format sebagai tabel JSON'}
        ]
    }]
)

Bab 6 — RAG dan Prompt Caching

Contextual Retrieval: RAG yang 49-67% Lebih Akurat

 
 
python
def generate_contextual_chunk(full_document: str, chunk: str) -> str:
    """Tambahkan konteks spesifik ke setiap chunk sebelum embedding"""
    response = client.messages.create(
        model='claude-haiku-4-5-20251001',  # Haiku untuk biaya rendah
        max_tokens=200,
        system=[
            {
                "type": "text",
                "text": full_document,
                "cache_control": {"type": "ephemeral"}  # Cache dokumen!
            }
        ],
        messages=[{
            'role': 'user',
            'content': f'Berikan konteks singkat (2-3 kalimat) untuk chunk ini: {chunk}'
        }]
    )
    context = response.content[0].text
    return f'{context}\n\n{chunk}'

Pipeline RAG: Ingest (chunking → contextual prefix → embed) → Index (vector + BM25 untuk hybrid search) → Retrieve (semantic + keyword + reranking) → Generate (dengan prompt caching).

Kapan tidak perlu RAG: knowledge base kurang dari 200.000 token (~500 halaman)? Pertimbangkan langsung masukkan ke context window — lebih sederhana dan dengan prompt caching bisa sangat cost-effective.

Prompt Caching: Hemat 90% Biaya Input

 
 
python
response = client.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": very_long_system_prompt,
            "cache_control": {"type": "ephemeral"}  # Cache 5 menit
        }
    ],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": large_reference_document,
                    "cache_control": {"type": "ephemeral"}
                },
                {
                    "type": "text",
                    "text": current_user_question  # Bagian yang berubah
                }
            ]
        }
    ]
)

usage = response.usage
print(f'Cache read: {usage.cache_read_input_tokens} tokens (hemat 90%)')
print(f'Cache write: {usage.cache_creation_input_tokens} tokens')

Kalkulasi nyata: sistem prompt 10.000 token + 1.000 request/hari = hemat ~$810/bulan pada harga Sonnet $3/1M tokens. Gunakan TTL 1 jam untuk extended thinking tasks yang berlangsung lama.

Bab 7 — Multi-Agent Systems dan MCP

Pola Parallelization

 
 
python
import asyncio

async def analyze_section(section: str, focus: str) -> str:
    response = await client.messages.create_async(
        model='claude-sonnet-4-6',
        max_tokens=1024,
        messages=[{'role': 'user', 'content': f'Analisis {focus} dari: {section}'}]
    )
    return response.content[0].text

# 5 analisis berjalan paralel
results = await asyncio.gather(
    analyze_section(doc, 'financial risks'),
    analyze_section(doc, 'operational risks'),
    analyze_section(doc, 'regulatory compliance'),
    analyze_section(doc, 'market opportunities'),
    analyze_section(doc, 'competitive landscape')
)

Pola Routing — Haiku untuk Klasifikasi Cepat

 
 
python
def route_request(user_message: str) -> str:
    response = client.messages.create(
        model='claude-haiku-4-5-20251001',  # Cepat & murah untuk routing
        max_tokens=50,
        messages=[{
            'role': 'user',
            'content': f'''Klasifikasikan ke salah satu: [billing, technical_support, sales, general]
Request: {user_message}
Jawab hanya dengan kategori.'''
        }]
    )
    return response.content[0].text.strip().lower()

Model Context Protocol (MCP)

MCP adalah protokol terbuka yang menstandardisasi cara AI terhubung ke tools dan data sources — seperti USB-C untuk AI integrations. Satu MCP server bisa digunakan oleh berbagai AI clients.

 
 
python
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

server = Server('my-company-tools')

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name='get_employee_info',
            description='Get employee information from HR system',
            inputSchema={
                'type': 'object',
                'properties': {'employee_id': {'type': 'string'}},
                'required': ['employee_id']
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == 'get_employee_info':
        data = hr_system.get_employee(arguments['employee_id'])
        return [TextContent(type='text', text=str(data))]

Prinsip agentic yang harus selalu diingat: minimal footprint, human in the loop untuk aksi irreversible, incremental progress dengan checkpoint, dan batasi max_iterations untuk mencegah runaway costs.

Bab 8 — Evaluasi dan Quality Assurance

LLM-as-Judge Implementation

 
 
python
def grade_response(question: str, expected: str, actual: str) -> dict:
    """Gunakan Claude untuk mengevaluasi kualitas respons"""
    grading_prompt = f"""
Evaluasi respons AI berikut berdasarkan rubrik ini:

PERTANYAAN: {question}
RESPONS YANG DIHARAPKAN: {expected}
RESPONS AKTUAL: {actual}

RUBRIK:
1. Akurasi faktual (0-30): Apakah informasi benar?
2. Kelengkapan (0-25): Apakah semua aspek tercakup?
3. Kejelasan (0-25): Apakah mudah dipahami?
4. Relevansi (0-20): Apakah fokus pada pertanyaan?

Format output sebagai JSON:
{{"accuracy": N, "completeness": N, "clarity": N, "relevance": N,
  "total": N, "reasoning": "..."}}
    """
    response = client.messages.create(
        model='claude-sonnet-4-6',
        max_tokens=500,
        messages=[{'role': 'user', 'content': grading_prompt}]
    )
    import json
    return json.loads(response.content[0].text)

Empat tipe grading: Code/Math (programatik, deterministik), Rubric-based LLM-as-Judge (kualitas tulisan dan analisis), Binary (safety check, compliance), Human (creative content, subjective quality).

Platform Deployment

Platform Keunggulan Cocok Untuk
Anthropic Direct API Semua fitur terbaru, paling cepat update Startup, prototyping, tim kecil
Amazon Bedrock AWS billing, IAM, regional compliance Enterprise dengan existing AWS infra
Google Vertex AI GCP billing, GDPR EU data residency Enterprise dengan existing GCP infra
Microsoft Foundry Azure billing, OAuth, enterprise SLA Enterprise dengan Microsoft ecosystem

Pertanyaan yang Sering Ditanyakan

Apa bedanya Messages API dengan Claude.ai biasa? Claude.ai adalah antarmuka chat untuk pengguna akhir. Messages API adalah antarmuka programatik untuk developer — memberikan kontrol penuh atas model yang digunakan, system prompt, parameter (temperature, max_tokens), format output, dan integrasi dengan tools eksternal. API cocok untuk membangun produk dan mengotomasi workflow.

Kapan harus menggunakan tool use vs RAG? Tool use untuk aksi real-time yang membutuhkan data terkini atau eksekusi di sistem eksternal (query database, kirim email, buat tiket). RAG untuk memberikan Claude akses ke knowledge base yang statis atau semi-statis (dokumentasi, FAQ, artikel). Keduanya bisa dikombinasikan: RAG untuk dokumen pengetahuan dan tool use untuk aksi operasional.

Bagaimana cara mengurangi biaya API secara signifikan? Tiga strategi utama: (1) model routing — Haiku untuk task sederhana, hemat 80-90% vs Sonnet. (2) Prompt caching — tandai sistem prompt dan dokumen referensi yang stabil, hemat 90% biaya input. (3) Batch API — untuk request non real-time, hemat 50% dengan Message Batches API.

Apa itu extended thinking dan kapan harus diaktifkan? Extended thinking memungkinkan Claude menggunakan chain-of-thought yang panjang sebelum menjawab. Gunakan untuk masalah multi-step reasoning kompleks, debugging sulit, atau analisis mendalam. Untuk Claude 4.6, gunakan mode adaptive — model memutuskan sendiri kapan perlu berpikir dalam, memberikan balance terbaik.

Bagaimana cara memulai membangun aplikasi production-ready? Mulai dengan satu use case yang jelas dan measurable. Setup evaluasi dengan test cases sebelum mulai build. Implementasi streaming untuk UX yang responsif. Tambahkan prompt caching dari awal untuk sistem prompt yang panjang. Baru setelah dasar berjalan dengan baik, tambahkan tool use dan agentic patterns.

Lanjutkan Perjalanan Belajar Claude Anda

Artikel ini adalah bagian dari seri Belajar Claude Gratis — panduan berbahasa Indonesia yang membahas ekosistem Claude untuk berbagai profil pembaca.

Kembali ke peta besar: Belajar Claude Gratis: Panduan Lengkap dari Nol hingga Mahir

Artikel cluster lainnya:

Tinggalkan Komentar

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *

Situs ini menggunakan Akismet untuk mengurangi spam. Pelajari bagaimana data komentar Anda diproses