Tutorial Membangun AI Agent Efektif dengan Pola Anthropic

Dalam satu tahun terakhir, Anthropic bekerja sama dengan puluhan tim yang membangun large language model agents di berbagai industri. Temuan yang konsisten: implementasi paling sukses justru tidak menggunakan framework kompleks atau library khusus. Mereka membangun dengan pola sederhana yang komposabel. Artikel ini merangkum praktik terbaik tersebut dan memberikan panduan praktis untuk developer Indonesia yang ingin membangun AI agent efektif tanpa terjebak dalam abstraksi yang tidak perlu.

Anthropic membedakan dua arsitektur utama: workflows, di mana LLM dan tools diorkestrasi melalui path kode yang telah ditentukan, serta agents, di mana LLM secara dinamis mengarahkan proses dan penggunaan tools sendiri. Kita akan membahas pola workflows yang paling umum ditemukan di production, lalu meninjau kapan sebaiknya beralih ke autonomous agents.

Prasyarat dan Rekomendasi Dasar

Sebelum membangun agentic system, Anthropic menekankan prinsip utama: cari solusi paling sederhana, baru tambah kompleksitas jika benar-benar diperlukan. Banyak aplikasi cukup dioptimasi dengan single LLM call yang dilengkapi retrieval dan in-context examples. Framework seperti Claude Agent SDK atau Strands Agents SDK memang mempercepat prototyping, namun sering menambah layer abstraksi yang menyulitkan debug.

Disarankan untuk memulai dengan LLM API langsung. Banyak pola bisa diimplementasikan dalam beberapa baris kode. Jika menggunakan framework, pastikan kamu memahami prompt dan response di bawah hood. Dokumentasi dan cookbook resmi Anthropic tersedia di platform.claude.com/cookbook.

Langkah 1: Mulai dengan Augmented LLM

Blok dasar dari agentic system adalah augmented LLM: model bahasa yang diperkaya dengan retrieval, tools, dan memory. Model terbaru dari Anthropic bisa aktif menggunakan kemampuan ini, seperti menghasilkan search query sendiri, memilih tool yang sesuai, dan menentukan informasi apa yang perlu dipertahankan.

Fokus pada dua aspek implementasi: tailor kemampuan ke use case spesifik, dan pastikan interface yang disediakan mudah dimengerti LLM. Salah satu pendekatan adalah menggunakan Model Context Protocol (MCP) untuk integrasi dengan third-party tools. Dengan MCP client sederhana, agent bisa terhubung ke database, Slack, atau GitHub tanpa hardcoding konektor custom.

Contoh setup augmented LLM dengan Python dan Anthropic SDK:

from anthropic import Anthropic
import json

client = Anthropic()

