Tutorial LangGraph: Apa Itu LangGraph dan Cara Menggunakannya

Apa Itu LangGraph?

LangGraph memampukan kita membuat aplikasi berstate dan multi-aktor yang memanfaatkan LLM dengan semudah mungkin. Ini memperluas kapabilitas LangChain, memperkenalkan kemampuan untuk membuat dan mengelola graph siklikal yang krusial untuk mengembangkan runtime agen yang canggih. Konsep inti LangGraph mencakup: struktur graph, manajemen state, dan koordinasi.

Struktur graph

Bayangkan aplikasi Anda sebagai graph berarah. Di LangGraph, setiap node merepresentasikan agen LLM, dan edge adalah saluran komunikasi antaragen. Struktur ini memungkinkan alur kerja yang jelas dan mudah dikelola, di mana setiap agen menjalankan tugas spesifik dan meneruskan informasi ke agen lain sesuai kebutuhan.

Manajemen state

Salah satu fitur menonjol LangGraph adalah manajemen state otomatis. Fitur ini memungkinkan kita melacak dan mempertahankan informasi di berbagai interaksi. Saat agen menjalankan tugasnya, state diperbarui secara dinamis, memastikan sistem menjaga konteks dan merespons input baru secara tepat.

Koordinasi

LangGraph memastikan agen dieksekusi dalam urutan yang benar dan informasi yang diperlukan dipertukarkan tanpa hambatan. Koordinasi ini sangat penting untuk aplikasi kompleks di mana banyak agen harus bekerja bersama untuk mencapai tujuan bersama. Dengan mengelola aliran data dan urutan operasi, LangGraph memungkinkan pengembang fokus pada logika tingkat tinggi aplikasi mereka alih-alih kerumitan koordinasi agen.

Mengapa LangGraph?

Seperti yang saya sebutkan di atas, LangGraph menawarkan beberapa keuntungan signifikan bagi pengembang yang bekerja dengan aplikasi LLM kompleks. Berikut beberapa manfaat nyata yang ditawarkan LangGraph.

Pengembangan yang disederhanakan

LangGraph mengabstraksi kerumitan terkait manajemen state dan koordinasi agen. Artinya, pengembang dapat mendefinisikan alur kerja dan logika tanpa mengkhawatirkan mekanisme dasar yang memastikan konsistensi data dan urutan eksekusi yang benar. Penyederhanaan ini mempercepat proses pengembangan dan mengurangi kemungkinan error. Ini benar-benar mengubah permainan!

Fleksibilitas

Dengan LangGraph, pengembang memiliki fleksibilitas untuk mendefinisikan logika agen dan protokol komunikasi sendiri. Ini memungkinkan aplikasi yang sangat tersesuaikan sesuai kasus penggunaan spesifik. Baik Anda memerlukan chatbot yang dapat menangani berbagai jenis permintaan pengguna atau sistem multi-agen yang melakukan tugas kompleks, LangGraph menyediakan alat untuk membangun tepat seperti yang Anda butuhkan. Intinya adalah memberi Anda kendali untuk berkreasi.

Skalabilitas

LangGraph dibangun untuk mendukung eksekusi aplikasi multi-agen skala besar. Arsitekturnya yang tangguh dapat menangani volume interaksi tinggi dan alur kerja kompleks, memungkinkan pengembangan sistem yang dapat diskalakan seiring kebutuhan Anda. Ini membuatnya cocok untuk aplikasi tingkat enterprise dan skenario di mana performa serta keandalan sangat krusial.

Toleransi kesalahan

Keandalan adalah pertimbangan inti dalam desain LangGraph. Pustaka ini menyertakan mekanisme untuk menangani error secara elegan, memastikan aplikasi Anda tetap berjalan meski agen individu mengalami masalah. Toleransi kesalahan ini penting untuk menjaga stabilitas dan ketangguhan sistem multi-agen yang kompleks. Ketenteraman pikiran tinggal satu fitur lagi.

Mulai Menggunakan LangGraph

Mari kita lihat cara menyiapkan LangGraph dan konsep dasarnya.

Instalasi

Untuk memasang LangGraph, Anda dapat menggunakan pip:

pip install -U langgraph

Konsep Dasar

Node: Node mewakili unit kerja dalam LangGraph Anda. Biasanya berupa fungsi Python yang melakukan tugas spesifik, seperti:

• Berinteraksi dengan LLM
• Memanggil alat atau API
• Melakukan manipulasi data
• Menerima input pengguna
• Menjalankan logika bisnis

Di LangGraph, Anda dapat menambahkan node menggunakan sintaks graph.add_node(name, value).

Edge: Edge adalah saluran komunikasi antar-node. Edge mendefinisikan aliran informasi dan urutan eksekusi. Anda dapat menambahkan edge menggunakan sintaks graph.add_edge(node1, node2).

