Build AI Agent dengan LangGraph: Tutorial Lengkap 2026
Lo lagi cari cara bikin AI agent yang beneran powerful, bukan cuma chatbot biasa? LangGraph jawabannya. Framework ini lagi booming di kalangan developer yang pengen bikin AI agent dengan workflow kompleks—dari yang cuma 2 langkah sampe yang ribet kayak sistem customer service otomatis.
Gue sendiri udah pake LangGraph beberapa bulan terakhir buat bikin agent yang bisa riset, nulis, sampe review kode. Dan jujur, ini game changer banget dibanding LangChain biasa.
Di artikel ini, gue bakal ngajarin lo dari nol: apa itu LangGraph, gimana cara kerjanya, sampe lo bisa bikin AI agent pertama lo sendiri. Gas!
Apa Sih LangGraph Itu?
LangGraph itu library Python yang dibangun di atas LangChain. Bedanya sama LangChain biasa? LangGraph pake konsep graph (grafik) buat ngedefine workflow agent lo.
Bayangin kayak flowchart. Lo punya:
- Node: Titik-titik yang ngejalanin tugas tertentu (misal: manggil LLM, search web, bikin keputusan)
- Edge: Koneksi antar node yang nentuin alur eksekusi
- State: Data yang di-pass antar node selama proses berjalan
Kenapa pake graph? Karena workflow agent itu jarang linear. Kadang lo perlu looping, branching, bahkan balik ke step sebelumnya. LangGraph handle semua itu dengan elegant.
[Start] → [Think] → [Decide] → [Action] → [Observe] → [Think]
↓
[End / Response]
Kalo lo familiar sama Python Automation, konsep workflow-nya mirip. Tapi kali ini, decision-making-nya diserahin ke LLM.
Kenapa Harus Pakai LangGraph?
Ada beberapa alasan kenapa LangGraph jadi pilihan utama gue:
1. Support Looping & Conditional Logic
Agent AI yang bener tuh harus bisa mikir ulang. Kalo hasilnya kurang bagus, dia harus bisa balik lagi dan coba approach lain. LangGraph bikin ini gampang banget pake conditional edges.
2. State Management yang Robust
Lo bisa define state schema yang jelas. Semua data yang di-pass antar node terstruktur dan bisa diakses kapan aja. Nggak ada lagi “data ilang” pas di tengah proses.
3. Human-in-the-Loop
Ini fitur killer. Lo bisa set breakpoint di mana agent bakal nunggu input dari manusia sebelum lanjut. Cocok buat workflow yang butuh approval atau review.
4. Visualization
LangGraph bisa nge-generate diagram dari workflow lo. Ini helpful banget buat debugging dan dokumentasi.
5. Integrasi Seamless sama LangChain
Kalo lo udah pake LangChain sebelumnya, transisi ke LangGraph gampang. Tools, LLMs, dan retrievers yang udah lo bikin tetep bisa dipake.
Instalasi dan Setup
Sebelum mulai, pastiin lo udah punya Python 3.9+ dan pip. Kalo lo prefer pake Docker, cek juga tutorial Cara Pakai Docker Compose biar setup-nya lebih rapi.
# Install dependencies
pip install langgraph langchain langchain-openai python-dotenv
# Atau kalo mau yang lebih lengkap
pip install langgraph langchain langchain-openai langchain-community tavily-python
Bikin file .env buat nyimpen API keys:
OPENAI_API_KEY=sk-xxxxxxxxxxxx
TAVILY_API_KEY=tvly-xxxxxxxxxxxx
Folder structure minimal:
project/
├── .env
├── main.py
├── agent/
│ ├── __init__.py
│ ├── graph.py
│ ├── nodes.py
│ └── state.py
└── tools/
├── __init__.py
└── search.py
Cara Kerja LangGraph: State, Node, Edge
Sebelum gue kasih contoh kode, lo harus paham 3 konsep dasar LangGraph.
State
State itu “container” buat data yang di-pass sepanjang workflow. Lo define pake Pydantic model atau TypedDict.
from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages
class AgentState(TypedDict):
messages: Annotated[list, add_messages]
current_task: str
iteration: int
final_output: str
Annotated[list, add_messages] itu artinya setiap kali node nambahin message, dia bakal di-append, bukan replace.
Node
Node itu function yang nerima state dan return updated state. Setiap node bisa:
- Manggil LLM
- Eksekusi tool/fungsi
- Transform data
- Apapun yang lo mau
def thinking_node(state: AgentState) -> AgentState:
"""Node buat mikir—panggil LLM buat analyze situasi"""
response = llm.invoke(state["messages"])
return {
"messages": [response],
"iteration": state["iteration"] + 1
}
Edge
Edge nentuin alur dari satu node ke node lain. Ada 3 jenis:
- Simple Edge: A → B (langsung)
- Conditional Edge: A → B atau A → C (tergantung kondisi)
- Entry/Finish Point: Start dan End dari graph
def should_continue(state: AgentState) -> str:
"""Decision function buat conditional edge"""
last_message = state["messages"][-1]
if "FINAL_ANSWER" in last_message.content:
return "end"
elif state["iteration"] >= 5:
return "end"
else:
return "continue"
Contoh Build AI Agent dengan LangGraph
Oke, sekarang saatnya praktik. Kita bakal bikin AI agent yang bisa:
- Nerima pertanyaan dari user
- Mikir dan riset (pake search tool kalo perlu)
- Kasih jawaban final
Step 1: Define State
# agent/state.py
from typing import TypedDict, Annotated, List
from langgraph.graph.message import add_messages
from langchain_core.messages import BaseMessage
class AgentState(TypedDict):
messages: Annotated[List[BaseMessage], add_messages]
tool_results: List[str]
iteration: int
Step 2: Setup Tools & LLM
# tools/search.py
from langchain_community.tools.tavily_search import TavilySearchResults
search_tool = TavilySearchResults(max_results=3)
# agent/graph.py
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="gpt-4o-mini",
temperature=0
)
# Bind tools ke LLM
tools = [search_tool]
llm_with_tools = llm.bind_tools(tools)
Step 3: Build Nodes
# agent/nodes.py
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
from .state import AgentState
from tools.search import search_tool
import json
SYSTEM_PROMPT = """Lo adalah AI assistant yang helpful.
Kalo butuh info terbaru, pake search tool.
Kalo udah punya jawaban yang cukup, langsung kasih jawaban.
Selalu akhiri dengan "FINAL_ANSWER" kalo udah selesai mikir."""
def agent_think(state: AgentState) -> AgentState:
"""Node utama: agent mikir dan decide langkah selanjutnya"""
messages = [
SystemMessage(content=SYSTEM_PROMPT),
*state["messages"]
]
response = llm_with_tools.invoke(messages)
return {
"messages": [response],
"iteration": state.get("iteration", 0) + 1
}
def execute_tools(state: AgentState) -> AgentState:
"""Node buat ngejalanin tools yang diminta LLM"""
last_message = state["messages"][-1]
tool_results = []
if hasattr(last_message, "tool_calls"):
for tool_call in last_message.tool_calls:
if tool_call["name"] == "tavily_search_results_json":
result = search_tool.invoke(tool_call["args"])
tool_results.append(json.dumps(result))
# Tambahin tool result ke messages
from langchain_core.messages import ToolMessage
tool_msg = ToolMessage(
content=json.dumps(result),
tool_call_id=tool_call["id"]
)
return {
"messages": [tool_msg],
"tool_results": state.get("tool_results", []) + tool_results,
"iteration": state.get("iteration", 0)
}
return state
def format_response(state: AgentState) -> AgentState:
"""Node buat format jawaban final"""
# Cari message terakhir dari AI yang bukan tool call
for msg in reversed(state["messages"]):
if isinstance(msg, AIMessage) and not msg.tool_calls:
cleaned = msg.content.replace("FINAL_ANSWER", "").strip()
return {
"messages": [AIMessage(content=cleaned)],
"final_output": cleaned,
"iteration": state.get("iteration", 0)
}
return state
Step 4: Build the Graph
# agent/graph.py
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from .state import AgentState
from .nodes import agent_think, execute_tools, format_response
from tools.search import tools
def should_use_tools(state: AgentState) -> str:
"""Decision: apakah perlu jalanin tools?"""
last_message = state["messages"][-1]
# Kalo LLM minta tool, jalanin tools
if hasattr(last_message, "tool_calls") and last_message.tool_calls:
return "tools"
# Kalo udah ada FINAL_ANSWER atau iterasi >= 5, selesai
if "FINAL_ANSWER" in last_message.content:
return "format"
if state.get("iteration", 0) >= 5:
return "format"
# Kalo nggak, balik lagi ke think
return "think"
def build_agent_graph():
"""Build dan return compiled graph"""
# Init graph
workflow = StateGraph(AgentState)
# Tambahin nodes
workflow.add_node("think", agent_think)
workflow.add_node("tools", ToolNode(tools))
workflow.add_node("format", format_response)
# Entry point
workflow.set_entry_point("think")
# Conditional edges dari think
workflow.add_conditional_edges(
"think",
should_use_tools,
{
"tools": "tools",
"format": "format",
"think": "think" # Loop back
}
)
# Setelah tools, balik ke think
workflow.add_edge("tools", "think")
# Setelah format, END
workflow.add_edge("format", END)
# Compile
return workflow.compile()
Step 5: Run the Agent
# main.py
from agent.graph import build_agent_graph
from langchain_core.messages import HumanMessage
from dotenv import load_dotenv
load_dotenv()
def main():
# Build agent
agent = build_agent_graph()
# Visualize (optional, buat debugging)
# print(agent.get_graph().draw_mermaid())
# Run
print("🤖 AI Agent siap! Ketik 'quit' buat keluar.\n")
while True:
user_input = input("Lo: ")
if user_input.lower() in ["quit", "exit", "q"]:
print("Bye! 👋")
break
# Invoke agent
result = agent.invoke({
"messages": [HumanMessage(content=user_input)],
"tool_results": [],
"iteration": 0
})
# Print jawaban
final_msg = result["messages"][-1]
print(f"\nAgent: {final_msg.content}")
print(f"(Iterasi: {result.get('iteration', 'N/A')})\n")
if __name__ == "__main__":
main()
Jalankan:
python main.py
Bonus: Tambahin Human-in-the-Loop
Fitur ini penting kalo lo bikin agent yang ngambil keputusan kritis (misal: kirim email, hapus data, transfer duit).
from langgraph.checkpoint.memory import MemorySaver
def build_agent_with_human_loop():
workflow = StateGraph(AgentState)
# ... (nodes sama kayak di atas)
workflow.add_node("human_review", human_review_node)
# Sebelum execute action penting, minta approval
workflow.add_conditional_edges(
"think",
should_need_approval,
{
"needs_approval": "human_review",
"safe_to_execute": "tools",
"format": "format"
}
)
workflow.add_edge("human_review", "tools")
# Compile dengan checkpointer
checkpointer = MemorySaver()
return workflow.compile(
checkpointer=checkpointer,
interrupt_before=["human_review"] # Pause di sini
)
def human_review_node(state: AgentState) -> AgentState:
"""Node yang nunggu approval dari manusia"""
last_msg = state["messages"][-1]
print(f"\n⚠️ Agent mau eksekusi: {last_msg.content}")
approval = input("Approve? (y/n): ")
if approval.lower() != 'y':
return {
"messages": [HumanMessage(content="Dibatalkan oleh user.")],
"iteration": state.get("iteration", 0)
}
return state
Kalo lo lagi bandingin tool coding AI, cek juga perbandingan Claude Code vs Codex dan Cursor vs Copilot di blog gue.
Tips Production-Ready
Pakai Checkpointer buat Persistence
from langgraph.checkpoint.sqlite import SqliteSaver
# Simpan state ke SQLite
checkpointer = SqliteSaver.from_conn_string(":memory:")
agent = workflow.compile(checkpointer=checkpointer)
# Setiap invoke butuh thread_id
config = {"configurable": {"thread_id": "user-123"}}
result = agent.invoke(input_data, config=config)
Tambahin Error Handling
def safe_node_wrapper(node_func):
def wrapper(state: AgentState) -> AgentState:
try:
return node_func(state)
except Exception as e:
return {
"messages": [AIMessage(
content=f"Waduh, error nih: {str(e)}. Coba lagi deh."
)],
"iteration": state.get("iteration", 0) + 1
}
return wrapper
Logging buat Debugging
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("agent")
def logged_node(name):
def decorator(func):
def wrapper(state):
logger.info(f"[{name}] Starting... (iterasi {state.get('iteration', 0)})")
result = func(state)
logger.info(f"[{name}] Done.")
return result
return wrapper
return decorator
FAQ Seputar LangGraph
Apa bedanya LangGraph sama LangChain biasa?
LangChain itu toolkit buat bikin aplikasi LLM—dari prompt management, retrieval, sampe chains. LangGraph itu spesifik buat bikin stateful agent yang punya workflow kompleks dengan loop, branching, dan conditional logic. Think of it: LangChain = lego bricks, LangGraph = blueprint buat nyusun jadi robot.
LangGraph bisa dipake sama LLM selain OpenAI?
Bisa banget! LangGraph support semua LLM yang ada di LangChain ecosystem: Anthropic Claude, Google Gemini, Mistral, bahkan model lokal pake Ollama. Ganti aja ChatOpenAI jadi ChatAnthropic atau yang lain.
Berapa biaya bikin AI agent pake LangGraph?
Library-nya sendiri gratis dan open-source. Biaya tergantung LLM API yang lo pake. GPT-4o-mini itu murah (~$0.15 per 1M input tokens), tapi kalo lo pake GPT-4o atau Claude Opus, cost-nya bisa naik signifikan. Buat development, mulai aja dulu pake model yang murah.
Bisa deploy LangGraph agent ke production?
Bisa. LangGraph Cloud (sekarang namanya LangGraph Platform) nawarin managed deployment. Tapi lo juga bisa deploy sendiri pake Docker + FastAPI. Yang penting: pake checkpointer buat persistence, tambahin rate limiting, dan handle errors dengan bener.
Agent gue sering loop terus, gimana fix-nya?
Ini masalah umum. Solusinya: (1) Tambahin max iteration limit di state, (2) Kasih instruksi yang lebih jelas di system prompt kapan harus stop, (3) Pakai should_continue logic yang lebih strict, dan (4) Tambahin timeout di level graph execution.
Mulai Build Agent Lo Sekarang!
LangGraph itu powerful, tapi tetep butuh practice. Mulai dari yang simple—misal agent yang bisa search dan summarize—baru naikin complexity pelan-pelan.
Kalo lo butuh bantuan setup, mau diskusi soal architecture, atau bahkan pengen gue bikinin custom AI agent buat use case spesifik lo, langsung aja email gue:
Gue bales semua email, serius. Mau nanya teknis, minta review kode, atau ngobrol soal project, feel free buat reach out. Let’s build something cool together! 🚀