Apa Itu LangGraph? Manfaat & Cara Menggunakannya

Rita Puspita Sari
•
7 jam yang lalu

Di era kecerdasan buatan (AI) yang semakin maju, penggunaan large language model (LLM) seperti GPT semakin meluas. Namun, membangun sistem multi-agen berbasis LLM bukanlah tugas yang mudah. Tantangan utama dalam pengembangan aplikasi semacam ini meliputi:

Mengelola status berbagai agen dalam sistem,
Mengoordinasikan interaksi antaragen, dan
Menangani kesalahan agar sistem tetap stabil.

Di sinilah LangGraph hadir sebagai solusi. LangGraph adalah library dalam ekosistem LangChain yang mempermudah pengelolaan dan koordinasi beberapa agen LLM dalam satu sistem yang terstruktur dan efisien. Dengan LangGraph, Anda bisa membangun aplikasi multi-agen yang fleksibel, skalabel, dan tahan terhadap kesalahan dengan lebih mudah.

Jika Anda tertarik untuk memahami lebih lanjut tentang LangGraph dan bagaimana cara menggunakannya, artikel ini akan membahasnya secara lengkap dan mudah dipahami.

Apa Itu LangGraph?

LangGraph adalah library yang memungkinkan kita membangun aplikasi multi-aktor berbasis LLM dengan manajemen status yang otomatis dan koordinasi yang mudah.

Library ini memperluas fitur LangChain dengan memungkinkan pembuatan graf siklikal, yang sangat penting dalam mengembangkan sistem multi-agen yang kompleks. Graf siklikal adalah struktur yang memungkinkan agen untuk berinteraksi secara berulang dan dinamis, sehingga menciptakan sistem yang lebih adaptif dan responsif terhadap berbagai situasi.

Ada tiga konsep utama dalam LangGraph yang perlu dipahami:

Struktur Graf dalam LangGraph
Bayangkan aplikasi Anda sebagai graf berarah, di mana setiap elemen memiliki hubungan yang jelas satu sama lain.
- Node dalam graf mewakili agen LLM yang menjalankan tugas tertentu.
- Edge (garis penghubung) adalah jalur komunikasi antara agen-agen tersebut.
Dengan model ini, LangGraph memungkinkan kita mengatur aliran kerja dengan lebih terstruktur, di mana setiap agen dapat menerima informasi, memprosesnya, dan meneruskan hasilnya ke agen lain sesuai kebutuhan.
Misalnya, dalam sebuah sistem chatbot cerdas, kita bisa memiliki beberapa agen dengan tugas yang berbeda:
- Agen A: Menganalisis pertanyaan pengguna,
- Agen B: Mencari jawaban dari database,
- Agen C: Menyusun respons dengan bahasa yang lebih alami,
- Agen D: Memeriksa apakah jawaban sudah sesuai sebelum dikirim ke pengguna.
Dengan struktur graf yang jelas, koordinasi antaragen menjadi lebih terkontrol dan efisien.
Manajemen Status dalam LangGraph
Salah satu fitur unggulan LangGraph adalah kemampuannya dalam mengelola status agen secara otomatis.
Tanpa fitur ini, setiap agen dalam sistem harus menyimpan dan mengelola data sendiri, yang bisa menyebabkan inkonsistensi dan kesalahan dalam komunikasi antaragen.
Dengan manajemen status otomatis, sistem akan:
- Menyimpan informasi penting dari setiap interaksi,
- Memastikan data yang dikirim antaragen tetap konsisten, dan
- Memungkinkan agen merespons perubahan dalam sistem secara dinamis.
Sebagai contoh, dalam sebuah asisten virtual berbasis AI, sistem perlu mengingat informasi yang telah diberikan oleh pengguna sebelumnya. Dengan LangGraph, status percakapan dapat dikelola secara otomatis, sehingga pengguna tidak perlu mengulangi informasi setiap kali berinteraksi.
Koordinasi Agen dalam LangGraph
Koordinasi adalah salah satu tantangan terbesar dalam pengembangan aplikasi multi-agen berbasis LLM. Jika tidak dikelola dengan baik, agen bisa:
- Menjalankan tugas dalam urutan yang salah,
- Menggunakan data yang tidak relevan, atau
- Menghasilkan hasil yang tidak akurat.
LangGraph memastikan bahwa setiap agen berjalan dalam urutan yang benar dan bahwa data yang diperlukan selalu tersedia di tempat yang tepat.
Misalnya, dalam sebuah aplikasi rekomendasi produk berbasis AI, LangGraph bisa memastikan bahwa:
- Agen pertama menganalisis preferensi pengguna,
- Agen kedua mencari produk yang sesuai,
- Agen ketiga menyusun rekomendasi, dan
- Agen keempat mengirimkan hasilnya ke pengguna.
Dengan koordinasi yang baik, pengalaman pengguna menjadi lebih mulus dan responsif.

