लैंगचेन एजेंट प्रवेश ट्यूटोरियल

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

सुझाव: विकास के दृष्टिकोण से, इसका मतलब है कि हम पहले से विभिन्न एपीआई डेवलप करते हैं और फिर एजेंट को एक कार्य देते हैं, जो एलएलएम के अनुसार कार्य को पूरा करने के लिए कौन सी एपीआई को कॉल करनी है उसे विश्लेषित करे।

लैंगचैन एजेंट का समस्या को समझने के लिए एक उदाहरण देखते हैं।

उदाहरण:

यदि हमें जांचना है कि "Docker को उत्पादन डिप्लॉयमेंट समाधान के रूप में क्या प्रयोग किया जा सकता है," तो हमें पहले "बाईडू पर डॉकर का परिचय" खोजना होगा, खोज के परिणाम देखना होगा, और फिर "डॉकर डिप्लॉयमेंट के फायदे और नुकसान" खोजना होगा और परिणाम देखना होगा, और इसी तरह, एक नतीजे तक पहुंचना होगा।

लैंगचैन एजेंट का उद्देश्य इस प्रक्रिया का अनुकरण करना है। मैं एक सर्वोपरि तरीके से एक सीरीज ऑफ औजार (जैसे कि बाईडू खोज, यूआरएल सामग्री निकालने वाले औज़ार) को पैकेज कर सकता हूं, और फिर एजेंट को लक्ष्य कार्य "क्या Docker को उत्पादन डिप्लॉयमेंट समाधान के रूप में इस्तेमाल किया जा सकता है?" देता हूं। एजेंट फिर एलएलएम को बुलाने के लिए प्रोंप्ट्स बनाएगा। इस कार्य को पूरा करने के लिए, अगला कदम क्या है—कौन सी क्रिया करनी है (अर्थात कौन सा औज़ार कॉल करना है)। एआई उस औज़ार को वापस बुलाएगी, कोड उस औज़ार को निष्पादित करेगा, फिर उस औज़ार के परिणामों को एआई को वापस भेजेगा, और आगे की किस क्रिया को निष्पादित करने की स्थिति में पूछेगा। इस प्रक्रिया को दोहराने से यह उपरोक्त कार्य पूरा हो जाएगा।

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

मूल अवधारणाएँ

अब हम संबंधित घटकों और अवधारणाओं को पेश करते हैं।

एजेंट

एक एजेंट को हमारा सहायक माना जा सकता है, जो हमारी पक्ष से निर्णय लेने के लिए कार्रवाई करता है। लैंगचैन एजेंट के अंतर्निहित कार्यान्वयन में, एलएलएम के माध्यम से अगली क्रिया (या एपीआई कॉल) निर्धारित की जाती है। ReAct मोड एआई निर्णय प्रक्रिया का वर्णन करता है। जो भी इसमें रुचि रखते हैं, वे इसे और अधिक अन्वेषित कर सकते हैं।

लैंगचैन विभिन्न प्रकार के एजेंट प्रदान करता है विभिन्न परिदृश्यों के लिए।

औजार

मुझे लगता है कि औज़ारों को एपीआई के रूप में बेहतर से समझा जा सकता है, जो एलएलएम की क्षमताओं को विस्तारित करने के लिए विभिन्न कार्यात्मक एपीआई के साथ पैकेजिंग किए गए हैं। एलएलएम निर्धारित करता है कि कौन सी विशिष्ट एपीआई को कॉल करना है कार्य पूरा करने के लिए।

उपकरणसंज्ञ

उपकरणसंज्ञ आमतौर पर एलएलएम को न केवल एक-दो, बल्कि एक सेट के साथ विन्यास देते हैं ताकि एलएलएम को कार्यों को पूरा करने के लिए अधिक विकल्प मिलें।

एजेंट निष्क्रियक

प्रॉक्सी निष्क्रियक जिम्मेदार है कि एलएलएम द्वारा चयनित उपकरण (एपीआई) को निष्पादित करने के लिए। इस रनटाइम के लिए प्यूडो कोड इस प्रकार है:

next_action = agent.get_action(...)
while next_action != AgentFinish:
    observation = run(next_action)
    next_action = agent.get_action(..., next_action, observation)
return next_action

हालांकि, निष्पादन प्रक्रिया जटिल नहीं है, निष्क्रियक विस्तारित विस्तृत मुद्दों को संभालता है, मुख्य रूप से शामिल हैं:

1. स्थिति का निपटान जब एजेंट अस्तित्व में नहीं होता है
2. उपकरण त्रुटि स्थितियों का संबोधन करना
3. स्थितियों का संबोधन करना जहां एजेंट उत्पन्न करता है जो एक उपकरण को कॉल के रूप में संबोधित नहीं किया जा सकता है
4. डीबगिंग मुद्दों का संबोधन करना।

तेज शुरू करें

इस भाग में लैंगचैन के एजेंट का मूल उपयोग पेश किया गया है।

1. एलएलएम लोड करें

