Cara Membuat Multi-Agent System dengan LangGraph: Panduan Step-by-Step (2026)

Banyak developer pertama kali mencoba multi-agent lewat framework berbasis peran: bikin “agen riset”, “agen penulis”, lalu biarkan mereka mengobrol. Hasilnya cepat jadi, tapi susah dikendalikan begitu alurnya harus pasti, misalnya pesanan wajib dicek stoknya dulu sebelum dicatat. LangGraph mengambil arah sebaliknya: kamu menggambar alurnya sendiri sebagai graph, lalu menentukan di titik mana AI boleh mengambil keputusan.

Apa Itu LangGraph?

LangGraph adalah framework orkestrasi tingkat rendah untuk membangun agen yang berjalan lama dan menyimpan state. Dokumentasi resmi LangGraph menyebut kemampuan intinya: eksekusi yang tahan gangguan (durable execution), streaming, human-in-the-loop, dan persistence. Per November 2026, versi terbaru di PyPI adalah langgraph 1.2.19 dengan lisensi MIT.

Tiga istilah yang akan sering muncul:

• State: data bersama yang dibawa sepanjang alur, misalnya isi pesan pelanggan dan jawaban sementara.
• Node: satu langkah kerja. Bisa berupa fungsi Python biasa atau pemanggilan agen AI.
• Edge: jalur dari satu node ke node berikutnya. Conditional edge memilih jalur berdasarkan isi state.

LangGraph tidak wajib dipakai bersama LangChain, tapi dokumentasi resminya memakai komponen LangChain untuk model dan tool. Tutorial di halaman ini mengikuti pola yang sama.

Kapan Perlu Multi-Agent, dan Kapan Tidak

Panduan multi-agent LangChain justru membuka dengan peringatan: tidak semua tugas kompleks butuh banyak agen, karena satu agen dengan tool dan prompt yang tepat sering memberi hasil serupa. Multi-agent baru masuk akal kalau kamu butuh salah satu dari ini:

• Context window terlalu penuh. Satu agen yang memegang puluhan tool mulai salah pilih tool.
• Tim berbeda memegang bagian berbeda. Agen stok dirawat tim gudang, agen CS dirawat tim layanan.
• Langkah bisa jalan paralel. Beberapa pengecekan dikerjakan bersamaan supaya respons lebih cepat.

Kalau kebutuhanmu belum sampai ke situ, mulai dari satu agen dulu. Penjelasan pola arsitektur yang lebih umum ada di panduan apa itu multi-agent system dan pola arsitekturnya.

Empat Pola Multi-Agent di Ekosistem LangGraph

Dokumentasi LangChain membagi pola multi-agent menjadi beberapa jenis, plus opsi custom workflow yang dibangun langsung dengan LangGraph. Mereka juga membandingkan jumlah panggilan model di tiga skenario uji:

Angka di tabel berasal dari skenario uji LangChain sendiri, bukan pengukuran kami. Pola subagents paling boros panggilan di permintaan sederhana, tapi paling mudah dipecah antartim dan paling kuat untuk eksekusi paralel. Tutorial di bawah memakai pola subagents, lalu menambahkan router deterministik dengan LangGraph.

Persiapan: Instalasi LangGraph

Siapkan Python 3.10 atau lebih baru, lalu instal paketnya sesuai halaman instalasi resmi:

pip install -U langgraph langchain "langchain[anthropic]"
export ANTHROPIC_API_KEY="isi-api-key-kamu"

Contoh di halaman ini memakai model Claude seperti quickstart resmi. Kamu bisa menggantinya dengan provider lain yang didukung LangChain, misalnya OpenAI, dengan mengganti nama model dan paket integrasinya. Kalau belum punya API key, langkahnya ada di panduan membuat Claude API key.

Tutorial: Bikin Multi-Agent Stok dan Order untuk Toko Online