Keunggulan LangGraph: Mengapa Harus Menggunakannya?

Menyederhanakan Pengembangan
Sebelum adanya LangGraph, pengembang harus mengelola status dan koordinasi agen secara manual, yang sangat rumit dan rentan terhadap kesalahan.
LangGraph mengotomatiskan banyak aspek teknis ini, sehingga pengembang bisa fokus pada logika bisnis tanpa perlu khawatir tentang detail teknis yang kompleks.
Fleksibilitas Tinggi
LangGraph memungkinkan pengembang untuk:
- Menyesuaikan logika agen,
- Mendefinisikan protokol komunikasi antaragen, dan
- Membuat sistem multi-agen yang sesuai dengan kebutuhan spesifik aplikasi mereka.
Baik Anda ingin membangun chatbot cerdas, asisten AI, atau sistem otomatisasi tingkat lanjut, LangGraph memberikan alat yang Anda butuhkan.
Skalabilitas yang Baik
LangGraph dirancang untuk menangani aplikasi berskala besar dengan volume interaksi yang tinggi.
Sistem ini cocok untuk berbagai kebutuhan, mulai dari startup kecil hingga aplikasi tingkat enterprise yang memerlukan performa tinggi dan reliabilitas tinggi.
Ketahanan terhadap Kesalahan (Fault Tolerance)
Dalam sistem multi-agen, kegagalan satu agen dapat menyebabkan seluruh sistem terganggu. LangGraph memiliki mekanisme bawaan untuk menangani kesalahan dengan baik, sehingga jika ada agen yang mengalami masalah, sistem tetap bisa berjalan tanpa hambatan.
Dengan fitur ini, pengembang bisa membangun sistem yang lebih stabil dan handal tanpa perlu khawatir tentang kegagalan teknis yang tidak terduga.

Cara Menggunakan LangGraph

Mari kita lihat cara mengatur LangGraph dan memahami konsep dasarnya.
Instalasi
Untuk menginstal LangGraph, gunakan perintah berikut di terminal atau command prompt:

pip install -U langgraph

Konsep Dasar LangGraph

Nodes
Nodes dalam LangGraph mewakili unit kerja yang melakukan tugas tertentu. Biasanya, nodes ini berupa fungsi Python yang bisa digunakan untuk:
- Berinteraksi dengan large language model (LLM)
- Memanggil alat atau API
- Memanipulasi data
- Menerima input dari pengguna
- Mengeksekusi logika bisnis
Di LangGraph, simpul bisa ditambahkan dengan sintaks berikut:
```
graph.add_node(nama, fungsi)
```
Edges
Edges dalam LangGraph adalah jalur komunikasi antara simpul-simpul yang mengatur alur informasi dan urutan eksekusi. Edge dapat ditambahkan menggunakan perintah:
```
graph.add_edge(nodes1, Nodes2)
```
State
State adalah objek pusat yang diperbarui oleh simpul-simpul dalam grafik. Objek ini mengelola keadaan internal aplikasi dan bisa dimodifikasi sesuai kebutuhan.
State dapat menyimpan berbagai jenis informasi, seperti:
- Riwayat percakapan: Daftar pesan antara agen dan pengguna
- Data kontekstual: Informasi yang relevan dengan tugas atau interaksi saat ini
- Variabel internal: Flag, penghitung, atau variabel lainnya yang melacak kemajuan dan perilaku agen

Membangun Aplikasi LangGraph Sederhana

Berikut adalah contoh langkah demi langkah untuk membuat chatbot sederhana menggunakan LangGraph.

Langkah 1: Mendefinisikan StateGraph
Kita mulai dengan mendefinisikan StateGraph, yang akan bertindak sebagai mesin keadaan chatbot.

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
class State(TypedDict):
    # "messages" adalah daftar pesan
    # Fungsi add_messages akan menambahkan pesan baru tanpa menimpa yang lama
    messages: Annotated[list, add_messages]
graph_builder = StateGraph(State)

Langkah 2: Inisialisasi LLM dan Menambahkannya sebagai Nodes Chatbot
Kita menginisialisasi model AzureChatOpenAI dan membuat fungsi chatbot sederhana. Fungsi ini menerima daftar pesan dalam state, lalu mengembalikan respons yang ditambahkan ke dalam state.

from langchain_openai import AzureChatOpenAI
import os
llm = AzureChatOpenAI(
    openai_api_version=os.environ["AZURE_OPENAI_API_VERSION"],
    azure_deployment=os.environ["AZURE_OPENAI_CHAT_DEPLOYMENT_NAME"],
)
def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}
# Menambahkan nodes chatbot ke dalam grafik
graph_builder.add_node("chatbot", chatbot)