पहले, आइए हम उस भाषा मॉडल (एलएलएम) को लोड करें जो हमें एजेंट को नियंत्रित करने के लिए उपयोग करेंगे।

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

2. उपकरणों को परिभाषित करें

अगले, हम एजेंट को कॉल करने के लिए कुछ उपकरण परिभाषित करते हैं। हम एक बहुत ही सरल पायथन फ़ंक्शन लिखेंगे जो इनपुट शब्द की लंबाई की गणना करता है।

from langchain.agents import tool

@tool
def get_word_length(word: str) -> int:
    """शब्द की लंबाई वापस लौटाता है।"""
    return len(word)

get_word_length.invoke("abc")

नोट: फ़ंक्शन टिप्पणियाँ बहुत महत्वपूर्ण होती हैं। वे एलएलएम को बताती हैं कि वह कौन सी समस्या को हल करने के लिए उन्हें कॉल करके क्या कर सकता है। get_word_length फ़ंक्शन एलएल

3. प्रॉम्प्ट बनाएं

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

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "आप बहुत शक्तिशाली सहायक हैं लेकिन वर्तमान स्थिति को समझ नहीं सकते।",
        ),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

4. टूल्स को LLM से जोड़ें

एजेंट को कैसे पता चलता है कि वह कौन-कौन से टूल्स का उपयोग कर सकता है?

इसका भरोसा OpenAI टूल कॉलिंग सुविधा पर होता है (कई मॉडल समर्थित सुविधाएँ समर्थन करते हैं)। हमें सिर्फ तय करना होगा कि मॉडल को परिभाषित टूल कॉल प्रारूप के बारे में बताना है।

llm_with_tools = llm.bind_tools(tools)

5. एजेंट बनाना

पिछले सामग्री को एकीकृत करने के बाद अब हम प्रॉक्सी प्रोग्राम बनाने के लिए आगे बढ़ सकते हैं। हम पिछले दो व्यावहारिक उपयोगिता फ़ंक्शंस डालेंगे: एक उपकरण के कदमों (प्रोक्सी क्रियाएँ, उपकरण आउटपुट) को इंपट संदेश में संरेखित करने के लिए, और दूसरा उत्पादन संदेशों को प्रोक्सी क्रियाओं/प्रोक्सी समाप्तियों में परिवर्तित करने के लिए।

from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]),
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

एजेंट कार्यकारी निर्धारित करना

from langchain.agents import AgentExecutor

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

एक उदाहरण के माध्यम से प्रॉक्सी प्रोग्राम के परिचालन को प्रदर्शित करें:

list(agent_executor.stream({"input": "शब्द 'educa' में कितने अक्षर हैं?"}))

एजेंट उत्पाद लॉग उदाहरण

> एक नयी एजेंट निष्पादन श्रृंखला में प्रवेश कर रहा है...

निवोकरण: `get_word_length` का चालू हो रहा है पैरामीटर `{'word': 'educa'}` के साथ

'educa' शब्द में 5 अक्षर हैं।

> निष्पादन श्रृंखला पूर्ण हुई।

इस उदाहरण के माध्यम से हमने प्रॉक्सी प्रोग्राम की पूरी प्रक्रिया का प्रदर्शन किया है।

एजेंट में स्मृति कार्यक्षमता जोड़ें

यदि हम चाहें कि एजेंट पिछली वार्ता को याद करे, तो यह बिल्कुल सरल है: हमें केवल एआई द्वारा वापस भेजी गई सामग्री को प्रॉम्प्ट में समाहित करना होगा और इसे एआई को साथ में सबमिट करना होगा।

प्रॉम्प्ट टेम्पलेट को संशोधित करें

निम्नलिखित कोड में प्रॉम्प्ट टेम्पलेट को संशोधित करने के लिए हम वार्ता इतिहास टेम्पलेट चर में शामिल करते हैं।

from langchain.prompts import MessagesPlaceholder

MEMORY_KEY = "chat_history"
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "आप बहुत शक्तिशाली सहायक हैं लेकिन शब्दों की लंबाई की गणना में अच्छे नहीं हैं।",
        ),
        MessagesPlaceholder(variable_name=MEMORY_KEY),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

एजेंट प्रक्रिया परिभाषा को संशोधित करें

आगे की कोड में एजेंट प्रक्रिया परिभाषा को संवेदना इतिहास डेटा प्रदान करने के लिए संशोधित करता है, जैसा कि निम्नलिखित कोड में दिखाया गया है, chat_history पैरामीटर हैंडलिंग जोड़ें।

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(
            x["intermediate_steps"]
        ),
        "chat_history": lambda x: x["chat_history"],
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

chat_history = []

input1 = "शब्द 'educa' में कितने अक्षर हैं?"
result = agent_executor.invoke({"input": input1, "chat_history": chat_history})
chat_history.extend(
    [
        HumanMessage(content=input1),
        AIMessage(content=result["output"]),
    ]
)
agent_executor.invoke({"input": "क्या यह शब्द वास्तव में मौजूद है?", "chat_history": chat_history})