Tutorial Membangun AI Agent Efektif dengan Workflow Pattern dari Anthropic
ND
Naufal Dev

Dipublikasikan 15 Agustus 2026

Tutorial Membangun AI Agent Efektif dengan Workflow Pattern dari Anthropic

python
python
tutorial
ai
ai-agent

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. Memahami kapan menggunakan workflows versus agents akan menghemat waktu development dan mengurangi kompleksitas maintenance secara signifikan.

Langkah 1: Setup Environment dan API Key

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

Buat file .env untuk menyimpan kredensial dengan format berikut:

ANTHROPIC_API_KEY=sk-ant-api03-xxx\nMODEL=claude-3-7-sonnet-20250219

Verifikasi koneksi API dengan script sederhana menggunakan Python dan library requests. Install dependency terlebih dahulu dengan pip install requests python-dotenv, lalu buat file test_api.py:

import requests, os\nfrom dotenv import load_dotenv\n\nload_dotenv()\n\nheaders = {\n    \"x-api-key\": os.getenv(\"ANTHROPIC_API_KEY\"),\n    \"content-type\": \"application/json\",\n    \"anthropic-version\": \"2023-06-01\"\n}\n\nresponse = requests.post(\n    \"https://api.anthropic.com/v1/messages\",\n    headers=headers,\n    json={\n        \"model\": os.getenv(\"MODEL\"),\n        \"max_tokens\": 1024,\n        \"messages\": [{\"role\": \"user\", \"content\": \"Halo, test koneksi\"}]\n    }\n)\nprint(response.json()[\"content\"][0][\"text\"])

Jika script berjalan dengan sukses dan mengembalikan respons dari Claude, environment kamu sudah siap untuk membangun workflows yang lebih kompleks.

Langkah 2: Implementasi 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 yang berurutan.

Berikut contoh implementasi prompt chaining untuk membuat artikel blog dengan Python:

def call_llm(prompt: str) -> str:\n    response = requests.post(\n        \"https://api.anthropic.com/v1/messages\",\n        headers=headers,\n        json={\n            \"model\": os.getenv(\"MODEL\"),\n            \"max_tokens\": 2048,\n            \"messages\": [{\"role\": \"user\", \"content\": prompt}]\n        }\n    )\n    return response.json()[\"content\"][0][\"text\"]\n\ndef generate_blog(topic: str) -> str:\n    outline = call_llm(f\"Buat outline untuk artikel teknis tentang {topic}\")\n    validation = call_llm(f\"Verifikasi outline ini cukup komprehensif: {outline}\")\n    if \"tidak\" in validation.lower():\n        return \"Outline perlu revisi\"\n    content = call_llm(f\"Tulis artikel 800 kata berdasarkan outline: {outline}\")\n    final = call_llm(f\"Edit artikel ini untuk clarity dan grammar: {content}\")\n    return final\n\nresult = generate_blog(\"Kubernetes untuk pemula\")\nprint(result)

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. Untuk use case di mana akurasi lebih penting daripada kecepatan, prompt chaining adalah pilihan yang solid.

Langkah 3: Membangun 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 untuk setiap kategori input. Routing bekerja dengan baik untuk sistem yang menangani berbagai jenis query yang memerlukan pendekatan berbeda.

Contoh implementasi routing untuk customer service automation:

def route_query(user_input: str) -> str:\n    category = call_llm(f\"Klasifikasikan pertanyaan ini ke salah satu kategori: refund, teknis, umum. Pertanyaan: {user_input}\")\n    \n    if \"refund\" in category.lower():\n        return call_llm(f\"Proses permintaan refund berikut: {user_input}\")\n    elif \"teknis\" in category.lower():\n        return call_llm(f\"Beri solusi teknis untuk masalah ini: {user_input}\")\n    else:\n        return call_llm(f\"Jawab pertanyaan umum berikut: {user_input}\")\n\nresponse = route_query(\"Aplikasi saya error setelah update terbaru\")\nprint(response)

Tanpa routing, optimasi untuk satu jenis input bisa merusak performa untuk input lainnya. Routing memungkinkan kamu menyempurnakan prompt untuk setiap kategori secara independen tanpa efek samping pada kategori lain.

Langkah 4: Parallelization untuk Review Kode

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 dengan Python concurrent.futures:

import concurrent.futures\n\ndef review_security(code: str) -> str:\n    return call_llm(f\"Review security vulnerability pada kode ini: {code}\")\n\ndef review_performance(code: str) -> str:\n    return call_llm(f\"Review performance issue pada kode ini: {code}\")\n\ndef review_readability(code: str) -> str:\n    return call_llm(f\"Review readability dan maintainability: {code}\")\n\ncode_snippet = \"function fetchData() { return fetch('/api/data').then(r => r.json()) }\"\n\nwith concurrent.futures.ThreadPoolExecutor() as executor:\n    futures = [\n        executor.submit(review_security, code_snippet),\n        executor.submit(review_performance, code_snippet),\n        executor.submit(review_readability, code_snippet)\n    ]\n    results = [f.result() for f in futures]\n\nfinal_review = call_llm(f\"Gabungkan review berikut menjadi satu laporan: {results}\")\nprint(final_review)

Parallelization mengurangi total latency dengan menjalankan review independen secara simultan. Agregasi hasil di akhir memastikan kamu mendapatkan pandangan holistik tanpa harus menunggu setiap review berjalan secara serial.

Langkah 5: Evaluasi dan Monitoring Agent

Setelah membangun workflows, 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 yang bisa kamu terapkan:

  • Unit test: Tulis unit test untuk setiap fungsi tool call secara independen. Pastikan setiap tool mengembalikan format yang konsisten dan menangani edge cases dengan benar.

  • Integration test: Uji end-to-end workflows dengan 20-50 contoh input representatif. Catat success rate dan identifikasi pola kegagalan.

  • Cost benchmark: Hitung rata-rata token consumption per workflow run. Bandingkan antara prompt chaining, routing, dan parallelization untuk menemukan tradeoff terbaik antara akurasi dan biaya.

  • Human review: Untuk output yang kritis, selalu sisakan mekanisme human-in-the-loop. AI agent hebat adalah yang bisa meminta persetujuan manusia ketika confidence score-nya rendah.

Monitoring di production juga penting. Log setiap LLM call beserta input, output, dan latency-nya. Dashboard ini akan membantu kamu mengidentifikasi degradasi performa ketika model provider merilis update atau ketika traffic meningkat secara tiba-tiba.

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 spesifikmu 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. Repository tersebut berisi puluhan contoh kode untuk berbagai pola workflows dan agents yang bisa kamu adaptasi ke projectmu.