Langkah 3: Menentukan Tepi (Edges)
Karena ini adalah chatbot sederhana, kita menjadikan simpul chatbot sebagai titik awal dan akhir proses.
```
graph_builder.set_entry_point("chatbot")
graph_builder.set_finish_point("chatbot")
```

Langkah 4: Mengompilasi dan Memvisualisasikan Grafik
Kita mengompilasi grafik menjadi objek CompiledGraph dan, jika perlu, memvisualisasikannya menggunakan Mermaid.

graph = graph_builder.compile()
from IPython.display import Image, display
try:
    display(Image(graph.get_graph().draw_mermaid_png()))
except Exception:
    pass

Langkah 5: Menjalankan Chatbot
Terakhir, kita membuat loop agar chatbot bisa terus menerima input dari pengguna dan menampilkan responsnya. Pengguna bisa keluar dengan mengetikkan "quit", "exit", atau "q".

while True:
    user_input = input("User: ")
    if user_input.lower() in ["quit", "exit", "q"]:
        print("Goodbye!")
        break
    for event in graph.stream({"messages": [("user", user_input)]}):
        for value in event.values():
            print("Assistant:", value["messages"][-1].content)

Fitur Lanjutan LangGraph

Setelah memahami dasar-dasarnya, mari kita lihat beberapa fitur lanjutan LangGraph.

Custom Node
LangGraph memungkinkan Anda membuat custom node untuk mengimplementasikan logika yang lebih kompleks.

from langchain_anthropic import ChatAnthropic
class MyCustomNode:
    def __init__(self, llm):
        self.llm = llm
    def __call__(self, state):
        # Mengakses state dan melakukan pemrosesan
        messages = state["messages"]
        response = self.llm.invoke(messages)
        return {"messages": [response]}
graph_builder = StateGraph(State)
llm = ChatAnthropic(model="claude-3-haiku-20240307")
custom_node = MyCustomNode(llm)
graph_builder.add_node("custom_node", custom_node)

Di sini, kita membuat kelas MyCustomNode untuk mengenkapsulasi logika khusus dan berinteraksi dengan LLM.

Edge Types
LangGraph mendukung berbagai edge types untuk menangani pola komunikasi yang berbeda antara simpul-simpul. Salah satu jenis yang berguna adalah conditional edge, yang memungkinkan pengambilan keputusan berdasarkan keluaran simpul sebelumnya.
Untuk membuat conditional edge, kita memerlukan tiga komponen:
- Edge awal: Edge yang keluarannya akan menentukan langkah berikutnya.
- Fungsi pengambilan keputusan: Fungsi yang mengevaluasi keluaran dan menentukan simpul berikutnya.
- Pemetaan hasil: Menautkan hasil evaluasi ke simpul yang sesuai.
Contoh:
```
graph.add_conditional_edge(
    "model",
    should_continue,
    {
        "end": END,
        "continue": "tools"
    }
)
```
Dalam contoh ini, setelah simpul model dieksekusi, kita bisa keluar dari grafik ("end") atau melanjutkan ke simpul tools, tergantung pada keputusan yang dibuat berdasarkan input pengguna.
Manajemen State
LangGraph memungkinkan penggunaan database eksternal seperti SQLite, PostgreSQL, dan MongoDB, atau penyimpanan cloud seperti Amazon S3, Google Cloud Storage, dan Azure Blob Storage untuk menyimpan dan mengambil state agen.
Berikut adalah contoh penggunaan SQLite untuk manajemen state:
```
from langgraph.checkpoint.sqlite import SqliteSaver
# Menghubungkan ke database SQLite
memory = SqliteSaver.from_conn_string(":memory:")
# Mengompilasi grafik dengan penyimpan state
graph = graph_builder.compile(checkpointer=memory)
```
Dengan menyimpan state dalam database, chatbot dapat memiliki rekam jejak percakapan dan mempertahankan konteks interaksi dari waktu ke waktu.

Fitur Penting dalam LangGraph

Dalam sistem berbasis AI, berbagai kesalahan bisa terjadi, seperti gangguan jaringan atau pemrosesan data yang gagal. LangGraph menawarkan beberapa cara untuk menangani kesalahan ini:

Pengecualian (Exceptions): Jika terjadi kesalahan selama proses eksekusi, LangGraph memungkinkan pengembang untuk menangkap dan menangani pengecualian sebelum sistem mengalami kegagalan total.
Mekanisme Percobaan Ulang (Retry Mechanisms): Jika terjadi kesalahan sementara, seperti koneksi yang terputus, LangGraph dapat mencoba kembali secara otomatis untuk menyelesaikan tugas tersebut.
Pencatatan (Logging): Semua kesalahan dan proses eksekusi dapat dicatat, sehingga pengembang lebih mudah melacak masalah dan memperbaikinya di kemudian hari.

