LangGraph ट्यूटोरियल: LangGraph क्या है और इसे कैसे उपयोग करें?

LangGraph क्या है?

LangGraph हमें LLMs का उपयोग करते हुए stateful, मल्टी-एक्टर एप्लिकेशन यथासंभव आसानी से बनाने देता है। यह LangChain की क्षमताओं का विस्तार करता है और चक्रीय ग्राफ बनाने व प्रबंधित करने की क्षमता प्रस्तुत करता है, जो उन्नत एजेंट रनटाइम विकसित करने में अहम है। LangGraph के मूल सिद्धांत हैं: ग्राफ संरचना, स्टेट प्रबंधन, और समन्वय।

ग्राफ संरचना

अपनी एप्लिकेशन को एक निर्देशित ग्राफ के रूप में सोचें। LangGraph में, हर नोड एक LLM एजेंट का प्रतिनिधित्व करता है, और एजेस (edges) इन एजेंट्स के बीच संचार चैनल होते हैं। यह संरचना स्पष्ट और प्रबंधनीय वर्कफ्लो की अनुमति देती है, जहाँ हर एजेंट विशिष्ट कार्य करता है और आवश्यकता अनुसार जानकारी अन्य एजेंट्स को भेजता है।

स्टेट प्रबंधन

LangGraph की प्रमुख विशेषताओं में से एक है इसका स्वचालित स्टेट प्रबंधन। यह हमें कई इंटरैक्शन्स में जानकारी को ट्रैक और संरक्षित करने में सक्षम बनाता है। जैसे-जैसे एजेंट्स अपने कार्य करते हैं, स्टेट गतिशील रूप से अपडेट होती रहती है, जिससे सिस्टम संदर्भ बनाए रखता है और नए इनपुट्स पर उपयुक्त प्रतिक्रिया देता है।

समन्वय

LangGraph सुनिश्चित करता है कि एजेंट्स सही क्रम में निष्पादित हों और आवश्यक जानकारी बिना रुकावट के आदान-प्रदान हो। यह समन्वय उन जटिल एप्लिकेशन्स के लिए महत्वपूर्ण है जहाँ कई एजेंट्स को मिलकर एक साझा लक्ष्य हासिल करना होता है। डेटा के प्रवाह और ऑपरेशन्स के अनुक्रम का प्रबंधन करके, LangGraph डेवलपर्स को एजेंट समन्वय की बारीकियों के बजाय अपनी एप्लिकेशन की उच्च-स्तरीय लॉजिक पर ध्यान केंद्रित करने देता है।

क्यों LangGraph?

जैसा कि मैंने ऊपर बताया, जटिल LLM एप्लिकेशन्स पर काम करने वाले डेवलपर्स के लिए LangGraph कई महत्वपूर्ण लाभ देता है। यहाँ कुछ वास्तविक-world फायदों की सूची है जो LangGraph प्रदान करता है।

सरल विकास

LangGraph स्टेट प्रबंधन और एजेंट समन्वय से जुड़ी जटिलताओं को अमूर्त कर देता है। इसका अर्थ है कि डेवलपर्स अपने वर्कफ्लोज़ और लॉजिक परिभाषित कर सकते हैं, बिना उन अंतर्निहित तंत्रों की चिंता किए जो डेटा की सुसंगतता और सही निष्पादन क्रम सुनिश्चित करते हैं। यह सरलीकरण विकास को तेज करता है और त्रुटियों की संभावना घटाता है। यह वाकई गेम-चेंजर है!

लचीलापन

LangGraph के साथ, डेवलपर्स अपने एजेंट लॉजिक और संचार प्रोटोकॉल स्वयं परिभाषित कर सकते हैं। इससे विशिष्ट उपयोग मामलों के अनुरूप अत्यधिक अनुकूलित एप्लिकेशन्स संभव हो पाते हैं। चाहे आपको ऐसा चैटबॉट चाहिए जो विभिन्न प्रकार के उपयोगकर्ता अनुरोधों को संभाल सके, या कोई मल्टी-एजेंट सिस्टम जो जटिल कार्य कर सके—LangGraph वह सभी औज़ार देता है जिनसे आप बिल्कुल वैसा ही बना सकें जैसा आपको चाहिए। उद्देश्य है आपको निर्माण की शक्ति देना।