# Definisikan tool schema untuk LLM
tools = [{
    "name": "search_database",
    "description": "Cari data di PostgreSQL",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string"}
        },
        "required": ["query"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Cari total order bulan ini"}]
)

Pada kode di atas, LLM akan memutuskan apakah perlu memanggil search_database atau menjawab langsung berdasarkan konteks yang diberikan. Tool schema yang jelas adalah kunci keberhasilan augmented LLM.

Langkah 2: Implementasi Prompt Chaining

Prompt chaining mendekomposisi tugas menjadi rangkaian langkah, di mana setiap LLM call memproses output dari call sebelumnya. Kamu bisa menambahkan programmatic check (gate) di setiap step untuk memastikan proses tetap on track.

Pola ini ideal untuk tugas yang mudah dipecah menjadi subtask tetap. Contoh paling umum: generate marketing copy, lalu terjemahkan ke bahasa lain. Atau tulis outline dokumen, verifikasi bahwa outline memenuhi kriteria, lalu tulis dokumen berdasarkan outline.

Implementasi prompt chaining di Python:

def generate_outline(topic):
    return call_llm(f"Buat outline artikel tentang {topic}")

def validate_outline(outline):
    criteria = ["Ada pendahuluan", "Minimal 3 sub-bab"]
    return all(c in outline for c in criteria)

def write_article(outline):
    return call_llm(f"Tulis artikel berdasarkan outline: {outline}")

outline = generate_outline("AI Agent Workflow")
if validate_outline(outline):
    article = write_article(outline)

Kelebihan prompt chaining adalah trade-off latency untuk akurasi yang lebih tinggi. Setiap LLM call menangani tugas yang lebih sederhana, sehingga error rate menurun dan output lebih terkontrol.

Langkah 3: Gunakan Routing untuk Klasifikasi Tugas

Routing mengklasifikasikan input dan mengarahkannya ke task khusus. Ini memungkinkan separation of concerns dan prompt yang lebih spesialis. Tanpa routing, optimasi untuk satu jenis input bisa merusak performa pada input lain.

Contoh routing untuk customer support: pertanyaan umum diarahkan ke model kecil seperti Claude Haiku, refund request ke departemen keuangan via tool, dan technical support ke engineer on-call dengan konteks log error. Implementasi routing bisa menggunakan LLM call pertama untuk klasifikasi, atau traditional classifier seperti logistic regression jika latensi kritis.

def route_query(user_input):
    intent = call_llm(f"Klasifikasikan intent: {user_input}")
    if intent == "general":
        return call_llm(user_input, model="haiku")
    elif intent == "refund":
        return process_refund(user_input)
    elif intent == "technical":
        return escalate_to_engineer(user_input)
    else:
        return human_handoff(user_input)

Pola routing bekerja sangat baik ketika ada kategori yang jelas dan klasifikasi bisa dilakukan dengan akurat. Ini adalah fondasi dari banyak chatbot production yang handal.

Langkah 4: Parallelization untuk Kecepatan dan Confidence

Parallelization menjalankan beberapa LLM call secara bersamaan dan menggabungkan output secara programmatic. Ada dua variasi: sectioning (memecah tugas jadi subtask independen) dan voting (menjalankan tugas yang sama berkali-kali untuk mendapat perspektif beragam).

Sectioning cocok untuk evaluasi kompleks. Misalnya, satu LLM mengevaluasi keamanan kode, satu lagi mengevaluasi readability, dan satu lagi mengevaluasi test coverage. Hasilnya digabung jadi report lengkap. Voting berguna untuk review konten: jalankan tiga prompt berbeda untuk mendeteksi konten tidak pantas, lalu ambil keputusan berdasarkan mayoritas.

import concurrent.futures

def evaluate_security(code):
    return call_llm(f"Review security: {code}")

def evaluate_readability(code):
    return call_llm(f"Review readability: {code}")

with concurrent.futures.ThreadPoolExecutor() as executor:
    sec_future = executor.submit(evaluate_security, code_snippet)
    read_future = executor.submit(evaluate_readability, code_snippet)
    security_score = sec_future.result()
    readability_score = read_future.result()

Parallelization efektif karena LLM umumnya bekerja lebih baik ketika setiap aspek ditangani oleh call terpisah, memungkinkan focused attention.

Langkah 5: Evaluator-Optimizer untuk Iterasi Berkualitas

Pola evaluator-optimizer menggunakan satu LLM call untuk menghasilkan response, dan LLM call lain untuk memberikan evaluasi serta feedback dalam loop. Ini sangat efektif ketika ada kriteria evaluasi yang jelas dan iterative refinement memberikan value terukur.

Contoh paling jelas adalah literary translation, di mana translator LLM mungkin tidak menangkap nuansa awal, tetapi evaluator LLM bisa memberikan kritik konstruktif. Atau complex search task yang memerlukan multiple rounds pencarian dan analisis, di mana evaluator memutuskan apakah pencarian tambahan diperlukan.

def generate_draft(requirements):
    return call_llm(f"Buat draft berdasarkan: {requirements}")

def evaluate_draft(draft, criteria):
    return call_llm(f"Evaluasi draft ini terhadap kriteria {criteria}")

draft = generate_draft("Sistem pembayaran mikro")
feedback = evaluate_draft(draft, ["Keamanan", "Skalabilitas"])

while "perlu revisi" in feedback.lower() and iterations < 5:
    draft = call_llm(f"Perbaiki draft berdasarkan feedback: {feedback}")
    feedback = evaluate_draft(draft, criteria)

Pola ini mengonsumsi lebih banyak token, namun menghasilkan output yang signifikan lebih polished untuk tugas kritis.

Kesimpulan

Membangun AI agent yang efektif tidak harus melibatkan framework kompleks. Mulai dengan augmented LLM, lalu tambahkan workflows seperti prompt chaining, routing, parallelization, atau evaluator-optimizer sesuai kebutuhan. Beralih ke autonomous agents hanya untuk masalah open-ended di mana jumlah langkah tidak bisa diprediksi.

Ukur performa setiap iterasi, dan tambah kompleksitas hanya ketika outcome benar-benar meningkat. Dokumentasi lengkap pola-pola ini tersedia di anthropic.com/research/building-effective-agents. Untuk contoh implementasi kode, kunjungi Anthropic Cookbook di GitHub.

Gambar: Anthropic Blog