State: State adalah objek pusat yang diperbarui seiring waktu oleh node dalam graph. State mengelola keadaan internal aplikasi Anda dan dapat dioverride atau ditambahkan sesuai kebutuhan aplikasi. State ini dapat menyimpan hal-hal seperti:

• Riwayat percakapan: Daftar pesan antara agen dan pengguna.
• Data kontekstual: Informasi yang relevan dengan tugas atau interaksi saat ini.
• Variabel internal: Flag, pencacah, atau variabel lain untuk melacak progres dan perilaku agen.

Membangun Aplikasi LangGraph Sederhana

Berikut contoh langkah demi langkah membuat aplikasi chatbot dasar menggunakan LangGraph.

Langkah 1: Definisikan StateGraph

Definisikan objek StateGraph untuk menyusun chatbot sebagai mesin state. State adalah objek kelas yang didefinisikan dengan satu kunci messages bertipe List dan menggunakan fungsi add_messages() untuk menambahkan pesan baru alih-alih menimpanya.

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 have the type "list".
    # The add_messages function appends messages to the list, rather than overwriting them
    messages: Annotated[list, add_messages]
graph_builder = StateGraph(State)

Langkah 2: Inisialisasi LLM dan tambahkan sebagai node Chatbot

Di sini, kita menginisialisasi model AzureChatOpenAI dan membuat fungsi chatbot sederhana yang menerima pesan state sebagai input dan menghasilkan respons pesan (yang kemudian ditambahkan ke state).

Fungsi chatbot ini ditambahkan sebagai node bernama “chatbot” ke graph.

from langchain_openai import AzureChatOpenAI
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"])]}
‘’’The first argument is the unique node name
# The second argument is the function or object that will be called whenever the node is used.’’’
graph_builder.add_node("chatbot", chatbot)

Langkah 3: Atur edge

Karena kita membangun chatbot sederhana, kita menetapkan node chatbot sebagai titik masuk dan titik selesai graph untuk menunjukkan di mana proses dimulai dan diakhiri.

# Set entry and finish points
graph_builder.set_entry_point("chatbot")
graph_builder.set_finish_point("chatbot")

Langkah 4: Kompilasi dan Visualisasikan Graph

Kompilasi graph untuk membuat objek CompiledGraph, dan opsional, kita dapat memvisualisasikan struktur graph menggunakan kode di bawah ini:

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

Langkah 5: Jalankan chatbot

Terakhir, kita mengimplementasikan loop untuk terus meminta input pengguna, memprosesnya melalui graph, dan mencetak respons asisten. Loop akan berhenti ketika pengguna mengetik "quit", "exit", atau "q".

# Run the chatbot
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

Sekarang kita sudah membahas dasar-dasarnya, mari lihat beberapa fitur lanjutan.

Tipe node kustom

LangGraph memungkinkan Anda membuat tipe node kustom untuk mengimplementasikan logika agen yang kompleks. Ini memberikan fleksibilitas dan kendali atas perilaku aplikasi Anda.

from typing import Annotated
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
class MyCustomNode:
    def __init__(self, llm):
        self.llm = llm
    def __call__(self, state):
        # Implement your custom logic here
        # Access the state and perform actions
        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 mendefinisikan kelas MyCustomNode yang merangkum logika kustom dan berinteraksi dengan LLM. Ini menyediakan cara yang lebih terstruktur dan mudah dirawat untuk mengimplementasikan perilaku node yang kompleks.

Tipe edge

LangGraph mendukung berbagai tipe edge untuk menangani pola komunikasi yang berbeda antar-node. Salah satu tipe yang berguna adalah conditional edge, yang memungkinkan pengambilan keputusan berdasarkan output suatu node.

Untuk membuat conditional edge, Anda memerlukan tiga komponen:

1. Node hulu: Output node ini menentukan langkah berikutnya.
2. Fungsi: Fungsi ini mengevaluasi output node hulu dan menentukan node berikutnya yang dieksekusi, mengembalikan string yang mewakili keputusan.
3. Pemetaan: Pemetaan ini menghubungkan kemungkinan keluaran fungsi ke node terkait yang akan dieksekusi.

Berikut contoh dalam pseudocode:

graph.add_conditional_edge(
    "model",
    should_continue,
    {
        "end": END,
        "continue": "tools"
    }
)

Di sini, setelah node “model” dipanggil, kita bisa keluar dari graph (”end”) dan kembali ke pengguna, atau kita bisa lanjut (”continue”) dan memanggil sebuah tool—bergantung pada apa yang diputuskan pengguna!

Manajemen state

LangGraph menawarkan teknik manajemen state yang kuat, termasuk menggunakan basis data eksternal seperti SQLite, PostgreSQL, dan MongoDB, atau solusi penyimpanan cloud seperti Amazon S3, Google Cloud Storage, dan Azure Blob Storage untuk menyimpan dan mengambil state agen Anda, sehingga meningkatkan keandalan dan skalabilitas.