स्केलेबिलिटी

LangGraph बड़े पैमाने के मल्टी-एजेंट एप्लिकेशन्स के निष्पादन का समर्थन करने के लिए बनाया गया है। इसकी मजबूत आर्किटेक्चर उच्च मात्रा की इंटरैक्शन्स और जटिल वर्कफ्लोज़ को संभाल सकती है, जिससे ऐसे स्केलेबल सिस्टम्स का विकास संभव होता है जो आपकी ज़रूरतों के साथ बढ़ सकें। यह एंटरप्राइज़-स्तरीय एप्लिकेशन्स और उन परिदृश्यों के लिए उपयुक्त है जहाँ प्रदर्शन और विश्वसनीयता महत्वपूर्ण हैं।

फॉल्ट टॉलरेंस

विश्वसनीयता, LangGraph के डिज़ाइन का केंद्रीय विचार है। यह लाइब्रेरी त्रुटियों को शालीनता से संभालने के तंत्र शामिल करती है, ताकि आपका एप्लिकेशन तब भी काम करता रहे जब व्यक्तिगत एजेंट्स में समस्याएँ आएँ। यह फॉल्ट टॉलरेंस जटिल मल्टी-एजेंट सिस्टम्स की स्थिरता और मज़बूती बनाए रखने के लिए आवश्यक है। निश्चिंतता बस एक फीचर दूर है।

LangGraph के साथ शुरुआत

आइए देखें कि हम LangGraph कैसे सेटअप कर सकते हैं और इसके बुनियादी सिद्धांत क्या हैं।

इंस्टॉलेशन

LangGraph इंस्टॉल करने के लिए, आप pip का उपयोग कर सकते हैं:

pip install -U langgraph

मूल सिद्धांत

Nodes: नोड्स आपके LangGraph के भीतर कार्य की इकाइयाँ हैं। ये सामान्यतः Python फ़ंक्शन्स होते हैं जो कोई विशिष्ट कार्य करते हैं, जैसे:

• किसी LLM के साथ इंटरैक्ट करना
• किसी टूल या API को कॉल करना
• कुछ डेटा प्रोसेसिंग करना
• उपयोगकर्ता इनपुट लेना
• बिज़नेस लॉजिक निष्पादित करना

LangGraph में, आप graph.add_node(name, value) सिंटैक्स का उपयोग करके नोड्स जोड़ सकते हैं।

Edges: एजेस नोड्स के बीच संचार चैनल हैं। ये जानकारी के प्रवाह और निष्पादन के क्रम को परिभाषित करते हैं। आप graph.add_edge(node1, node2) सिंटैक्स से एजेस जोड़ सकते हैं।

State: स्टेट एक केंद्रीय ऑब्जेक्ट है जिसे ग्राफ के नोड्स समय के साथ अपडेट करते हैं। यह आपकी एप्लिकेशन की आंतरिक स्थिति का प्रबंधन करता है और आवश्यकताओं के अनुसार ओवरराइड किया जा सकता है या उसमें जोड़ा जा सकता है। इस स्टेट में निम्न चीज़ें हो सकती हैं:

• वार्तालाप इतिहास: एजेंट और उपयोगकर्ता के बीच संदेशों की सूची।
• संदर्भात्मक डेटा: वर्तमान कार्य या इंटरैक्शन से संबंधित जानकारी।
• आंतरिक वेरिएबल्स: फ्लैग्स, काउंटर्स, या अन्य वेरिएबल्स जो एजेंट की प्रगति और व्यवहार को ट्रैक करें।

एक साधारण LangGraph एप्लिकेशन बनाना

यहाँ LangGraph का उपयोग करके एक बेसिक चैटबॉट एप्लिकेशन बनाने का चरण-दर-चरण उदाहरण है।

चरण 1: StateGraph परिभाषित करें