Studi kasusnya sederhana tapi dekat dengan bisnis kecil di Indonesia: pelanggan bertanya stok atau memesan lewat chat. Satu agen khusus mengurus stok, satu agen khusus mencatat pesanan, dan satu supervisor membagi tugas. Kode di bawah diadaptasi dari tutorial supervisor resmi LangChain; datanya masih contoh statis supaya mudah dicoba.

Langkah 1: Definisikan model dan tool

from langchain.tools import tool
from langchain.chat_models import init_chat_model

model = init_chat_model("claude-sonnet-4-6", temperature=0)

STOK = {"kopi susu": 12, "matcha latte": 0}

@tool
def cek_stok(nama_produk: str) -> str:
    """Cek sisa stok satu produk di gudang."""
    jumlah = STOK.get(nama_produk.lower())
    if jumlah is None:
        return f"Produk {nama_produk} tidak terdaftar."
    return f"Stok {nama_produk}: {jumlah} pcs"

@tool
def catat_pesanan(nama_produk: str, jumlah: int, nama_pelanggan: str) -> str:
    """Catat pesanan baru ke sistem order."""
    return f"Pesanan {jumlah} {nama_produk} atas nama {nama_pelanggan} tercatat."

Docstring tiap tool penting karena model membacanya untuk memutuskan kapan tool dipakai. Di sistem nyata, isi fungsi diganti dengan panggilan ke database atau spreadsheet stokmu.

Langkah 2: Buat agen spesialis

from langchain.agents import create_agent

agen_stok = create_agent(
    model,
    tools=[cek_stok],
    system_prompt="Kamu petugas gudang. Jawab pertanyaan stok hanya dari hasil tool cek_stok.",
)

agen_order = create_agent(
    model,
    tools=[catat_pesanan, cek_stok],
    system_prompt=(
        "Kamu petugas order. Selalu cek stok dulu. "
        "Kalau stok 0 atau kurang, jangan catat pesanan dan jelaskan alasannya."
    ),
)

Tiap agen hanya memegang tool yang relevan. Inilah manfaat utama multi-agent: pilihan tool per agen jadi sempit, jadi peluang salah pilih ikut turun.

Langkah 3: Bungkus agen spesialis jadi tool

@tool
def urus_stok(permintaan: str) -> str:
    """Tanyakan ketersediaan stok produk dengan bahasa biasa."""
    hasil = agen_stok.invoke({"messages": [{"role": "user", "content": permintaan}]})
    return hasil["messages"][-1].text

@tool
def urus_pesanan(permintaan: str) -> str:
    """Proses pesanan pelanggan: nama produk, jumlah, dan nama pemesan."""
    hasil = agen_order.invoke({"messages": [{"role": "user", "content": permintaan}]})
    return hasil["messages"][-1].text

Supervisor hanya melihat dua tool tingkat tinggi ini, bukan tool teknis di dalamnya. Yang dikembalikan ke supervisor cuma jawaban akhir agen spesialis, bukan seluruh proses berpikirnya, sehingga context supervisor tetap ramping.

Langkah 4: Buat supervisor dan jalankan

supervisor = create_agent(
    model,
    tools=[urus_stok, urus_pesanan],
    system_prompt=(
        "Kamu admin toko online. Pecah permintaan pelanggan jadi tugas stok "
        "atau pesanan, panggil tool yang sesuai, lalu rangkum jawabannya."
    ),
)

hasil = supervisor.invoke({
    "messages": [{"role": "user", "content": "Kopi susu masih ada? Kalau ada pesan 3 atas nama Rina."}]
})
print(hasil["messages"][-1].text)

Untuk permintaan seperti contoh di atas, supervisor idealnya memanggil urus_stok lalu urus_pesanan, kemudian merangkum hasilnya dalam satu balasan. Urutan pastinya tetap diputuskan model, jadi uji beberapa variasi kalimat sebelum dipakai ke pelanggan sungguhan.

Tambah Alur Pasti dengan StateGraph