Berikut contoh penggunaan basis data SQLite untuk manajemen state:

from langgraph.checkpoint.sqlite import SqliteSaver
# Connect to the SQLite database
memory = SqliteSaver.from_conn_string(":memory:")
# Compile the graph with the checkpointer
graph = graph_builder.compile(checkpointer=memory)

Penanganan error

LangGraph juga menyediakan mekanisme untuk penanganan error:

• Exception: Fungsi node dapat melempar exception untuk memberi sinyal adanya error saat eksekusi. Anda dapat menangkap dan menanganinya untuk mencegah graph Anda crash.
• Mekanisme retry: Anda dapat mengimplementasikan logika retry dalam node untuk menangani error sementara, seperti masalah jaringan atau timeout API.
• Logging: Gunakan logging untuk mencatat error dan melacak eksekusi graph Anda.

Aplikasi Dunia Nyata dari LangGraph

LangGraph dapat digunakan untuk membangun berbagai jenis aplikasi.

Chatbot

LangGraph ideal untuk mengembangkan chatbot canggih yang dapat menangani beragam permintaan pengguna. Dengan memanfaatkan beberapa agen LLM, chatbot ini dapat memproses kueri bahasa alami, memberikan respons akurat, dan beralih topik percakapan dengan mulus. Kemampuan mengelola state dan mengoordinasikan interaksi memastikan chatbot menjaga konteks dan memberikan pengalaman pengguna yang koheren.

Agen otonom

Untuk aplikasi yang memerlukan pengambilan keputusan otonom, LangGraph memungkinkan pembuatan agen yang dapat menjalankan tugas secara mandiri berdasarkan input pengguna dan logika yang telah ditetapkan.

Agen-agen ini dapat mengeksekusi alur kerja kompleks, berinteraksi dengan sistem lain, dan beradaptasi dengan informasi baru secara dinamis. Kerangka kerja terstruktur LangGraph memastikan setiap agen beroperasi secara efisien dan efektif, sehingga cocok untuk tugas seperti dukungan pelanggan otomatis, pemrosesan data, dan pemantauan sistem.

Sistem Multi-Agen

LangGraph unggul dalam membangun aplikasi di mana beberapa agen berkolaborasi untuk mencapai tujuan bersama. Misalnya, pada sistem manajemen rantai pasok, agen yang berbeda dapat mengelola inventaris, memproses pesanan, dan mengoordinasikan pengiriman. Kapabilitas koordinasi LangGraph memastikan setiap agen berkomunikasi secara efektif, berbagi informasi, dan mengambil keputusan secara tersinkronisasi. Ini menghasilkan operasi yang lebih efisien dan kinerja sistem secara keseluruhan yang lebih baik.

Alat otomasi alur kerja

Dengan LangGraph, mengotomasi proses bisnis dan alur kerja menjadi lebih mudah. Agen cerdas dapat dirancang untuk menangani tugas seperti pemrosesan dokumen, alur persetujuan, dan analisis data. Dengan mendefinisikan alur kerja yang jelas dan memanfaatkan manajemen state LangGraph, alat ini dapat mengeksekusi rangkaian tindakan kompleks tanpa intervensi manusia, mengurangi kesalahan dan meningkatkan produktivitas.

Sistem rekomendasi

Sistem rekomendasi yang dipersonalisasi dapat sangat diuntungkan dari kapabilitas LangGraph. Dengan menggunakan beberapa agen untuk menganalisis perilaku pengguna, preferensi, dan data kontekstual, sistem ini dapat memberikan saran yang disesuaikan untuk produk, konten, atau layanan. Fleksibilitas LangGraph memungkinkan integrasi berbagai sumber data dan algoritma, meningkatkan akurasi dan relevansi rekomendasi.

Lingkungan belajar yang dipersonalisasi

Dalam platform pendidikan, LangGraph dapat digunakan untuk menciptakan lingkungan belajar adaptif yang sesuai dengan gaya dan kebutuhan belajar individu. Beberapa agen dapat menilai progres siswa, menyediakan latihan yang disesuaikan, dan menawarkan umpan balik waktu nyata. Sifat berstate LangGraph memastikan sistem mempertahankan informasi tentang performa dan preferensi setiap pelajar, sehingga menghadirkan pengalaman pendidikan yang lebih personal dan efektif.

Kesimpulan

LangGraph secara signifikan menyederhanakan pengembangan aplikasi LLM yang kompleks dengan menyediakan kerangka kerja terstruktur untuk mengelola state dan mengoordinasikan interaksi agen.

Potensi pengembangan LangGraph mencakup integrasi dengan komponen LangChain lainnya, dukungan untuk model LLM baru, dan pengenalan runtime agen yang lebih maju dari akademia.

Jika Anda ingin mempelajari lebih lanjut tentang pengembangan aplikasi dalam ekosistem LangChain, saya merekomendasikan kursus tentang mengembangkan aplikasi LLM dengan LangChain.