एक StateGraph ऑब्जेक्ट परिभाषित करें ताकि चैटबॉट को एक स्टेट मशीन के रूप में संरचित किया जा सके। State एक क्लास ऑब्जेक्ट है जिसमें एकमात्र कुंजी messages टाइप List के साथ परिभाषित है और यह add_messages() फ़ंक्शन का उपयोग नए संदेशों को ओवरराइट करने के बजाय जोड़ने के लिए करता है।

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)

चरण 2: एक LLM इनिशियलाइज़ करें और उसे Chatbot नोड के रूप में जोड़ें

यहाँ, हम AzureChatOpenAI मॉडल को इनिशियलाइज़ करते हैं और एक सरल चैटबॉट फ़ंक्शन बनाते हैं जो इनपुट के रूप में स्टेट मैसेजेस लेता है और एक संदेश प्रतिक्रिया जनरेट करता है (जिसे बाद में स्टेट में जोड़ दिया जाता है)।

यह चैटबॉट फ़ंक्शन ग्राफ में “chatbot” नामक नोड के रूप में जोड़ा जाता है।

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)

चरण 3: एजेस सेट करें

क्योंकि हम एक सरल चैटबॉट बना रहे हैं, हम प्रक्रिया कहाँ से शुरू और कहाँ समाप्त हो यह बताने के लिए chatbot नोड को ही ग्राफ का एंट्री और फिनिश पॉइंट सेट करते हैं।

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

चरण 4: ग्राफ को कम्पाइल और विज़ुअलाइज़ करें

ग्राफ को कम्पाइल करके CompiledGraph ऑब्जेक्ट बनाएं, और वैकल्पिक रूप से, हम नीचे दिए गए कोड से ग्राफ संरचना को विज़ुअलाइज़ कर सकते हैं:

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

चरण 5: चैटबॉट चलाएँ

अंत में, हम एक लूप लागू करते हैं जो उपयोगकर्ता से लगातार इनपुट लेता है, उसे ग्राफ के माध्यम से प्रोसेस करता है, और सहायक (assistant) की प्रतिक्रिया प्रिंट करता है। जब उपयोगकर्ता "quit", "exit", या "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)

उन्नत LangGraph फीचर्स

अब जबकि हमने बुनियादी बातें कवर कर ली हैं, आइए कुछ उन्नत फीचर्स पर नज़र डालें।

कस्टम नोड प्रकार

LangGraph आपको जटिल एजेंट लॉजिक लागू करने के लिए कस्टम नोड प्रकार बनाने देता है। इससे आपकी एप्लिकेशन के व्यवहार पर लचीलापन और नियंत्रण मिलता है।

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)

यहाँ, हम MyCustomNode नामक एक क्लास परिभाषित करते हैं जो कस्टम लॉजिक को समाहित करता है और LLM के साथ इंटरैक्ट करता है। यह जटिल नोड व्यवहारों को लागू करने का अधिक संरचित और मेंटेन करने योग्य तरीका प्रदान करता है।

एज प्रकार

LangGraph नोड्स के बीच विभिन्न संचार पैटर्न संभालने के लिए अलग-अलग एज प्रकारों का समर्थन करता है। एक उपयोगी प्रकार है कंडीशनल एज, जो किसी नोड के आउटपुट के आधार पर निर्णय लेने की अनुमति देता है।

कंडीशनल एज बनाने के लिए आपको तीन घटकों की आवश्यकता होती है:

1. अपस्ट्रीम नोड: जिसका आउटपुट अगला कदम तय करता है।
2. एक फ़ंक्शन: जो अपस्ट्रीम नोड के आउटपुट का मूल्यांकन कर यह निर्धारित करता है कि अगला कौन-सा नोड निष्पादित होना है, और एक स्ट्रिंग लौटाता है जो निर्णय का प्रतिनिधित्व करती है।
3. एक मैपिंग: जो फ़ंक्शन के संभावित परिणामों को निष्पादित किए जाने वाले संबंधित नोड्स से जोड़ती है।

यहाँ एक छद्म-कोड (pseudocode) उदाहरण है:

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