Pola supervisor menyerahkan pembagian tugas ke model. Kalau kamu ingin sebagian alur dijamin pasti, misalnya setiap pesan yang mengandung kata “pesan” atau “beli” selalu masuk jalur order, gunakan StateGraph dari Graph API LangGraph. Di sinilah LangGraph berbeda dari framework berbasis peran.

from typing import Literal
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END

class State(TypedDict):
    pesan: str
    jenis: str
    jawaban: str

def klasifikasi(state: State):
    teks = state["pesan"].lower()
    jenis = "order" if ("pesan" in teks or "beli" in teks) else "stok"
    return {"jenis": jenis}

def node_stok(state: State):
    hasil = agen_stok.invoke({"messages": [{"role": "user", "content": state["pesan"]}]})
    return {"jawaban": hasil["messages"][-1].text}

def node_order(state: State):
    hasil = agen_order.invoke({"messages": [{"role": "user", "content": state["pesan"]}]})
    return {"jawaban": hasil["messages"][-1].text}

def pilih_rute(state: State) -> Literal["node_stok", "node_order"]:
    return "node_order" if state["jenis"] == "order" else "node_stok"

builder = StateGraph(State)
builder.add_node("klasifikasi", klasifikasi)
builder.add_node("node_stok", node_stok)
builder.add_node("node_order", node_order)
builder.add_edge(START, "klasifikasi")
builder.add_conditional_edges("klasifikasi", pilih_rute, ["node_stok", "node_order"])
builder.add_edge("node_stok", END)
builder.add_edge("node_order", END)
graph = builder.compile()

print(graph.invoke({"pesan": "Mau beli 2 matcha latte atas nama Doni"})["jawaban"])

Node klasifikasi adalah kode Python biasa tanpa AI, jadi hasilnya selalu sama untuk input yang sama dan mudah diaudit. AI baru bekerja di node agen. Aturan kata kunci di contoh ini sengaja dibuat sederhana; di produksi kamu bisa menggantinya dengan pengklasifikasi yang lebih ketat.

Menyimpan Memori Percakapan dengan Checkpointer

Secara default, graph tidak mengingat percakapan sebelumnya. Lapisan persistence LangGraph menyimpan state di setiap langkah lewat checkpointer, sehingga agen punya memori jangka pendek per thread percakapan.

from langgraph.checkpoint.memory import InMemorySaver

graph = builder.compile(checkpointer=InMemorySaver())
config = {"configurable": {"thread_id": "pelanggan-rina"}}
graph.invoke({"pesan": "Kopi susu masih ada?"}, config)

InMemorySaver hilang saat program berhenti, jadi cocok untuk uji coba saja. Untuk produksi, LangGraph menyediakan checkpointer berbasis database seperti SQLite dan Postgres. Checkpointer juga menjadi dasar fitur human-in-the-loop, misalnya pesanan di atas nominal tertentu harus disetujui admin dulu.

LangGraph vs CrewAI vs OpenClaw: Pilih yang Mana?

Kalau kamu ingin mencoba versi berbasis peran, ikuti tutorial multi-agent dengan CrewAI. Perbandingan yang lebih lebar, termasuk AutoGen dan Claude, ada di daftar framework multi-agent AI terbaik 2026.

Komunitech mengajarkan pembuatan AI Agent berbasis OpenClaw untuk pebisnis yang tidak mau ngoding, sementara LangGraph lebih pas untuk tim IT yang membangun sistem sendiri dari kode. Kalau tujuanmu menjalankan tim agen untuk operasional bisnis tanpa menulis Python, lihat cara bikin tim sub-agent OpenClaw untuk otomatisasi bisnis.

Kesalahan Umum dan Catatan Keamanan

