मूलतः, लैंगचैन भाषा मॉडल की क्षमताओं का लाभ उठाने वाले अनुप्रयोगों को तैयार करने के लिए तैयार किया गया एक अभिनव ढांचा है। यह एक टूलकिट है जिसे डेवलपर्स के लिए ऐसे एप्लिकेशन बनाने के लिए डिज़ाइन किया गया है जो संदर्भ-जागरूक हों और परिष्कृत तर्क करने में सक्षम हों।
इसका मतलब यह है कि लैंगचेन एप्लिकेशन संदर्भ को समझ सकते हैं, जैसे त्वरित निर्देश या सामग्री ग्राउंडिंग प्रतिक्रियाएं और जटिल तर्क कार्यों के लिए भाषा मॉडल का उपयोग कर सकते हैं, जैसे कि कैसे प्रतिक्रिया देनी है या क्या कार्रवाई करनी है, यह तय करना। लैंगचेन बुद्धिमान अनुप्रयोगों को विकसित करने के लिए एक एकीकृत दृष्टिकोण का प्रतिनिधित्व करता है, जो अपने विविध घटकों के साथ अवधारणा से निष्पादन तक की यात्रा को सरल बनाता है।
लैंगचेन को समझना
लैंगचेन सिर्फ एक ढांचे से कहीं अधिक है; यह एक पूर्ण पारिस्थितिकी तंत्र है जिसमें कई अभिन्न अंग शामिल हैं।
- सबसे पहले, लैंगचेन लाइब्रेरीज़ हैं, जो पायथन और जावास्क्रिप्ट दोनों में उपलब्ध हैं। ये लाइब्रेरी लैंगचेन की रीढ़ हैं, जो विभिन्न घटकों के लिए इंटरफेस और एकीकरण की पेशकश करती हैं। वे तत्काल उपयोग के लिए तैयार कार्यान्वयन के साथ-साथ इन घटकों को एकजुट श्रृंखलाओं और एजेंटों में संयोजित करने के लिए एक बुनियादी रनटाइम प्रदान करते हैं।
- इसके बाद, हमारे पास लैंगचेन टेम्प्लेट हैं। ये कार्यों की एक विस्तृत श्रृंखला के लिए तैयार किए गए तैनाती योग्य संदर्भ आर्किटेक्चर का एक संग्रह है। चाहे आप एक चैटबॉट या एक जटिल विश्लेषणात्मक उपकरण बना रहे हों, ये टेम्पलेट एक ठोस प्रारंभिक बिंदु प्रदान करते हैं।
- लैंगसर्व ने लैंगचेन चेन को REST API के रूप में तैनात करने के लिए एक बहुमुखी लाइब्रेरी के रूप में कदम रखा है। यह टूल आपके लैंगचेन प्रोजेक्ट्स को सुलभ और स्केलेबल वेब सेवाओं में बदलने के लिए आवश्यक है।
- अंत में, लैंगस्मिथ एक डेवलपर प्लेटफ़ॉर्म के रूप में कार्य करता है। इसे किसी भी एलएलएम ढांचे पर निर्मित श्रृंखलाओं को डिबग, परीक्षण, मूल्यांकन और मॉनिटर करने के लिए डिज़ाइन किया गया है। लैंगचेन के साथ सहज एकीकरण इसे उन डेवलपर्स के लिए एक अनिवार्य उपकरण बनाता है जो अपने अनुप्रयोगों को परिष्कृत और परिपूर्ण करने का लक्ष्य रखते हैं।
साथ में, ये घटक आपको आसानी से एप्लिकेशन विकसित करने, उत्पादन करने और तैनात करने के लिए सशक्त बनाते हैं। लैंगचेन के साथ, आप पुस्तकालयों का उपयोग करके अपने एप्लिकेशन लिखना शुरू करते हैं, मार्गदर्शन के लिए टेम्पलेट्स का संदर्भ देते हैं। फिर लैंगस्मिथ आपकी श्रृंखलाओं का निरीक्षण, परीक्षण और निगरानी करने में आपकी मदद करता है, यह सुनिश्चित करते हुए कि आपके एप्लिकेशन लगातार सुधार कर रहे हैं और तैनाती के लिए तैयार हैं। अंत में, लैंगसर्व के साथ, आप आसानी से किसी भी श्रृंखला को एपीआई में बदल सकते हैं, जिससे तैनाती आसान हो जाएगी।
अगले अनुभागों में, हम लैंगचेन को कैसे स्थापित करें और बुद्धिमान, भाषा मॉडल-संचालित एप्लिकेशन बनाने में आपकी यात्रा शुरू करने के बारे में गहराई से जानेंगे।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
स्थापना और सेटअप
क्या आप लैंगचेन की दुनिया में उतरने के लिए तैयार हैं? इसे स्थापित करना सीधा है, और यह मार्गदर्शिका आपको चरण-दर-चरण प्रक्रिया के बारे में बताएगी।
आपकी लैंगचेन यात्रा में पहला कदम इसे स्थापित करना है। आप इसे पिप या कोंडा का उपयोग करके आसानी से कर सकते हैं। अपने टर्मिनल में निम्नलिखित कमांड चलाएँ:
pip install langchain
उन लोगों के लिए जो नवीनतम सुविधाओं को पसंद करते हैं और थोड़े अधिक रोमांच के साथ सहज हैं, आप सीधे स्रोत से लैंगचेन इंस्टॉल कर सकते हैं। रिपॉजिटरी को क्लोन करें और नेविगेट करें langchain/libs/langchain
निर्देशिका। तो भागो:
pip install -e .
प्रायोगिक सुविधाओं के लिए, इंस्टॉल करने पर विचार करें langchain-experimental
. यह एक पैकेज है जिसमें अत्याधुनिक कोड शामिल है और यह अनुसंधान और प्रयोगात्मक उद्देश्यों के लिए है। इसका उपयोग करके इसे स्थापित करें:
pip install langchain-experimental
लैंगचेन सीएलआई लैंगचेन टेम्पलेट्स और लैंगसर्व प्रोजेक्ट्स के साथ काम करने के लिए एक उपयोगी उपकरण है। लैंगचेन सीएलआई स्थापित करने के लिए, इसका उपयोग करें:
pip install langchain-cli
लैंगसर्व आपकी लैंगचेन श्रृंखलाओं को REST API के रूप में तैनात करने के लिए आवश्यक है। यह लैंगचेन सीएलआई के साथ स्थापित हो जाता है।
लैंगचेन को अक्सर मॉडल प्रदाताओं, डेटा स्टोर, एपीआई आदि के साथ एकीकरण की आवश्यकता होती है। इस उदाहरण के लिए, हम ओपनएआई के मॉडल एपीआई का उपयोग करेंगे। OpenAI Python पैकेज का उपयोग करके स्थापित करें:
pip install openai
एपीआई तक पहुंचने के लिए, अपनी ओपनएआई एपीआई कुंजी को पर्यावरण चर के रूप में सेट करें:
export OPENAI_API_KEY="your_api_key"
वैकल्पिक रूप से, कुंजी को सीधे अपने पायथन वातावरण में पास करें:
import os
os.environ['OPENAI_API_KEY'] = 'your_api_key'
लैंगचेन मॉड्यूल के माध्यम से भाषा मॉडल अनुप्रयोगों के निर्माण की अनुमति देता है। ये मॉड्यूल या तो अकेले खड़े हो सकते हैं या जटिल उपयोग के मामलों के लिए बनाए जा सकते हैं। ये मॉड्यूल हैं -
- मॉडल I/O: विभिन्न भाषा मॉडलों के साथ बातचीत की सुविधा प्रदान करता है, उनके इनपुट और आउटपुट को कुशलतापूर्वक संभालता है।
- बहाली: एप्लिकेशन-विशिष्ट डेटा तक पहुंच और उसके साथ इंटरेक्शन को सक्षम बनाता है, जो गतिशील डेटा उपयोग के लिए महत्वपूर्ण है।
- एजेंटों: निर्णय लेने की क्षमताओं को बढ़ाते हुए, उच्च-स्तरीय निर्देशों के आधार पर उपयुक्त उपकरणों का चयन करने के लिए अनुप्रयोगों को सशक्त बनाना।
- चेन: पूर्व-परिभाषित, पुन: प्रयोज्य रचनाएँ प्रदान करता है जो अनुप्रयोग विकास के लिए बिल्डिंग ब्लॉक्स के रूप में काम करती हैं।
- याद: कई श्रृंखला निष्पादनों में एप्लिकेशन स्थिति को बनाए रखता है, जो संदर्भ-जागरूक इंटरैक्शन के लिए आवश्यक है।
प्रत्येक मॉड्यूल विशिष्ट विकास आवश्यकताओं को लक्षित करता है, जिससे लैंगचेन उन्नत भाषा मॉडल एप्लिकेशन बनाने के लिए एक व्यापक टूलकिट बन जाता है।
उपरोक्त घटकों के साथ, हमारे पास यह भी है लैंगचेन अभिव्यक्ति भाषा (एलसीईएल), जो आसानी से मॉड्यूल को एक साथ संकलित करने का एक घोषणात्मक तरीका है, और यह एक सार्वभौमिक रननेबल इंटरफ़ेस का उपयोग करके घटकों की श्रृंखला को सक्षम बनाता है।
एलसीईएल कुछ इस तरह दिखता है -
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import BaseOutputParser # Example chain
chain = ChatPromptTemplate() | ChatOpenAI() | CustomOutputParser()
अब जब हमने मूल बातें कवर कर ली हैं, तो हम इसे जारी रखेंगे:
- प्रत्येक लैंगचैन मॉड्यूल के बारे में विस्तार से जानें।
- लैंगचेन एक्सप्रेशन लैंग्वेज का उपयोग करना सीखें।
- सामान्य उपयोग के मामलों का पता लगाएं और उन्हें लागू करें।
- लैंगसर्व के साथ एक संपूर्ण एप्लिकेशन परिनियोजित करें।
- डिबगिंग, परीक्षण और निगरानी के लिए लैंगस्मिथ की जाँच करें।
चलो शुरू हो जाओ!
मॉड्यूल I: मॉडल I/O
लैंगचेन में, किसी भी एप्लिकेशन का मुख्य तत्व भाषा मॉडल के इर्द-गिर्द घूमता है। यह मॉड्यूल किसी भी भाषा मॉडल के साथ प्रभावी ढंग से इंटरफ़ेस करने के लिए आवश्यक बिल्डिंग ब्लॉक प्रदान करता है, जो निर्बाध एकीकरण और संचार सुनिश्चित करता है।
मॉडल I/O के प्रमुख घटक
- एलएलएम और चैट मॉडल (पर्यायवाची रूप से प्रयुक्त):
- एलएलएम:
- परिभाषा: शुद्ध पाठ पूर्णता मॉडल।
- इनपुट / आउटपुट: एक टेक्स्ट स्ट्रिंग को इनपुट के रूप में लें और एक टेक्स्ट स्ट्रिंग को आउटपुट के रूप में लौटाएँ।
- चैट मॉडल
- एलएलएम:
- परिभाषा: मॉडल जो आधार के रूप में भाषा मॉडल का उपयोग करते हैं लेकिन इनपुट और आउटपुट स्वरूपों में भिन्न होते हैं।
- इनपुट / आउटपुट: चैट संदेशों की सूची को इनपुट के रूप में स्वीकार करें और एक चैट संदेश लौटाएँ।
- संकेतों: मॉडल इनपुट को टेम्प्लेटाइज़ करें, गतिशील रूप से चुनें और प्रबंधित करें। लचीले और संदर्भ-विशिष्ट संकेतों के निर्माण की अनुमति देता है जो भाषा मॉडल की प्रतिक्रियाओं का मार्गदर्शन करते हैं।
- आउटपुट पार्सर्स: मॉडल आउटपुट से जानकारी निकालें और प्रारूपित करें। भाषा मॉडल के कच्चे आउटपुट को संरचित डेटा या एप्लिकेशन के लिए आवश्यक विशिष्ट प्रारूपों में परिवर्तित करने के लिए उपयोगी।
एलएलएम
ओपनएआई, कोहेयर और हगिंग फेस जैसे बड़े भाषा मॉडल (एलएलएम) के साथ लैंगचेन का एकीकरण इसकी कार्यक्षमता का एक मूलभूत पहलू है। लैंगचेन स्वयं एलएलएम की मेजबानी नहीं करता है लेकिन विभिन्न एलएलएम के साथ बातचीत करने के लिए एक समान इंटरफ़ेस प्रदान करता है।
यह अनुभाग लैंगचेन में ओपनएआई एलएलएम रैपर का उपयोग करने का एक सिंहावलोकन प्रदान करता है, जो अन्य एलएलएम प्रकारों पर भी लागू होता है। हमने इसे पहले ही "आरंभ करना" अनुभाग में स्थापित कर दिया है। आइए एलएलएम आरंभ करें।
from langchain.llms import OpenAI
llm = OpenAI()
- एलएलएम इसे लागू करते हैं चलने योग्य इंटरफ़ेस, का बुनियादी निर्माण खंड लैंगचेन अभिव्यक्ति भाषा (एलसीईएल). इसका मतलब है कि वे समर्थन करते हैं
invoke
,ainvoke
,stream
,astream
,batch
,abatch
,astream_log
कहता है। - एलएलएम स्वीकार करते हैं तार इनपुट के रूप में, या ऑब्जेक्ट जिन्हें स्ट्रिंग प्रॉम्प्ट के लिए बाध्य किया जा सकता है, जिनमें शामिल हैं
List[BaseMessage]
औरPromptValue
. (इन पर बाद में और अधिक जानकारी)
आइए कुछ उदाहरण देखें।
response = llm.invoke("List the seven wonders of the world.")
print(response)
आप टेक्स्ट प्रतिक्रिया को स्ट्रीम करने के लिए वैकल्पिक रूप से स्ट्रीम विधि को कॉल कर सकते हैं।
for chunk in llm.stream("Where were the 2012 Olympics held?"): print(chunk, end="", flush=True)
चैट मॉडल
चैट मॉडल के साथ लैंगचेन का एकीकरण, भाषा मॉडल की एक विशेष विविधता, इंटरैक्टिव चैट एप्लिकेशन बनाने के लिए आवश्यक है। जबकि वे आंतरिक रूप से भाषा मॉडल का उपयोग करते हैं, चैट मॉडल इनपुट और आउटपुट के रूप में चैट संदेशों के आसपास केंद्रित एक अलग इंटरफ़ेस प्रस्तुत करते हैं। यह अनुभाग लैंगचेन में ओपनएआई के चैट मॉडल का उपयोग करने का विस्तृत अवलोकन प्रदान करता है।
from langchain.chat_models import ChatOpenAI
chat = ChatOpenAI()
लैंगचेन में चैट मॉडल विभिन्न संदेश प्रकारों के साथ काम करते हैं जैसे AIMessage
, HumanMessage
, SystemMessage
, FunctionMessage
, तथा ChatMessage
(एक मनमाना भूमिका पैरामीटर के साथ)। आम तौर पर, HumanMessage
, AIMessage
, तथा SystemMessage
सबसे अधिक उपयोग किये जाते हैं।
चैट मॉडल मुख्य रूप से स्वीकार करते हैं List[BaseMessage]
इनपुट के रूप में. स्ट्रिंग्स को परिवर्तित किया जा सकता है HumanMessage
, तथा PromptValue
भी समर्थित है।
from langchain.schema.messages import HumanMessage, SystemMessage
messages = [ SystemMessage(content="You are Micheal Jordan."), HumanMessage(content="Which shoe manufacturer are you associated with?"),
]
response = chat.invoke(messages)
print(response.content)
संकेतों
प्रासंगिक और सुसंगत आउटपुट उत्पन्न करने के लिए भाषा मॉडल का मार्गदर्शन करने में संकेत आवश्यक हैं। वे सरल निर्देशों से लेकर जटिल कुछ-शॉट उदाहरणों तक हो सकते हैं। लैंगचेन में, कई समर्पित कक्षाओं और कार्यों के लिए धन्यवाद, संकेतों को संभालना एक बहुत ही सुव्यवस्थित प्रक्रिया हो सकती है।
लैंगचैन का PromptTemplate
स्ट्रिंग प्रॉम्प्ट बनाने के लिए क्लास एक बहुमुखी उपकरण है। यह Python का उपयोग करता है str.format
वाक्यविन्यास, गतिशील शीघ्र पीढ़ी के लिए अनुमति देता है। आप प्लेसहोल्डर्स के साथ एक टेम्पलेट परिभाषित कर सकते हैं और उन्हें आवश्यकतानुसार विशिष्ट मानों से भर सकते हैं।
from langchain.prompts import PromptTemplate # Simple prompt with placeholders
prompt_template = PromptTemplate.from_template( "Tell me a {adjective} joke about {content}."
) # Filling placeholders to create a prompt
filled_prompt = prompt_template.format(adjective="funny", content="robots")
print(filled_prompt)
चैट मॉडल के लिए, संकेत अधिक संरचित होते हैं, जिनमें विशिष्ट भूमिकाओं वाले संदेश शामिल होते हैं। लैंगचेन ऑफर करता है ChatPromptTemplate
इस उद्देश्य से।
from langchain.prompts import ChatPromptTemplate # Defining a chat prompt with various roles
chat_template = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful AI bot. Your name is {name}."), ("human", "Hello, how are you doing?"), ("ai", "I'm doing well, thanks!"), ("human", "{user_input}"), ]
) # Formatting the chat prompt
formatted_messages = chat_template.format_messages(name="Bob", user_input="What is your name?")
for message in formatted_messages: print(message)
यह दृष्टिकोण गतिशील प्रतिक्रियाओं के साथ इंटरैक्टिव, आकर्षक चैटबॉट के निर्माण की अनुमति देता है।
दोनों PromptTemplate
और ChatPromptTemplate
लैंगचेन एक्सप्रेशन लैंग्वेज (एलसीईएल) के साथ सहजता से एकीकृत करें, जिससे वे बड़े, जटिल वर्कफ़्लो का हिस्सा बन सकें। इस पर हम बाद में और चर्चा करेंगे.
अद्वितीय स्वरूपण या विशिष्ट निर्देशों की आवश्यकता वाले कार्यों के लिए कस्टम प्रॉम्प्ट टेम्पलेट कभी-कभी आवश्यक होते हैं। एक कस्टम प्रॉम्प्ट टेम्प्लेट बनाने में इनपुट वेरिएबल्स और एक कस्टम फ़ॉर्मेटिंग विधि को परिभाषित करना शामिल है। यह लचीलापन लैंगचेन को एप्लिकेशन-विशिष्ट आवश्यकताओं की एक विस्तृत श्रृंखला को पूरा करने की अनुमति देता है। यहाँ और अधिक पढ़ें।
लैंगचेन कुछ-शॉट प्रॉम्प्टिंग का भी समर्थन करता है, जो मॉडल को उदाहरणों से सीखने में सक्षम बनाता है। प्रासंगिक समझ या विशिष्ट पैटर्न की आवश्यकता वाले कार्यों के लिए यह सुविधा महत्वपूर्ण है। कुछ-शॉट प्रॉम्प्ट टेम्प्लेट उदाहरणों के एक सेट से या उदाहरण चयनकर्ता ऑब्जेक्ट का उपयोग करके बनाए जा सकते हैं। यहाँ और अधिक पढ़ें।
आउटपुट पार्सर्स
लैंगचैन में आउटपुट पार्सर एक महत्वपूर्ण भूमिका निभाते हैं, जो उपयोगकर्ताओं को भाषा मॉडल द्वारा उत्पन्न प्रतिक्रियाओं की संरचना करने में सक्षम बनाता है। इस अनुभाग में, हम आउटपुट पार्सर की अवधारणा का पता लगाएंगे और लैंगचैन के पाइडेंटिकऑटपुटपार्सर, सिंपलजेसनआउटपुटपार्सर, कॉमासेपरेटेडलिस्टऑटपुटपार्सर, डेटटाइमआउटपुटपार्सर और एक्सएमएलआउटपुटपार्सर का उपयोग करके कोड उदाहरण प्रदान करेंगे।
पाइडेंटिकआउटपुट पार्सर
लैंगचैन पाइडेंटिक डेटा संरचनाओं में प्रतिक्रियाओं को पार्स करने के लिए पाइडेंटिकआउटपुट पार्सर प्रदान करता है। इसका उपयोग कैसे करें इसका चरण-दर-चरण उदाहरण नीचे दिया गया है:
from typing import List
from langchain.llms import OpenAI
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.pydantic_v1 import BaseModel, Field, validator # Initialize the language model
model = OpenAI(model_name="text-davinci-003", temperature=0.0) # Define your desired data structure using Pydantic
class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field # Set up a PydanticOutputParser
parser = PydanticOutputParser(pydantic_object=Joke) # Create a prompt with format instructions
prompt = PromptTemplate( template="Answer the user query.n{format_instructions}n{query}n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},
) # Define a query to prompt the language model
query = "Tell me a joke." # Combine prompt, model, and parser to get structured output
prompt_and_model = prompt | model
output = prompt_and_model.invoke({"query": query}) # Parse the output using the parser
parsed_result = parser.invoke(output) # The result is a structured object
print(parsed_result)
उत्पादन हो जाएगा:
SimpleJsonOutputParser
जब आप JSON-जैसे आउटपुट को पार्स करना चाहते हैं तो लैंगचैन के SimpleJsonOutputParser का उपयोग किया जाता है। यहाँ एक उदाहरण है:
from langchain.output_parsers.json import SimpleJsonOutputParser # Create a JSON prompt
json_prompt = PromptTemplate.from_template( "Return a JSON object with `birthdate` and `birthplace` key that answers the following question: {question}"
) # Initialize the JSON parser
json_parser = SimpleJsonOutputParser() # Create a chain with the prompt, model, and parser
json_chain = json_prompt | model | json_parser # Stream through the results
result_list = list(json_chain.stream({"question": "When and where was Elon Musk born?"})) # The result is a list of JSON-like dictionaries
print(result_list)
अल्पविराम से पृथक सूची आउटपुट पार्सर
जब आप मॉडल प्रतिक्रियाओं से अल्पविराम से अलग की गई सूचियाँ निकालना चाहते हैं तो CommaSeparatedListOutputParser उपयोगी होता है। यहाँ एक उदाहरण है:
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI # Initialize the parser
output_parser = CommaSeparatedListOutputParser() # Create format instructions
format_instructions = output_parser.get_format_instructions() # Create a prompt to request a list
prompt = PromptTemplate( template="List five {subject}.n{format_instructions}", input_variables=["subject"], partial_variables={"format_instructions": format_instructions}
) # Define a query to prompt the model
query = "English Premier League Teams" # Generate the output
output = model(prompt.format(subject=query)) # Parse the output using the parser
parsed_result = output_parser.parse(output) # The result is a list of items
print(parsed_result)
दिनांकसमयआउटपुटपार्सर
लैंगचैन का DatetimeOutputParser डेटाटाइम जानकारी को पार्स करने के लिए डिज़ाइन किया गया है। इसका उपयोग कैसे करें यहां बताया गया है:
from langchain.prompts import PromptTemplate
from langchain.output_parsers import DatetimeOutputParser
from langchain.chains import LLMChain
from langchain.llms import OpenAI # Initialize the DatetimeOutputParser
output_parser = DatetimeOutputParser() # Create a prompt with format instructions
template = """
Answer the user's question:
{question}
{format_instructions} """ prompt = PromptTemplate.from_template( template, partial_variables={"format_instructions": output_parser.get_format_instructions()},
) # Create a chain with the prompt and language model
chain = LLMChain(prompt=prompt, llm=OpenAI()) # Define a query to prompt the model
query = "when did Neil Armstrong land on the moon in terms of GMT?" # Run the chain
output = chain.run(query) # Parse the output using the datetime parser
parsed_result = output_parser.parse(output) # The result is a datetime object
print(parsed_result)
ये उदाहरण दिखाते हैं कि कैसे लैंगचैन के आउटपुट पार्सर्स का उपयोग विभिन्न प्रकार की मॉडल प्रतिक्रियाओं की संरचना के लिए किया जा सकता है, जिससे उन्हें विभिन्न अनुप्रयोगों और प्रारूपों के लिए उपयुक्त बनाया जा सके। लैंगचैन में भाषा मॉडल आउटपुट की उपयोगिता और व्याख्याशीलता को बढ़ाने के लिए आउटपुट पार्सर एक मूल्यवान उपकरण है।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
मॉड्यूल II: पुनर्प्राप्ति
लैंगचेन में पुनर्प्राप्ति उन अनुप्रयोगों में महत्वपूर्ण भूमिका निभाती है जिनके लिए उपयोगकर्ता-विशिष्ट डेटा की आवश्यकता होती है, जो मॉडल के प्रशिक्षण सेट में शामिल नहीं है। रिट्रीवल ऑगमेंटेड जेनरेशन (आरएजी) के रूप में जानी जाने वाली इस प्रक्रिया में बाहरी डेटा प्राप्त करना और इसे भाषा मॉडल की पीढ़ी प्रक्रिया में एकीकृत करना शामिल है। लैंगचेन सरल और जटिल दोनों अनुप्रयोगों को पूरा करते हुए, इस प्रक्रिया को सुविधाजनक बनाने के लिए उपकरणों और कार्यात्मकताओं का एक व्यापक सूट प्रदान करता है।
लैंगचेन घटकों की एक श्रृंखला के माध्यम से पुनर्प्राप्ति प्राप्त करता है जिस पर हम एक-एक करके चर्चा करेंगे।
दस्तावेज़ लोडर
लैंगचेन में दस्तावेज़ लोडर विभिन्न स्रोतों से डेटा निकालने में सक्षम बनाते हैं। 100 से अधिक लोडर उपलब्ध होने के साथ, वे कई प्रकार के दस्तावेज़ प्रकारों, ऐप्स और स्रोतों (निजी एस3 बकेट, सार्वजनिक वेबसाइट, डेटाबेस) का समर्थन करते हैं।
आप अपनी आवश्यकताओं के आधार पर दस्तावेज़ लोडर चुन सकते हैं यहाँ उत्पन्न करें.
ये सभी लोडर डेटा ग्रहण करते हैं दस्तावेज़ कक्षाएं. हम बाद में सीखेंगे कि दस्तावेज़ कक्षाओं में शामिल डेटा का उपयोग कैसे करें।
टेक्स्ट फ़ाइल लोडर: एक सरल लोड करें .txt
एक दस्तावेज़ में फ़ाइल करें.
from langchain.document_loaders import TextLoader loader = TextLoader("./sample.txt")
document = loader.load()
सीएसवी लोडर: किसी दस्तावेज़ में CSV फ़ाइल लोड करें.
from langchain.document_loaders.csv_loader import CSVLoader loader = CSVLoader(file_path='./example_data/sample.csv')
documents = loader.load()
हम फ़ील्ड नाम निर्दिष्ट करके पार्सिंग को अनुकूलित करना चुन सकते हैं -
loader = CSVLoader(file_path='./example_data/mlb_teams_2012.csv', csv_args={ 'delimiter': ',', 'quotechar': '"', 'fieldnames': ['MLB Team', 'Payroll in millions', 'Wins']
})
documents = loader.load()
पीडीएफ लोडर: लैंगचेन में पीडीएफ लोडर पीडीएफ फाइलों से सामग्री को पार्स करने और निकालने के लिए विभिन्न तरीके प्रदान करते हैं। प्रत्येक लोडर विभिन्न आवश्यकताओं को पूरा करता है और विभिन्न अंतर्निहित पुस्तकालयों का उपयोग करता है। नीचे प्रत्येक लोडर के लिए विस्तृत उदाहरण दिए गए हैं।
PyPDFLoader का उपयोग बुनियादी पीडीएफ पार्सिंग के लिए किया जाता है।
from langchain.document_loaders import PyPDFLoader loader = PyPDFLoader("example_data/layout-parser-paper.pdf")
pages = loader.load_and_split()
MathPixLoader गणितीय सामग्री और आरेख निकालने के लिए आदर्श है।
from langchain.document_loaders import MathpixPDFLoader loader = MathpixPDFLoader("example_data/math-content.pdf")
data = loader.load()
PyMuPDFLoader तेज़ है और इसमें विस्तृत मेटाडेटा निष्कर्षण शामिल है।
from langchain.document_loaders import PyMuPDFLoader loader = PyMuPDFLoader("example_data/layout-parser-paper.pdf")
data = loader.load() # Optionally pass additional arguments for PyMuPDF's get_text() call
data = loader.load(option="text")
पीडीएफमाइनर लोडर का उपयोग टेक्स्ट निष्कर्षण पर अधिक बारीक नियंत्रण के लिए किया जाता है।
from langchain.document_loaders import PDFMinerLoader loader = PDFMinerLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
AmazonTextractPDFParser OCR और अन्य उन्नत पीडीएफ पार्सिंग सुविधाओं के लिए AWS टेक्स्टट्रैक्ट का उपयोग करता है।
from langchain.document_loaders import AmazonTextractPDFLoader # Requires AWS account and configuration
loader = AmazonTextractPDFLoader("example_data/complex-layout.pdf")
documents = loader.load()
PDFMinerPDFasHTMLLoader सिमेंटिक पार्सिंग के लिए पीडीएफ से HTML उत्पन्न करता है।
from langchain.document_loaders import PDFMinerPDFasHTMLLoader loader = PDFMinerPDFasHTMLLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
PDFPlumberLoader विस्तृत मेटाडेटा प्रदान करता है और प्रति पृष्ठ एक दस्तावेज़ का समर्थन करता है।
from langchain.document_loaders import PDFPlumberLoader loader = PDFPlumberLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
एकीकृत लोडर: लैंगचेन आपके ऐप्स (जैसे स्लैक, सिग्मा, नोशन, कॉन्फ्लुएंस, गूगल ड्राइव और कई अन्य) और डेटाबेस से सीधे डेटा लोड करने और एलएलएम अनुप्रयोगों में उनका उपयोग करने के लिए विभिन्न प्रकार के कस्टम लोडर प्रदान करता है।
पूरी सूची है यहाँ उत्पन्न करें.
इसे स्पष्ट करने के लिए नीचे कुछ उदाहरण दिए गए हैं -
उदाहरण I - सुस्त
स्लैक, एक व्यापक रूप से उपयोग किया जाने वाला इंस्टेंट मैसेजिंग प्लेटफ़ॉर्म है, जिसे एलएलएम वर्कफ़्लो और एप्लिकेशन में एकीकृत किया जा सकता है।
- अपने स्लैक वर्कस्पेस प्रबंधन पृष्ठ पर जाएँ।
- पर जाए
{your_slack_domain}.slack.com/services/export
. - वांछित दिनांक सीमा का चयन करें और निर्यात आरंभ करें।
- निर्यात तैयार होने पर स्लैक ईमेल और डीएम के माध्यम से सूचित करता है।
- निर्यात का परिणाम है a
.zip
फ़ाइल आपके डाउनलोड फ़ोल्डर या आपके निर्दिष्ट डाउनलोड पथ में स्थित है। - डाउनलोड किए गए का पथ निर्दिष्ट करें
.zip
फ़ाइलLOCAL_ZIPFILE
. - उपयोग
SlackDirectoryLoader
सेlangchain.document_loaders
पैकेज.
from langchain.document_loaders import SlackDirectoryLoader SLACK_WORKSPACE_URL = "https://xxx.slack.com" # Replace with your Slack URL
LOCAL_ZIPFILE = "" # Path to the Slack zip file loader = SlackDirectoryLoader(LOCAL_ZIPFILE, SLACK_WORKSPACE_URL)
docs = loader.load()
print(docs)
उदाहरण II - फिग्मा
फ़िग्मा, इंटरफ़ेस डिज़ाइन के लिए एक लोकप्रिय उपकरण, डेटा एकीकरण के लिए एक REST API प्रदान करता है।
- यूआरएल प्रारूप से फिग्मा फ़ाइल कुंजी प्राप्त करें:
https://www.figma.com/file/{filekey}/sampleFilename
. - नोड आईडी यूआरएल पैरामीटर में पाए जाते हैं
?node-id={node_id}
. - निर्देशों का पालन करते हुए एक एक्सेस टोकन जेनरेट करें फिग्मा सहायता केंद्र.
- RSI
FigmaFileLoader
से कक्षाlangchain.document_loaders.figma
फिग्मा डेटा लोड करने के लिए उपयोग किया जाता है। - विभिन्न लैंगचेन मॉड्यूल जैसे
CharacterTextSplitter
,ChatOpenAI
आदि को प्रसंस्करण के लिए नियोजित किया जाता है।
import os
from langchain.document_loaders.figma import FigmaFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.chat_models import ChatOpenAI
from langchain.indexes import VectorstoreIndexCreator
from langchain.chains import ConversationChain, LLMChain
from langchain.memory import ConversationBufferWindowMemory
from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate figma_loader = FigmaFileLoader( os.environ.get("ACCESS_TOKEN"), os.environ.get("NODE_IDS"), os.environ.get("FILE_KEY"),
) index = VectorstoreIndexCreator().from_loaders([figma_loader])
figma_doc_retriever = index.vectorstore.as_retriever()
- RSI
generate_code
फ़ंक्शन HTML/CSS कोड बनाने के लिए फिग्मा डेटा का उपयोग करता है। - यह GPT-आधारित मॉडल के साथ एक टेम्पलेटेड वार्तालाप को नियोजित करता है।
def generate_code(human_input): # Template for system and human prompts system_prompt_template = "Your coding instructions..." human_prompt_template = "Code the {text}. Ensure it's mobile responsive" # Creating prompt templates system_message_prompt = SystemMessagePromptTemplate.from_template(system_prompt_template) human_message_prompt = HumanMessagePromptTemplate.from_template(human_prompt_template) # Setting up the AI model gpt_4 = ChatOpenAI(temperature=0.02, model_name="gpt-4") # Retrieving relevant documents relevant_nodes = figma_doc_retriever.get_relevant_documents(human_input) # Generating and formatting the prompt conversation = [system_message_prompt, human_message_prompt] chat_prompt = ChatPromptTemplate.from_messages(conversation) response = gpt_4(chat_prompt.format_prompt(context=relevant_nodes, text=human_input).to_messages()) return response # Example usage
response = generate_code("page top header")
print(response.content)
- RSI
generate_code
फ़ंक्शन, निष्पादित होने पर, फिगमा डिज़ाइन इनपुट के आधार पर HTML/CSS कोड लौटाता है।
आइए अब कुछ दस्तावेज़ सेट बनाने के लिए अपने ज्ञान का उपयोग करें।
हम सबसे पहले एक पीडीएफ, बीसीजी वार्षिक स्थिरता रिपोर्ट लोड करते हैं।
हम इसके लिए PyPDFLoader का उपयोग करते हैं।
from langchain.document_loaders import PyPDFLoader loader = PyPDFLoader("bcg-2022-annual-sustainability-report-apr-2023.pdf")
pdfpages = loader.load_and_split()
अब हम एयरटेबल से डेटा ग्रहण करेंगे। हमारे पास एक एयरटेबल है जिसमें विभिन्न ओसीआर और डेटा निष्कर्षण मॉडल के बारे में जानकारी है -
आइए इसके लिए AirtableLoader का उपयोग करें, जो एकीकृत लोडर की सूची में पाया जाता है।
from langchain.document_loaders import AirtableLoader api_key = "XXXXX"
base_id = "XXXXX"
table_id = "XXXXX" loader = AirtableLoader(api_key, table_id, base_id)
airtabledocs = loader.load()
आइए अब आगे बढ़ें और सीखें कि इन दस्तावेज़ वर्गों का उपयोग कैसे करें।
दस्तावेज़ ट्रांसफार्मर
लैंगचेन में दस्तावेज़ ट्रांसफार्मर दस्तावेज़ों में हेरफेर करने के लिए डिज़ाइन किए गए आवश्यक उपकरण हैं, जिन्हें हमने अपने पिछले उपधारा में बनाया था।
उनका उपयोग लंबे दस्तावेज़ों को छोटे टुकड़ों में विभाजित करने, संयोजन करने और फ़िल्टर करने जैसे कार्यों के लिए किया जाता है, जो किसी मॉडल की संदर्भ विंडो में दस्तावेज़ों को अनुकूलित करने या विशिष्ट एप्लिकेशन आवश्यकताओं को पूरा करने के लिए महत्वपूर्ण हैं।
ऐसा ही एक उपकरण है रिकर्सिव कैरेक्टरटेक्स्टस्प्लिटर, एक बहुमुखी टेक्स्ट स्प्लिटर जो विभाजन के लिए वर्ण सूची का उपयोग करता है। यह चंक साइज, ओवरलैप और शुरुआती इंडेक्स जैसे मापदंडों की अनुमति देता है। पायथन में इसका उपयोग कैसे किया जाता है इसका एक उदाहरण यहां दिया गया है:
from langchain.text_splitter import RecursiveCharacterTextSplitter state_of_the_union = "Your long text here..." text_splitter = RecursiveCharacterTextSplitter( chunk_size=100, chunk_overlap=20, length_function=len, add_start_index=True,
) texts = text_splitter.create_documents([state_of_the_union])
print(texts[0])
print(texts[1])
एक अन्य उपकरण कैरेक्टरटेक्स्टस्प्लिटर है, जो एक निर्दिष्ट वर्ण के आधार पर पाठ को विभाजित करता है और इसमें खंड आकार और ओवरलैप के लिए नियंत्रण शामिल होता है:
from langchain.text_splitter import CharacterTextSplitter text_splitter = CharacterTextSplitter( separator="nn", chunk_size=1000, chunk_overlap=200, length_function=len, is_separator_regex=False,
) texts = text_splitter.create_documents([state_of_the_union])
print(texts[0])
HTMLHeaderTextSplitter को सिमेंटिक संरचना को बनाए रखते हुए, हेडर टैग के आधार पर HTML सामग्री को विभाजित करने के लिए डिज़ाइन किया गया है:
from langchain.text_splitter import HTMLHeaderTextSplitter html_string = "Your HTML content here..."
headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")] html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
html_header_splits = html_splitter.split_text(html_string)
print(html_header_splits[0])
HTMLHeaderTextSplitter को पाइपलाइन स्प्लिटर जैसे किसी अन्य स्प्लिटर के साथ संयोजित करके अधिक जटिल हेरफेर प्राप्त किया जा सकता है:
from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter url = "https://example.com"
headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")]
html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
html_header_splits = html_splitter.split_text_from_url(url) chunk_size = 500
text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size)
splits = text_splitter.split_documents(html_header_splits)
print(splits[0])
लैंगचेन विभिन्न प्रोग्रामिंग भाषाओं के लिए विशिष्ट स्प्लिटर भी प्रदान करता है, जैसे पायथन कोड स्प्लिटर और जावास्क्रिप्ट कोड स्प्लिटर:
from langchain.text_splitter import RecursiveCharacterTextSplitter, Language python_code = """
def hello_world(): print("Hello, World!")
hello_world() """ python_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PYTHON, chunk_size=50
)
python_docs = python_splitter.create_documents([python_code])
print(python_docs[0]) js_code = """
function helloWorld() { console.log("Hello, World!");
}
helloWorld(); """ js_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.JS, chunk_size=60
)
js_docs = js_splitter.create_documents([js_code])
print(js_docs[0])
टोकन गणना के आधार पर पाठ को विभाजित करने के लिए, जो टोकन सीमा वाले भाषा मॉडल के लिए उपयोगी है, टोकनटेक्स्टस्प्लिटर का उपयोग किया जाता है:
from langchain.text_splitter import TokenTextSplitter text_splitter = TokenTextSplitter(chunk_size=10)
texts = text_splitter.split_text(state_of_the_union)
print(texts[0])
अंत में, LongContextReorder लंबे संदर्भों के कारण मॉडलों में प्रदर्शन में गिरावट को रोकने के लिए दस्तावेज़ों को पुन: व्यवस्थित करता है:
from langchain.document_transformers import LongContextReorder reordering = LongContextReorder()
reordered_docs = reordering.transform_documents(docs)
print(reordered_docs[0])
ये उपकरण लैंगचेन में दस्तावेज़ों को बदलने के विभिन्न तरीकों को प्रदर्शित करते हैं, सरल पाठ विभाजन से लेकर जटिल पुनर्क्रमण और भाषा-विशिष्ट विभाजन तक। अधिक गहन और विशिष्ट उपयोग के मामलों के लिए, लैंगचेन दस्तावेज़ीकरण और एकीकरण अनुभाग से परामर्श लिया जाना चाहिए।
हमारे उदाहरणों में, लोडर ने पहले ही हमारे लिए खंडित दस्तावेज़ बना दिए हैं, और यह भाग पहले ही संभाल लिया गया है।
टेक्स्ट एम्बेडिंग मॉडल
लैंगचेन में टेक्स्ट एम्बेडिंग मॉडल ओपनएआई, कोहेयर और हगिंग फेस जैसे विभिन्न एम्बेडिंग मॉडल प्रदाताओं के लिए एक मानकीकृत इंटरफ़ेस प्रदान करते हैं। ये मॉडल टेक्स्ट को वेक्टर अभ्यावेदन में बदल देते हैं, जिससे वेक्टर स्पेस में टेक्स्ट समानता के माध्यम से सिमेंटिक खोज जैसे ऑपरेशन सक्षम हो जाते हैं।
टेक्स्ट एम्बेडिंग मॉडल के साथ आरंभ करने के लिए, आपको आमतौर पर विशिष्ट पैकेज स्थापित करने और एपीआई कुंजी सेट करने की आवश्यकता होती है। हम OpenAI के लिए यह पहले ही कर चुके हैं
लैंगचेन में, embed_documents
विधि का उपयोग कई पाठों को एम्बेड करने के लिए किया जाता है, जो वेक्टर अभ्यावेदन की एक सूची प्रदान करता है। उदाहरण के लिए:
from langchain.embeddings import OpenAIEmbeddings # Initialize the model
embeddings_model = OpenAIEmbeddings() # Embed a list of texts
embeddings = embeddings_model.embed_documents( ["Hi there!", "Oh, hello!", "What's your name?", "My friends call me World", "Hello World!"]
)
print("Number of documents embedded:", len(embeddings))
print("Dimension of each embedding:", len(embeddings[0]))
किसी एकल पाठ, जैसे कि खोज क्वेरी, को एम्बेड करने के लिए embed_query
विधि का प्रयोग किया जाता है. यह किसी क्वेरी की तुलना दस्तावेज़ एम्बेडिंग के सेट से करने के लिए उपयोगी है। उदाहरण के लिए:
from langchain.embeddings import OpenAIEmbeddings # Initialize the model
embeddings_model = OpenAIEmbeddings() # Embed a single query
embedded_query = embeddings_model.embed_query("What was the name mentioned in the conversation?")
print("First five dimensions of the embedded query:", embedded_query[:5])
इन एम्बेडिंग को समझना महत्वपूर्ण है। पाठ का प्रत्येक भाग एक वेक्टर में परिवर्तित हो जाता है, जिसका आयाम उपयोग किए गए मॉडल पर निर्भर करता है। उदाहरण के लिए, OpenAI मॉडल आमतौर पर 1536-आयामी वैक्टर उत्पन्न करते हैं। फिर इन एम्बेडिंग का उपयोग प्रासंगिक जानकारी प्राप्त करने के लिए किया जाता है।
लैंगचेन की एम्बेडिंग कार्यक्षमता ओपनएआई तक सीमित नहीं है बल्कि विभिन्न प्रदाताओं के साथ काम करने के लिए डिज़ाइन की गई है। प्रदाता के आधार पर सेटअप और उपयोग थोड़ा भिन्न हो सकता है, लेकिन टेक्स्ट को वेक्टर स्पेस में एम्बेड करने की मूल अवधारणा वही रहती है। विभिन्न एम्बेडिंग मॉडल प्रदाताओं के साथ उन्नत कॉन्फ़िगरेशन और एकीकरण सहित विस्तृत उपयोग के लिए, एकीकरण अनुभाग में लैंगचेन दस्तावेज़ एक मूल्यवान संसाधन है।
वेक्टर स्टोर
लैंगचेन में वेक्टर स्टोर टेक्स्ट एम्बेडिंग के कुशल भंडारण और खोज का समर्थन करते हैं। लैंगचेन 50 से अधिक वेक्टर स्टोर्स के साथ एकीकृत है, जो उपयोग में आसानी के लिए एक मानकीकृत इंटरफ़ेस प्रदान करता है।
उदाहरण: एंबेडिंग को संग्रहीत करना और खोजना
टेक्स्ट एम्बेड करने के बाद, हम उन्हें वेक्टर स्टोर जैसे में स्टोर कर सकते हैं Chroma
और समानता खोजें करें:
from langchain.vectorstores import Chroma db = Chroma.from_texts(embedded_texts)
similar_texts = db.similarity_search("search query")
आइए हम अपने दस्तावेज़ों के लिए अनुक्रमणिका बनाने के लिए वैकल्पिक रूप से FAISS वेक्टर स्टोर का उपयोग करें।
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS pdfstore = FAISS.from_documents(pdfpages, embedding=OpenAIEmbeddings()) airtablestore = FAISS.from_documents(airtabledocs, embedding=OpenAIEmbeddings())
retrievers
लैंगचेन में रिट्रीवर्स ऐसे इंटरफेस हैं जो एक असंरचित क्वेरी के जवाब में दस्तावेज़ लौटाते हैं। वे वेक्टर स्टोर्स की तुलना में अधिक सामान्य हैं, भंडारण के बजाय पुनर्प्राप्ति पर ध्यान केंद्रित करते हैं। हालाँकि वेक्टर स्टोर्स का उपयोग रिट्रीवर्स की रीढ़ के रूप में किया जा सकता है, अन्य प्रकार के रिट्रीवर्स भी हैं।
क्रोमा रिट्रीवर को सेट करने के लिए, आप सबसे पहले इसका उपयोग करके इंस्टॉल करें pip install chromadb
. फिर, आप पायथन कमांड की एक श्रृंखला का उपयोग करके दस्तावेज़ों को लोड, विभाजित, एम्बेड और पुनर्प्राप्त करते हैं। क्रोमा रिट्रीवर स्थापित करने के लिए यहां एक कोड उदाहरण दिया गया है:
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma full_text = open("state_of_the_union.txt", "r").read()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
texts = text_splitter.split_text(full_text) embeddings = OpenAIEmbeddings()
db = Chroma.from_texts(texts, embeddings)
retriever = db.as_retriever() retrieved_docs = retriever.invoke("What did the president say about Ketanji Brown Jackson?")
print(retrieved_docs[0].page_content)
MultiQueryRetriever उपयोगकर्ता इनपुट क्वेरी के लिए एकाधिक क्वेरी उत्पन्न करके त्वरित ट्यूनिंग को स्वचालित करता है और परिणामों को जोड़ता है। यहां इसके सरल उपयोग का एक उदाहरण दिया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.retrievers.multi_query import MultiQueryRetriever question = "What are the approaches to Task Decomposition?"
llm = ChatOpenAI(temperature=0)
retriever_from_llm = MultiQueryRetriever.from_llm( retriever=db.as_retriever(), llm=llm
) unique_docs = retriever_from_llm.get_relevant_documents(query=question)
print("Number of unique documents:", len(unique_docs))
लैंगचेन में प्रासंगिक संपीड़न क्वेरी के संदर्भ का उपयोग करके पुनर्प्राप्त दस्तावेज़ों को संपीड़ित करता है, यह सुनिश्चित करता है कि केवल प्रासंगिक जानकारी लौटाई जाए। इसमें सामग्री में कमी और कम प्रासंगिक दस्तावेज़ों को फ़िल्टर करना शामिल है। निम्नलिखित कोड उदाहरण दिखाता है कि प्रासंगिक संपीड़न पुनर्प्राप्ति का उपयोग कैसे करें:
from langchain.llms import OpenAI
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor llm = OpenAI(temperature=0)
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=retriever) compressed_docs = compression_retriever.get_relevant_documents("What did the president say about Ketanji Jackson Brown")
print(compressed_docs[0].page_content)
एन्सेम्बलरिट्रीवर बेहतर प्रदर्शन प्राप्त करने के लिए विभिन्न पुनर्प्राप्ति एल्गोरिदम को जोड़ता है। BM25 और FAISS रिट्रीवर्स के संयोजन का एक उदाहरण निम्नलिखित कोड में दिखाया गया है:
from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain.vectorstores import FAISS bm25_retriever = BM25Retriever.from_texts(doc_list).set_k(2)
faiss_vectorstore = FAISS.from_texts(doc_list, OpenAIEmbeddings())
faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": 2}) ensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]
) docs = ensemble_retriever.get_relevant_documents("apples")
print(docs[0].page_content)
लैंगचेन में मल्टीवेक्टर रिट्रीवर प्रति दस्तावेज़ कई वैक्टर के साथ दस्तावेज़ों को क्वेरी करने की अनुमति देता है, जो दस्तावेज़ के भीतर विभिन्न अर्थ संबंधी पहलुओं को कैप्चर करने के लिए उपयोगी है। एकाधिक वैक्टर बनाने की विधियों में छोटे-छोटे हिस्सों में विभाजित करना, सारांशित करना या काल्पनिक प्रश्न उत्पन्न करना शामिल है। दस्तावेज़ों को छोटे टुकड़ों में विभाजित करने के लिए, निम्नलिखित पायथन कोड का उपयोग किया जा सकता है:
python
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.storage import InMemoryStore
from langchain.document_loaders from TextLoader
import uuid loaders = [TextLoader("file1.txt"), TextLoader("file2.txt")]
docs = [doc for loader in loaders for doc in loader.load()]
text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000)
docs = text_splitter.split_documents(docs) vectorstore = Chroma(collection_name="full_documents", embedding_function=OpenAIEmbeddings())
store = InMemoryStore()
id_key = "doc_id"
retriever = MultiVectorRetriever(vectorstore=vectorstore, docstore=store, id_key=id_key) doc_ids = [str(uuid.uuid4()) for _ in docs]
child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
sub_docs = [sub_doc for doc in docs for sub_doc in child_text_splitter.split_documents([doc])]
for sub_doc in sub_docs: sub_doc.metadata[id_key] = doc_ids[sub_docs.index(sub_doc)] retriever.vectorstore.add_documents(sub_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
अधिक केंद्रित सामग्री प्रतिनिधित्व के कारण बेहतर पुनर्प्राप्ति के लिए सारांश तैयार करना एक अन्य तरीका है। यहां सारांश तैयार करने का एक उदाहरण दिया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.document import Document chain = (lambda x: x.page_content) | ChatPromptTemplate.from_template("Summarize the following document:nn{doc}") | ChatOpenAI(max_retries=0) | StrOutputParser()
summaries = chain.batch(docs, {"max_concurrency": 5}) summary_docs = [Document(page_content=s, metadata={id_key: doc_ids[i]}) for i, s in enumerate(summaries)]
retriever.vectorstore.add_documents(summary_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
एलएलएम का उपयोग करके प्रत्येक दस्तावेज़ के लिए प्रासंगिक काल्पनिक प्रश्न उत्पन्न करना एक अन्य दृष्टिकोण है। यह निम्नलिखित कोड के साथ किया जा सकता है:
functions = [{"name": "hypothetical_questions", "parameters": {"questions": {"type": "array", "items": {"type": "string"}}}}]
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser chain = (lambda x: x.page_content) | ChatPromptTemplate.from_template("Generate 3 hypothetical questions:nn{doc}") | ChatOpenAI(max_retries=0).bind(functions=functions, function_call={"name": "hypothetical_questions"}) | JsonKeyOutputFunctionsParser(key_name="questions")
hypothetical_questions = chain.batch(docs, {"max_concurrency": 5}) question_docs = [Document(page_content=q, metadata={id_key: doc_ids[i]}) for i, questions in enumerate(hypothetical_questions) for q in questions]
retriever.vectorstore.add_documents(question_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
पेरेंट डॉक्यूमेंट रिट्रीवर एक अन्य रिट्रीवर है जो छोटे टुकड़ों को संग्रहीत करके और उनके बड़े मूल दस्तावेज़ों को पुनर्प्राप्त करके एम्बेडिंग सटीकता और संदर्भ प्रतिधारण के बीच संतुलन बनाता है। इसका कार्यान्वयन इस प्रकार है:
from langchain.retrievers import ParentDocumentRetriever loaders = [TextLoader("file1.txt"), TextLoader("file2.txt")]
docs = [doc for loader in loaders for doc in loader.load()] child_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
vectorstore = Chroma(collection_name="full_documents", embedding_function=OpenAIEmbeddings())
store = InMemoryStore()
retriever = ParentDocumentRetriever(vectorstore=vectorstore, docstore=store, child_splitter=child_splitter) retriever.add_documents(docs, ids=None) retrieved_docs = retriever.get_relevant_documents("query")
एक स्व-क्वेरींग रिट्रीवर प्राकृतिक भाषा इनपुट से संरचित क्वेरी बनाता है और उन्हें अपने अंतर्निहित वेक्टरस्टोर पर लागू करता है। इसका कार्यान्वयन निम्नलिखित कोड में दिखाया गया है:
from langchain.chat_models from ChatOpenAI
from langchain.chains.query_constructor.base from AttributeInfo
from langchain.retrievers.self_query.base from SelfQueryRetriever metadata_field_info = [AttributeInfo(name="genre", description="...", type="string"), ...]
document_content_description = "Brief summary of a movie"
llm = ChatOpenAI(temperature=0) retriever = SelfQueryRetriever.from_llm(llm, vectorstore, document_content_description, metadata_field_info) retrieved_docs = retriever.invoke("query")
WebResearchRetriever किसी दी गई क्वेरी के आधार पर वेब अनुसंधान करता है -
from langchain.retrievers.web_research import WebResearchRetriever # Initialize components
llm = ChatOpenAI(temperature=0)
search = GoogleSearchAPIWrapper()
vectorstore = Chroma(embedding_function=OpenAIEmbeddings()) # Instantiate WebResearchRetriever
web_research_retriever = WebResearchRetriever.from_llm(vectorstore=vectorstore, llm=llm, search=search) # Retrieve documents
docs = web_research_retriever.get_relevant_documents("query")
हमारे उदाहरणों के लिए, हम अपने वेक्टर स्टोर ऑब्जेक्ट के हिस्से के रूप में पहले से ही लागू मानक रिट्रीवर का उपयोग इस प्रकार कर सकते हैं -
अब हम पुनर्प्राप्तिकर्ताओं से पूछताछ कर सकते हैं। हमारी क्वेरी का आउटपुट क्वेरी से प्रासंगिक दस्तावेज़ ऑब्जेक्ट होगा। इनका उपयोग अंततः आगे के अनुभागों में प्रासंगिक प्रतिक्रियाएँ बनाने के लिए किया जाएगा।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
मॉड्यूल III: एजेंट
लैंगचेन ने "एजेंट" नामक एक शक्तिशाली अवधारणा पेश की है जो श्रृंखलाओं के विचार को एक नए स्तर पर ले जाती है। एजेंट निष्पादित किए जाने वाले कार्यों के अनुक्रम को गतिशील रूप से निर्धारित करने के लिए भाषा मॉडल का लाभ उठाते हैं, जिससे वे अविश्वसनीय रूप से बहुमुखी और अनुकूली बन जाते हैं। पारंपरिक श्रृंखलाओं के विपरीत, जहां क्रियाओं को कोड में हार्डकोड किया जाता है, एजेंट भाषा मॉडल को तर्क इंजन के रूप में नियोजित करते हैं ताकि यह तय किया जा सके कि कौन सी क्रियाएं करनी हैं और किस क्रम में।
एजेंट निर्णय लेने के लिए जिम्मेदार मुख्य घटक है। यह एक विशिष्ट उद्देश्य को प्राप्त करने के लिए अगले चरणों को निर्धारित करने के लिए भाषा मॉडल की शक्ति और संकेत का उपयोग करता है। किसी एजेंट के इनपुट में आम तौर पर शामिल होते हैं:
- उपकरण: उपलब्ध उपकरणों का विवरण (इस पर बाद में और अधिक जानकारी)।
- उपयोगकर्ता का निवेश: उपयोगकर्ता की ओर से उच्च-स्तरीय उद्देश्य या प्रश्न।
- मध्यवर्ती चरण: वर्तमान उपयोगकर्ता इनपुट तक पहुंचने के लिए निष्पादित (एक्शन, टूल आउटपुट) जोड़ियों का इतिहास।
एक एजेंट का आउटपुट अगला हो सकता है कार्य कार्रवाई करने के लिए (एजेंटकार्रवाई) या अंतिम प्रतिक्रिया उपयोगकर्ता को भेजने के लिए (एजेंटसमाप्त)। एक कार्य निर्दिष्ट करता है a साधन और निवेश उस उपकरण के लिए.
टूल्स
उपकरण ऐसे इंटरफ़ेस हैं जिनका उपयोग एक एजेंट दुनिया के साथ बातचीत करने के लिए कर सकता है। वे एजेंटों को विभिन्न कार्य करने में सक्षम बनाते हैं, जैसे वेब पर खोज करना, शेल कमांड चलाना या बाहरी एपीआई तक पहुंचना। लैंगचेन में, एजेंटों की क्षमताओं का विस्तार करने और उन्हें विविध कार्यों को पूरा करने में सक्षम बनाने के लिए उपकरण आवश्यक हैं।
लैंगचेन में टूल का उपयोग करने के लिए, आप उन्हें निम्नलिखित स्निपेट का उपयोग करके लोड कर सकते हैं:
from langchain.agents import load_tools tool_names = [...]
tools = load_tools(tool_names)
कुछ उपकरणों को आरंभ करने के लिए आधार भाषा मॉडल (एलएलएम) की आवश्यकता हो सकती है। ऐसे मामलों में, आप एलएलएम भी पास कर सकते हैं:
from langchain.agents import load_tools tool_names = [...]
llm = ...
tools = load_tools(tool_names, llm=llm)
यह सेटअप आपको विभिन्न प्रकार के टूल तक पहुंचने और उन्हें आपके एजेंट के वर्कफ़्लो में एकीकृत करने की अनुमति देता है। उपयोग दस्तावेज़ के साथ उपकरणों की पूरी सूची है यहाँ उत्पन्न करें.
आइए टूल्स के कुछ उदाहरण देखें।
DuckDuckGo
DuckDuckGo टूल आपको अपने खोज इंजन का उपयोग करके वेब खोज करने में सक्षम बनाता है। इसका उपयोग कैसे करें यहां बताया गया है:
from langchain.tools import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
search.run("manchester united vs luton town match summary")
डेटाफॉरसेओ
DataForSeo टूलकिट आपको DataForSeo API का उपयोग करके खोज इंजन परिणाम प्राप्त करने की अनुमति देता है। इस टूलकिट का उपयोग करने के लिए, आपको अपना एपीआई क्रेडेंशियल सेट करना होगा। क्रेडेंशियल्स को कॉन्फ़िगर करने का तरीका यहां बताया गया है:
import os os.environ["DATAFORSEO_LOGIN"] = "<your_api_access_username>"
os.environ["DATAFORSEO_PASSWORD"] = "<your_api_access_password>"
एक बार जब आपके क्रेडेंशियल सेट हो जाएं, तो आप एक बना सकते हैं DataForSeoAPIWrapper
एपीआई तक पहुँचने के लिए उपकरण:
from langchain.utilities.dataforseo_api_search import DataForSeoAPIWrapper wrapper = DataForSeoAPIWrapper() result = wrapper.run("Weather in Los Angeles")
RSI DataForSeoAPIWrapper
टूल विभिन्न स्रोतों से खोज इंजन परिणाम पुनर्प्राप्त करता है।
आप JSON प्रतिक्रिया में लौटाए गए परिणामों और फ़ील्ड के प्रकार को अनुकूलित कर सकते हैं। उदाहरण के लिए, आप परिणाम प्रकार, फ़ील्ड निर्दिष्ट कर सकते हैं और वापस आने वाले शीर्ष परिणामों की संख्या के लिए अधिकतम गणना निर्धारित कर सकते हैं:
json_wrapper = DataForSeoAPIWrapper( json_result_types=["organic", "knowledge_graph", "answer_box"], json_result_fields=["type", "title", "description", "text"], top_count=3,
) json_result = json_wrapper.results("Bill Gates")
यह उदाहरण परिणाम प्रकार, फ़ील्ड निर्दिष्ट करके और परिणामों की संख्या सीमित करके JSON प्रतिक्रिया को अनुकूलित करता है।
आप एपीआई रैपर में अतिरिक्त पैरामीटर पास करके अपने खोज परिणामों के लिए स्थान और भाषा भी निर्दिष्ट कर सकते हैं:
customized_wrapper = DataForSeoAPIWrapper( top_count=10, json_result_types=["organic", "local_pack"], json_result_fields=["title", "description", "type"], params={"location_name": "Germany", "language_code": "en"},
) customized_result = customized_wrapper.results("coffee near me")
स्थान और भाषा पैरामीटर प्रदान करके, आप अपने खोज परिणामों को विशिष्ट क्षेत्रों और भाषाओं के अनुरूप बना सकते हैं।
आपके पास उस खोज इंजन को चुनने की सुविधा है जिसका आप उपयोग करना चाहते हैं। बस वांछित खोज इंजन निर्दिष्ट करें:
customized_wrapper = DataForSeoAPIWrapper( top_count=10, json_result_types=["organic", "local_pack"], json_result_fields=["title", "description", "type"], params={"location_name": "Germany", "language_code": "en", "se_name": "bing"},
) customized_result = customized_wrapper.results("coffee near me")
इस उदाहरण में, खोज को खोज इंजन के रूप में बिंग का उपयोग करने के लिए अनुकूलित किया गया है।
एपीआई रैपर आपको यह निर्दिष्ट करने की भी अनुमति देता है कि आप किस प्रकार की खोज करना चाहते हैं। उदाहरण के लिए, आप मानचित्र खोज कर सकते हैं:
maps_search = DataForSeoAPIWrapper( top_count=10, json_result_fields=["title", "value", "address", "rating", "type"], params={ "location_coordinate": "52.512,13.36,12z", "language_code": "en", "se_type": "maps", },
) maps_search_result = maps_search.results("coffee near me")
यह मानचित्र-संबंधित जानकारी पुनर्प्राप्त करने के लिए खोज को अनुकूलित करता है।
शैल (बैश)
शेल टूलकिट एजेंटों को शेल वातावरण तक पहुंच प्रदान करता है, जिससे उन्हें शेल कमांड निष्पादित करने की अनुमति मिलती है। यह सुविधा शक्तिशाली है लेकिन इसका उपयोग सावधानी से किया जाना चाहिए, विशेष रूप से सैंडबॉक्स वाले वातावरण में। यहां बताया गया है कि आप शेल टूल का उपयोग कैसे कर सकते हैं:
from langchain.tools import ShellTool shell_tool = ShellTool() result = shell_tool.run({"commands": ["echo 'Hello World!'", "time"]})
इस उदाहरण में, शेल टूल दो शेल कमांड चलाता है: "हैलो वर्ल्ड!" और वर्तमान समय प्रदर्शित कर रहा है।
आप किसी एजेंट को अधिक जटिल कार्य करने के लिए शेल टूल प्रदान कर सकते हैं। यहां एक एजेंट द्वारा शेल टूल का उपयोग करके वेब पेज से लिंक लाने का एक उदाहरण दिया गया है:
from langchain.agents import AgentType, initialize_agent
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(temperature=0.1) shell_tool.description = shell_tool.description + f"args {shell_tool.args}".replace( "{", "{{"
).replace("}", "}}")
self_ask_with_search = initialize_agent( [shell_tool], llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
self_ask_with_search.run( "Download the langchain.com webpage and grep for all urls. Return only a sorted list of them. Be sure to use double quotes."
)
इस परिदृश्य में, एजेंट वेब पेज से यूआरएल लाने, फ़िल्टर करने और सॉर्ट करने के लिए आदेशों के अनुक्रम को निष्पादित करने के लिए शेल टूल का उपयोग करता है।
दिए गए उदाहरण लैंगचेन में उपलब्ध कुछ उपकरणों को प्रदर्शित करते हैं। ये उपकरण अंततः एजेंटों की क्षमताओं का विस्तार करते हैं (अगले उपधारा में चर्चा की गई है) और उन्हें विभिन्न कार्यों को कुशलतापूर्वक करने के लिए सशक्त बनाते हैं। अपनी आवश्यकताओं के आधार पर, आप ऐसे उपकरण और टूलकिट चुन सकते हैं जो आपके प्रोजेक्ट की आवश्यकताओं के लिए सबसे उपयुक्त हों और उन्हें अपने एजेंट के वर्कफ़्लो में एकीकृत कर सकें।
एजेंटों के पास वापस जाएँ
आइए अब एजेंटों पर चलते हैं।
AgentExecutor एक एजेंट के लिए रनटाइम वातावरण है। यह एजेंट को कॉल करने, उसके द्वारा चुनी गई कार्रवाइयों को निष्पादित करने, एक्शन आउटपुट को एजेंट को वापस भेजने और एजेंट के समाप्त होने तक प्रक्रिया को दोहराने के लिए जिम्मेदार है। छद्मकोड में, AgentExecutor कुछ इस तरह दिख सकता है:
next_action = agent.get_action(...)
while next_action != AgentFinish: observation = run(next_action) next_action = agent.get_action(..., next_action, observation)
return next_action
AgentExecutor विभिन्न जटिलताओं को संभालता है, जैसे ऐसे मामलों से निपटना जहां एजेंट एक गैर-मौजूद उपकरण का चयन करता है, उपकरण त्रुटियों को संभालना, एजेंट-निर्मित आउटपुट का प्रबंधन करना, और सभी स्तरों पर लॉगिंग और अवलोकन प्रदान करना।
जबकि AgentExecutor वर्ग लैंगचेन में प्राथमिक एजेंट रनटाइम है, अन्य, अधिक प्रयोगात्मक रनटाइम समर्थित हैं, जिनमें शामिल हैं:
- योजना-एवं-निष्पादित एजेंट
- बेबी एजीआई
- ऑटो जीपीटी
एजेंट ढांचे की बेहतर समझ हासिल करने के लिए, आइए शुरुआत से एक बुनियादी एजेंट बनाएं, और फिर पूर्व-निर्मित एजेंटों का पता लगाने के लिए आगे बढ़ें।
इससे पहले कि हम एजेंट के निर्माण में उतरें, कुछ प्रमुख शब्दावली और स्कीमा पर दोबारा गौर करना आवश्यक है:
- एजेंटकार्रवाई: यह एक डेटा वर्ग है जो एक एजेंट द्वारा की जाने वाली कार्रवाई का प्रतिनिधित्व करता है। इसमें शामिल है ए
tool
संपत्ति (आह्वान करने के लिए उपकरण का नाम) और एtool_input
संपत्ति (उस उपकरण के लिए इनपुट)। - एजेंटसमाप्त: यह डेटा वर्ग इंगित करता है कि एजेंट ने अपना कार्य पूरा कर लिया है और उसे उपयोगकर्ता को प्रतिक्रिया लौटानी चाहिए। इसमें आम तौर पर रिटर्न मानों का एक शब्दकोश शामिल होता है, अक्सर एक कुंजी "आउटपुट" के साथ जिसमें प्रतिक्रिया पाठ होता है।
- मध्यवर्ती चरण: ये पिछले एजेंट कार्यों और संबंधित आउटपुट के रिकॉर्ड हैं। वे एजेंट के भविष्य के पुनरावृत्तियों के संदर्भ को पारित करने के लिए महत्वपूर्ण हैं।
हमारे उदाहरण में, हम अपना एजेंट बनाने के लिए OpenAI फ़ंक्शन कॉलिंग का उपयोग करेंगे। एजेंट निर्माण के लिए यह दृष्टिकोण विश्वसनीय है। हम एक सरल उपकरण बनाकर शुरुआत करेंगे जो किसी शब्द की लंबाई की गणना करता है। यह उपकरण उपयोगी है क्योंकि भाषा मॉडल कभी-कभी शब्दों की लंबाई गिनते समय टोकनाइजेशन के कारण गलतियाँ कर सकते हैं।
सबसे पहले, आइए उस भाषा मॉडल को लोड करें जिसका उपयोग हम एजेंट को नियंत्रित करने के लिए करेंगे:
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
आइए शब्द लंबाई गणना के साथ मॉडल का परीक्षण करें:
llm.invoke("how many letters in the word educa?")
प्रतिक्रिया में "एजुका" शब्द में अक्षरों की संख्या का संकेत होना चाहिए।
इसके बाद, हम किसी शब्द की लंबाई की गणना करने के लिए एक सरल पायथन फ़ंक्शन को परिभाषित करेंगे:
from langchain.agents import tool @tool
def get_word_length(word: str) -> int: """Returns the length of a word.""" return len(word)
हमने नाम का एक टूल बनाया है get_word_length
यह एक शब्द को इनपुट के रूप में लेता है और उसकी लंबाई लौटाता है।
अब, आइए एजेंट के लिए प्रॉम्प्ट बनाएं। प्रॉम्प्ट एजेंट को तर्क करने और आउटपुट को प्रारूपित करने का निर्देश देता है। हमारे मामले में, हम OpenAI फ़ंक्शन कॉलिंग का उपयोग कर रहे हैं, जिसके लिए न्यूनतम निर्देशों की आवश्यकता होती है। हम उपयोगकर्ता इनपुट और एजेंट स्क्रैचपैड के लिए प्लेसहोल्डर्स के साथ प्रॉम्प्ट को परिभाषित करेंगे:
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a very powerful assistant but not great at calculating word lengths.", ), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]
)
अब, एजेंट को कैसे पता चलेगा कि वह किन उपकरणों का उपयोग कर सकता है? हम OpenAI फ़ंक्शन कॉलिंग भाषा मॉडल पर भरोसा कर रहे हैं, जिसके लिए फ़ंक्शन को अलग से पारित करने की आवश्यकता होती है। एजेंट को अपने उपकरण प्रदान करने के लिए, हम उन्हें OpenAI फ़ंक्शन कॉल के रूप में प्रारूपित करेंगे:
from langchain.tools.render import format_tool_to_openai_function llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools])
अब, हम इनपुट मैपिंग को परिभाषित करके और घटकों को जोड़कर एजेंट बना सकते हैं:
यह एलसीईएल भाषा है। इस पर हम बाद में विस्तार से चर्चा करेंगे.
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai _function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
)
हमने अपना एजेंट बनाया है, जो उपयोगकर्ता इनपुट को समझता है, उपलब्ध टूल का उपयोग करता है और आउटपुट को प्रारूपित करता है। अब, आइए इसके साथ बातचीत करें:
agent.invoke({"input": "how many letters in the word educa?", "intermediate_steps": []})
एजेंट को अगली कार्रवाई का संकेत देते हुए एजेंटएक्शन के साथ जवाब देना चाहिए।
हमने एजेंट बना लिया है, लेकिन अब हमें इसके लिए एक रनटाइम लिखना होगा। सबसे सरल रनटाइम वह है जो एजेंट को लगातार कॉल करता है, कार्रवाई निष्पादित करता है और एजेंट के समाप्त होने तक दोहराता रहता है। यहाँ एक उदाहरण है:
from langchain.schema.agent import AgentFinish user_input = "how many letters in the word educa?"
intermediate_steps = [] while True: output = agent.invoke( { "input": user_input, "intermediate_steps": intermediate_steps, } ) if isinstance(output, AgentFinish): final_result = output.return_values["output"] break else: print(f"TOOL NAME: {output.tool}") print(f"TOOL INPUT: {output.tool_input}") tool = {"get_word_length": get_word_length}[output.tool] observation = tool.run(output.tool_input) intermediate_steps.append((output, observation)) print(final_result)
इस लूप में, हम बार-बार एजेंट को कॉल करते हैं, कार्रवाई निष्पादित करते हैं, और एजेंट के समाप्त होने तक मध्यवर्ती चरणों को अपडेट करते हैं। हम लूप के भीतर टूल इंटरैक्शन को भी संभालते हैं।
इस प्रक्रिया को सरल बनाने के लिए, लैंगचेन एजेंट एक्ज़ीक्यूटर क्लास प्रदान करता है, जो एजेंट निष्पादन को समाहित करता है और त्रुटि प्रबंधन, शीघ्र रोक, ट्रेसिंग और अन्य सुधार प्रदान करता है। आइए एजेंट के साथ बातचीत करने के लिए AgentExecutor का उपयोग करें:
from langchain.agents import AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "how many letters in the word educa?"})
AgentExecutor निष्पादन प्रक्रिया को सरल बनाता है और एजेंट के साथ बातचीत करने का एक सुविधाजनक तरीका प्रदान करता है।
स्मृति पर बाद में भी विस्तार से चर्चा की गई है।
अब तक हमने जो एजेंट बनाया है वह स्टेटलेस है, जिसका अर्थ है कि यह पिछले इंटरैक्शन को याद नहीं रखता है। अनुवर्ती प्रश्नों और वार्तालापों को सक्षम करने के लिए, हमें एजेंट में मेमोरी जोड़ने की आवश्यकता है। इसमें दो चरण शामिल हैं:
- चैट इतिहास को संग्रहीत करने के लिए प्रॉम्प्ट में एक मेमोरी वेरिएबल जोड़ें।
- बातचीत के दौरान चैट इतिहास पर नज़र रखें।
आइए प्रॉम्प्ट में मेमोरी प्लेसहोल्डर जोड़कर शुरुआत करें:
from langchain.prompts import MessagesPlaceholder MEMORY_KEY = "chat_history"
prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a very powerful assistant but not great at calculating word lengths.", ), MessagesPlaceholder(variable_name=MEMORY_KEY), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]
)
अब, चैट इतिहास को ट्रैक करने के लिए एक सूची बनाएं:
from langchain.schema.messages import HumanMessage, AIMessage chat_history = []
एजेंट निर्माण चरण में, हम मेमोरी को भी शामिल करेंगे:
agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), "chat_history": lambda x: x["chat_history"], } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
)
अब, एजेंट चलाते समय, चैट इतिहास को अपडेट करना सुनिश्चित करें:
input1 = "how many letters in the word 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": "is that a real word?", "chat_history": chat_history})
यह एजेंट को बातचीत का इतिहास बनाए रखने और पिछली बातचीत के आधार पर अनुवर्ती प्रश्नों का उत्तर देने में सक्षम बनाता है।
बधाई हो! आपने लैंगचेन में अपना पहला एंड-टू-एंड एजेंट सफलतापूर्वक बना और निष्पादित कर लिया है। लैंगचेन की क्षमताओं को गहराई से जानने के लिए, आप इसका पता लगा सकते हैं:
- विभिन्न एजेंट प्रकार समर्थित.
- पूर्व-निर्मित एजेंट
- टूल और टूल इंटीग्रेशन के साथ कैसे काम करें।
एजेंट के प्रकार
लैंगचेन विभिन्न प्रकार के एजेंट प्रदान करता है, जिनमें से प्रत्येक विशिष्ट उपयोग के मामलों के लिए उपयुक्त है। यहां कुछ उपलब्ध एजेंट हैं:
- शून्य-शॉट प्रतिक्रिया: यह एजेंट केवल अपने विवरण के आधार पर टूल चुनने के लिए ReAct फ्रेमवर्क का उपयोग करता है। इसमें प्रत्येक उपकरण के लिए विवरण की आवश्यकता होती है और यह अत्यधिक बहुमुखी है।
- संरचित इनपुट प्रतिक्रिया: यह एजेंट मल्टी-इनपुट टूल संभालता है और वेब ब्राउज़र को नेविगेट करने जैसे जटिल कार्यों के लिए उपयुक्त है। यह संरचित इनपुट के लिए टूल के तर्क स्कीमा का उपयोग करता है।
- ओपनएआई कार्य: फ़ंक्शन कॉलिंग के लिए फाइन-ट्यून किए गए मॉडलों के लिए विशेष रूप से डिज़ाइन किया गया, यह एजेंट gpt-3.5-टर्बो-0613 और gpt-4-0613 जैसे मॉडलों के साथ संगत है। हमने उपरोक्त अपना पहला एजेंट बनाने के लिए इसका उपयोग किया।
- संवादी: वार्तालाप सेटिंग्स के लिए डिज़ाइन किया गया, यह एजेंट टूल चयन के लिए ReAct का उपयोग करता है और पिछले इंटरैक्शन को याद रखने के लिए मेमोरी का उपयोग करता है।
- खोज के साथ स्वयं पूछें: यह एजेंट एक एकल टूल, "इंटरमीडिएट उत्तर" पर निर्भर करता है, जो प्रश्नों के तथ्यात्मक उत्तर ढूंढता है। यह खोज पेपर के साथ मूल स्व-पूछने के बराबर है।
- रिएक्ट दस्तावेज़ भंडार: यह एजेंट ReAct फ्रेमवर्क का उपयोग करके दस्तावेज़ स्टोर के साथ इंटरैक्ट करता है। इसके लिए "खोज" और "लुकअप" टूल की आवश्यकता होती है और यह मूल रिएक्ट पेपर के विकिपीडिया उदाहरण के समान है।
लैंगचेन में आपकी आवश्यकताओं के लिए सबसे उपयुक्त एजेंट ढूंढने के लिए इन एजेंट प्रकारों का अन्वेषण करें। ये एजेंट आपको क्रियाओं को संभालने और प्रतिक्रियाएँ उत्पन्न करने के लिए उनके भीतर उपकरणों के सेट को बाँधने की अनुमति देते हैं। आगे जानें यहां टूल के साथ अपना खुद का एजेंट कैसे बनाएं.
पूर्वनिर्मित एजेंट
आइए लैंगचेन में उपलब्ध पूर्वनिर्मित एजेंटों पर ध्यान केंद्रित करते हुए एजेंटों की खोज जारी रखें।
जीमेल
लैंगचेन एक जीमेल टूलकिट प्रदान करता है जो आपको अपने लैंगचेन ईमेल को जीमेल एपीआई से कनेक्ट करने की अनुमति देता है। आरंभ करने के लिए, आपको अपना क्रेडेंशियल सेट करना होगा, जिसे जीमेल एपीआई दस्तावेज़ में समझाया गया है। एक बार जब आप डाउनलोड कर लें credentials.json
फ़ाइल, आप जीमेल एपीआई का उपयोग करके आगे बढ़ सकते हैं। इसके अतिरिक्त, आपको निम्नलिखित आदेशों का उपयोग करके कुछ आवश्यक लाइब्रेरी स्थापित करने की आवश्यकता होगी:
pip install --upgrade google-api-python-client > /dev/null
pip install --upgrade google-auth-oauthlib > /dev/null
pip install --upgrade google-auth-httplib2 > /dev/null
pip install beautifulsoup4 > /dev/null # Optional for parsing HTML messages
आप जीमेल टूलकिट इस प्रकार बना सकते हैं:
from langchain.agents.agent_toolkits import GmailToolkit toolkit = GmailToolkit()
आप अपनी आवश्यकताओं के अनुसार प्रमाणीकरण को अनुकूलित भी कर सकते हैं। पर्दे के पीछे, निम्नलिखित विधियों का उपयोग करके एक googleapi संसाधन बनाया जाता है:
from langchain.tools.gmail.utils import build_resource_service, get_gmail_credentials credentials = get_gmail_credentials( token_file="token.json", scopes=["https://mail.google.com/"], client_secrets_file="credentials.json",
)
api_resource = build_resource_service(credentials=credentials)
toolkit = GmailToolkit(api_resource=api_resource)
टूलकिट विभिन्न उपकरण प्रदान करता है जिनका उपयोग एक एजेंट के भीतर किया जा सकता है, जिनमें शामिल हैं:
GmailCreateDraft
: निर्दिष्ट संदेश फ़ील्ड के साथ एक ड्राफ्ट ईमेल बनाएं।GmailSendMessage
: ईमेल संदेश भेजें.GmailSearch
: ईमेल संदेश या थ्रेड खोजें.GmailGetMessage
: संदेश आईडी द्वारा एक ईमेल प्राप्त करें।GmailGetThread
: ईमेल संदेश खोजें.
किसी एजेंट के भीतर इन उपकरणों का उपयोग करने के लिए, आप एजेंट को निम्नानुसार आरंभ कर सकते हैं:
from langchain.llms import OpenAI
from langchain.agents import initialize_agent, AgentType llm = OpenAI(temperature=0)
agent = initialize_agent( tools=toolkit.get_tools(), llm=llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
)
यहां कुछ उदाहरण दिए गए हैं कि इन उपकरणों का उपयोग कैसे किया जा सकता है:
- संपादन के लिए एक जीमेल ड्राफ्ट बनाएं:
agent.run( "Create a gmail draft for me to edit of a letter from the perspective of a sentient parrot " "who is looking to collaborate on some research with her estranged friend, a cat. " "Under no circumstances may you send the message, however."
)
- अपने ड्राफ्ट में नवीनतम ईमेल खोजें:
agent.run("Could you search in my drafts for the latest email?")
ये उदाहरण एक एजेंट के भीतर लैंगचेन के जीमेल टूलकिट की क्षमताओं को प्रदर्शित करते हैं, जो आपको जीमेल के साथ प्रोग्रामेटिक रूप से इंटरैक्ट करने में सक्षम बनाता है।
SQL डेटाबेस एजेंट
यह अनुभाग SQL डेटाबेस, विशेष रूप से चिनूक डेटाबेस के साथ इंटरैक्ट करने के लिए डिज़ाइन किए गए एजेंट का अवलोकन प्रदान करता है। यह एजेंट डेटाबेस के बारे में सामान्य प्रश्नों का उत्तर दे सकता है और त्रुटियों से उबर सकता है। कृपया ध्यान दें कि यह अभी भी सक्रिय विकास में है, और सभी उत्तर सही नहीं हो सकते हैं। इसे संवेदनशील डेटा पर चलाते समय सावधान रहें, क्योंकि यह आपके डेटाबेस पर डीएमएल स्टेटमेंट निष्पादित कर सकता है।
इस एजेंट का उपयोग करने के लिए, आप इसे इस प्रकार प्रारंभ कर सकते हैं:
from langchain.agents import create_sql_agent
from langchain.agents.agent_toolkits import SQLDatabaseToolkit
from langchain.sql_database import SQLDatabase
from langchain.llms.openai import OpenAI
from langchain.agents import AgentExecutor
from langchain.agents.agent_types import AgentType
from langchain.chat_models import ChatOpenAI db = SQLDatabase.from_uri("sqlite:///../../../../../notebooks/Chinook.db")
toolkit = SQLDatabaseToolkit(db=db, llm=OpenAI(temperature=0)) agent_executor = create_sql_agent( llm=OpenAI(temperature=0), toolkit=toolkit, verbose=True, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)
इस एजेंट को का उपयोग करके प्रारंभ किया जा सकता है ZERO_SHOT_REACT_DESCRIPTION
एजेंट प्रकार. इसे प्रश्नों का उत्तर देने और विवरण प्रदान करने के लिए डिज़ाइन किया गया है। वैकल्पिक रूप से, आप इसका उपयोग करके एजेंट को प्रारंभ कर सकते हैं OPENAI_FUNCTIONS
एजेंट प्रकार OpenAI के GPT-3.5-टर्बो मॉडल के साथ, जिसे हमने अपने पिछले क्लाइंट में उपयोग किया था।
Disclaimer
- क्वेरी श्रृंखला सम्मिलित/अपडेट/डिलीट क्वेरी उत्पन्न कर सकती है। सावधान रहें, और यदि आवश्यक हो तो कस्टम प्रॉम्प्ट का उपयोग करें या बिना लिखने की अनुमति के SQL उपयोगकर्ता बनाएं।
- सावधान रहें कि कुछ क्वेरीज़, जैसे कि "सबसे बड़ी क्वेरी चलाएं" चलाने से आपका SQL डेटाबेस ओवरलोड हो सकता है, खासकर यदि इसमें लाखों पंक्तियाँ हों।
- डेटा वेयरहाउस-उन्मुख डेटाबेस अक्सर संसाधन उपयोग को सीमित करने के लिए उपयोगकर्ता-स्तरीय कोटा का समर्थन करते हैं।
आप एजेंट से किसी तालिका का वर्णन करने के लिए कह सकते हैं, जैसे "प्लेलिस्टट्रैक" तालिका। इसे कैसे करें इसका एक उदाहरण यहां दिया गया है:
agent_executor.run("Describe the playlisttrack table")
एजेंट तालिका की स्कीमा और नमूना पंक्तियों के बारे में जानकारी प्रदान करेगा।
यदि आप गलती से किसी ऐसी तालिका के बारे में पूछते हैं जो मौजूद नहीं है, तो एजेंट पुनर्प्राप्त कर सकता है और निकटतम मिलान तालिका के बारे में जानकारी प्रदान कर सकता है। उदाहरण के लिए:
agent_executor.run("Describe the playlistsong table")
एजेंट निकटतम मिलान तालिका ढूंढेगा और उसके बारे में जानकारी प्रदान करेगा।
आप एजेंट से डेटाबेस पर क्वेरी चलाने के लिए भी कह सकते हैं। उदाहरण के लिए:
agent_executor.run("List the total sales per country. Which country's customers spent the most?")
एजेंट क्वेरी निष्पादित करेगा और परिणाम प्रदान करेगा, जैसे कि सबसे अधिक कुल बिक्री वाला देश।
प्रत्येक प्लेलिस्ट में ट्रैक की कुल संख्या प्राप्त करने के लिए, आप निम्नलिखित क्वेरी का उपयोग कर सकते हैं:
agent_executor.run("Show the total number of tracks in each playlist. The Playlist name should be included in the result.")
एजेंट संबंधित कुल ट्रैक संख्या के साथ प्लेलिस्ट के नाम लौटाएगा।
ऐसे मामलों में जहां एजेंट को त्रुटियों का सामना करना पड़ता है, यह ठीक हो सकता है और सटीक प्रतिक्रिया प्रदान कर सकता है। उदाहरण के लिए:
agent_executor.run("Who are the top 3 best selling artists?")
प्रारंभिक त्रुटि का सामना करने के बाद भी, एजेंट समायोजित करेगा और सही उत्तर प्रदान करेगा, जो इस मामले में, शीर्ष 3 सबसे अधिक बिकने वाले कलाकार हैं।
पांडा डेटाफ़्रेम एजेंट
यह अनुभाग प्रश्न-उत्तर उद्देश्यों के लिए पांडा डेटाफ़्रेम के साथ बातचीत करने के लिए डिज़ाइन किए गए एजेंट का परिचय देता है। कृपया ध्यान दें कि यह एजेंट एक भाषा मॉडल (एलएलएम) द्वारा उत्पन्न पायथन कोड को निष्पादित करने के लिए हुड के तहत पायथन एजेंट का उपयोग करता है। एलएलएम द्वारा उत्पन्न दुर्भावनापूर्ण पायथन कोड से संभावित नुकसान को रोकने के लिए इस एजेंट का उपयोग करते समय सावधानी बरतें।
आप पांडास डेटाफ़्रेम एजेंट को इस प्रकार प्रारंभ कर सकते हैं:
from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType from langchain.llms import OpenAI
import pandas as pd df = pd.read_csv("titanic.csv") # Using ZERO_SHOT_REACT_DESCRIPTION agent type
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), df, verbose=True) # Alternatively, using OPENAI_FUNCTIONS agent type
# agent = create_pandas_dataframe_agent(
# ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613"),
# df,
# verbose=True,
# agent_type=AgentType.OPENAI_FUNCTIONS,
# )
आप एजेंट से डेटाफ़्रेम में पंक्तियों की संख्या गिनने के लिए कह सकते हैं:
agent.run("how many rows are there?")
एजेंट कोड निष्पादित करेगा df.shape[0]
और उत्तर प्रदान करें, जैसे "डेटाफ़्रेम में 891 पंक्तियाँ हैं।"
आप एजेंट से विशिष्ट मानदंडों के आधार पर पंक्तियों को फ़िल्टर करने के लिए भी कह सकते हैं, जैसे कि 3 से अधिक भाई-बहन वाले लोगों की संख्या का पता लगाना:
agent.run("how many people have more than 3 siblings")
एजेंट कोड निष्पादित करेगा df[df['SibSp'] > 3].shape[0]
और उत्तर प्रदान करें, जैसे "30 लोगों के 3 से अधिक भाई-बहन हैं।"
यदि आप औसत आयु का वर्गमूल निकालना चाहते हैं, तो आप एजेंट से पूछ सकते हैं:
agent.run("whats the square root of the average age?")
एजेंट इसका उपयोग करके औसत आयु की गणना करेगा df['Age'].mean()
और फिर इसका उपयोग करके वर्गमूल की गणना करें math.sqrt()
. यह उत्तर प्रदान करेगा, जैसे "औसत आयु का वर्गमूल 5.449689683556195 है।"
आइए डेटाफ़्रेम की एक प्रति बनाएँ, और लुप्त आयु मानों को औसत आयु से भरें:
df1 = df.copy()
df1["Age"] = df1["Age"].fillna(df1["Age"].mean())
फिर, आप एजेंट को दोनों डेटाफ़्रेम के साथ प्रारंभ कर सकते हैं और उससे एक प्रश्न पूछ सकते हैं:
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), [df, df1], verbose=True)
agent.run("how many rows in the age column are different?")
एजेंट दोनों डेटाफ़्रेम में आयु कॉलम की तुलना करेगा और उत्तर प्रदान करेगा, जैसे "आयु कॉलम में 177 पंक्तियाँ अलग-अलग हैं।"
जिरा टूलकिट
यह अनुभाग बताता है कि जीरा टूलकिट का उपयोग कैसे करें, जो एजेंटों को जीरा उदाहरण के साथ बातचीत करने की अनुमति देता है। आप इस टूलकिट का उपयोग करके विभिन्न कार्य कर सकते हैं जैसे मुद्दों की खोज करना और मुद्दे बनाना। यह एटलसियन-पायथन-एपीआई लाइब्रेरी का उपयोग करता है। इस टूलकिट का उपयोग करने के लिए, आपको अपने जिरा इंस्टेंस के लिए पर्यावरण चर सेट करने की आवश्यकता है, जिसमें JIRA_API_TOKEN, JIRA_USERNAME और JIRA_INSTANCE_URL शामिल हैं। इसके अतिरिक्त, आपको अपनी OpenAI API कुंजी को एक पर्यावरण चर के रूप में सेट करने की आवश्यकता हो सकती है।
आरंभ करने के लिए, एटलसियन-पायथन-एपीआई लाइब्रेरी स्थापित करें और आवश्यक पर्यावरण चर सेट करें:
%pip install atlassian-python-api import os
from langchain.agents import AgentType
from langchain.agents import initialize_agent
from langchain.agents.agent_toolkits.jira.toolkit import JiraToolkit
from langchain.llms import OpenAI
from langchain.utilities.jira import JiraAPIWrapper os.environ["JIRA_API_TOKEN"] = "abc"
os.environ["JIRA_USERNAME"] = "123"
os.environ["JIRA_INSTANCE_URL"] = "https://jira.atlassian.com"
os.environ["OPENAI_API_KEY"] = "xyz" llm = OpenAI(temperature=0)
jira = JiraAPIWrapper()
toolkit = JiraToolkit.from_jira_api_wrapper(jira)
agent = initialize_agent( toolkit.get_tools(), llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
आप एजेंट को सारांश और विवरण के साथ किसी विशिष्ट प्रोजेक्ट में एक नया मुद्दा बनाने का निर्देश दे सकते हैं:
agent.run("make a new issue in project PW to remind me to make more fried rice")
एजेंट समस्या बनाने के लिए आवश्यक कार्रवाइयां निष्पादित करेगा और प्रतिक्रिया प्रदान करेगा, जैसे "प्रोजेक्ट पीडब्ल्यू में 'अधिक तले हुए चावल बनाएं' सारांश और 'अधिक तले हुए चावल बनाने के लिए अनुस्मारक' के सारांश के साथ एक नया मुद्दा बनाया गया है।"
यह आपको प्राकृतिक भाषा निर्देशों और जीरा टूलकिट का उपयोग करके अपने जीरा इंस्टेंस के साथ बातचीत करने की अनुमति देता है।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
मॉड्यूल IV: जंजीरें
लैंगचेन एक उपकरण है जिसे जटिल अनुप्रयोगों में बड़े भाषा मॉडल (एलएलएम) का उपयोग करने के लिए डिज़ाइन किया गया है। यह एलएलएम और अन्य प्रकार के घटकों सहित घटकों की श्रृंखला बनाने के लिए रूपरेखा प्रदान करता है। दो प्राथमिक ढाँचे
- लैंगचेन अभिव्यक्ति भाषा (एलसीईएल)
- विरासत श्रृंखला इंटरफ़ेस
लैंगचेन एक्सप्रेशन लैंग्वेज (एलसीईएल) एक वाक्यविन्यास है जो श्रृंखलाओं की सहज संरचना की अनुमति देता है। यह स्ट्रीमिंग, एसिंक्रोनस कॉल, बैचिंग, पैरेललाइज़ेशन, रिट्रीज़, फ़ॉलबैक और ट्रेसिंग जैसी उन्नत सुविधाओं का समर्थन करता है। उदाहरण के लिए, आप LCEL में एक प्रॉम्प्ट, मॉडल और आउटपुट पार्सर बना सकते हैं जैसा कि निम्नलिखित कोड में दिखाया गया है:
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
prompt = ChatPromptTemplate.from_messages([ ("system", "You're a very knowledgeable historian who provides accurate and eloquent answers to historical questions."), ("human", "{question}")
])
runnable = prompt | model | StrOutputParser() for chunk in runnable.stream({"question": "What are the seven wonders of the world"}): print(chunk, end="", flush=True)
वैकल्पिक रूप से, LLMChain घटकों की रचना के लिए LCEL के समान एक विकल्प है। LLMChain उदाहरण इस प्रकार है:
from langchain.chains import LLMChain chain = LLMChain(llm=model, prompt=prompt, output_parser=StrOutputParser())
chain.run(question="What are the seven wonders of the world")
लैंगचेन में चेन को मेमोरी ऑब्जेक्ट को शामिल करके स्टेटफुल भी बनाया जा सकता है। यह कॉल के दौरान डेटा को कायम रखने की अनुमति देता है, जैसा कि इस उदाहरण में दिखाया गया है:
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory conversation = ConversationChain(llm=chat, memory=ConversationBufferMemory())
conversation.run("Answer briefly. What are the first 3 colors of a rainbow?")
conversation.run("And the next 4?")
लैंगचेन ओपनएआई के फ़ंक्शन-कॉलिंग एपीआई के साथ एकीकरण का भी समर्थन करता है, जो संरचित आउटपुट प्राप्त करने और एक श्रृंखला के भीतर कार्यों को निष्पादित करने के लिए उपयोगी है। संरचित आउटपुट प्राप्त करने के लिए, आप उन्हें पाइडेंटिक कक्षाओं या JsonSchema का उपयोग करके निर्दिष्ट कर सकते हैं, जैसा कि नीचे दिखाया गया है:
from langchain.pydantic_v1 import BaseModel, Field
from langchain.chains.openai_functions import create_structured_output_runnable
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate class Person(BaseModel): name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") llm = ChatOpenAI(model="gpt-4", temperature=0)
prompt = ChatPromptTemplate.from_messages([ # Prompt messages here
]) runnable = create_structured_output_runnable(Person, llm, prompt)
runnable.invoke({"input": "Sally is 13"})
संरचित आउटपुट के लिए, LLMChain का उपयोग करने वाला एक विरासत दृष्टिकोण भी उपलब्ध है:
from langchain.chains.openai_functions import create_structured_output_chain class Person(BaseModel): name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") chain = create_structured_output_chain(Person, llm, prompt, verbose=True)
chain.run("Sally is 13")
लैंगचेन विभिन्न उद्देश्यों के लिए विभिन्न विशिष्ट श्रृंखलाएं बनाने के लिए ओपनएआई फ़ंक्शंस का लाभ उठाता है। इनमें उद्धरणों के साथ निष्कर्षण, टैगिंग, ओपनएपीआई और क्यूए के लिए श्रृंखलाएं शामिल हैं।
निष्कर्षण के संदर्भ में, प्रक्रिया संरचित आउटपुट श्रृंखला के समान है लेकिन सूचना या इकाई निष्कर्षण पर केंद्रित है। टैगिंग के लिए, किसी दस्तावेज़ को भावना, भाषा, शैली, कवर किए गए विषय या राजनीतिक प्रवृत्ति जैसे वर्गों के साथ लेबल करने का विचार है।
लैंगचेन में टैगिंग कैसे काम करती है इसका एक उदाहरण पायथन कोड के साथ प्रदर्शित किया जा सकता है। प्रक्रिया आवश्यक पैकेजों को स्थापित करने और पर्यावरण की स्थापना के साथ शुरू होती है:
pip install langchain openai
# Set env var OPENAI_API_KEY or load from a .env file:
# import dotenv
# dotenv.load_dotenv() from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import create_tagging_chain, create_tagging_chain_pydantic
टैगिंग के लिए स्कीमा को परिभाषित किया गया है, जिसमें गुणों और उनके अपेक्षित प्रकारों को निर्दिष्ट किया गया है:
schema = { "properties": { "sentiment": {"type": "string"}, "aggressiveness": {"type": "integer"}, "language": {"type": "string"}, }
} llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
chain = create_tagging_chain(schema, llm)
विभिन्न इनपुट के साथ टैगिंग श्रृंखला चलाने के उदाहरण मॉडल की भावनाओं, भाषाओं और आक्रामकता की व्याख्या करने की क्षमता दिखाते हैं:
inp = "Estoy increiblemente contento de haberte conocido! Creo que seremos muy buenos amigos!"
chain.run(inp)
# {'sentiment': 'positive', 'language': 'Spanish'} inp = "Estoy muy enojado con vos! Te voy a dar tu merecido!"
chain.run(inp)
# {'sentiment': 'enojado', 'aggressiveness': 1, 'language': 'es'}
बेहतर नियंत्रण के लिए, स्कीमा को अधिक विशिष्ट रूप से परिभाषित किया जा सकता है, जिसमें संभावित मान, विवरण और आवश्यक गुण शामिल हैं। इस उन्नत नियंत्रण का एक उदाहरण नीचे दिखाया गया है:
schema = { "properties": { # Schema definitions here }, "required": ["language", "sentiment", "aggressiveness"],
} chain = create_tagging_chain(schema, llm)
पाइडेंटिक स्कीमा का उपयोग टैगिंग मानदंड को परिभाषित करने के लिए भी किया जा सकता है, जो आवश्यक गुणों और प्रकारों को निर्दिष्ट करने के लिए पायथोनिक तरीका प्रदान करता है:
from enum import Enum
from pydantic import BaseModel, Field class Tags(BaseModel): # Class fields here chain = create_tagging_chain_pydantic(Tags, llm)
इसके अतिरिक्त, लैंगचेन के मेटाडेटा टैगर दस्तावेज़ ट्रांसफार्मर का उपयोग लैंगचेन दस्तावेज़ों से मेटाडेटा निकालने के लिए किया जा सकता है, जो टैगिंग श्रृंखला के समान कार्यक्षमता प्रदान करता है लेकिन लैंगचेन दस्तावेज़ पर लागू होता है।
पुनर्प्राप्ति स्रोतों का हवाला देना लैंगचेन की एक अन्य विशेषता है, जो पाठ से उद्धरण निकालने के लिए ओपनएआई फ़ंक्शंस का उपयोग करता है। इसे निम्नलिखित कोड में प्रदर्शित किया गया है:
from langchain.chains import create_citation_fuzzy_match_chain
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
chain = create_citation_fuzzy_match_chain(llm)
# Further code for running the chain and displaying results
लैंगचेन में, लार्ज लैंग्वेज मॉडल (एलएलएम) अनुप्रयोगों में चेनिंग में आमतौर पर एलएलएम के साथ एक प्रॉम्प्ट टेम्पलेट और वैकल्पिक रूप से एक आउटपुट पार्सर का संयोजन शामिल होता है। ऐसा करने का अनुशंसित तरीका लैंगचेन एक्सप्रेशन लैंग्वेज (एलसीईएल) के माध्यम से है, हालांकि विरासत एलएलएमसीचेन दृष्टिकोण भी समर्थित है।
एलसीईएल का उपयोग करते हुए, बेसप्रॉम्प्टटेम्प्लेट, बेसलैंग्वेजमॉडल और बेसऑउटपुटपार्सर सभी रननेबल इंटरफ़ेस को कार्यान्वित करते हैं और आसानी से एक दूसरे में पाइप किए जा सकते हैं। इसे प्रदर्शित करने वाला एक उदाहरण यहां दिया गया है:
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.schema import StrOutputParser prompt = PromptTemplate.from_template( "What is a good name for a company that makes {product}?"
)
runnable = prompt | ChatOpenAI() | StrOutputParser()
runnable.invoke({"product": "colorful socks"})
# Output: 'VibrantSocks'
लैंगचेन में रूटिंग गैर-नियतात्मक श्रृंखला बनाने की अनुमति देती है जहां पिछले चरण का आउटपुट अगले चरण को निर्धारित करता है। यह एलएलएम के साथ बातचीत में संरचना और स्थिरता बनाए रखने में मदद करता है। उदाहरण के लिए, यदि आपके पास विभिन्न प्रकार के प्रश्नों के लिए अनुकूलित दो टेम्पलेट हैं, तो आप उपयोगकर्ता इनपुट के आधार पर टेम्पलेट चुन सकते हैं।
यहां बताया गया है कि आप RunnableBranch के साथ LCEL का उपयोग करके इसे कैसे प्राप्त कर सकते हैं, जिसे (स्थिति, runnable) जोड़े और एक डिफ़ॉल्ट runnable की सूची के साथ आरंभ किया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableBranch
# Code for defining physics_prompt and math_prompt general_prompt = PromptTemplate.from_template( "You are a helpful assistant. Answer the question as accurately as you can.nn{input}"
)
prompt_branch = RunnableBranch( (lambda x: x["topic"] == "math", math_prompt), (lambda x: x["topic"] == "physics", physics_prompt), general_prompt,
) # More code for setting up the classifier and final chain
फिर इनपुट के विषय के आधार पर प्रवाह को निर्धारित करने के लिए विभिन्न घटकों, जैसे विषय क्लासिफायरियर, प्रॉम्प्ट शाखा और आउटपुट पार्सर का उपयोग करके अंतिम श्रृंखला का निर्माण किया जाता है:
from operator import itemgetter
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough final_chain = ( RunnablePassthrough.assign(topic=itemgetter("input") | classifier_chain) | prompt_branch | ChatOpenAI() | StrOutputParser()
) final_chain.invoke( { "input": "What is the first prime number greater than 40 such that one plus the prime number is divisible by 3?" }
)
# Output: Detailed answer to the math question
यह दृष्टिकोण जटिल प्रश्नों को संभालने और इनपुट के आधार पर उन्हें उचित रूप से रूट करने में लैंगचेन के लचीलेपन और शक्ति का उदाहरण देता है।
भाषा मॉडल के दायरे में, एक सामान्य अभ्यास यह है कि एक प्रारंभिक कॉल के बाद बाद की कॉलों की एक श्रृंखला का पालन किया जाता है, एक कॉल के आउटपुट को अगले के लिए इनपुट के रूप में उपयोग किया जाता है। यह अनुक्रमिक दृष्टिकोण विशेष रूप से तब फायदेमंद होता है जब आप पिछली बातचीत में उत्पन्न जानकारी पर निर्माण करना चाहते हैं। जबकि लैंगचेन एक्सप्रेशन लैंग्वेज (एलसीईएल) इन अनुक्रमों को बनाने के लिए अनुशंसित विधि है, सीक्वेंशियलचेन विधि अभी भी इसकी पिछली संगतता के लिए प्रलेखित है।
इसे स्पष्ट करने के लिए, आइए एक परिदृश्य पर विचार करें जहां हम पहले एक नाटक सारांश तैयार करते हैं और फिर उस सारांश के आधार पर एक समीक्षा करते हैं। पायथन का उपयोग करना langchain.prompts
, हम दो बनाते हैं PromptTemplate
उदाहरण: एक सारांश के लिए और दूसरा समीक्षा के लिए। इन टेम्पलेट्स को सेट करने के लिए कोड यहां दिया गया है:
from langchain.prompts import PromptTemplate synopsis_prompt = PromptTemplate.from_template( "You are a playwright. Given the title of play, it is your job to write a synopsis for that title.nnTitle: {title}nPlaywright: This is a synopsis for the above play:"
) review_prompt = PromptTemplate.from_template( "You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:"
)
एलसीईएल दृष्टिकोण में, हम इन संकेतों को श्रृंखलाबद्ध करते हैं ChatOpenAI
और StrOutputParser
एक अनुक्रम बनाने के लिए जो पहले एक सारांश और फिर एक समीक्षा उत्पन्न करता है। कोड स्निपेट इस प्रकार है:
from langchain.chat_models import ChatOpenAI
from langchain.schema import StrOutputParser llm = ChatOpenAI()
chain = ( {"synopsis": synopsis_prompt | llm | StrOutputParser()} | review_prompt | llm | StrOutputParser()
)
chain.invoke({"title": "Tragedy at sunset on the beach"})
यदि हमें सारांश और समीक्षा दोनों की आवश्यकता है, तो हम इसका उपयोग कर सकते हैं RunnablePassthrough
प्रत्येक के लिए एक अलग श्रृंखला बनाना और फिर उन्हें संयोजित करना:
from langchain.schema.runnable import RunnablePassthrough synopsis_chain = synopsis_prompt | llm | StrOutputParser()
review_chain = review_prompt | llm | StrOutputParser()
chain = {"synopsis": synopsis_chain} | RunnablePassthrough.assign(review=review_chain)
chain.invoke({"title": "Tragedy at sunset on the beach"})
अधिक जटिल अनुक्रमों वाले परिदृश्यों के लिए, SequentialChain
विधि चलन में आती है. यह एकाधिक इनपुट और आउटपुट की अनुमति देता है। एक ऐसे मामले पर विचार करें जहां हमें नाटक के शीर्षक और युग के आधार पर एक सारांश की आवश्यकता है। यहां बताया गया है कि हम इसे कैसे सेट कर सकते हैं:
from langchain.llms import OpenAI
from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate llm = OpenAI(temperature=0.7) synopsis_template = "You are a playwright. Given the title of play and the era it is set in, it is your job to write a synopsis for that title.nnTitle: {title}nEra: {era}nPlaywright: This is a synopsis for the above play:"
synopsis_prompt_template = PromptTemplate(input_variables=["title", "era"], template=synopsis_template)
synopsis_chain = LLMChain(llm=llm, prompt=synopsis_prompt_template, output_key="synopsis") review_template = "You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:"
prompt_template = PromptTemplate(input_variables=["synopsis"], template=review_template)
review_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="review") overall_chain = SequentialChain( chains=[synopsis_chain, review_chain], input_variables=["era", "title"], output_variables=["synopsis", "review"], verbose=True,
) overall_chain({"title": "Tragedy at sunset on the beach", "era": "Victorian England"})
ऐसे परिदृश्यों में जहां आप पूरी श्रृंखला में या श्रृंखला के बाद के भाग के लिए संदर्भ बनाए रखना चाहते हैं, SimpleMemory
इस्तेमाल किया जा सकता है। यह जटिल इनपुट/आउटपुट संबंधों के प्रबंधन के लिए विशेष रूप से उपयोगी है। उदाहरण के लिए, ऐसे परिदृश्य में जहां हम किसी नाटक के शीर्षक, युग, सारांश और समीक्षा के आधार पर सोशल मीडिया पोस्ट तैयार करना चाहते हैं, SimpleMemory
इन चरों को प्रबंधित करने में सहायता कर सकते हैं:
from langchain.memory import SimpleMemory
from langchain.chains import SequentialChain template = "You are a social media manager for a theater company. Given the title of play, the era it is set in, the date, time and location, the synopsis of the play, and the review of the play, it is your job to write a social media post for that play.nnHere is some context about the time and location of the play:nDate and Time: {time}nLocation: {location}nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:n{review}nnSocial Media Post:"
prompt_template = PromptTemplate(input_variables=["synopsis", "review", "time", "location"], template=template)
social_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="social_post_text") overall_chain = SequentialChain( memory=SimpleMemory(memories={"time": "December 25th, 8pm PST", "location": "Theater in the Park"}), chains=[synopsis_chain, review_chain, social_chain], input_variables=["era", "title"], output_variables=["social_post_text"], verbose=True,
) overall_chain({"title": "Tragedy at sunset on the beach", "era": "Victorian England"})
अनुक्रमिक श्रृंखलाओं के अलावा, दस्तावेज़ों के साथ काम करने के लिए विशेष श्रृंखलाएँ भी हैं। इनमें से प्रत्येक श्रृंखला एक अलग उद्देश्य को पूरा करती है, जिसमें दस्तावेज़ों के संयोजन से लेकर पुनरावृत्त दस्तावेज़ विश्लेषण के आधार पर उत्तरों को परिष्कृत करना, संक्षेपण के लिए दस्तावेज़ सामग्री को मैप करना और कम करना या स्कोर किए गए प्रतिक्रियाओं के आधार पर पुन: रैंकिंग करना शामिल है। अतिरिक्त लचीलेपन और अनुकूलन के लिए इन श्रृंखलाओं को LCEL के साथ फिर से बनाया जा सकता है।
-
StuffDocumentsChain
एलएलएम को दिए गए एकल प्रॉम्प्ट में दस्तावेज़ों की सूची को संयोजित करता है। -
RefineDocumentsChain
प्रत्येक दस्तावेज़ के लिए अपने उत्तर को पुनरावर्ती रूप से अद्यतन करता है, उन कार्यों के लिए उपयुक्त जहां दस्तावेज़ मॉडल की संदर्भ क्षमता से अधिक हैं। -
MapReduceDocumentsChain
प्रत्येक दस्तावेज़ पर व्यक्तिगत रूप से एक श्रृंखला लागू करता है और फिर परिणामों को जोड़ता है। -
MapRerankDocumentsChain
प्रत्येक दस्तावेज़-आधारित प्रतिक्रिया को स्कोर करता है और उच्चतम स्कोरिंग वाले को चुनता है।
यहां एक उदाहरण दिया गया है कि आप कैसे सेट अप कर सकते हैं MapReduceDocumentsChain
एलसीईएल का उपयोग करना:
from functools import partial
from langchain.chains.combine_documents import collapse_docs, split_list_of_docs
from langchain.schema import Document, StrOutputParser
from langchain.schema.prompt_template import format_document
from langchain.schema.runnable import RunnableParallel, RunnablePassthrough llm = ChatAnthropic()
document_prompt = PromptTemplate.from_template("{page_content}")
partial_format_document = partial(format_document, prompt=document_prompt) map_chain = ( {"context": partial_format_document} | PromptTemplate.from_template("Summarize this content:nn{context}") | llm | StrOutputParser()
) map_as_doc_chain = ( RunnableParallel({"doc": RunnablePassthrough(), "content": map_chain}) | (lambda x: Document(page_content=x["content"], metadata=x["doc"].metadata))
).with_config(run_name="Summarize (return doc)") def format_docs(docs): return "nn".join(partial_format_document(doc) for doc in docs) collapse_chain = ( {"context": format_docs} | PromptTemplate.from_template("Collapse this content:nn{context}") | llm | StrOutputParser()
) reduce_chain = ( {"context": format_docs} | PromptTemplate.from_template("Combine these summaries:nn{context}") | llm | StrOutputParser()
).with_config(run_name="Reduce") map_reduce = (map_as_doc_chain.map() | collapse | reduce_chain).with_config(run_name="Map reduce")
यह कॉन्फ़िगरेशन एलसीईएल और अंतर्निहित भाषा मॉडल की ताकत का लाभ उठाते हुए दस्तावेज़ सामग्री के विस्तृत और व्यापक विश्लेषण की अनुमति देता है।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
मॉड्यूल V: मेमोरी
लैंगचेन में, मेमोरी संवादात्मक इंटरफेस का एक मूलभूत पहलू है, जो सिस्टम को पिछले इंटरैक्शन को संदर्भित करने की अनुमति देता है। यह दो प्राथमिक क्रियाओं के साथ जानकारी संग्रहीत करने और पूछताछ करने के माध्यम से प्राप्त किया जाता है: पढ़ना और लिखना। मेमोरी सिस्टम एक रन के दौरान दो बार एक श्रृंखला के साथ इंटरैक्ट करता है, उपयोगकर्ता इनपुट को बढ़ाता है और भविष्य के संदर्भ के लिए इनपुट और आउटपुट को संग्रहीत करता है।
एक सिस्टम में मेमोरी का निर्माण
- चैट संदेश संग्रहीत करना: लैंगचेन मेमोरी मॉड्यूल चैट संदेशों को संग्रहीत करने के लिए इन-मेमोरी सूचियों से लेकर डेटाबेस तक विभिन्न तरीकों को एकीकृत करता है। यह सुनिश्चित करता है कि सभी चैट इंटरैक्शन भविष्य के संदर्भ के लिए रिकॉर्ड किए गए हैं।
- चैट संदेशों को क्वेरी करना: चैट संदेशों को संग्रहीत करने के अलावा, लैंगचेन इन संदेशों का एक उपयोगी दृश्य बनाने के लिए डेटा संरचनाओं और एल्गोरिदम को नियोजित करता है। सरल मेमोरी सिस्टम हाल के संदेश लौटा सकते हैं, जबकि अधिक उन्नत सिस्टम पिछले इंटरैक्शन का सारांश दे सकते हैं या वर्तमान इंटरैक्शन में उल्लिखित इकाइयों पर ध्यान केंद्रित कर सकते हैं।
लैंगचेन में मेमोरी के उपयोग को प्रदर्शित करने के लिए, इस पर विचार करें ConversationBufferMemory
क्लास, एक सरल मेमोरी फॉर्म जो चैट संदेशों को एक बफर में संग्रहीत करता है। यहाँ एक उदाहरण है:
from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("Hello!")
memory.chat_memory.add_ai_message("How can I assist you?")
मेमोरी को एक श्रृंखला में एकीकृत करते समय, मेमोरी से लौटाए गए वेरिएबल्स को समझना और श्रृंखला में उनका उपयोग कैसे किया जाता है, यह समझना महत्वपूर्ण है। उदाहरण के लिए, load_memory_variables
विधि स्मृति से पढ़े गए चर को श्रृंखला की अपेक्षाओं के साथ संरेखित करने में मदद करती है।
लैंगचेन के साथ शुरू से अंत तक उदाहरण
उपयोग करने पर विचार करें ConversationBufferMemory
एक में LLMChain
. उपयुक्त प्रॉम्प्ट टेम्पलेट और मेमोरी के साथ संयुक्त श्रृंखला, एक सहज वार्तालाप अनुभव प्रदान करती है। यहां एक सरलीकृत उदाहरण दिया गया है:
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory llm = OpenAI(temperature=0)
template = "Your conversation template here..."
prompt = PromptTemplate.from_template(template)
memory = ConversationBufferMemory(memory_key="chat_history")
conversation = LLMChain(llm=llm, prompt=prompt, memory=memory) response = conversation({"question": "What's the weather like?"})
यह उदाहरण दर्शाता है कि कैसे लैंगचेन की मेमोरी प्रणाली एक सुसंगत और प्रासंगिक रूप से जागरूक वार्तालाप अनुभव प्रदान करने के लिए अपनी श्रृंखलाओं के साथ एकीकृत होती है।
लैंगचैन में मेमोरी प्रकार
लैंगचैन विभिन्न मेमोरी प्रकार प्रदान करता है जिनका उपयोग एआई मॉडल के साथ इंटरैक्शन बढ़ाने के लिए किया जा सकता है। प्रत्येक मेमोरी प्रकार के अपने पैरामीटर और रिटर्न प्रकार होते हैं, जो उन्हें विभिन्न परिदृश्यों के लिए उपयुक्त बनाते हैं। आइए कोड उदाहरणों के साथ लैंगचैन में उपलब्ध कुछ मेमोरी प्रकारों का पता लगाएं।
1. वार्तालाप बफ़र मेमोरी
यह मेमोरी प्रकार आपको वार्तालापों से संदेशों को संग्रहीत करने और निकालने की अनुमति देता है। आप इतिहास को एक स्ट्रिंग के रूप में या संदेशों की सूची के रूप में निकाल सकते हैं।
from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory()
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.load_memory_variables({}) # Extract history as a string
{'history': 'Human: hinAI: whats up'} # Extract history as a list of messages
{'history': [HumanMessage(content='hi', additional_kwargs={}), AIMessage(content='whats up', additional_kwargs={})]}
आप चैट-जैसी बातचीत के लिए एक श्रृंखला में वार्तालाप बफ़र मेमोरी का भी उपयोग कर सकते हैं।
2. वार्तालाप बफ़र विंडो मेमोरी
यह मेमोरी प्रकार हाल के इंटरैक्शन की एक सूची रखता है और अंतिम K इंटरैक्शन का उपयोग करता है, जिससे बफर को बहुत बड़ा होने से रोका जा सकता है।
from langchain.memory import ConversationBufferWindowMemory memory = ConversationBufferWindowMemory(k=1)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
memory.load_memory_variables({}) {'history': 'Human: not much younAI: not much'}
कन्वर्सेशन बफ़र मेमोरी की तरह, आप इस मेमोरी प्रकार का उपयोग चैट-जैसी इंटरैक्शन के लिए एक श्रृंखला में भी कर सकते हैं।
3. वार्तालाप इकाई मेमोरी
यह मेमोरी प्रकार बातचीत में विशिष्ट संस्थाओं के बारे में तथ्यों को याद रखता है और एलएलएम का उपयोग करके जानकारी निकालता है।
from langchain.memory import ConversationEntityMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationEntityMemory(llm=llm)
_input = {"input": "Deven & Sam are working on a hackathon project"}
memory.load_memory_variables(_input)
memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"}
)
memory.load_memory_variables({"input": 'who is Sam'}) {'history': 'Human: Deven & Sam are working on a hackathon projectnAI: That sounds like a great project! What kind of project are they working on?', 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}
4. वार्तालाप ज्ञान ग्राफ़ मेमोरी
यह मेमोरी प्रकार मेमोरी को पुनः बनाने के लिए एक ज्ञान ग्राफ़ का उपयोग करता है। आप संदेशों से वर्तमान इकाइयाँ और ज्ञान त्रिक निकाल सकते हैं।
from langchain.memory import ConversationKGMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationKGMemory(llm=llm)
memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"})
memory.save_context({"input": "sam is a friend"}, {"output": "okay"})
memory.load_memory_variables({"input": "who is sam"}) {'history': 'On Sam: Sam is friend.'}
आप इस मेमोरी प्रकार का उपयोग वार्तालाप-आधारित ज्ञान पुनर्प्राप्ति के लिए एक श्रृंखला में भी कर सकते हैं।
5. वार्तालाप सारांश स्मृति
यह मेमोरी प्रकार समय के साथ बातचीत का सारांश बनाता है, जो लंबी बातचीत से जानकारी को संक्षिप्त करने के लिए उपयोगी है।
from langchain.memory import ConversationSummaryMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.load_memory_variables({}) {'history': 'nThe human greets the AI, to which the AI responds.'}
6. वार्तालाप सारांश बफ़र मेमोरी
यह मेमोरी प्रकार वार्तालाप सारांश और बफ़र को जोड़ती है, हाल की बातचीत और सारांश के बीच संतुलन बनाए रखती है। यह निर्धारित करने के लिए टोकन लंबाई का उपयोग करता है कि इंटरैक्शन को कब फ्लश करना है।
from langchain.memory import ConversationSummaryBufferMemory
from langchain.llms import OpenAI llm = OpenAI()
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
memory.load_memory_variables({}) {'history': 'System: nThe human says "hi", and the AI responds with "whats up".nHuman: not much younAI: not much'}
आप लैंगचैन में एआई मॉडल के साथ अपनी बातचीत को बढ़ाने के लिए इन मेमोरी प्रकारों का उपयोग कर सकते हैं। प्रत्येक मेमोरी प्रकार एक विशिष्ट उद्देश्य को पूरा करता है और इसे आपकी आवश्यकताओं के आधार पर चुना जा सकता है।
7. वार्तालाप टोकन बफ़र मेमोरी
ConversationTokenBufferMemory एक अन्य मेमोरी प्रकार है जो मेमोरी में हाल के इंटरैक्शन का बफर रखता है। पिछले मेमोरी प्रकारों के विपरीत, जो इंटरैक्शन की संख्या पर ध्यान केंद्रित करते हैं, यह इंटरैक्शन को फ्लश करने के समय को निर्धारित करने के लिए टोकन लंबाई का उपयोग करता है।
एलएलएम के साथ मेमोरी का उपयोग करना:
from langchain.memory import ConversationTokenBufferMemory
from langchain.llms import OpenAI llm = OpenAI() memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': 'Human: not much younAI: not much'}
इस उदाहरण में, मेमोरी को इंटरैक्शन की संख्या के बजाय टोकन लंबाई के आधार पर इंटरैक्शन को सीमित करने के लिए सेट किया गया है।
इस मेमोरी प्रकार का उपयोग करते समय आप इतिहास को संदेशों की सूची के रूप में भी प्राप्त कर सकते हैं।
memory = ConversationTokenBufferMemory( llm=llm, max_token_limit=10, return_messages=True
)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
एक श्रृंखला में उपयोग करना:
आप AI मॉडल के साथ इंटरैक्शन बढ़ाने के लिए एक श्रृंखला में ConversationTokenBufferMemory का उपयोग कर सकते हैं।
from langchain.chains import ConversationChain conversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationTokenBufferMemory(llm=OpenAI(), max_token_limit=60), verbose=True,
)
conversation_with_summary.predict(input="Hi, what's up?")
इस उदाहरण में, ConversationTokenBufferMemory का उपयोग ConversationChain में बातचीत को प्रबंधित करने और टोकन लंबाई के आधार पर इंटरैक्शन को सीमित करने के लिए किया जाता है।
8. वेक्टरस्टोररिट्रीवरमेमोरी
वेक्टरस्टोररिट्रीवरमेमोरी एक वेक्टर स्टोर में यादों को संग्रहीत करती है और हर बार कॉल किए जाने पर शीर्ष-के सबसे "मुख्य" दस्तावेजों पर सवाल उठाती है। यह मेमोरी प्रकार स्पष्ट रूप से इंटरैक्शन के क्रम को ट्रैक नहीं करता है, लेकिन प्रासंगिक यादें लाने के लिए वेक्टर पुनर्प्राप्ति का उपयोग करता है।
from datetime import datetime
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate # Initialize your vector store (specifics depend on the chosen vector store)
import faiss
from langchain.docstore import InMemoryDocstore
from langchain.vectorstores import FAISS embedding_size = 1536 # Dimensions of the OpenAIEmbeddings
index = faiss.IndexFlatL2(embedding_size)
embedding_fn = OpenAIEmbeddings().embed_query
vectorstore = FAISS(embedding_fn, index, InMemoryDocstore({}), {}) # Create your VectorStoreRetrieverMemory
retriever = vectorstore.as_retriever(search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever) # Save context and relevant information to the memory
memory.save_context({"input": "My favorite food is pizza"}, {"output": "that's good to know"})
memory.save_context({"input": "My favorite sport is soccer"}, {"output": "..."})
memory.save_context({"input": "I don't like the Celtics"}, {"output": "ok"}) # Retrieve relevant information from memory based on a query
print(memory.load_memory_variables({"prompt": "what sport should i watch?"})["history"])
इस उदाहरण में, वेक्टरस्टोररिट्रीवरमेमोरी का उपयोग वेक्टर पुनर्प्राप्ति के आधार पर बातचीत से प्रासंगिक जानकारी को संग्रहीत और पुनर्प्राप्त करने के लिए किया जाता है।
आप वार्तालाप-आधारित ज्ञान पुनर्प्राप्ति के लिए एक श्रृंखला में वेक्टरस्टोररिट्रीवरमेमोरी का भी उपयोग कर सकते हैं, जैसा कि पिछले उदाहरणों में दिखाया गया है।
लैंगचैन में ये विभिन्न मेमोरी प्रकार बातचीत से जानकारी को प्रबंधित करने और पुनर्प्राप्त करने के विभिन्न तरीके प्रदान करते हैं, उपयोगकर्ता प्रश्नों और संदर्भ को समझने और जवाब देने में एआई मॉडल की क्षमताओं को बढ़ाते हैं। आपके एप्लिकेशन की विशिष्ट आवश्यकताओं के आधार पर प्रत्येक मेमोरी प्रकार का चयन किया जा सकता है।
अब हम सीखेंगे कि LLMChain के साथ मेमोरी का उपयोग कैसे करें। LLMChain में मेमोरी मॉडल को अधिक सुसंगत और संदर्भ-जागरूक प्रतिक्रियाएँ प्रदान करने के लिए पिछले इंटरैक्शन और संदर्भ को याद रखने की अनुमति देती है।
LLMChain में मेमोरी सेट करने के लिए, आपको एक मेमोरी क्लास बनाने की आवश्यकता है, जैसे कि ConversationBufferMemory। यहां बताया गया है कि आप इसे कैसे सेट कर सकते हैं:
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate template = """You are a chatbot having a conversation with a human. {chat_history}
Human: {human_input}
Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input"], template=template
)
memory = ConversationBufferMemory(memory_key="chat_history") llm = OpenAI()
llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,
) llm_chain.predict(human_input="Hi there my friend")
इस उदाहरण में, वार्तालाप इतिहास को संग्रहीत करने के लिए कन्वर्सेशनबफ़रमेमोरी का उपयोग किया जाता है। memory_key
पैरामीटर वार्तालाप इतिहास को संग्रहीत करने के लिए उपयोग की जाने वाली कुंजी निर्दिष्ट करता है।
यदि आप पूर्णता-शैली मॉडल के बजाय चैट मॉडल का उपयोग कर रहे हैं, तो आप मेमोरी का बेहतर उपयोग करने के लिए अपने संकेतों को अलग तरीके से तैयार कर सकते हैं। मेमोरी के साथ चैट मॉडल-आधारित LLMChain कैसे सेट करें, इसका एक उदाहरण यहां दिया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.schema import SystemMessage
from langchain.prompts import ( ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder,
) # Create a ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages( [ SystemMessage( content="You are a chatbot having a conversation with a human." ), # The persistent system prompt MessagesPlaceholder( variable_name="chat_history" ), # Where the memory will be stored. HumanMessagePromptTemplate.from_template( "{human_input}" ), # Where the human input will be injected ]
) memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) llm = ChatOpenAI() chat_llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,
) chat_llm_chain.predict(human_input="Hi there my friend")
इस उदाहरण में, ChatPromptTemplate का उपयोग प्रॉम्प्ट को संरचित करने के लिए किया जाता है, और ConversationBufferMemory का उपयोग वार्तालाप इतिहास को संग्रहीत और पुनर्प्राप्त करने के लिए किया जाता है। यह दृष्टिकोण चैट-शैली की बातचीत के लिए विशेष रूप से उपयोगी है जहां संदर्भ और इतिहास महत्वपूर्ण भूमिका निभाते हैं।
मेमोरी को कई इनपुट वाली श्रृंखला में भी जोड़ा जा सकता है, जैसे प्रश्न/उत्तर श्रृंखला। प्रश्न/उत्तर श्रृंखला में मेमोरी कैसे सेट करें इसका एक उदाहरण यहां दिया गया है:
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.embeddings.cohere import CohereEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch
from langchain.vectorstores import Chroma
from langchain.docstore.document import Document
from langchain.chains.question_answering import load_qa_chain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory # Split a long document into smaller chunks
with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_text(state_of_the_union) # Create an ElasticVectorSearch instance to index and search the document chunks
embeddings = OpenAIEmbeddings()
docsearch = Chroma.from_texts( texts, embeddings, metadatas=[{"source": i} for i in range(len(texts))]
) # Perform a question about the document
query = "What did the president say about Justice Breyer"
docs = docsearch.similarity_search(query) # Set up a prompt for the question-answering chain with memory
template = """You are a chatbot having a conversation with a human. Given the following extracted parts of a long document and a question, create a final answer. {context} {chat_history}
Human: {human_input}
Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input", "context"], template=template
)
memory = ConversationBufferMemory(memory_key="chat_history", input_key="human_input")
chain = load_qa_chain( OpenAI(temperature=0), chain_type="stuff", memory=memory, prompt=prompt
) # Ask the question and retrieve the answer
query = "What did the president say about Justice Breyer"
result = chain({"input_documents": docs, "human_input": query}, return_only_outputs=True) print(result)
print(chain.memory.buffer)
इस उदाहरण में, एक प्रश्न का उत्तर छोटे टुकड़ों में विभाजित दस्तावेज़ का उपयोग करके दिया जाता है। कन्वर्सेशनबफ़रमेमोरी का उपयोग वार्तालाप इतिहास को संग्रहीत और पुनर्प्राप्त करने के लिए किया जाता है, जिससे मॉडल को संदर्भ-जागरूक उत्तर प्रदान करने की अनुमति मिलती है।
किसी एजेंट में मेमोरी जोड़ने से उसे प्रश्नों के उत्तर देने और संदर्भ-जागरूक प्रतिक्रियाएँ प्रदान करने के लिए पिछले इंटरैक्शन को याद रखने और उपयोग करने की अनुमति मिलती है। यहां बताया गया है कि आप किसी एजेंट में मेमोरी कैसे सेट कर सकते हैं:
from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.utilities import GoogleSearchAPIWrapper # Create a tool for searching
search = GoogleSearchAPIWrapper()
tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", )
] # Create a prompt with memory
prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!" {chat_history}
Question: {input}
{agent_scratchpad}""" prompt = ZeroShotAgent.create_prompt( tools, prefix=prefix, suffix=suffix, input_variables=["input", "chat_history", "agent_scratchpad"],
)
memory = ConversationBufferMemory(memory_key="chat_history") # Create an LLMChain with memory
llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
agent_chain = AgentExecutor.from_agent_and_tools( agent=agent, tools=tools, verbose=True, memory=memory
) # Ask a question and retrieve the answer
response = agent_chain.run(input="How many people live in Canada?")
print(response) # Ask a follow-up question
response = agent_chain.run(input="What is their national anthem called?")
print(response)
इस उदाहरण में, एक एजेंट में मेमोरी जोड़ी जाती है, जो उसे पिछले वार्तालाप इतिहास को याद रखने और संदर्भ-जागरूक उत्तर प्रदान करने की अनुमति देती है। यह एजेंट को मेमोरी में संग्रहीत जानकारी के आधार पर अनुवर्ती प्रश्नों का सटीक उत्तर देने में सक्षम बनाता है।
लैंगचेन अभिव्यक्ति भाषा
प्राकृतिक भाषा प्रसंस्करण और मशीन सीखने की दुनिया में, संचालन की जटिल श्रृंखला बनाना एक कठिन काम हो सकता है। सौभाग्य से, लैंगचेन एक्सप्रेशन लैंग्वेज (एलसीईएल) बचाव के लिए आती है, जो परिष्कृत भाषा प्रसंस्करण पाइपलाइनों के निर्माण और तैनाती के लिए एक घोषणात्मक और कुशल तरीका प्रदान करती है। एलसीईएल को चेन बनाने की प्रक्रिया को सरल बनाने के लिए डिज़ाइन किया गया है, जिससे प्रोटोटाइप से उत्पादन तक आसानी से जाना संभव हो सके। इस ब्लॉग में, हम पता लगाएंगे कि एलसीईएल क्या है और आप इसका उपयोग क्यों करना चाहते हैं, साथ ही इसकी क्षमताओं को दर्शाने के लिए व्यावहारिक कोड उदाहरण भी देंगे।
एलसीईएल, या लैंगचेन एक्सप्रेशन लैंग्वेज, भाषा प्रसंस्करण श्रृंखलाओं की रचना के लिए एक शक्तिशाली उपकरण है। इसे व्यापक कोड परिवर्तनों की आवश्यकता के बिना, प्रोटोटाइप से उत्पादन तक संक्रमण को निर्बाध रूप से समर्थन देने के उद्देश्य से बनाया गया था। चाहे आप एक सरल "प्रॉम्प्ट + एलएलएम" श्रृंखला बना रहे हों या सैकड़ों चरणों वाली एक जटिल पाइपलाइन, एलसीईएल ने आपको कवर किया है।
आपकी भाषा प्रसंस्करण परियोजनाओं में एलसीईएल का उपयोग करने के कुछ कारण यहां दिए गए हैं:
- तेज़ टोकन स्ट्रीमिंग: एलसीईएल वास्तविक समय में भाषा मॉडल से आउटपुट पार्सर तक टोकन वितरित करता है, जिससे प्रतिक्रिया और दक्षता में सुधार होता है।
- बहुमुखी एपीआई: एलसीईएल प्रोटोटाइप और उत्पादन उपयोग के लिए सिंक्रोनस और एसिंक्रोनस एपीआई दोनों का समर्थन करता है, कई अनुरोधों को कुशलतापूर्वक संभालता है।
- स्वचालित समानांतरीकरण: LCEL जब संभव हो तो समानांतर निष्पादन को अनुकूलित करता है, जिससे सिंक और एसिंक दोनों इंटरफेस में विलंबता कम हो जाती है।
- विश्वसनीय कॉन्फ़िगरेशन: विकास में स्ट्रीमिंग समर्थन के साथ, बड़े पैमाने पर बढ़ी हुई श्रृंखला विश्वसनीयता के लिए पुन: प्रयास और फ़ॉलबैक कॉन्फ़िगर करें।
- स्ट्रीम इंटरमीडिएट परिणाम: उपयोगकर्ता अपडेट या डिबगिंग उद्देश्यों के लिए प्रसंस्करण के दौरान मध्यवर्ती परिणामों तक पहुंचें।
- स्कीमा जनरेशन: LCEL इनपुट और आउटपुट सत्यापन के लिए पाइडेंटिक और JSONSchema स्कीमा उत्पन्न करता है।
- व्यापक अनुरेखण: लैंगस्मिथ अवलोकन और डिबगिंग के लिए जटिल श्रृंखलाओं में सभी चरणों का स्वचालित रूप से पता लगाता है।
- आसान तैनाती: लैंगसर्व का उपयोग करके एलसीईएल-निर्मित श्रृंखलाओं को आसानी से तैनात करें।
अब, आइए व्यावहारिक कोड उदाहरणों पर गौर करें जो एलसीईएल की शक्ति को प्रदर्शित करते हैं। हम उन सामान्य कार्यों और परिदृश्यों का पता लगाएंगे जहां एलसीईएल चमकता है।
प्रॉम्प्ट + एलएलएम
सबसे मौलिक संरचना में एक श्रृंखला बनाने के लिए एक संकेत और एक भाषा मॉडल को संयोजित करना शामिल है जो उपयोगकर्ता इनपुट लेता है, इसे एक संकेत में जोड़ता है, इसे एक मॉडल में भेजता है, और कच्चे मॉडल आउटपुट लौटाता है। यहाँ एक उदाहरण है:
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")
model = ChatOpenAI()
chain = prompt | model result = chain.invoke({"foo": "bears"})
print(result)
इस उदाहरण में, श्रृंखला भालू के बारे में एक चुटकुला उत्पन्न करती है।
यह नियंत्रित करने के लिए कि यह पाठ को कैसे संसाधित करता है, आप अपनी श्रृंखला में स्टॉप अनुक्रम संलग्न कर सकते हैं। उदाहरण के लिए:
chain = prompt | model.bind(stop=["n"])
result = chain.invoke({"foo": "bears"})
print(result)
जब कोई न्यूलाइन कैरेक्टर सामने आता है तो यह कॉन्फ़िगरेशन टेक्स्ट जेनरेशन को रोक देता है।
एलसीईएल आपकी श्रृंखला में फ़ंक्शन कॉल जानकारी संलग्न करने का समर्थन करता है। यहाँ एक उदाहरण है:
functions = [ { "name": "joke", "description": "A joke", "parameters": { "type": "object", "properties": { "setup": {"type": "string", "description": "The setup for the joke"}, "punchline": { "type": "string", "description": "The punchline for the joke", }, }, "required": ["setup", "punchline"], }, }
]
chain = prompt | model.bind(function_call={"name": "joke"}, functions=functions)
result = chain.invoke({"foo": "bears"}, config={})
print(result)
यह उदाहरण चुटकुला उत्पन्न करने के लिए फ़ंक्शन कॉल जानकारी संलग्न करता है।
प्रॉम्प्ट + एलएलएम + आउटपुट पार्सर
आप कच्चे मॉडल आउटपुट को अधिक व्यावहारिक प्रारूप में बदलने के लिए आउटपुट पार्सर जोड़ सकते हैं। यहां बताया गया है कि आप यह कैसे कर सकते हैं:
from langchain.schema.output_parser import StrOutputParser chain = prompt | model | StrOutputParser()
result = chain.invoke({"foo": "bears"})
print(result)
आउटपुट अब स्ट्रिंग प्रारूप में है, जो डाउनस्ट्रीम कार्यों के लिए अधिक सुविधाजनक है।
किसी फ़ंक्शन को वापस लौटने के लिए निर्दिष्ट करते समय, आप इसे सीधे LCEL का उपयोग करके पार्स कर सकते हैं। उदाहरण के लिए:
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser chain = ( prompt | model.bind(function_call={"name": "joke"}, functions=functions) | JsonOutputFunctionsParser()
)
result = chain.invoke({"foo": "bears"})
print(result)
यह उदाहरण सीधे "मजाक" फ़ंक्शन के आउटपुट को पार्स करता है।
ये केवल कुछ उदाहरण हैं कि कैसे LCEL जटिल भाषा प्रसंस्करण कार्यों को सरल बनाता है। चाहे आप चैटबॉट बना रहे हों, सामग्री तैयार कर रहे हों, या जटिल पाठ परिवर्तन कर रहे हों, एलसीईएल आपके वर्कफ़्लो को सुव्यवस्थित कर सकता है और आपके कोड को अधिक रखरखाव योग्य बना सकता है।
आरएजी (पुनर्प्राप्ति-संवर्धित पीढ़ी)
एलसीईएल का उपयोग पुनर्प्राप्ति-संवर्धित पीढ़ी श्रृंखला बनाने के लिए किया जा सकता है, जो पुनर्प्राप्ति और भाषा निर्माण चरणों को जोड़ती है। यहाँ एक उदाहरण है:
from operator import itemgetter from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain.vectorstores import FAISS # Create a vector store and retriever
vectorstore = FAISS.from_texts( ["harrison worked at kensho"], embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever() # Define templates for prompts
template = """Answer the question based only on the following context:
{context} Question: {question} """
prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() # Create a retrieval-augmented generation chain
chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | model | StrOutputParser()
) result = chain.invoke("where did harrison work?")
print(result)
इस उदाहरण में, श्रृंखला संदर्भ से प्रासंगिक जानकारी पुनर्प्राप्त करती है और प्रश्न का उत्तर उत्पन्न करती है।
संवादी पुनर्प्राप्ति श्रृंखला
आप आसानी से अपनी श्रृंखलाओं में वार्तालाप इतिहास जोड़ सकते हैं। यहां संवादात्मक पुनर्प्राप्ति श्रृंखला का एक उदाहरण दिया गया है:
from langchain.schema.runnable import RunnableMap
from langchain.schema import format_document from langchain.prompts.prompt import PromptTemplate # Define templates for prompts
_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language. Chat History:
{chat_history}
Follow Up Input: {question}
Standalone question:"""
CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template) template = """Answer the question based only on the following context:
{context} Question: {question} """
ANSWER_PROMPT = ChatPromptTemplate.from_template(template) # Define input map and context
_inputs = RunnableMap( standalone_question=RunnablePassthrough.assign( chat_history=lambda x: _format_chat_history(x["chat_history"]) ) | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),
)
_context = { "context": itemgetter("standalone_question") | retriever | _combine_documents, "question": lambda x: x["standalone_question"],
}
conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI() result = conversational_qa_chain.invoke( { "question": "where did harrison work?", "chat_history": [], }
)
print(result)
इस उदाहरण में, श्रृंखला बातचीत के संदर्भ में एक अनुवर्ती प्रश्न को संभालती है।
मेमोरी और रिटर्निंग सोर्स दस्तावेज़ों के साथ
एलसीईएल मेमोरी और रिटर्निंग सोर्स दस्तावेज़ों का भी समर्थन करता है। यहां बताया गया है कि आप एक श्रृंखला में मेमोरी का उपयोग कैसे कर सकते हैं:
from operator import itemgetter
from langchain.memory import ConversationBufferMemory # Create a memory instance
memory = ConversationBufferMemory( return_messages=True, output_key="answer", input_key="question"
) # Define steps for the chain
loaded_memory = RunnablePassthrough.assign( chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter("history"),
) standalone_question = { "standalone_question": { "question": lambda x: x["question"], "chat_history": lambda x: _format_chat_history(x["chat_history"]), } | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),
} retrieved_documents = { "docs": itemgetter("standalone_question") | retriever, "question": lambda x: x["standalone_question"],
} final_inputs = { "context": lambda x: _combine_documents(x["docs"]), "question": itemgetter("question"),
} answer = { "answer": final_inputs | ANSWER_PROMPT | ChatOpenAI(), "docs": itemgetter("docs"),
} # Create the final chain by combining the steps
final_chain = loaded_memory | standalone_question | retrieved_documents | answer inputs = {"question": "where did harrison work?"}
result = final_chain.invoke(inputs)
print(result)
इस उदाहरण में, मेमोरी का उपयोग वार्तालाप इतिहास और स्रोत दस्तावेज़ों को संग्रहीत और पुनर्प्राप्त करने के लिए किया जाता है।
एकाधिक जंजीरें
आप Runnables का उपयोग करके कई श्रृंखलाओं को एक साथ जोड़ सकते हैं। यहाँ एक उदाहरण है:
from operator import itemgetter from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser prompt1 = ChatPromptTemplate.from_template("what is the city {person} is from?")
prompt2 = ChatPromptTemplate.from_template( "what country is the city {city} in? respond in {language}"
) model = ChatOpenAI() chain1 = prompt1 | model | StrOutputParser() chain2 = ( {"city": chain1, "language": itemgetter("language")} | prompt2 | model | StrOutputParser()
) result = chain2.invoke({"person": "obama", "language": "spanish"})
print(result)
इस उदाहरण में, एक निर्दिष्ट भाषा में एक शहर और उसके देश के बारे में जानकारी उत्पन्न करने के लिए दो श्रृंखलाओं को संयोजित किया गया है।
शाखाकरण और विलय
LCEL आपको RunnableMaps का उपयोग करके श्रृंखलाओं को विभाजित और विलय करने की अनुमति देता है। यहां शाखाकरण और विलय का एक उदाहरण दिया गया है:
from operator import itemgetter from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser planner = ( ChatPromptTemplate.from_template("Generate an argument about: {input}") | ChatOpenAI() | StrOutputParser() | {"base_response": RunnablePassthrough()}
) arguments_for = ( ChatPromptTemplate.from_template( "List the pros or positive aspects of {base_response}" ) | ChatOpenAI() | StrOutputParser()
)
arguments_against = ( ChatPromptTemplate.from_template( "List the cons or negative aspects of {base_response}" ) | ChatOpenAI() | StrOutputParser()
) final_responder = ( ChatPromptTemplate.from_messages( [ ("ai", "{original_response}"), ("human", "Pros:n{results_1}nnCons:n{results_2}"), ("system", "Generate a final response given the critique"), ] ) | ChatOpenAI() | StrOutputParser()
) chain = ( planner | { "results_1": arguments_for, "results_2": arguments_against, "original_response": itemgetter("base_response"), } | final_responder
) result = chain.invoke({"input": "scrum"})
print(result)
इस उदाहरण में, एक शाखा और विलय श्रृंखला का उपयोग एक तर्क उत्पन्न करने और अंतिम प्रतिक्रिया उत्पन्न करने से पहले इसके पेशेवरों और विपक्षों का मूल्यांकन करने के लिए किया जाता है।
एलसीईएल के साथ पायथन कोड लिखना
लैंगचेन एक्सप्रेशन लैंग्वेज (एलसीईएल) के शक्तिशाली अनुप्रयोगों में से एक उपयोगकर्ता की समस्याओं को हल करने के लिए पायथन कोड लिखना है। पायथन कोड लिखने के लिए एलसीईएल का उपयोग कैसे करें इसका एक उदाहरण नीचे दिया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain_experimental.utilities import PythonREPL template = """Write some python code to solve the user's problem. Return only python code in Markdown format, e.g.: ```python
....
```"""
prompt = ChatPromptTemplate.from_messages([("system", template), ("human", "{input}")]) model = ChatOpenAI() def _sanitize_output(text: str): _, after = text.split("```python") return after.split("```")[0] chain = prompt | model | StrOutputParser() | _sanitize_output | PythonREPL().run result = chain.invoke({"input": "what's 2 plus 2"})
print(result)
इस उदाहरण में, एक उपयोगकर्ता इनपुट प्रदान करता है, और LCEL समस्या को हल करने के लिए पायथन कोड उत्पन्न करता है। फिर कोड को Python REPL का उपयोग करके निष्पादित किया जाता है, और परिणामी Python कोड को मार्कडाउन प्रारूप में वापस कर दिया जाता है।
कृपया ध्यान दें कि Python REPL का उपयोग मनमाना कोड निष्पादित कर सकता है, इसलिए इसका उपयोग सावधानी से करें।
एक शृंखला में मेमोरी जोड़ना
कई संवादात्मक एआई अनुप्रयोगों में मेमोरी आवश्यक है। यहां एक मनमानी श्रृंखला में मेमोरी जोड़ने का तरीका बताया गया है:
from operator import itemgetter
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder model = ChatOpenAI()
prompt = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful chatbot"), MessagesPlaceholder(variable_name="history"), ("human", "{input}"), ]
) memory = ConversationBufferMemory(return_messages=True) # Initialize memory
memory.load_memory_variables({}) chain = ( RunnablePassthrough.assign( history=RunnableLambda(memory.load_memory_variables) | itemgetter("history") ) | prompt | model
) inputs = {"input": "hi, I'm Bob"}
response = chain.invoke(inputs)
response # Save the conversation in memory
memory.save_context(inputs, {"output": response.content}) # Load memory to see the conversation history
memory.load_memory_variables({})
इस उदाहरण में, मेमोरी का उपयोग वार्तालाप इतिहास को संग्रहीत करने और पुनर्प्राप्त करने के लिए किया जाता है, जिससे चैटबॉट को संदर्भ बनाए रखने और उचित रूप से प्रतिक्रिया देने की अनुमति मिलती है।
रननेबल्स के साथ बाहरी उपकरणों का उपयोग करना
एलसीईएल आपको रननेबल्स के साथ बाहरी उपकरणों को सहजता से एकीकृत करने की अनुमति देता है। यहां DuckDuckGo सर्च टूल का उपयोग करके एक उदाहरण दिया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.tools import DuckDuckGoSearchRun search = DuckDuckGoSearchRun() template = """Turn the following user input into a search query for a search engine: {input}"""
prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() chain = prompt | model | StrOutputParser() | search search_result = chain.invoke({"input": "I'd like to figure out what games are tonight"})
print(search_result)
इस उदाहरण में, LCEL डकडकगो सर्च टूल को श्रृंखला में एकीकृत करता है, जिससे यह उपयोगकर्ता इनपुट से एक खोज क्वेरी उत्पन्न करने और खोज परिणाम पुनर्प्राप्त करने की अनुमति देता है।
एलसीईएल का लचीलापन आपकी भाषा प्रसंस्करण पाइपलाइनों में विभिन्न बाहरी उपकरणों और सेवाओं को शामिल करना आसान बनाता है, जिससे उनकी क्षमताओं और कार्यक्षमता में वृद्धि होती है।
एलएलएम एप्लिकेशन में मॉडरेशन जोड़ना
यह सुनिश्चित करने के लिए कि आपका एलएलएम एप्लिकेशन सामग्री नीतियों का पालन करता है और इसमें मॉडरेशन सुरक्षा उपाय शामिल हैं, आप अपनी श्रृंखला में मॉडरेशन जांच को एकीकृत कर सकते हैं। लैंगचेन का उपयोग करके मॉडरेशन जोड़ने का तरीका यहां बताया गया है:
from langchain.chains import OpenAIModerationChain
from langchain.llms import OpenAI
from langchain.prompts import ChatPromptTemplate moderate = OpenAIModerationChain() model = OpenAI()
prompt = ChatPromptTemplate.from_messages([("system", "repeat after me: {input}")]) chain = prompt | model # Original response without moderation
response_without_moderation = chain.invoke({"input": "you are stupid"})
print(response_without_moderation) moderated_chain = chain | moderate # Response after moderation
response_after_moderation = moderated_chain.invoke({"input": "you are stupid"})
print(response_after_moderation)
इस उदाहरण में, OpenAIModerationChain
एलएलएम द्वारा उत्पन्न प्रतिक्रिया में संयम जोड़ने के लिए उपयोग किया जाता है। मॉडरेशन श्रृंखला उस सामग्री की प्रतिक्रिया की जाँच करती है जो OpenAI की सामग्री नीति का उल्लंघन करती है। यदि कोई उल्लंघन पाया जाता है, तो यह तदनुसार प्रतिक्रिया को चिह्नित करेगा।
सिमेंटिक समानता द्वारा रूटिंग
एलसीईएल आपको उपयोगकर्ता इनपुट की अर्थ संबंधी समानता के आधार पर कस्टम रूटिंग लॉजिक लागू करने की अनुमति देता है। उपयोगकर्ता इनपुट के आधार पर श्रृंखला तर्क को गतिशील रूप से कैसे निर्धारित किया जाए इसका एक उदाहरण यहां दिया गया है:
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import PromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableLambda, RunnablePassthrough
from langchain.utils.math import cosine_similarity physics_template = """You are a very smart physics professor. You are great at answering questions about physics in a concise and easy to understand manner. When you don't know the answer to a question you admit that you don't know. Here is a question:
{query}""" math_template = """You are a very good mathematician. You are great at answering math questions. You are so good because you are able to break down hard problems into their component parts, answer the component parts, and then put them together to answer the broader question. Here is a question:
{query}""" embeddings = OpenAIEmbeddings()
prompt_templates = [physics_template, math_template]
prompt_embeddings = embeddings.embed_documents(prompt_templates) def prompt_router(input): query_embedding = embeddings.embed_query(input["query"]) similarity = cosine_similarity([query_embedding], prompt_embeddings)[0] most_similar = prompt_templates[similarity.argmax()] print("Using MATH" if most_similar == math_template else "Using PHYSICS") return PromptTemplate.from_template(most_similar) chain = ( {"query": RunnablePassthrough()} | RunnableLambda(prompt_router) | ChatOpenAI() | StrOutputParser()
) print(chain.invoke({"query": "What's a black hole"}))
print(chain.invoke({"query": "What's a path integral"}))
इस उदाहरण में, prompt_router
फ़ंक्शन भौतिकी और गणित के प्रश्नों के लिए उपयोगकर्ता इनपुट और पूर्वनिर्धारित प्रॉम्प्ट टेम्पलेट्स के बीच कोसाइन समानता की गणना करता है। समानता स्कोर के आधार पर, श्रृंखला गतिशील रूप से सबसे प्रासंगिक प्रॉम्प्ट टेम्पलेट का चयन करती है, यह सुनिश्चित करते हुए कि चैटबॉट उपयोगकर्ता के प्रश्न का उचित उत्तर देता है।
एजेंटों और रननेबल्स का उपयोग करना
लैंगचेन आपको रननेबल्स, प्रॉम्प्ट्स, मॉडल्स और टूल्स को मिलाकर एजेंट बनाने की अनुमति देता है। यहां एक एजेंट बनाने और उसका उपयोग करने का एक उदाहरण दिया गया है:
from langchain.agents import XMLAgent, tool, AgentExecutor
from langchain.chat_models import ChatAnthropic model = ChatAnthropic(model="claude-2") @tool
def search(query: str) -> str: """Search things about current events.""" return "32 degrees" tool_list = [search] # Get prompt to use
prompt = XMLAgent.get_default_prompt() # Logic for going from intermediate steps to a string to pass into the model
def convert_intermediate_steps(intermediate_steps): log = "" for action, observation in intermediate_steps: log += ( f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" f"</tool_input><observation>{observation}</observation>" ) return log # Logic for converting tools to a string to go in the prompt
def convert_tools(tools): return "n".join([f"{tool.name}: {tool.description}" for tool in tools]) agent = ( { "question": lambda x: x["question"], "intermediate_steps": lambda x: convert_intermediate_steps( x["intermediate_steps"] ), } | prompt.partial(tools=convert_tools(tool_list)) | model.bind(stop=["</tool_input>", "</final_answer>"]) | XMLAgent.get_default_output_parser()
) agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True) result = agent_executor.invoke({"question": "What's the weather in New York?"})
print(result)
इस उदाहरण में, मध्यवर्ती चरणों और टूल रूपांतरण के लिए एक मॉडल, टूल, एक प्रॉम्प्ट और एक कस्टम तर्क को मिलाकर एक एजेंट बनाया जाता है। फिर एजेंट को निष्पादित किया जाता है, जो उपयोगकर्ता की क्वेरी का उत्तर प्रदान करता है।
SQL डेटाबेस को क्वेरी करना
आप SQL डेटाबेस को क्वेरी करने और उपयोगकर्ता के प्रश्नों के आधार पर SQL क्वेरी उत्पन्न करने के लिए लैंगचेन का उपयोग कर सकते हैं। यहाँ एक उदाहरण है:
from langchain.prompts import ChatPromptTemplate template = """Based on the table schema below, write a SQL query that would answer the user's question:
{schema} Question: {question}
SQL Query:"""
prompt = ChatPromptTemplate.from_template(template) from langchain.utilities import SQLDatabase # Initialize the database (you'll need the Chinook sample DB for this example)
db = SQLDatabase.from_uri("sqlite:///./Chinook.db") def get_schema(_): return db.get_table_info() def run_query(query): return db.run(query) from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough model = ChatOpenAI() sql_response = ( RunnablePassthrough.assign(schema=get_schema) | prompt | model.bind(stop=["nSQLResult:"]) | StrOutputParser()
) result = sql_response.invoke({"question": "How many employees are there?"})
print(result) template = """Based on the table schema below, question, SQL query, and SQL response, write a natural language response:
{schema} Question: {question}
SQL Query: {query}
SQL Response: {response}"""
prompt_response = ChatPromptTemplate.from_template(template) full_chain = ( RunnablePassthrough.assign(query=sql_response) | RunnablePassthrough.assign( schema=get_schema, response=lambda x: db.run(x["query"]), ) | prompt_response | model
) response = full_chain.invoke({"question": "How many employees are there?"})
print(response)
इस उदाहरण में, लैंगचेन का उपयोग उपयोगकर्ता के प्रश्नों के आधार पर SQL क्वेरी उत्पन्न करने और SQL डेटाबेस से प्रतिक्रियाएँ प्राप्त करने के लिए किया जाता है। डेटाबेस के साथ प्राकृतिक भाषा इंटरैक्शन प्रदान करने के लिए संकेतों और प्रतिक्रियाओं को स्वरूपित किया जाता है।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
लैंगसर्व और लैंगस्मिथ
लैंगसर्व डेवलपर्स को लैंगचेन रननेबल्स और चेन को REST API के रूप में तैनात करने में मदद करता है। यह लाइब्रेरी फास्टएपीआई के साथ एकीकृत है और डेटा सत्यापन के लिए पाइडेंटिक का उपयोग करती है। इसके अतिरिक्त, यह एक क्लाइंट प्रदान करता है जिसका उपयोग सर्वर पर तैनात रननेबल्स में कॉल करने के लिए किया जा सकता है, और एक जावास्क्रिप्ट क्लाइंट लैंगचेनजेएस में उपलब्ध है।
विशेषताएं
- इनपुट और आउटपुट स्कीमा स्वचालित रूप से आपके लैंगचेन ऑब्जेक्ट से अनुमानित होते हैं और समृद्ध त्रुटि संदेशों के साथ प्रत्येक एपीआई कॉल पर लागू होते हैं।
- JSONSchema और Swagger के साथ एक API दस्तावेज़ पृष्ठ उपलब्ध है।
- एक ही सर्वर पर कई समवर्ती अनुरोधों के समर्थन के साथ कुशल /आह्वान, /बैच, और /स्ट्रीम एंडपॉइंट।
- आपकी श्रृंखला/एजेंट से सभी (या कुछ) मध्यवर्ती चरणों को स्ट्रीम करने के लिए /stream_log एंडपॉइंट।
- स्ट्रीमिंग आउटपुट और मध्यवर्ती चरणों के साथ /प्लेग्राउंड पर प्लेग्राउंड पेज।
- लैंगस्मिथ में अंतर्निहित (वैकल्पिक) ट्रेसिंग; बस अपनी एपीआई कुंजी जोड़ें (निर्देश देखें)।
- सभी को फास्टएपीआई, पाइडेंटिक, यूव्लूप और एसिंकियो जैसे युद्ध-परीक्षणित ओपन-सोर्स पायथन लाइब्रेरी के साथ बनाया गया है।
सीमाओं
- क्लाइंट कॉलबैक अभी तक सर्वर पर उत्पन्न होने वाली घटनाओं के लिए समर्थित नहीं हैं।
- Pydantic V2 का उपयोग करते समय OpenAPI दस्तावेज़ उत्पन्न नहीं होंगे। फास्टएपीआई पाइडेंटिक वी1 और वी2 नेमस्पेस को मिलाने का समर्थन नहीं करता है। अधिक विवरण के लिए नीचे अनुभाग देखें।
लैंगसर्व प्रोजेक्ट को शीघ्रता से बूटस्ट्रैप करने के लिए लैंगचेन सीएलआई का उपयोग करें। लैंगचैन सीएलआई का उपयोग करने के लिए, सुनिश्चित करें कि आपके पास लैंगचैन-सीएलआई का नवीनतम संस्करण स्थापित है। आप इसे पिप इंस्टाल -यू लैंगचैन-सीएलआई के साथ इंस्टॉल कर सकते हैं।
langchain app new ../path/to/directory
लैंगचेन टेम्प्लेट के साथ अपना लैंगसर्व इंस्टेंस शीघ्रता से प्रारंभ करें। अधिक उदाहरणों के लिए, टेम्प्लेट इंडेक्स या उदाहरण निर्देशिका देखें।
यहां एक सर्वर है जो एक ओपनएआई चैट मॉडल, एक एंथ्रोपिक चैट मॉडल और एक श्रृंखला तैनात करता है जो किसी विषय के बारे में चुटकुले बताने के लिए एंथ्रोपिक मॉडल का उपयोग करता है।
#!/usr/bin/env python
from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatAnthropic, ChatOpenAI
from langserve import add_routes app = FastAPI( title="LangChain Server", version="1.0", description="A simple api server using Langchain's Runnable interfaces",
) add_routes( app, ChatOpenAI(), path="/openai",
) add_routes( app, ChatAnthropic(), path="/anthropic",
) model = ChatAnthropic()
prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
add_routes( app, prompt | model, path="/chain",
) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="localhost", port=8000)
एक बार जब आप उपरोक्त सर्वर तैनात कर लेते हैं, तो आप निम्न का उपयोग करके जेनरेट किए गए OpenAPI दस्तावेज़ देख सकते हैं:
curl localhost:8000/docs
/docs प्रत्यय जोड़ना सुनिश्चित करें।
from langchain.schema import SystemMessage, HumanMessage
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnableMap
from langserve import RemoteRunnable openai = RemoteRunnable("http://localhost:8000/openai/")
anthropic = RemoteRunnable("http://localhost:8000/anthropic/")
joke_chain = RemoteRunnable("http://localhost:8000/chain/") joke_chain.invoke({"topic": "parrots"}) # or async
await joke_chain.ainvoke({"topic": "parrots"}) prompt = [ SystemMessage(content='Act like either a cat or a parrot.'), HumanMessage(content='Hello!')
] # Supports astream
async for msg in anthropic.astream(prompt): print(msg, end="", flush=True) prompt = ChatPromptTemplate.from_messages( [("system", "Tell me a long story about {topic}")]
) # Can define custom chains
chain = prompt | RunnableMap({ "openai": openai, "anthropic": anthropic,
}) chain.batch([{ "topic": "parrots" }, { "topic": "cats" }])
टाइपस्क्रिप्ट में (LangChain.js संस्करण 0.0.166 या बाद के संस्करण की आवश्यकता है):
import { RemoteRunnable } from "langchain/runnables/remote"; const chain = new RemoteRunnable({ url: `http://localhost:8000/chain/invoke/`,
});
const result = await chain.invoke({ topic: "cats",
});
अनुरोधों का उपयोग करते हुए पायथन:
import requests
response = requests.post( "http://localhost:8000/chain/invoke/", json={'input': {'topic': 'cats'}}
)
response.json()
आप कर्ल का भी उपयोग कर सकते हैं:
curl --location --request POST 'http://localhost:8000/chain/invoke/' --header 'Content-Type: application/json' --data-raw '{ "input": { "topic": "cats" } }'
निम्नलिखित कोड:
...
add_routes( app, runnable, path="/my_runnable",
)
इन समापन बिंदुओं को सर्वर पर जोड़ता है:
- POST /my_runnable/invoke - एक ही इनपुट पर रननेबल को इनवॉक करें
- POST /my_runnable/batch - इनपुट के एक बैच पर रननेबल को लागू करें
- POST /my_runnable/stream - एकल इनपुट पर इनवॉक करें और आउटपुट स्ट्रीम करें
- POST /my_runnable/stream_log - एकल इनपुट पर इनवॉक करें और आउटपुट को स्ट्रीम करें, जिसमें उत्पन्न होने वाले मध्यवर्ती चरणों का आउटपुट भी शामिल है
- रननेबल में इनपुट के लिए /my_runnable/input_schema - json स्कीमा प्राप्त करें
- रननेबल के आउटपुट के लिए /my_runnable/output_schema - json स्कीमा प्राप्त करें
- रननेबल के कॉन्फिगरेशन के लिए /my_runnable/config_schema - json स्कीमा प्राप्त करें
आप अपने रननेबल के लिए खेल का मैदान पृष्ठ /my_runnable/playground पर पा सकते हैं। यह स्ट्रीमिंग आउटपुट और मध्यवर्ती चरणों के साथ आपके रननेबल को कॉन्फ़िगर करने और लागू करने के लिए एक सरल यूआई को उजागर करता है।
क्लाइंट और सर्वर दोनों के लिए:
pip install "langserve[all]"
या पिप क्लाइंट कोड के लिए "langserve[client]" इंस्टॉल करें, और सर्वर कोड के लिए पाइप "langserve[server]" इंस्टॉल करें।
यदि आपको अपने सर्वर पर प्रमाणीकरण जोड़ने की आवश्यकता है, तो कृपया फास्टएपीआई के सुरक्षा दस्तावेज़ और मिडलवेयर दस्तावेज़ का संदर्भ लें।
आप निम्न आदेश का उपयोग करके GCP क्लाउड रन पर तैनात कर सकते हैं:
gcloud run deploy [your-service-name] --source . --port 8001 --allow-unauthenticated --region us-central1 --set-env-vars=OPENAI_API_KEY=your_key
लैंगसर्व कुछ सीमाओं के साथ पाइडेंटिक 2 के लिए समर्थन प्रदान करता है। Pydantic V2 का उपयोग करते समय इनवोक/बैच/स्ट्रीम/स्ट्रीम_लॉग के लिए OpenAPI डॉक्स जेनरेट नहीं किए जाएंगे। फास्ट एपीआई पाइडेंटिक वी1 और वी2 नेमस्पेस को मिलाने का समर्थन नहीं करता है। लैंगचेन पाइडेंटिक v1 में v2 नेमस्पेस का उपयोग करता है। कृपया लैंगचेन के साथ अनुकूलता सुनिश्चित करने के लिए निम्नलिखित दिशानिर्देश पढ़ें। इन सीमाओं को छोड़कर, हम उम्मीद करते हैं कि एपीआई एंडपॉइंट, खेल का मैदान और अन्य सुविधाएं उम्मीद के मुताबिक काम करेंगी।
एलएलएम एप्लिकेशन अक्सर फाइलों से निपटते हैं। फ़ाइल प्रोसेसिंग को लागू करने के लिए अलग-अलग आर्किटेक्चर बनाए जा सकते हैं; उच्च स्तर पर:
- फ़ाइल को एक समर्पित एंडपॉइंट के माध्यम से सर्वर पर अपलोड किया जा सकता है और एक अलग एंडपॉइंट का उपयोग करके संसाधित किया जा सकता है।
- फ़ाइल को या तो मान (फ़ाइल के बाइट्स) या संदर्भ (उदाहरण के लिए, फ़ाइल सामग्री के लिए s3 यूआरएल) द्वारा अपलोड किया जा सकता है।
- प्रसंस्करण समापन बिंदु अवरुद्ध या गैर-अवरुद्ध हो सकता है।
- यदि महत्वपूर्ण प्रसंस्करण की आवश्यकता है, तो प्रसंस्करण को एक समर्पित प्रक्रिया पूल में लोड किया जा सकता है।
आपको यह निर्धारित करना चाहिए कि आपके एप्लिकेशन के लिए उपयुक्त आर्किटेक्चर क्या है। वर्तमान में, किसी रननेबल में मान के अनुसार फ़ाइलें अपलोड करने के लिए, फ़ाइल के लिए बेस64 एन्कोडिंग का उपयोग करें (मल्टीपार्ट/फ़ॉर्म-डेटा अभी तक समर्थित नहीं है)।
यहाँ एक है उदाहरण यह दिखाता है कि रिमोट रननेबल पर फ़ाइल भेजने के लिए बेस 64 एन्कोडिंग का उपयोग कैसे करें। याद रखें, आप हमेशा संदर्भ द्वारा फ़ाइलें अपलोड कर सकते हैं (उदाहरण के लिए, s3 यूआरएल) या उन्हें एक समर्पित एंडपॉइंट पर मल्टीपार्ट/फॉर्म-डेटा के रूप में अपलोड कर सकते हैं।
इनपुट और आउटपुट प्रकार सभी रननेबल्स पर परिभाषित किए गए हैं। आप उन्हें इनपुट_स्कीमा और आउटपुट_स्कीमा गुणों के माध्यम से एक्सेस कर सकते हैं। लैंगसर्व सत्यापन और दस्तावेज़ीकरण के लिए इन प्रकारों का उपयोग करता है। यदि आप डिफ़ॉल्ट अनुमानित प्रकारों को ओवरराइड करना चाहते हैं, तो आप with_types विधि का उपयोग कर सकते हैं।
इस विचार को स्पष्ट करने के लिए यहां एक खिलौने का उदाहरण दिया गया है:
from typing import Any
from fastapi import FastAPI
from langchain.schema.runnable import RunnableLambda app = FastAPI() def func(x: Any) -> int: """Mistyped function that should accept an int but accepts anything.""" return x + 1 runnable = RunnableLambda(func).with_types( input_schema=int,
) add_routes(app, runnable)
यदि आप चाहते हैं कि डेटा को समतुल्य तानाशाही प्रतिनिधित्व के बजाय एक पाइडेंटिक मॉडल में डिसेरिएलाइज़ किया जाए तो CustomUserType से इनहेरिट करें। फिलहाल, यह प्रकार केवल सर्वर-साइड पर काम करता है और वांछित डिकोडिंग व्यवहार को निर्दिष्ट करने के लिए उपयोग किया जाता है। यदि इस प्रकार से विरासत में मिला है, तो सर्वर डिकोड किए गए प्रकार को एक तानाशाही में परिवर्तित करने के बजाय एक पाइडेंटिक मॉडल के रूप में रखेगा।
from fastapi import FastAPI
from langchain.schema.runnable import RunnableLambda
from langserve import add_routes
from langserve.schema import CustomUserType app = FastAPI() class Foo(CustomUserType): bar: int def func(foo: Foo) -> int: """Sample function that expects a Foo type which is a pydantic model""" assert isinstance(foo, Foo) return foo.bar add_routes(app, RunnableLambda(func), path="/foo")
खेल का मैदान आपको बैकएंड से अपने रननेबल के लिए कस्टम विजेट परिभाषित करने की अनुमति देता है। एक विजेट फ़ील्ड स्तर पर निर्दिष्ट किया जाता है और इनपुट प्रकार के JSON स्कीमा के भाग के रूप में भेजा जाता है। एक विजेट में टाइप नामक एक कुंजी होनी चाहिए जिसका मान विजेट्स की एक प्रसिद्ध सूची में से एक हो। अन्य विजेट कुंजियाँ उन मानों से जुड़ी होंगी जो JSON ऑब्जेक्ट में पथों का वर्णन करते हैं।
सामान्य स्कीमा:
type JsonPath = number | string | (number | string)[];
type NameSpacedPath = { title: string; path: JsonPath }; // Using title to mimic json schema, but can use namespace
type OneOfPath = { oneOf: JsonPath[] }; type Widget = { type: string // Some well-known type (e.g., base64file, chat, etc.) [key: string]: JsonPath | NameSpacedPath | OneOfPath;
};
बेस64 एन्कोडेड स्ट्रिंग्स के रूप में अपलोड की गई फ़ाइलों के लिए यूआई प्लेग्राउंड में फ़ाइल अपलोड इनपुट के निर्माण की अनुमति देता है। यहाँ पूरा उदाहरण है.
try: from pydantic.v1 import Field
except ImportError: from pydantic import Field from langserve import CustomUserType # ATTENTION: Inherit from CustomUserType instead of BaseModel otherwise
# the server will decode it into a dict instead of a pydantic model.
class FileProcessingRequest(CustomUserType): """Request including a base64 encoded file.""" # The extra field is used to specify a widget for the playground UI. file: str = Field(..., extra={"widget": {"type": "base64file"}}) num_chars: int = 100
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
लैंगस्मिथ का परिचय
लैंगचेन एलएलएम अनुप्रयोगों और एजेंटों को प्रोटोटाइप करना आसान बनाता है। हालाँकि, एलएलएम अनुप्रयोगों को उत्पादन तक पहुंचाना भ्रामक रूप से कठिन हो सकता है। उच्च गुणवत्ता वाला उत्पाद बनाने के लिए आपको संभवतः अपने संकेतों, श्रृंखलाओं और अन्य घटकों को भारी रूप से अनुकूलित और पुनरावृत्त करना होगा।
इस प्रक्रिया में सहायता के लिए, लैंगस्मिथ पेश किया गया, जो आपके एलएलएम अनुप्रयोगों को डिबगिंग, परीक्षण और निगरानी के लिए एक एकीकृत मंच है।
यह कब काम आ सकता है? आपको यह तब उपयोगी लग सकता है जब आप किसी नई श्रृंखला, एजेंट, या उपकरणों के सेट को जल्दी से डीबग करना चाहते हैं, कल्पना करना चाहते हैं कि घटक (चेन, एलएलएम, रिट्रीवर्स, आदि) कैसे संबंधित हैं और उपयोग किए जाते हैं, एक ही घटक के लिए विभिन्न संकेतों और एलएलएम का मूल्यांकन करें, यह सुनिश्चित करने के लिए कि यह लगातार गुणवत्ता बार को पूरा करता है, किसी डेटासेट पर दी गई श्रृंखला को कई बार चलाएं, या उपयोग के निशान कैप्चर करें और अंतर्दृष्टि उत्पन्न करने के लिए एलएलएम या एनालिटिक्स पाइपलाइन का उपयोग करें।
आवश्यक:
- एक लैंगस्मिथ खाता बनाएं और एक एपीआई कुंजी बनाएं (निचला बायां कोना देखें)।
- दस्तावेज़ों को देखकर प्लेटफ़ॉर्म से स्वयं को परिचित करें।
अब, चलो शुरू हो जाओ!
सबसे पहले, लैंगचेन को ट्रेस लॉग करने के लिए कहने के लिए अपने पर्यावरण चर को कॉन्फ़िगर करें। यह LANGCHAIN_TRACING_V2 पर्यावरण चर को सत्य पर सेट करके किया जाता है। आप LANGCHAIN_PROJECT पर्यावरण चर सेट करके लैंगचेन को बता सकते हैं कि किस प्रोजेक्ट में लॉग इन करना है (यदि यह सेट नहीं है, तो रन डिफ़ॉल्ट प्रोजेक्ट में लॉग हो जाएंगे)। यदि यह मौजूद नहीं है तो यह स्वचालित रूप से आपके लिए प्रोजेक्ट बना देगा। आपको LANGCHAIN_ENDPOINT और LANGCHAIN_API_KEY पर्यावरण चर भी सेट करना होगा।
ध्यान दें: आप निम्न का उपयोग करके ट्रेस लॉग करने के लिए पायथन में एक संदर्भ प्रबंधक का भी उपयोग कर सकते हैं:
from langchain.callbacks.manager import tracing_v2_enabled with tracing_v2_enabled(project_name="My Project"): agent.run("How many people live in canada as of 2023?")
हालाँकि, इस उदाहरण में, हम पर्यावरण चर का उपयोग करेंगे।
%pip install openai tiktoken pandas duckduckgo-search --quiet import os
from uuid import uuid4 unique_id = uuid4().hex[0:8]
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = f"Tracing Walkthrough - {unique_id}"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_API_KEY"] = "<YOUR-API-KEY>" # Update to your API key # Used by the agent in this tutorial
os.environ["OPENAI_API_KEY"] = "<YOUR-OPENAI-API-KEY>"
एपीआई के साथ इंटरैक्ट करने के लिए लैंगस्मिथ क्लाइंट बनाएं:
from langsmith import Client client = Client()
एक लैंगचेन घटक बनाएं और प्लेटफ़ॉर्म पर लॉग रन करें। इस उदाहरण में, हम एक सामान्य खोज टूल (डकडकगो) तक पहुंच के साथ एक रिएक्ट-शैली एजेंट बनाएंगे। एजेंट का संकेत यहां हब में देखा जा सकता है:
from langchain import hub
from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.chat_models import ChatOpenAI
from langchain.tools import DuckDuckGoSearchResults
from langchain.tools.render import format_tool_to_openai_function # Fetches the latest version of this prompt
prompt = hub.pull("wfh/langsmith-agent-prompt:latest") llm = ChatOpenAI( model="gpt-3.5-turbo-16k", temperature=0,
) tools = [ DuckDuckGoSearchResults( name="duck_duck_go" ), # General internet search using DuckDuckGo
] llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools]) runnable_agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
) agent_executor = AgentExecutor( agent=runnable_agent, tools=tools, handle_parsing_errors=True
)
हम विलंबता को कम करने के लिए एजेंट को कई इनपुट पर एक साथ चला रहे हैं। रन पृष्ठभूमि में लैंगस्मिथ में लॉग हो जाते हैं, इसलिए निष्पादन विलंबता अप्रभावित रहती है:
inputs = [ "What is LangChain?", "What's LangSmith?", "When was Llama-v2 released?", "What is the langsmith cookbook?", "When did langchain first announce the hub?",
] results = agent_executor.batch([{"input": x} for x in inputs], return_exceptions=True) results[:2]
यह मानते हुए कि आपने अपना परिवेश सफलतापूर्वक स्थापित कर लिया है, आपके एजेंट के निशान ऐप में प्रोजेक्ट अनुभाग में दिखाई देने चाहिए। बधाई!
हालाँकि ऐसा लगता है कि एजेंट प्रभावी ढंग से टूल का उपयोग नहीं कर रहा है। आइए इसका मूल्यांकन करें ताकि हमारे पास एक आधार रेखा हो।
लॉगिंग रन के अलावा, लैंगस्मिथ आपको अपने एलएलएम अनुप्रयोगों का परीक्षण और मूल्यांकन करने की भी अनुमति देता है।
इस अनुभाग में, आप एक बेंचमार्क डेटासेट बनाने और एक एजेंट पर एआई-सहायता प्राप्त मूल्यांकनकर्ताओं को चलाने के लिए लैंगस्मिथ का लाभ उठाएंगे। आप ऐसा कुछ चरणों में करेंगे:
- लैंगस्मिथ डेटासेट बनाएं:
नीचे, हम ऊपर दिए गए इनपुट प्रश्नों और एक सूची लेबल से डेटासेट बनाने के लिए लैंगस्मिथ क्लाइंट का उपयोग करते हैं। आप किसी नए एजेंट के प्रदर्शन को मापने के लिए बाद में इनका उपयोग करेंगे। डेटासेट उदाहरणों का एक संग्रह है, जो इनपुट-आउटपुट जोड़े से ज्यादा कुछ नहीं है जिन्हें आप अपने एप्लिकेशन में परीक्षण मामलों के रूप में उपयोग कर सकते हैं:
outputs = [ "LangChain is an open-source framework for building applications using large language models. It is also the name of the company building LangSmith.", "LangSmith is a unified platform for debugging, testing, and monitoring language model applications and agents powered by LangChain", "July 18, 2023", "The langsmith cookbook is a github repository containing detailed examples of how to use LangSmith to debug, evaluate, and monitor large language model-powered applications.", "September 5, 2023",
] dataset_name = f"agent-qa-{unique_id}" dataset = client.create_dataset( dataset_name, description="An example dataset of questions over the LangSmith documentation.",
) for query, answer in zip(inputs, outputs): client.create_example( inputs={"input": query}, outputs={"output": answer}, dataset_id=dataset.id )
- बेंचमार्क करने के लिए एक नया एजेंट प्रारंभ करें:
लैंगस्मिथ आपको किसी एलएलएम, चेन, एजेंट या यहां तक कि एक कस्टम फ़ंक्शन का मूल्यांकन करने देता है। संवादी एजेंट स्टेटफुल होते हैं (उनके पास स्मृति होती है); यह सुनिश्चित करने के लिए कि यह स्थिति डेटासेट रन के बीच साझा नहीं की जाती है, हम एक चेन_फैक्ट्री (
प्रत्येक कॉल के लिए प्रारंभ करने के लिए एक कंस्ट्रक्टर) फ़ंक्शन:
# Since chains can be stateful (e.g. they can have memory), we provide
# a way to initialize a new chain for each row in the dataset. This is done
# by passing in a factory function that returns a new chain for each row.
def agent_factory(prompt): llm_with_tools = llm.bind( functions=[format_tool_to_openai_function(t) for t in tools] ) runnable_agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser() ) return AgentExecutor(agent=runnable_agent, tools=tools, handle_parsing_errors=True)
- मूल्यांकन कॉन्फ़िगर करें:
यूआई में श्रृंखलाओं के परिणामों की मैन्युअल रूप से तुलना करना प्रभावी है, लेकिन इसमें समय लग सकता है। आपके घटक के प्रदर्शन का मूल्यांकन करने के लिए स्वचालित मेट्रिक्स और एआई-सहायता प्राप्त फीडबैक का उपयोग करना सहायक हो सकता है:
from langchain.evaluation import EvaluatorType
from langchain.smith import RunEvalConfig evaluation_config = RunEvalConfig( evaluators=[ EvaluatorType.QA, EvaluatorType.EMBEDDING_DISTANCE, RunEvalConfig.LabeledCriteria("helpfulness"), RunEvalConfig.LabeledScoreString( { "accuracy": """
Score 1: The answer is completely unrelated to the reference.
Score 3: The answer has minor relevance but does not align with the reference.
Score 5: The answer has moderate relevance but contains inaccuracies.
Score 7: The answer aligns with the reference but has minor errors or omissions.
Score 10: The answer is completely accurate and aligns perfectly with the reference.""" }, normalize_by=10, ), ], custom_evaluators=[],
)
- एजेंट और मूल्यांकनकर्ता चलाएँ:
अपने मॉडल का मूल्यांकन करने के लिए run_on_dataset (या एसिंक्रोनस arun_on_dataset) फ़ंक्शन का उपयोग करें। यह करेगा:
- निर्दिष्ट डेटासेट से उदाहरण पंक्तियाँ प्राप्त करें।
- प्रत्येक उदाहरण पर अपना एजेंट (या कोई कस्टम फ़ंक्शन) चलाएँ।
- स्वचालित फीडबैक उत्पन्न करने के लिए परिणामी रन ट्रेस और संबंधित संदर्भ उदाहरणों पर मूल्यांकनकर्ताओं को लागू करें।
परिणाम लैंगस्मिथ ऐप में दिखाई देंगे:
chain_results = run_on_dataset( dataset_name=dataset_name, llm_or_chain_factory=functools.partial(agent_factory, prompt=prompt), evaluation=evaluation_config, verbose=True, client=client, project_name=f"runnable-agent-test-5d466cbc-{unique_id}", tags=[ "testing-notebook", "prompt:5d466cbc", ],
)
अब जब हमारे पास हमारे परीक्षण परिणाम हैं, तो हम अपने एजेंट में बदलाव कर सकते हैं और उन्हें बेंचमार्क कर सकते हैं। आइए एक अलग संकेत के साथ इसे फिर से आज़माएँ और परिणाम देखें:
candidate_prompt = hub.pull("wfh/langsmith-agent-prompt:39f3bbd0") chain_results = run_on_dataset( dataset_name=dataset_name, llm_or_chain_factory=functools.partial(agent_factory, prompt=candidate_prompt), evaluation=evaluation_config, verbose=True, client=client, project_name=f"runnable-agent-test-39f3bbd0-{unique_id}", tags=[ "testing-notebook", "prompt:39f3bbd0", ],
)
लैंगस्मिथ आपको सीधे वेब ऐप में सीएसवी या जेएसओएनएल जैसे सामान्य प्रारूपों में डेटा निर्यात करने देता है। आप क्लाइंट का उपयोग आगे के विश्लेषण के लिए रन लाने, अपने डेटाबेस में संग्रहीत करने, या दूसरों के साथ साझा करने के लिए भी कर सकते हैं। आइए मूल्यांकन रन से रन ट्रेस प्राप्त करें:
runs = client.list_runs(project_name=chain_results["project_name"], execution_order=1) # After some time, these will be populated.
client.read_project(project_name=chain_results["project_name"]).feedback_stats
आरंभ करने के लिए यह एक त्वरित मार्गदर्शिका थी, लेकिन आपके डेवलपर प्रवाह को तेज़ करने और बेहतर परिणाम देने के लिए लैंगस्मिथ का उपयोग करने के कई और तरीके हैं।
आप लैंगस्मिथ से अधिकतम लाभ कैसे प्राप्त कर सकते हैं, इसके बारे में अधिक जानकारी के लिए लैंगस्मिथ दस्तावेज़ देखें।
नैनोनेट्स के साथ स्तर बढ़ाएं
जबकि लैंगचेन आपके अनुप्रयोगों के साथ भाषा मॉडल (एलएलएम) को एकीकृत करने के लिए एक मूल्यवान उपकरण है, जब उद्यम उपयोग के मामलों की बात आती है तो इसे सीमाओं का सामना करना पड़ सकता है। आइए जानें कि नैनोनेट्स इन चुनौतियों का समाधान करने के लिए लैंगचेन से आगे कैसे जाता है:
1. व्यापक डेटा कनेक्टिविटी:
लैंगचेन कनेक्टर प्रदान करता है, लेकिन यह उन सभी कार्यक्षेत्र ऐप्स और डेटा प्रारूपों को कवर नहीं कर सकता है जिन पर व्यवसाय भरोसा करते हैं। नैनोनेट्स 100 से अधिक व्यापक रूप से उपयोग किए जाने वाले वर्कस्पेस ऐप्स के लिए डेटा कनेक्टर प्रदान करता है, जिनमें स्लैक, नोशन, गूगल सूट, सेल्सफोर्स, ज़ेंडेस्क और कई अन्य शामिल हैं। यह सभी असंरचित डेटा प्रकारों जैसे पीडीएफ, टीएक्सटी, छवियां, ऑडियो फ़ाइलें और वीडियो फ़ाइलों के साथ-साथ सीएसवी, स्प्रेडशीट, मोंगोडीबी और एसक्यूएल डेटाबेस जैसे संरचित डेटा प्रकारों का भी समर्थन करता है।
2. कार्यक्षेत्र ऐप्स के लिए कार्य स्वचालन:
जबकि पाठ/प्रतिक्रिया निर्माण बढ़िया काम करता है, जब विभिन्न अनुप्रयोगों में कार्य करने के लिए प्राकृतिक भाषा का उपयोग करने की बात आती है तो लैंगचेन की क्षमताएं सीमित होती हैं। नैनोनेट्स सबसे लोकप्रिय वर्कस्पेस ऐप्स के लिए ट्रिगर/एक्शन एजेंट प्रदान करता है, जो आपको वर्कफ़्लो सेट करने की अनुमति देता है जो घटनाओं को सुनता है और कार्रवाई करता है। उदाहरण के लिए, आप प्राकृतिक भाषा कमांड के माध्यम से ईमेल प्रतिक्रियाओं, सीआरएम प्रविष्टियों, एसक्यूएल क्वेरीज़ और बहुत कुछ को स्वचालित कर सकते हैं।
3. वास्तविक समय डेटा सिंक:
लैंगचेन डेटा कनेक्टर्स के साथ स्थिर डेटा प्राप्त करता है, जो स्रोत डेटाबेस में डेटा परिवर्तनों के साथ तालमेल नहीं रख सकता है। इसके विपरीत, नैनोनेट्स डेटा स्रोतों के साथ वास्तविक समय सिंक्रनाइज़ेशन सुनिश्चित करता है, यह सुनिश्चित करते हुए कि आप हमेशा नवीनतम जानकारी के साथ काम कर रहे हैं।
3. सरलीकृत विन्यास:
लैंगचेन पाइपलाइन के तत्वों, जैसे रिट्रीवर्स और सिंथेसाइज़र को कॉन्फ़िगर करना एक जटिल और समय लेने वाली प्रक्रिया हो सकती है। नैनोनेट्स प्रत्येक डेटा प्रकार के लिए अनुकूलित डेटा अंतर्ग्रहण और अनुक्रमण प्रदान करके इसे सुव्यवस्थित करता है, सभी को एआई असिस्टेंट द्वारा पृष्ठभूमि में नियंत्रित किया जाता है। इससे फाइन-ट्यूनिंग का बोझ कम हो जाता है और इसे स्थापित करना और उपयोग करना आसान हो जाता है।
4. एकीकृत समाधान:
लैंगचेन के विपरीत, जिसे प्रत्येक कार्य के लिए अद्वितीय कार्यान्वयन की आवश्यकता हो सकती है, नैनोनेट्स आपके डेटा को एलएलएम से जोड़ने के लिए वन-स्टॉप समाधान के रूप में कार्य करता है। चाहे आपको एलएलएम एप्लिकेशन या एआई वर्कफ़्लो बनाने की आवश्यकता हो, नैनोनेट्स आपकी विविध आवश्यकताओं के लिए एक एकीकृत मंच प्रदान करता है।
नैनोनेट्स एआई वर्कफ़्लोज़
नैनोनेट्स वर्कफ़्लोज़ एक सुरक्षित, बहुउद्देश्यीय एआई सहायक है जो एलएलएम के साथ आपके ज्ञान और डेटा के एकीकरण को सरल बनाता है और नो-कोड एप्लिकेशन और वर्कफ़्लो के निर्माण की सुविधा प्रदान करता है। यह उपयोग में आसान उपयोगकर्ता इंटरफ़ेस प्रदान करता है, जो इसे व्यक्तियों और संगठनों दोनों के लिए सुलभ बनाता है।
आरंभ करने के लिए, आप हमारे एआई विशेषज्ञों में से एक के साथ कॉल शेड्यूल कर सकते हैं, जो आपके विशिष्ट उपयोग के मामले के अनुरूप नैनोनेट्स वर्कफ़्लो का व्यक्तिगत डेमो और परीक्षण प्रदान कर सकता है।
एक बार सेट हो जाने पर, आप एलएलएम द्वारा संचालित जटिल अनुप्रयोगों और वर्कफ़्लो को डिजाइन और निष्पादित करने के लिए प्राकृतिक भाषा का उपयोग कर सकते हैं, जो आपके ऐप्स और डेटा के साथ सहजता से एकीकृत होता है।
ऐप बनाने और अपने डेटा को एआई-संचालित एप्लिकेशन और वर्कफ़्लो के साथ एकीकृत करने के लिए नैनोनेट्स एआई के साथ अपनी टीमों को सुपरचार्ज करें, जिससे आपकी टीमों को वास्तव में जो मायने रखता है उस पर ध्यान केंद्रित करने की अनुमति मिलती है।
आपके और आपकी टीमों के लिए नैनोनेट्स द्वारा डिज़ाइन किए गए हमारे एआई-संचालित वर्कफ़्लो बिल्डर के साथ मैन्युअल कार्यों और वर्कफ़्लो को स्वचालित करें।
- एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
- प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
- प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
- प्लेटोईएसजी. कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
- प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
- स्रोत: https://nanonets.com/blog/langchain/
- :हैस
- :है
- :नहीं
- :कहाँ
- $यूपी
- 1
- 10
- 100
- 114
- 13
- 15% तक
- 2000
- 2012
- 2023
- 25
- 30
- 32
- 36
- 40
- 400
- 408
- 50
- 500
- 7
- 8
- a
- एबीसी
- क्षमता
- योग्य
- About
- इसके बारे में
- ऊपर
- स्वीकार करें
- स्वीकार करता है
- पहुँच
- सुलभ
- तक पहुँचने
- पूरा
- तदनुसार
- लेखा
- शुद्धता
- सही
- सही रूप में
- पाना
- हासिल
- प्राप्त
- के पार
- अधिनियम
- कार्य
- कार्रवाई
- सक्रिय
- अनुकूल ढालने
- अनुकूली
- जोड़ना
- जोड़ा
- जोड़ने
- इसके अलावा
- अतिरिक्त
- इसके अतिरिक्त
- पता
- जोड़ता है
- स्वीकार करना
- उन्नत
- साहसिक
- बाद
- फिर
- उम्र
- एजेंट
- एजेंटों
- AI
- एआई सहायक
- एआई मॉडल
- सहायता
- एमिंग
- एल्गोरिदम
- संरेखित करें
- संरेखित करता है
- सब
- अनुमति देना
- की अनुमति दे
- की अनुमति देता है
- अकेला
- साथ में
- साथ - साथ
- पहले ही
- भी
- हालांकि
- हमेशा
- an
- विश्लेषण
- विश्लेषणात्मक
- विश्लेषिकी
- और
- एंजेल्स
- की घोषणा
- वार्षिक
- अन्य
- जवाब
- जवाब
- गान
- anthropic
- कोई
- कुछ भी
- एपीआई
- एपीआई कुंजियाँ
- एपीआई
- अनुप्रयोग
- उपयुक्त
- आवेदन
- अनुप्रयोग विकास
- अनुप्रयोगों
- लागू
- लागू होता है
- दृष्टिकोण
- दृष्टिकोण
- उपयुक्त
- उचित रूप से
- क्षुधा
- स्थापत्य
- हैं
- तर्क
- तर्क
- आर्मस्ट्रांग
- चारों ओर
- ऐरे
- कलाकार
- AS
- पूछना
- पहलू
- पहलुओं
- सहायता
- सहायक
- जुड़े
- At
- संलग्न करना
- ध्यान
- ऑडियो
- संवर्धित
- प्रमाणीकरण
- को स्वचालित रूप से
- स्वचालित
- ऑटोमेटा
- स्वतः
- स्वचालन
- उपलब्ध
- औसत
- का इंतजार
- जागरूक
- एडब्ल्यूएस
- वापस
- आधार
- बैकएण्ड
- पृष्ठभूमि
- बुरी तरह
- शेष
- बार
- आधार
- आधारित
- आधारभूत
- खूब जोर से पीटना
- बुनियादी
- मूल बातें
- बीसीजी
- BE
- समुद्र तट
- भालू
- क्योंकि
- किया गया
- से पहले
- शुरू करना
- व्यवहार
- पीछे
- परदे के पीछे
- जा रहा है
- नीचे
- बेंचमार्क
- लाभदायक
- BEST
- बेहतर
- के बीच
- परे
- सबसे बड़ा
- बिल
- बिल गेट्स
- बाँध
- बिंग
- बिट
- काली
- ब्लैक होल
- खंड
- ब्लॉकिंग
- ब्लॉक
- ब्लॉग
- अनाज
- जूते का फीता
- जन्म
- बीओटी
- के छात्रों
- तल
- शाखा
- टूटना
- बयार
- संक्षिप्त
- व्यापक
- भूरा
- ब्राउज़र
- बफर
- निर्माण
- निर्माता
- इमारत
- बनाया गया
- बोझ
- व्यवसायों
- लेकिन
- by
- गणना
- गणना
- परिकलन
- हिसाब
- कॉल
- कॉलबैक
- बुलाया
- बुला
- कॉल
- कर सकते हैं
- पा सकते हैं
- कनाडा
- क्षमताओं
- सक्षम
- क्षमता
- कब्जा
- कैप्चरिंग
- मामला
- मामलों
- कैट
- पूरा
- खानपान
- पूरा करता है
- बिल्ली की
- सावधानी
- सतर्क
- केंद्रित
- कुछ
- श्रृंखला
- चेन
- चुनौतियों
- परिवर्तन
- चरित्र
- chatbot
- chatbots
- चेक
- जाँचता
- चुनें
- करने के लिए चुना
- हालत
- City
- कक्षा
- कक्षाएं
- ग्राहक
- बादल
- कोड
- कोडन
- कॉफी
- सुसंगत
- जोड़नेवाला
- सहयोग
- संक्षिप्त करें
- संग्रह
- रंगीन
- स्तंभ
- स्तंभ
- COM
- गठबंधन
- संयुक्त
- जोड़ती
- संयोजन
- कैसे
- आता है
- आरामदायक
- सामान्य
- संचार
- कंपनी
- तुलना
- की तुलना
- अनुकूलता
- संगत
- पूरा
- पूरी तरह से
- समापन
- जटिल
- जटिलताओं
- अंग
- घटकों
- प्रकृतिस्थ
- रचना
- व्यापक
- शामिल
- संकल्पना
- संक्षिप्त
- समवर्ती
- शर्त
- विन्यास
- संगम
- जुडिये
- कनेक्ट कर रहा है
- कनेक्टिविटी
- नुकसान
- विचार करना
- लगातार
- होते हैं
- कंसोल
- निरंतर
- constructs
- शामिल
- शामिल हैं
- सामग्री
- प्रसंग
- संदर्भों
- प्रासंगिक
- जारी रखने के
- लगातार
- इसके विपरीत
- नियंत्रण
- नियंत्रण
- सुविधाजनक
- कन्वर्सेशन (Conversation)
- संवादी
- संवादी ऐ
- बातचीत
- रूपांतरण
- परिवर्तित
- परिवर्तित
- मूल
- कोना
- सही
- इसी
- सका
- गिनती
- देश
- युगल
- आवरण
- कवर
- बनाना
- बनाया
- बनाता है
- बनाना
- निर्माण
- साख
- मापदंड
- आलोचक
- सीआरएम
- महत्वपूर्ण
- वर्तमान
- वर्तमान में
- रिवाज
- ग्राहक
- अनुकूलन
- अनुकूलित
- अनुकूलित
- अग्रणी
- तिथि
- डेटा संरचना
- डाटाबेस
- डेटाबेस
- तारीख
- दिनांक और समय
- सौदा
- व्यवहार
- दिसंबर
- तय
- निर्णय लेने से
- निर्णय
- डिकोडिंग
- समर्पित
- और गहरा
- चूक
- परिभाषित
- परिभाषित
- परिभाषित करने
- परिभाषाएँ
- पहुंचाने
- बचाता है
- गड्ढा
- डेमो
- दिखाना
- साबित
- प्रदर्शन
- निर्भर
- निर्भर करता है
- निर्भर करता है
- तैनात
- तैनात
- तैनाती
- तैनाती
- तैनात
- वर्णन
- विवरण
- डिज़ाइन
- निर्दिष्ट
- बनाया गया
- वांछित
- विस्तार
- विस्तृत
- विवरण
- निर्धारित करना
- निर्धारित
- विकसित करना
- डेवलपर
- डेवलपर्स
- विकासशील
- विकास
- चित्र
- dict
- डीआईडी
- अलग
- विभिन्न
- अलग ढंग से
- मुश्किल
- आयाम
- आयाम
- निर्देशों
- सीधे
- चर्चा करना
- चर्चा की
- प्रदर्शित
- अलग
- डुबकी
- कई
- DM
- do
- दस्तावेज़
- दस्तावेज़ीकरण
- दस्तावेजों
- कर देता है
- नहीं करता है
- कर
- डॉन
- किया
- डबल
- नीचे
- डाउनलोड
- डाउनलोड
- मसौदा
- ड्राइव
- दो
- दौरान
- गतिशील
- गतिशील
- e
- से प्रत्येक
- पूर्व
- शीघ्र
- आराम
- उपयोग में आसानी
- आसान
- आसानी
- आसान
- आसान करने के लिए उपयोग
- गूंज
- पारिस्थितिकी तंत्र
- प्रभावी
- प्रभावी रूप से
- दक्षता
- कुशल
- कुशलता
- अनायास
- भी
- तत्व
- तत्व
- एलोन
- एलोन मस्क
- अन्य
- ईमेल
- एम्बेड
- एम्बेडेड
- embedding
- कार्यरत
- कर्मचारियों
- रोजगार
- सशक्त
- सक्षम
- सक्षम बनाता है
- समर्थकारी
- समाहित
- सामना
- शुरू से अंत तक
- endpoint
- मनोहन
- इंजन
- इंजन
- इंगलैंड
- अंग्रेज़ी
- इंग्लिश प्रीमियर लीग
- बढ़ाना
- वर्धित
- बढ़ाने
- सुनिश्चित
- सुनिश्चित
- सुनिश्चित
- उद्यम
- संस्थाओं
- सत्ता
- वातावरण
- वातावरण
- बराबर
- युग
- त्रुटि
- त्रुटियाँ
- विशेष रूप से
- आवश्यक
- पराया
- आदि
- मूल्यांकन करें
- मूल्यांकन
- और भी
- घटनाओं
- प्रत्येक
- उदाहरण
- उदाहरण
- से अधिक
- सिवाय
- निष्पादित
- मार डाला
- निष्पादित करता है
- को क्रियान्वित
- निष्पादन
- मिसाल
- व्यायाम
- मौजूद
- उम्मीद
- उम्मीदों
- अपेक्षित
- उम्मीद
- अनुभव
- प्रयोगात्मक
- विशेषज्ञों
- समझाया
- बताते हैं
- स्पष्ट रूप से
- अन्वेषण
- का पता लगाने
- पता लगाया
- निर्यात
- अभिव्यक्ति
- विस्तार
- का विस्तार
- व्यापक
- बाहरी
- अतिरिक्त
- उद्धरण
- निष्कर्षण
- अर्क
- चेहरा
- की सुविधा
- की सुविधा
- कारखाना
- तथ्यों
- दूर
- फास्ट
- पसंदीदा
- Feature
- विशेषताएं
- प्रतिक्रिया
- कुछ
- खेत
- फ़ील्ड
- अंजीर
- आकृति
- पट्टिका
- फ़ाइलें
- भरना
- भरा हुआ
- भरने
- फ़िल्टर
- छानने
- अंतिम
- अंत में
- खोज
- खोज
- प्रथम
- पांच
- लचीलापन
- लचीला
- प्रवाह
- फोकस
- ध्यान केंद्रित
- केंद्रित
- ध्यान केंद्रित
- का पालन करें
- निम्नलिखित
- इस प्रकार है
- भोजन
- के लिए
- प्रपत्र
- प्रारूप
- निर्मित
- भाग्यवश
- पाया
- ढांचा
- चौखटे
- अक्सर
- मित्र
- मित्रों
- से
- पूर्ण
- पूर्ण
- समारोह
- कार्यक्षमताओं
- कार्यक्षमता
- कार्यों
- मौलिक
- मजेदार
- आगे
- भविष्य
- लाभ
- Games
- गेट्स
- सामान्य जानकारी
- आम तौर पर
- उत्पन्न
- उत्पन्न
- उत्पन्न करता है
- सृजन
- पीढ़ी
- शैली
- जर्मनी
- मिल
- मिल रहा
- gif
- GitHub
- दी
- GMT
- Go
- चला जाता है
- जा
- अच्छा
- गूगल
- दानेदार
- ग्राफ
- महान
- अधिक से अधिक
- मार्गदर्शन
- गाइड
- दिशा निर्देशों
- आयोजित हैकथॉन
- संभालना
- हैंडल
- हैंडलिंग
- सुविधाजनक
- कठिन
- नुकसान
- हार्नेस
- है
- होने
- भारी
- धारित
- मदद
- सहायक
- मदद करता है
- उसे
- यहाँ उत्पन्न करें
- hi
- हाई
- उच्च स्तर
- उच्च गुणवत्ता
- उच्चतम
- अत्यधिक
- ऐतिहासिक
- इतिहास
- छेद
- हुड
- मेजबान
- कैसे
- How To
- तथापि
- एचटीएमएल
- http
- HTTPS
- हब
- मानव
- सैकड़ों
- i
- ID
- विचार
- आदर्श
- आईडी
- if
- ii
- iii
- समझाना
- दिखाता है
- छवियों
- तत्काल
- लागू करने के
- कार्यान्वयन
- कार्यान्वयन
- कार्यान्वित
- आयात
- सुधार
- में सुधार लाने
- in
- में गहराई
- शामिल
- शामिल
- शामिल
- सहित
- सम्मिलित
- शामिल
- अविश्वसनीय रूप से
- अनुक्रमणिका
- अनुक्रमणिका
- संकेत मिलता है
- इंगित करता है
- व्यक्तिगत रूप से
- व्यक्तियों
- करें-
- प्रारंभिक
- आरंभ
- अभिनव
- निवेश
- निविष्टियां
- अंतर्दृष्टि
- स्थापित
- installed
- स्थापित कर रहा है
- उदाहरण
- तुरंत
- बजाय
- निर्देश
- अभिन्न
- एकीकृत
- एकीकृत
- एकीकृत
- घालमेल
- एकीकरण
- एकीकरण
- बुद्धिमान
- इरादा
- बातचीत
- बातचीत
- बातचीत
- इंटरैक्टिव
- सूचना का आदान प्रदान
- इंटरफेस
- इंटरफेस
- के भीतर
- इंटरनेट
- में
- शुरू की
- द्वारा प्रस्तुत
- सहज ज्ञान युक्त
- शामिल
- प्रतिसाद नहीं
- मुद्दा
- मुद्दों
- IT
- आइटम
- पुनरावृत्तियों
- आईटी इस
- खुद
- जैक्सन
- जावास्क्रिप्ट
- काम
- जॉर्डन
- यात्रा
- JSON
- जुलाई
- केवल
- न्याय
- रखना
- रखता है
- कुंजी
- Instagram पर
- बच्चा
- जानना
- ज्ञान
- ज्ञान ग्राफ
- जानने वाला
- लेबल
- लेबल
- भूमि
- भाषा
- भाषाऐं
- बड़ा
- बड़ा
- पिछली बार
- विलंब
- बाद में
- ताज़ा
- लीग
- जानें
- सीख रहा हूँ
- बाएं
- विरासत
- लंबाई
- कम
- चलो
- चलें
- पत्र
- स्तर
- स्तर
- लीवरेज
- leverages
- लाभ
- पुस्तकालयों
- पुस्तकालय
- पसंद
- संभावित
- सीमा
- सीमाओं
- सीमित
- सीमित
- सीमाएं
- लिंक
- सूची
- बात सुनो
- सूचियाँ
- जीना
- ll
- एलएलएम
- भार
- लोडर
- स्थित
- स्थान
- लॉग इन
- लॉग इन
- लॉगिंग
- तर्क
- लंबा
- लंबे समय तक
- देखिए
- देख
- लग रहा है
- लुकअप
- उन
- लॉस एंजिल्स
- निम्न
- मशीन
- यंत्र अधिगम
- बनाया गया
- बनाए रखना
- अनुरक्षणीय
- को बनाए रखने के
- का कहना है
- बनाना
- बनाता है
- निर्माण
- प्रबंधन
- प्रबंध
- प्रबंधक
- प्रबंध
- मेनचेस्टर
- मैनचेस्टर यूनाइटेड
- जोड़ - तोड़
- ढंग
- गाइड
- उत्पादक
- बहुत
- बुहत सारे लोग
- नक्शा
- मानचित्रण
- मैप्स
- मैच
- मिलान
- गणित
- गणितीय
- मैटर्स
- अधिकतम
- मई..
- me
- मतलब
- अर्थ
- साधन
- माप
- मीडिया
- बैठक
- की बैठक
- -K-on (ITS MY FAVORITE ANIME!)
- याद
- उल्लेख किया
- मर्ज
- विलय
- message
- संदेश
- मैसेजिंग
- मेटाडाटा
- तरीका
- तरीकों
- मेट्रिक्स
- हो सकता है
- लाखों
- कम से कम
- नाबालिग
- लापता
- गलतियां
- मिश्रण
- MLB
- मोबाइल
- आदर्श
- मॉडल
- संयम
- मॉड्यूल
- मॉड्यूल
- पल
- MongoDB
- मॉनिटर
- निगरानी
- चन्द्रमा
- अधिक
- अधिकांश
- सबसे लोकप्रिय
- चाल
- चलचित्र
- बहुत
- विभिन्न
- कई जंजीर
- कस्तूरी
- चाहिए
- my
- नाम
- नामांकित
- नामों
- राष्ट्रीय
- प्राकृतिक
- प्राकृतिक भाषा संसाधन
- नेविगेट करें
- नेविगेट
- निकट
- आवश्यक
- आवश्यकता
- जरूरत
- की जरूरत है
- नकारात्मक
- नया
- न्यूयॉर्क
- न्यूयॉर्क टाइम्स
- अगला
- नहीं
- कोई नहीं
- कुछ नहीं
- धारणा
- अभी
- संख्या
- ओबामा
- वस्तु
- उद्देश्य
- वस्तुओं
- अवलोकन
- प्राप्त
- प्राप्त करने के
- ओसीआर
- of
- प्रस्ताव
- की पेशकश
- ऑफर
- अक्सर
- oh
- ठीक है
- ओलंपिक
- on
- एक बार
- ONE
- केवल
- खुला स्रोत
- OpenAI
- संचालन
- ऑपरेटर
- अनुकूलित
- अनुकूलन
- विकल्प
- or
- आदेश
- जैविक
- संगठनों
- मूल
- OS
- अन्य
- अन्य
- अन्यथा
- हमारी
- आउट
- उत्पादन
- outputs के
- के ऊपर
- ओवरराइड
- सिंहावलोकन
- अपना
- पैकेज
- संकुल
- पृष्ठ
- पृष्ठों
- जोड़े
- पांडा
- काग़ज़
- समानांतर
- प्राचल
- पैरामीटर
- पार्क
- भाग
- विशेष रूप से
- भागों
- पास
- पारित कर दिया
- गुजरता
- पासिंग
- अतीत
- पथ
- पथ
- पैटर्न उपयोग करें
- पेरोल
- पीडीएफ
- स्टाफ़
- प्रति
- उत्तम
- पूरी तरह से
- निष्पादन
- प्रदर्शन
- प्रदर्शन
- प्रदर्शन
- अनुमतियाँ
- हठ
- व्यक्ति
- निजीकृत
- परिप्रेक्ष्य
- भौतिक विज्ञान
- टुकड़ा
- पाइपलाइन
- पिज़्ज़ा
- प्लेसहोल्डर
- मंच
- प्लेटो
- प्लेटो डेटा इंटेलिजेंस
- प्लेटोडाटा
- प्ले
- खेल का मैदान
- निभाता
- कृप्या अ
- प्लस
- बिन्दु
- नीतियाँ
- नीति
- राजनीतिक
- पूल
- लोकप्रिय
- आबादी वाले
- सकारात्मक
- संभव
- पद
- पोस्ट
- संभावित
- बिजली
- संचालित
- शक्तिशाली
- व्यावहारिक
- अभ्यास
- पसंद करते हैं
- प्रधानमंत्री
- वर्तमान
- अध्यक्ष
- को रोकने के
- रोकने
- पिछला
- मुख्यत
- प्राथमिक
- मुख्य
- निजी
- मुसीबत
- समस्याओं
- बढ़ना
- प्रक्रिया
- प्रसंस्कृत
- प्रक्रियाओं
- प्रसंस्करण
- उत्पादन
- एस्ट्रो मॉल
- उत्पादन
- प्रोफेसर
- प्रोग्रामिंग
- प्रोग्रामिंग की भाषाएँ
- परियोजना
- परियोजनाओं
- गुण
- संपत्ति
- PROS
- प्रोटोटाइप
- प्रोटोटाइप
- प्रदान करना
- बशर्ते
- प्रदाता
- प्रदाताओं
- प्रदान करता है
- प्रदान कर
- सार्वजनिक
- उद्देश्य
- प्रयोजनों
- रखना
- अजगर
- क्यू एंड ए
- गुणवत्ता
- प्रश्नों
- प्रश्न
- प्रशन
- त्वरित
- जल्दी से
- उद्धरण
- R
- उठाना
- रेंज
- लेकर
- बल्कि
- दर्ज़ा
- कच्चा
- RE
- पहुंच
- प्रतिक्रिया
- पढ़ना
- पढ़ना
- तैयार
- वास्तविक
- वास्तविक समय
- वास्तविक समय डाटा
- क्षेत्र
- कारण
- कारण
- हाल
- की सिफारिश की
- दर्ज
- अभिलेख
- की वसूली
- को कम करने
- कम कर देता है
- को कम करने
- कमी
- संदर्भ
- संदर्भित
- को परिष्कृत
- रिफाइनिंग
- क्षेत्रों
- रिश्ते
- रिहा
- प्रासंगिकता
- प्रासंगिक
- विश्वसनीयता
- विश्वसनीय
- भरोसा करना
- भरोसा
- बाकी है
- याद
- अनुस्मारक
- दूरस्थ
- उपज
- दोहराना
- बार बार
- अलग ढंग से व्यक्त
- की जगह
- रिपोर्ट
- कोष
- प्रतिनिधित्व
- का प्रतिनिधित्व
- का प्रतिनिधित्व करता है
- का अनुरोध
- अनुरोधों
- की आवश्यकता होती है
- अपेक्षित
- आवश्यकताएँ
- की आवश्यकता होती है
- बचाव
- अनुसंधान
- संकल्प
- संसाधन
- प्रतिक्रिया
- जवाब
- प्रतिक्रिया
- प्रतिक्रियाएं
- जिम्मेदार
- उत्तरदायी
- बाकी
- परिणाम
- जिसके परिणामस्वरूप
- परिणाम
- बनाए रखने की
- प्रतिधारण
- वापसी
- लौटने
- रिटर्न
- पुन: प्रयोज्य
- की समीक्षा
- घूमता
- चावल
- धनी
- रोबोट
- भूमिका
- भूमिकाओं
- जड़
- मार्ग
- आरओडब्ल्यू
- रन
- दौड़ना
- चलाता है
- क्रम
- s
- सुरक्षा उपायों
- विक्रय
- salesforce
- सैम
- वही
- सहेजें
- कहना
- कहते हैं
- स्केलेबल
- स्केल
- परिदृश्य
- परिदृश्यों
- दृश्यों
- अनुसूची
- स्कोर
- खरोंच
- निर्बाध
- मूल
- Search
- search engine
- खोजें
- खोज
- अनुभाग
- वर्गों
- सुरक्षित
- सुरक्षा
- देखना
- चयनित
- चयन
- बेचना
- भेजें
- संवेदनशील
- भावुकता
- भावनाओं
- अलग
- सितंबर
- अनुक्रम
- कई
- सेवा
- सर्वर
- कार्य करता है
- सेवाएँ
- सेट
- सेट
- की स्थापना
- सेटिंग्स
- व्यवस्था
- सात
- कई
- Share
- साझा
- खोल
- चमकता
- भेज दिया
- चाहिए
- दिखाना
- प्रदर्शन
- दिखाया
- दिखाता है
- सिग्मा
- महत्वपूर्ण
- समान
- सरल
- सरलीकृत
- को आसान बनाने में
- सरल बनाने
- केवल
- के बाद से
- एक
- आकार
- ढीला
- छोटा
- छोटे
- स्मार्ट
- टुकड़ा
- So
- अब तक
- फुटबॉल
- सोशल मीडिया
- सोशल मीडिया
- सोशल मीडिया पोस्ट
- केवल
- ठोस
- समाधान
- हल
- कुछ
- कुछ
- कभी कभी
- परिष्कृत
- लगता है
- स्रोत
- सूत्रों का कहना है
- अंतरिक्ष
- स्पेनिश
- विशेषीकृत
- विशिष्ट
- विशेष रूप से
- बारीकियों
- विनिर्दिष्ट
- गति
- खर्च
- विभाजित
- विभाजन
- खेल
- चौकोर
- स्टैंड
- स्टैंडअलोन
- मानक
- प्रारंभ
- शुरू
- शुरुआत में
- राज्य
- बयान
- स्थिर
- कदम
- कदम
- फिर भी
- रुकें
- रोक
- बंद हो जाता है
- भंडारण
- की दुकान
- संग्रहित
- भंडार
- भंडारण
- कहानी
- सरल
- धारा
- स्ट्रीमिंग
- सुवीही
- बुद्धिसंगत
- ताकत
- हड़तालों
- तार
- संरचना
- संरचित
- संरचनाओं
- संरचना
- अंदाज
- विषय
- आगामी
- सफलतापूर्वक
- ऐसा
- सूट
- उपयुक्त
- सूट
- संक्षेप में प्रस्तुत करना
- सारांश
- सूर्य का अस्त होना
- समर्थन
- समर्थित
- समर्थन करता है
- निश्चित
- स्थिरता
- तुल्यकालन
- सार
- वाक्यविन्यास
- प्रणाली
- सिस्टम
- तालिका
- दर्जी
- अनुरूप
- लेना
- लेता है
- लक्ष्य
- कार्य
- कार्य
- टीम
- टीमों
- कहना
- टेम्पलेट
- टेम्पलेट्स
- अंतिम
- शब्दावली
- शर्तों
- परीक्षण
- परीक्षण
- टेक्स्ट
- से
- धन्यवाद
- कि
- RSI
- मूल बातें
- केंद्र
- जानकारी
- न्यूयॉर्क टाइम्स
- परियोजनाएं
- स्रोत
- दुनिया
- लेकिन हाल ही
- उन
- फिर
- वहाँ।
- इन
- वे
- चीज़ें
- इसका
- उन
- हालांकि?
- यहाँ
- भर
- पहर
- बहुत समय लगेगा
- बार
- शीर्षक
- सेवा मेरे
- एक साथ
- टोकन
- tokenization
- टोकन
- भी
- साधन
- टूलकिट
- उपकरण
- ऊपर का
- विषय
- विषय
- कुल
- शहर
- ट्रेसिंग
- ट्रैक
- परंपरागत
- प्रशिक्षण
- बदालना
- परिवर्तनों
- ट्रांसफार्मर
- ट्रान्सफ़ॉर्मर
- संक्रमण
- परीक्षण
- <strong>उद्देश्य</strong>
- वास्तव में
- कोशिश
- ट्यूनिंग
- मोड़
- मोड़
- ट्यूटोरियल
- दो बार
- दो
- टाइप
- प्रकार
- टाइपप्रति
- आम तौर पर
- ui
- अंत में
- अप्रभावित
- के अंतर्गत
- आधारभूत
- समझना
- समझ
- समझता है
- एकीकृत
- अद्वितीय
- यूनाइटेड
- सार्वभौम
- भिन्न
- जब तक
- अपडेट
- अपडेट
- अपलोड की गई
- यूआरएल
- us
- प्रयोज्य
- प्रयोग
- उपयोग
- उदाहरण
- प्रयुक्त
- उपयोगकर्ता
- यूजर इंटरफेस
- उपयोगकर्ताओं
- का उपयोग करता है
- का उपयोग
- उपयोगिताओं
- उपयोग
- उपयोग किया
- इस्तेमाल
- उपयोग
- v1
- सत्यापन
- सत्यापनकर्ता
- मूल्यवान
- मूल्य
- मान
- परिवर्तनशील
- विविधता
- विभिन्न
- Ve
- बहुमुखी
- संस्करण
- बहुत
- के माध्यम से
- वीडियो
- देखें
- उल्लंघन
- दिखाई
- कल्पना
- महत्वपूर्ण
- vs
- चलना
- walkthrough
- करना चाहते हैं
- था
- घड़ी
- मार्ग..
- तरीके
- we
- मौसम
- वेब
- वेब ब्राउजर
- वेब सेवाओं
- वेबसाइटों
- कुंआ
- प्रसिद्ध
- थे
- क्या
- एचएमबी क्या है?
- Whats
- कब
- या
- कौन कौन से
- जब
- कौन
- पूरा का पूरा
- क्यों
- चौड़ा
- व्यापक रूप से
- विजेट
- विकिपीडिया
- मर्जी
- खिड़की
- जीत
- साथ में
- अंदर
- बिना
- शब्द
- काम
- काम किया
- वर्कफ़्लो
- workflows
- काम कर रहे
- कार्य
- विश्व
- होगा
- लिखना
- लिख रहे हैं
- X
- अभी तक
- यॉर्क
- आप
- आपका
- स्वयं
- यूट्यूब
- Zendesk
- जेफिरनेट
- ज़िप