यहाँ, “model” नोड कॉल होने के बाद, हम या तो ग्राफ से बाहर निकल सकते हैं (”end”) और उपयोगकर्ता के पास लौट सकते हैं, या जारी रख सकते हैं (”continue”) और किसी टूल को कॉल कर सकते हैं—यह इस पर निर्भर करता है कि उपयोगकर्ता ने क्या तय किया!

स्टेट प्रबंधन

LangGraph शक्तिशाली स्टेट प्रबंधन तकनीकें प्रदान करता है, जिनमें SQLite, PostgreSQL और MongoDB जैसे बाहरी डेटाबेस या Amazon S3, Google Cloud Storage और Azure Blob Storage जैसी क्लाउड स्टोरेज सेवाओं का उपयोग करके आपके एजेंट की स्टेट को स्टोर और रिट्रीव करना शामिल है, जिससे विश्वसनीयता और स्केलेबिलिटी सक्षम होती है।

यहाँ स्टेट प्रबंधन के लिए SQLite डेटाबेस का उपयोग करने का एक उदाहरण है:

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)

त्रुटि प्रबंधन

LangGraph त्रुटि प्रबंधन के लिए भी तंत्र प्रदान करता है:

• एक्सेप्शन्स: नोड फ़ंक्शन्स निष्पादन के दौरान त्रुटियों का संकेत देने के लिए एक्सेप्शन उठा सकते हैं। आप इन एक्सेप्शन्स को पकड़कर हैंडल कर सकते हैं ताकि आपका ग्राफ क्रैश न हो।
• रीट्राई तंत्र: आप अपने नोड्स के अंदर रीट्राई लॉजिक लागू कर सकते हैं ताकि नेटवर्क समस्याओं या API टाइमआउट्स जैसी अस्थायी त्रुटियों को संभाला जा सके।
• लॉगिंग: त्रुटियों को रिकॉर्ड करने और अपने ग्राफ के निष्पादन को ट्रैक करने के लिए लॉगिंग का उपयोग करें।

LangGraph के वास्तविक-जीवन अनुप्रयोग

LangGraph का उपयोग व्यापक प्रकार की एप्लिकेशन्स बनाने के लिए किया जा सकता है।

चैटबॉट्स

LangGraph उन्नत चैटबॉट्स विकसित करने के लिए आदर्श है जो उपयोगकर्ता के विभिन्न प्रकार के अनुरोधों को संभाल सकें। कई LLM एजेंट्स का लाभ उठाकर, ये चैटबॉट्स प्राकृतिक भाषा क्वेरीज़ प्रोसेस कर सकते हैं, सटीक उत्तर दे सकते हैं, और अलग-अलग वार्तालाप विषयों के बीच सहजता से स्विच कर सकते हैं। स्टेट प्रबंधन और इंटरैक्शन्स का समन्वय करने की क्षमता सुनिश्चित करती है कि चैटबॉट संदर्भ बनाए रखे और एक सुसंगत उपयोगकर्ता अनुभव दे।

स्वायत्त एजेंट्स

ऐसी एप्लिकेशन्स के लिए जिन्हें स्वायत्त निर्णय-निर्धारण की आवश्यकता है, LangGraph ऐसे एजेंट्स बनाने में सक्षम बनाता है जो उपयोगकर्ता इनपुट्स और पूर्व-परिभाषित लॉजिक के आधार पर स्वतंत्र रूप से कार्य कर सकें।

ये एजेंट्स जटिल वर्कफ्लोज़ निष्पादित कर सकते हैं, अन्य सिस्टम्स के साथ इंटरैक्ट कर सकते हैं, और नई जानकारी के अनुरूप गतिशील रूप से ढल सकते हैं। LangGraph का संरचित फ्रेमवर्क सुनिश्चित करता है कि हर एजेंट कुशलतापूर्वक और प्रभावी ढंग से काम करे, जिससे यह स्वचालित ग्राहक सहायता, डेटा प्रोसेसिंग, और सिस्टम मॉनिटरिंग जैसे कार्यों के लिए उपयुक्त बनता है।

मल्टी-एजेंट सिस्टम्स