Dengan fitur ini, sistem berbasis LangGraph menjadi lebih stabil dan tahan terhadap berbagai gangguan.

Penerapan LangGraph dalam Berbagai Bidang

LangGraph telah digunakan di berbagai industri untuk membangun sistem yang cerdas, otomatis, dan efisien. Berikut beberapa contoh penerapannya:

Chatbot Cerdas
Chatbot berbasis LangGraph bisa menjawab pertanyaan dengan lebih akurat dan berpindah antar topik tanpa kehilangan konteks percakapan. Beberapa keunggulannya:
✅ Memahami dan menjawab pertanyaan secara natural.
✅ Bisa menangani berbagai permintaan pengguna.
✅ Mampu mengingat konteks percakapan sebelumnya.
Contoh: Chatbot layanan pelanggan yang dapat memberikan informasi produk, menangani keluhan pelanggan, dan membantu proses pembelian dalam satu sistem.
Agen Otonom untuk Otomatisasi Pekerjaan
Agen otonom yang dibangun dengan LangGraph mampu bekerja tanpa campur tangan manusia, hanya berdasarkan data dan aturan yang telah ditetapkan.
Contoh penerapan:
✅ Customer support otomatis: Menjawab pertanyaan pelanggan tanpa operator manusia.
✅ Pemrosesan data otomatis: Menganalisis laporan keuangan perusahaan secara real-time.
✅ Sistem pemantauan: Memantau server dan memperbaiki kesalahan sebelum sistem mengalami gangguan.
Sistem Multi-Agen untuk Manajemen Supply Chain
Dalam industri logistik dan manajemen inventaris, LangGraph membantu berbagai agen AI untuk bekerja sama dan berbagi data secara otomatis.
Contoh:
✅ Agen pertama memantau jumlah stok barang.
✅ Agen kedua memproses pesanan pelanggan.
✅ Agen ketiga mengoordinasikan pengiriman barang ke pelanggan.

Dengan sistem ini, operasional perusahaan menjadi lebih efisien, kesalahan berkurang, dan pelanggan mendapatkan layanan lebih cepat.
Alat Otomasi Proses Bisnis
LangGraph juga bisa digunakan untuk mengotomatisasi berbagai tugas di dunia bisnis, seperti:
- Pemrosesan dokumen: Sistem AI dapat membaca dan memproses dokumen tanpa perlu intervensi manusia.
- Persetujuan otomatis: Misalnya, dalam dunia perbankan, sistem dapat menyetujui atau menolak pengajuan pinjaman secara otomatis berdasarkan data yang diberikan.
- Analisis data: AI dapat menganalisis data bisnis dan memberikan laporan langsung ke manajemen.
  Sistem ini tidak hanya menghemat waktu, tetapi juga mengurangi risiko kesalahan manusia.
Sistem Rekomendasi Cerdas
Sistem rekomendasi berbasis LangGraph memungkinkan perusahaan untuk memberikan saran yang lebih personal kepada pengguna.
Contoh penerapan:
✅ E-commerce: Menyediakan rekomendasi produk berdasarkan riwayat pembelian pelanggan.
✅ Streaming musik & film: Memberikan saran lagu atau film yang sesuai dengan preferensi pengguna.
✅ Konten edukasi: Menyesuaikan materi pembelajaran dengan kebutuhan siswa.

Dengan menggabungkan data perilaku pengguna dan algoritma AI, rekomendasi yang dihasilkan menjadi lebih relevan dan akurat.
Pembelajaran yang Dipersonalisasi dalam Pendidikan
LangGraph juga bisa digunakan dalam sistem pembelajaran digital untuk membuat pengalaman belajar yang lebih interaktif dan personal.
Keunggulan:
✅ AI dapat menilai perkembangan siswa dan memberikan tugas yang sesuai dengan kemampuan mereka.
✅ Sistem dapat memberikan umpan balik langsung kepada siswa.
✅ Siswa bisa mendapatkan materi belajar yang sesuai dengan gaya belajarnya.

Sistem pembelajaran berbasis AI ini dapat membantu siswa belajar lebih efektif dan meningkatkan pemahaman mereka dalam berbagai mata pelajaran.

LangGraph adalah alat yang sangat berguna bagi pengembang yang ingin membangun aplikasi multi-agen berbasis LLM dengan cara yang lebih efisien.
Dengan struktur graf yang jelas, manajemen status otomatis, dan koordinasi yang efektif, LangGraph menyederhanakan pengelolaan aplikasi yang kompleks.

Jika Anda sedang membangun aplikasi berbasis AI multi-agen, LangGraph adalah solusi yang patut Anda pertimbangkan!

Tag Terkait