LangGraph Essentials

> LangGraph adalah framework untuk membangun aplikasi AI sebagai graph yang eksplisit dan stateful, bukan sekadar prompt chain linear. Notebook ini membahas masalah apa yang diselesaikannya, building block utamanya, dan contoh singkat merangkai agent yang bisa looping, branching, dan pause.

Apa itu LangGraph?

LangGraph adalah library orchestration low-level (dibuat oleh tim LangChain) untuk membangun aplikasi di mana control flow LLM butuh lebih dari sekadar "prompt masuk, jawaban keluar." Alih-alih merangkai step secara linear, aplikasi dimodelkan sebagai graph: node adalah unit kerja, edge menentukan bagaimana kontrol berpindah antar node, dan sebuah state bersama mengalir di sepanjang proses eksekusi.

Ini penting karena agent di dunia nyata jarang berjalan lurus dari awal sampai akhir. Mereka memanggil tool, melihat hasilnya, memutuskan apakah perlu coba lagi, meminta approval dari manusia, atau hand off ke specialist lain. Control flow semacam ini pada dasarnya bersifat cyclic — sesuatu yang tidak bisa direpresentasikan oleh chain sederhana, tapi bisa oleh graph.

Karakteristik utama:

Stateful by design — sebuah typed state object mengalir melalui setiap node

Cyclic graph — agent bisa loop kembali (retry, re-plan) alih-alih terbatas pada satu forward pass

Persistence bawaan — checkpointer bisa menyimpan state sehingga sebuah run bisa di-pause dan dilanjutkan kembali nanti

Human-in-the-loop — graph bisa pause sebelum sebuah node dan menunggu approval

Streaming — intermediate step dan token bisa di-stream saat graph berjalan

Kenapa Tidak Pakai Chain Biasa Saja?

Chain (prompt → LLM → parse → selesai) sudah cukup untuk task single-shot. Tapi mulai kurang memadai begitu dibutuhkan:

Conditional branching — "kalau model memanggil tool, jalankan; kalau tidak, selesai"

Loop — "coba lagi tool call, sampai 3 kali, sampai berhasil"

Shared state yang terus berubah — beberapa step membaca dan menulis context yang sama (message history, hasil retrieval, catatan sementara)

Resumability — workflow yang berlangsung berjam-jam, atau butuh manusia klik "approve" sebelum lanjut

LangGraph dibuat khusus untuk kelas masalah ini — layer di atas "sekadar panggil LLM API," dipakai begitu control flow aplikasi berubah dari garis lurus menjadi graph.

Konsep Inti

State — schema bertipe (misalnya TypedDict atau Pydantic model) yang merepresentasikan semua yang dibawa graph antar step: riwayat percakapan, hasil tool, counter, flag.

Node — fungsi biasa yang menerima state saat ini dan mengembalikan partial update ke state tersebut. Sebuah node bisa memanggil LLM, memanggil tool, atau menjalankan logic deterministik.

Edge — koneksi antar node. Normal edge selalu mengarah dari A ke B. Conditional edge menjalankan fungsi routing terhadap state untuk menentukan node berikutnya.

Checkpointer — backend persistence (in-memory, SQLite, Postgres, dll) yang menyimpan snapshot state setelah setiap step, memungkinkan pause/resume dan memory multi-turn lintas sesi.

Use Case Umum

Tool-using agent yang perlu retry, re-plan, atau chaining beberapa tool call sebelum menjawab

Approval workflow — misalnya draft email, pause untuk approval manusia, baru kirim

Long-running assistant yang harus melanjutkan percakapan atau task lintas sesi

Multi-agent system di mana kontrol secara eksplisit berpindah antara router, specialist, dan synthesizer

Contoh Praktis: Agent Loop dengan Tool Calling

Sketsa ini menunjukkan bentuk minimal sebuah agent graph: node LLM yang bisa meminta tool, node eksekusi tool, dan conditional edge yang loop kembali sampai model selesai memanggil tool.

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langchain_core.messages import AnyMessage

class AgentState(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

def call_model(state: AgentState) -> dict:
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def call_tools(state: AgentState) -> dict:
    last_message = state["messages"][-1]
    results = [run_tool(call) for call in last_message.tool_calls]
    return {"messages": results}

def should_continue(state: AgentState) -> str:
    last_message = state["messages"][-1]
    return "tools" if last_message.tool_calls else END

graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_node("tools", call_tools)
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")  # loop balik setelah tool dieksekusi

app = graph.compile(checkpointer=my_checkpointer)

result = app.invoke(
    {"messages": [("user", "Cuaca di Jakarta gimana, terus convert ke Fahrenheit?")]},
    config={"configurable": {"thread_id": "user-123"}},
)

thread_id di config inilah yang membuat proses ini resumable — checkpointer meng-index state berdasarkan thread, jadi memanggil invoke lagi dengan thread_id yang sama akan melanjutkan percakapan yang sama dari titik terakhir.

Best Practices

Buat fungsi node kecil dan single-purpose — satu node, satu tugas

Definisikan typed state schema di awal, jangan asal lempar dictionary lepas

Pakai checkpointer sungguhan (bukan default in-memory) untuk apa pun yang harus bertahan setelah restart

Tambahkan conditional edge eksplisit untuk error path, jangan biarkan exception menyebar diam-diam

Stream intermediate step ke user untuk graph yang long-running — ini membuat latency terasa "disengaja", bukan lag

Kapan Pakai LangGraph (dan Kapan Tidak)

Cocok untuk:

Agent multi-step dengan tool use, retry, atau branching logic

Workflow yang perlu pause untuk input manusia

Apa pun yang harus resume lintas sesi atau restart proses

Berlebihan untuk:

Completion single-shot (klasifikasi, summarization, ekstraksi)

RAG lookup sederhana tanpa branching (chain linear lebih simple dan lebih mudah dipahami)

Key Takeaways

LangGraph memodelkan control flow agent sebagai graph, bukan chain — inilah yang dibutuhkan untuk cycle, branching, dan pause

State bersifat eksplisit dan bertipe, mengalir melalui setiap node di graph

Checkpointer mengubah satu kali run menjadi proses resumable, multi-turn

Pakai LangGraph begitu control flow berhenti menjadi garis lurus — bukan sebelum itu

Resources

Dokumentasi LangGraph: https://langchain-ai.github.io/langgraph/

GitHub LangGraph: https://github.com/langchain-ai/langgraph

LangGraph Essentials

Di Halaman Ini

LangGraph Essentials

Apa itu LangGraph?

Kenapa Tidak Pakai Chain Biasa Saja?

Konsep Inti

Use Case Umum

Contoh Praktis: Agent Loop dengan Tool Calling

Best Practices

Kapan Pakai LangGraph (dan Kapan Tidak)

Key Takeaways

Resources

Topik

Apakah Ini Membantu?