LangGraph उन एप्लिकेशन्स के निर्माण में उत्कृष्ट है जहाँ कई एजेंट्स मिलकर एक साझा लक्ष्य हासिल करते हैं। उदाहरण के लिए, सप्लाई चेन मैनेजमेंट सिस्टम में अलग-अलग एजेंट्स इन्वेंटरी प्रबंधित कर सकते हैं, ऑर्डर्स प्रोसेस कर सकते हैं, और डिलीवरी का समन्वय कर सकते हैं। LangGraph की समन्वय क्षमताएँ सुनिश्चित करती हैं कि हर एजेंट प्रभावी ढंग से संवाद करे, जानकारी साझा करे, और समकालिक ढंग से निर्णय ले। इससे ऑपरेशन्स अधिक कुशल बनते हैं और संपूर्ण सिस्टम प्रदर्शन बेहतर होता है।

वर्कफ़्लो ऑटोमेशन टूल्स

LangGraph के साथ, व्यापार प्रक्रियाओं और वर्कफ़्लोज़ का स्वचालन सरल हो जाता है। बुद्धिमान एजेंट्स को दस्तावेज़ प्रोसेसिंग, अप्रूवल वर्कफ़्लोज़, और डेटा विश्लेषण जैसे कार्य संभालने के लिए डिज़ाइन किया जा सकता है। स्पष्ट वर्कफ़्लोज़ परिभाषित करके और LangGraph के स्टेट प्रबंधन का लाभ उठाकर, ये टूल्स बिना मानवीय हस्तक्षेप के जटिल कार्रवाइयों का क्रम निष्पादित कर सकते हैं, त्रुटियाँ घटाते हैं और उत्पादकता बढ़ाते हैं।

रेकमेंडेशन सिस्टम्स

व्यक्तिगत रेकमेंडेशन सिस्टम्स LangGraph की क्षमताओं से बहुत लाभान्वित हो सकते हैं। कई एजेंट्स का उपयोग करके उपयोगकर्ता व्यवहार, प्राथमिकताएँ, और संदर्भात्मक डेटा का विश्लेषण कर, ये सिस्टम्स उत्पादों, कंटेंट, या सेवाओं के लिए कस्टम सुझाव दे सकते हैं। LangGraph का लचीलापन विभिन्न डेटा स्रोतों और एल्गोरिद्म्स के एकीकरण की अनुमति देता है, जिससे सिफारिशों की सटीकता और प्रासंगिकता बढ़ती है।

व्यक्तिगत शिक्षा परिवेश

शैक्षिक प्लेटफ़ॉर्म्स में, LangGraph का उपयोग अनुकूली सीखने के वातावरण बनाने के लिए किया जा सकता है जो व्यक्तिगत सीखने की शैलियों और आवश्यकताओं के अनुरूप हों। कई एजेंट्स छात्र की प्रगति का आकलन कर सकते हैं, कस्टम अभ्यास दे सकते हैं, और रीयल-टाइम फीडबैक प्रदान कर सकते हैं। LangGraph की stateful प्रकृति सुनिश्चित करती है कि सिस्टम प्रत्येक शिक्षार्थी के प्रदर्शन और प्राथमिकताओं की जानकारी बनाए रखे, जिससे अधिक व्यक्तिगत और प्रभावी शैक्षिक अनुभव संभव होता है।

निष्कर्ष

LangGraph स्टेट प्रबंधन और एजेंट इंटरैक्शन्स के समन्वय के लिए एक संरचित फ्रेमवर्क प्रदान करके जटिल LLM एप्लिकेशन्स के विकास को काफी सरल बनाता है।

LangGraph के संभावित विकास में अन्य LangChain घटकों के साथ इंटीग्रेशन, नए LLM मॉडलों के लिए समर्थन, और अकादमिक जगत से और उन्नत एजेंट रनटाइम्स की शुरुआत शामिल है।

यदि आप LangChain इकोसिस्टम के भीतर एप्लिकेशन्स विकसित करने के बारे में और सीखना चाहते हैं, तो मैं इस कोर्स की सिफारिश करता/करती हूँ: LangChain के साथ LLM एप्लिकेशन्स विकसित करना।