• Memakai tutorial lama tanpa cek ulang. README resmi langgraph-supervisor kini menyarankan pola supervisor via tool dibanding library itu untuk sebagian besar kasus. Banyak tutorial di internet masih memakai create_supervisor dan create_react_agent.
• Langsung multi-agent padahal satu agen cukup. Setiap agen tambahan berarti panggilan model tambahan, latensi tambahan, dan biaya token tambahan.
• Deskripsi tool terlalu umum. Docstring seperti “fungsi untuk data” membuat supervisor salah memilih agen.
• Tidak memperbarui paket checkpoint. Basis data NVD mencatat beberapa CVE pada ekosistem LangGraph, antara lain CVE-2026-27794 (remote code execution di lapisan cache, diperbaiki di langgraph-checkpoint 4.0.0) dan CVE-2026-48776 (kritis, langgraph-sdk versi 0.3.14 ke bawah). Per November 2026, versi terbaru di PyPI adalah langgraph-checkpoint 4.3.1 dan langgraph-sdk 0.4.11.

Satu batasan jujur: kode di halaman Komunitech yang sedang kamu baca diadaptasi dari dokumentasi resmi dan ditulis ulang dengan contoh lokal, tapi belum kami jalankan di lingkungan produksi. Uji di environment terpisah dulu, terutama bagian yang menulis data.

Pertanyaan yang Sering Ditanya

Apakah LangGraph gratis?

Library LangGraph open-source dengan lisensi MIT dan gratis dipakai. Yang berbayar adalah pemakaian model AI lewat API, serta layanan tambahan seperti LangSmith kalau kamu memakainya untuk tracing atau deployment.

Apa beda LangGraph dan LangChain?

LangChain menyediakan komponen siap pakai seperti integrasi model, tool, dan fungsi create_agent. LangGraph adalah runtime orkestrasi tingkat rendah di bawahnya untuk mengatur alur, state, dan persistence. Agen yang dibuat dengan create_agent di LangChain berjalan di atas LangGraph.

Apakah LangGraph bisa dipakai dengan model selain Claude?

Bisa. LangGraph mendukung berbagai provider lewat integrasi LangChain, termasuk OpenAI, Google, dan Azure. Kamu cukup mengganti paket integrasi dan nama model di init_chat_model.

Apakah LangGraph tersedia untuk JavaScript?

Ya, LangGraph punya versi JavaScript/TypeScript dengan konsep yang sama. Tutorial di halaman ini memakai versi Python.

Perlu berapa agen untuk mulai?

Mulai dari dua agen spesialis dan satu supervisor seperti contoh di atas. Tambah agen baru hanya kalau satu agen sudah memegang terlalu banyak tool atau ada tim lain yang perlu merawat bagiannya sendiri.

Kesimpulan

LangGraph cocok untuk multi-agent system yang alurnya perlu dikendalikan dan diaudit: pola supervisor via tool calling untuk pembagian tugas, lalu StateGraph untuk bagian yang wajib pasti. Kekuatan itu datang dengan harga: kamu harus menulis kode Python dan merawat versi paketnya.

Langkah praktisnya: jalankan contoh toko online di atas dengan data dummy, ganti fungsi stok dengan data aslimu, lalu tambahkan checkpointer sebelum dipakai ke pelanggan sungguhan.

Referensi

• LangChain. LangGraph overview. Diakses 2 November 2026.
• LangChain. Build a personal assistant with subagents. Diakses 2 November 2026.
• LangChain. Multi-agent. Diakses 2 November 2026.
• LangChain. Persistence. Diakses 2 November 2026.
• LangChain. langgraph-supervisor-py README. Diakses 2 November 2026.
• PyPI. langgraph. Diakses 2 November 2026.
• NIST. National Vulnerability Database: langgraph. Diakses 2 November 2026.

Disclaimer

Contoh kode disediakan untuk tujuan edukasi dan diadaptasi dari dokumentasi resmi LangChain per November 2026. API dan versi paket bisa berubah; selalu cek dokumentasi terbaru sebelum dipakai di produksi. Komunitech tidak berafiliasi dengan LangChain.