Panduan Praktis Membangun AI Agent dengan Workflow dari Anthropic
AP
Adrian Prat

Dipublikasikan 8 Juni 2026

Panduan Praktis Membangun AI Agent dengan Workflow dari Anthropic

ai
agent
ai-agent
claude
claude

AI agent sudah menjadi topik hangat di kalangan developer sepanjang tahun 2026. Banyak tim engineering mulai beralih dari sekadar menggunakan LLM untuk chatbot sederhana ke arah sistem agentik yang bisa menjalankan tugas kompleks secara otonom. Menurut riset terbaru dari Anthropic, implementasi AI agent yang paling sukses justru tidak mengandalkan framework kompleks. Mereka yang berhasil justru membangun dengan pola sederhana yang komposabel.

Artikel ini akan membahas panduan praktis membangun AI agent berdasarkan best practices yang dipublikasikan oleh tim Anthropic. Kita akan mulai dari konsep dasar, membedakan antara workflows dan agents, hingga implementasi nyata yang bisa langsung dipraktekkan.

Memahami Perbedaan Workflows dan Agents

Sebelum mulai coding, penting untuk memahami terminologi yang dipakai Anthropic. Mereka membedakan dua arsitektur utama:

Workflows adalah sistem di mana LLM dan tools diorkestrasi melalui jalur kode yang sudah ditentukan. Sedangkan Agents adalah sistem di mana LLM secara dinamis mengarahkan proses dan pemakaian tools sendiri, menjaga kontrol penuh atas cara menyelesaikan tugas.

Workflows cocok untuk tugas yang terdefinisi dengan baik dan memerlukan konsistensi. Agents lebih baik untuk skenario yang memerlukan fleksibilitas dan pengambilan keputusan yang didorong oleh model itu sendiri. Sebagian besar aplikasi produksi sebenarnya cukup dengan workflows yang optimal, tanpa perlu membangun agents yang kompleks.

Persiapan Environment dan API Key

Langkah pertama untuk membangun AI agent adalah menyiapkan environment yang tepat. Anda memerlukan API key dari penyedia LLM. Anthropic merekomendasikan menggunakan Claude 3.7 Sonnet atau model dengan kemampuan thinking untuk hasil terbaik.

  1. Daftar akun di Anthropic Console dan buat API key baru.

  2. Install library HTTP client seperti requests atau httpx di Python:

pip install requests

  1. Buat file .env untuk menyimpan kredensial:

ANTHROPIC_API_KEY=sk-ant-xxx
MODEL=claude-3-7-sonnet-20250219

  1. Verifikasi koneksi API dengan script sederhana:

import requests, os

headers = {
    "x-api-key": os.getenv("ANTHROPIC_API_KEY"),
    "content-type": "application/json",
    "anthropic-version": "2023-06-01"
}

response = requests.post(
    "https://api.anthropic.com/v1/messages",
    headers=headers,
    json={
        "model": "claude-3-7-sonnet-20250219",
        "max_tokens": 1024,
        "messages": [{"role": "user", "content": "Halo"}]
    }
)
print(response.json())

Membangun Workflow Prompt Chaining

Prompt chaining adalah pola workflows yang paling sederhana. Tugas besar dipecah menjadi serangkaian langkah, di mana setiap panggilan LLM memproses output dari panggilan sebelumnya. Pola ini ideal untuk tugas yang bisa dipecah menjadi subtask tetap.

Berikut contoh implementasi prompt chaining untuk membuat artikel blog:

def generate_blog(topic):
    # Step 1: Buat outline
    outline = call_llm(f"Buat outline untuk artikel tentang {topic}")
    
    # Step 2: Verifikasi outline
    validation = call_llm(f"Verifikasi outline ini cukup komprehensif: {outline}")
    if "tidak" in validation.lower():
        return "Outline perlu diperbaiki"
    
    # Step 3: Tulis konten
    content = call_llm(f"Tulis artikel 500 kata berdasarkan outline: {outline}")
    
    # Step 4: Edit dan polish
    final = call_llm(f"Edit artikel ini untuk clarity dan grammar: {content}")
    return final

result = generate_blog("Docker untuk pemula")

Keunggulan prompt chaining adalah setiap LLM call menjadi tugas yang lebih mudah, meningkatkan akurasi secara keseluruhan. Trade-off-nya adalah latency yang lebih tinggi karena beberapa panggilan berurutan.

Implementasi Workflow Routing

Routing adalah pola workflows yang mengklasifikasikan input dan mengarahkannya ke task spesialis yang sesuai. Pola ini memungkinkan pemisahan concerns dan membangun prompt yang lebih spesialis.

Contoh implementasi routing untuk customer service:

def route_query(user_input):
    # Klasifikasikan jenis pertanyaan
    category = call_llm(f"Klasifikasikan pertanyaan ini: {user_input}")
    
    if "refund" in category.lower():
        return call_llm(f"Proses refund untuk: {user_input}")
    elif "teknis" in category.lower():
        return call_llm(f"Beri solusi teknis untuk: {user_input}")
    else:
        return call_llm(f"Jawab pertanyaan umum: {user_input}")

response = route_query("Aplikasi saya error setelah update")

Routing bekerja dengan baik untuk tugas kompleks di mana ada kategori yang berbeda dan lebih baik ditangani secara terpisah. Tanpa routing, optimasi untuk satu jenis input bisa merusak performa untuk input lainnya.

Implementasi Workflow Parallelization

Parallelization memungkinkan LLM bekerja secara bersamaan pada tugas yang sama, kemudian output-nya diagregasi secara programmatic. Ada dua variasi utama: sectioning (memecah tugas menjadi subtask independen) dan voting (menjalankan tugas yang sama beberapa kali untuk mendapatkan hasil yang lebih andal).

Contoh sectioning untuk review kode:

import concurrent.futures

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

def review_performance(code):
    return call_llm(f"Review performance issue: {code}")

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

with concurrent.futures.ThreadPoolExecutor() as executor:
    futures = [
        executor.submit(review_security, code),
        executor.submit(review_performance, code),
        executor.submit(review_readability, code)
    ]
    results = [f.result() for f in futures]

# Agregasi hasil
final_review = call_llm(f"Gabungkan review ini: {results}")

Menambahkan Model Context Protocol (MCP)

Model Context Protocol (MCP) adalah protokol yang dirilis Anthropic untuk memudahkan integrasi LLM dengan tools eksternal. MCP memungkinkan developer menghubungkan LLM dengan ekosistem tools pihak ketiga menggunakan client implementation yang sederhana.

Untuk memulai dengan MCP, install MCP client library:

pip install mcp

Kemudian buat client yang bisa berkomunikasi dengan server MCP:

from mcp import ClientSession

async def use_mcp_tool():
    async with ClientSession("http://localhost:3000") as session:
        result = await session.call_tool(
            "search_documentation",
            {"query": "Dockerfile best practices"}
        )
        return result

# Gunakan hasil sebagai konteks untuk LLM
context = await use_mcp_tool()
response = call_llm(f"Jelaskan berdasarkan: {context}")

Testing dan Evaluasi Agent

Setelah membangun agent, testing adalah langkah kritis. Anthropic menekankan bahwa developer harus menguji agent dengan dataset representatif dari kasus penggunaan nyata. Gunakan framework evaluasi untuk mengukur metrik seperti accuracy, latency, dan cost per request.

Berikut checklist evaluasi sederhana:

  • Unit test untuk setiap fungsi tool call

  • Integration test untuk end-to-end workflows

  • Benchmark dengan 50-100 contoh input representatif

  • Human review untuk output yang kritis

  • Monitoring cost dan latency di production

Kesimpulan

Membangun AI agent yang efektif tidak selalu memerlukan framework kompleks. Mulai dengan pola sederhana seperti prompt chaining, routing, atau parallelization. Gunakan LLM API secara langsung sebelum beralih ke framework abstrak. Fokus pada tailoring capabilities ke use case spesifik Anda dan pastikan interface yang disediakan mudah digunakan oleh LLM.

Sumber utama artikel ini berdasarkan publikasi riset Anthropic: Building Effective AI Agents. Untuk contoh implementasi lebih lanjut, kunjungi Anthropic Cookbook di GitHub.