संदर्भ-सचेत चैटबॉट बनाना: ChatGPT के लिए LangChain फ्रेमवर्क का लाभ उठाना

आज के तेज़-रफ़्तार डिजिटल परिदृश्य में, बड़े भाषा मॉडलों (LLMs) के उभार के साथ, संवादात्मक अनुप्रयोगों ने अत्यधिक लोकप्रियता हासिल की है। चैटबॉट्स ने हमारे दैनिक जीवन में ऐप्लिकेशनों, वेबसाइटों, और यहाँ तक कि कस्टमर सर्विस चैनलों के साथ बातचीत करने के तरीके को बदल दिया है।

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

यह लेख इस बात को विभाजित करने का उद्देश्य रखता है कि LLMs की शक्ति का लाभ उठाकर Python में चैटबॉट कैसे बनाया जाए। हम देखेंगे कि ChatGPT का उपयोग करके अपना चैटबॉट कैसे बनाया जाए और लोकप्रिय LangChain फ्रेमवर्क का उपयोग करके इसे और कैसे अनुकूलित किया जाए।

यदि आप ChatGPT और LangChain में नए हैं, तो नीचे हमारा GPT और LangChain के साथ बड़े भाषा मॉडलों का परिचय: AI कोड-अलॉन्ग देखें: 

यह लेख एक अनुकूलित चैटबॉट के विकास के सभी महत्वपूर्ण पहलुओं को कवर करता है जो अंदरूनी तौर पर मॉडल के रूप में ChatGPT का उपयोग करता है। हम Jupyter Notebook का उपयोग करेंगे, जिसमें openai और langchain दोनों लाइब्रेरी इंस्टॉल होंगी। आप इस DataLab वर्कबुक में साथ-साथ चल सकते हैं।

आगामी अनुभागों में, हम देखेंगे कि OpenAI API का उपयोग करके ChatGPT को बुनियादी API कॉल्स कैसे करें, जो हमारी बातचीत के निर्माण खंड होंगे। इसके अलावा, हम बुनियादी Python संरचनाओं का उपयोग करके अपने चैटबॉट के लिए संदर्भ-जागरूकता लागू करेंगे। अंत में, हम LangChain का उपयोग करके चैटबॉट इम्प्लीमेंटेशन और बातचीत इतिहास दोनों को अनुकूलित करेंगे और इसकी मेमोरी विशेषताओं का अन्वेषण करेंगे।

बुनियादी ChatGPT API कॉल्स

हम अपने चैटबॉट के पीछे के मॉडल के रूप में ChatGPT का उपयोग करने जा रहे हैं। इसी कारण, हमारा पहला व्यावहारिक कार्य ChatGPT को एक सरल लेकिन पूर्ण API कॉल लिखने का होगा ताकि हम पहली बातचीत स्थापित कर सकें।

निम्न Python फ़ंक्शन केवल openai लाइब्रेरी का उपयोग करके ChatGPT के लिए हमारी इच्छित API कॉल को समाहित करता है।

import os
import openai

openai_api_key = os.environ["OPENAI_API_KEY"]

def chatgpt_call(prompt, model="gpt-3.5-turbo"):
   response = openai.ChatCompletion.create(
       model=model,
       messages=[{"role": "user", "content": prompt}]
   )
   return response.choices[0].message["content"]
संचालित द्वारा

ध्यान दें कि इस मामले में, हम gpt-3.5-turbo मॉडल का उपयोग कर रहे हैं क्योंकि यह सबसे सक्षम GPT-3.5 मॉडल है और चैट के लिए अनुकूलित है, साथ ही यह सबसे सस्ते मॉडलों में से एक है। उपलब्ध विभिन्न मॉडलों के बारे में अधिक जानकारी OpenAI की डॉक्यूमेंटेशन में मिल सकती है।

क्या आपको अपने OpenAI API कीज़ प्राप्त करने में मदद चाहिए? तो Getting Started with the OpenAI API and ChatGPT प्रशिक्षण आपके लिए है।

आइए अपनी इम्प्लीमेंटेशन को चरण-दर-चरण परखें!

chatgpt_call() फ़ंक्शन, OpenAI के मूल फ़ंक्शन कॉल ChatCompletion.create के चारों ओर एक रैपर है, जो एक चैट कम्प्लीशन अनुरोध बनाता है।

दिए गए वांछित प्रॉम्प्ट के आधार पर, फ़ंक्शन संबंधित ChatGPT कम्प्लीशन लौटाता है। एक सफल कम्प्लीशन कॉल के लिए, केवल उपयोग करने वाले मॉडल का ID (model) और वांछित प्रॉम्प्ट (prompt) प्रदान करना आवश्यक है।

ChatGPT द्वारा लौटाया गया वास्तविक कम्प्लीशन, प्रतिक्रिया के साथ-साथ मेटाडेटा भी शामिल करता है। फिर भी, कम्प्लीशन स्वयं हमेशा response.choices[0].message[“content”] फ़ील्ड में लौटाया जाता है। पूर्ण कम्प्लीशन सामग्री के बारे में अधिक जानकारी OpenAI की डॉक्यूमेंटेशन में मिल सकती है।

इस इम्प्लीमेंटेशन के आधार पर, हम एक ही लाइन में ChatGPT को सरलता से प्रॉम्प्ट कर सकते हैं:

prompt = "My name is Andrea"
response = chatgpt_call(prompt)
print(response)

# Output: Nice to meet you, Andrea! How can I assist you today?
संचालित द्वारा

कॉल एक स्टैंडअलोन इंटरैक्शन के रूप में

क्या आपको ऊपर की इम्प्लीमेंटेशन में कोई पेच नज़र आता है?

एक इशारा देने के लिए, चलिए एक फ़ॉलो-अप इंटरैक्शन करते हैं:

prompt = "Do you remember my name?"
response = chatgpt_call(prompt)
print(response)

# Output: I'm sorry, as an AI language model, I don't have the ability to remember specific information about individual users.
संचालित द्वारा

सही, जैसा कि हम देख सकते हैं, प्रत्येक API कॉल एक स्टैंडअलोन इंटरैक्शन है। इसका मतलब है कि मॉडल को पहले दिए गए इनपुट प्रॉम्प्ट्स या कम्प्लीशनों की कोई याद नहीं रहती। हर बार जब हम chatgpt_call() फ़ंक्शन को कॉल करते हैं, हम एक बिल्कुल नई बातचीत शुरू करते हैं।

जब हम चैटबॉट बनाने की कोशिश कर रहे हों, तो यह निश्चित रूप से एक समस्या है, क्योंकि यदि मॉडल को अब तक की चर्चा की कोई याद न हो, तो उससे बातचीत करना असंभव है। इसी कारण, हमारा अगला कदम मॉडल को हमारी पिछली बातचीतों के बारे में जागरूक बनाना होगा।

संदर्भ-जागरूकता

संदर्भ-जागरूकता चैटबॉट्स को चल रही बातचीत के आधार पर उपयुक्त रूप से समझने और प्रतिक्रिया देने में सक्षम बनाती है।

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

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

ChatGPT के लिए मूल OpenAI API पहले से ही प्रत्येक नए प्रॉम्प्ट के साथ हमारी बातचीत का इतिहास मॉडल को भेजने का तरीका प्रदान करता है। इसके अतिरिक्त, LangChain फ्रेमवर्क भी ChatGPT की मेमोरी को अधिक प्रभावी और लागत-अनुकूलित तरीके से प्रबंधित करने का साधन प्रदान करता है।

System, Assistant, और User संदेशों को समझना

ChatGPT का बातचीत इतिहास संरचना

इस बिंदु पर, हम केवल वांछित प्रॉम्प्ट प्रदान करके सीधे chatgpt_call() विधि का उपयोग कर सकते हैं। यदि हम इम्प्लीमेंटेशन पर बारीकी से नज़र डालें, तो इनपुट प्रॉम्प्ट को messages सूची का हिस्सा बनाकर फ़ॉर्मैट किया जाता है। यह सूची वास्तव में बातचीत इतिहास का ट्रैक रखने के लिए होती है, और यही कारण है कि इसे एक बहुत ही विशिष्ट तरीके से फ़ॉर्मैट करना पड़ता है।

आइए इसे और करीब से देखें!

अब तक, हमने chatgpt_call() में संदेशों की सूची को इस प्रकार फ़ॉर्मैट किया है:

messages = [{"role": "user", "content": prompt}]
संचालित द्वारा

messages सूची बातचीत इतिहास को डिक्शनरियों के संग्रह के रूप में संग्रहीत करती है। सूची के भीतर प्रत्येक डिक्शनरी, दो की-वैल्यू पेयर्स का उपयोग करके बातचीत में एक संदेश का प्रतिनिधित्व करती है।

• role कुंजी जिसका मान user है, यह दर्शाती है कि संदेश उपयोगकर्ता द्वारा भेजा गया है।
• content कुंजी जिसका मान prompt है, वास्तविक उपयोगकर्ता प्रॉम्प्ट को समाहित करती है।

यह केवल एक इंटरैक्शन वाला बहुत सरल उदाहरण है। यद्यपि content कुंजी हमेशा या तो उपयोगकर्ता प्रॉम्प्ट या चैटबॉट का कम्प्लीशन संग्रहीत करेगी, role कुंजी कहीं अधिक बहुमुखी है।

System, Assistant, और User भूमिकाएँ

role कुंजी, content में संदेश के स्वामी को दर्शाती है। ChatGPT का उपयोग करते समय, हमारे पास अधिकतम तीन भूमिकाएँ हो सकती हैं:

• User. जैसा कि हमने पहले ही चर्चा की है, user भूमिका उस वास्तविक उपयोगकर्ता से मेल खाती है जो चैटबॉट के साथ बातचीत करता है।
• Assistant. assistant भूमिका चैटबॉट से मेल खाती है।
• System. system भूमिका चैटबॉट को निर्देश, मार्गदर्शन और संदर्भ प्रदान करने का काम करती है। सिस्टम संदेश उपयोगकर्ता इंटरैक्शनों का मार्गदर्शन करते हैं, चैटबॉट का व्यवहार निर्धारित करते हैं, संदर्भात्मक जानकारी प्रदान करते हैं और बातचीत के भीतर विशिष्ट इंटरैक्शनों को संभालते हैं। सिस्टम संदेशों को उपयोगकर्ता के लिए पारदर्शी, चैटबॉट के लिए उच्च-स्तरीय निर्देशों के रूप में देखा जा सकता है।

स्व-निर्मित चित्र। chatGPT के साथ चैटबॉट बनाते समय बातचीत श्रृंखला में विभिन्न भूमिकाओं की परस्पर क्रिया।

बातचीत इतिहास बनाना

हम अपने messages सूची में user, assistant, और system—इन तीनों भूमिकाओं का उपयोग करके अपना बातचीत इतिहास बना सकते हैं।

हमारी परीक्षण बातचीतों को देखते हुए, उपर्युक्त तीनों भूमिकाओं का उपयोग करके ठीक से फ़ॉर्मैट किया गया बातचीत इतिहास कुछ इस प्रकार दिख सकता है:

messages =  [ 
{'role':'system', 'content':'You are friendly chatbot.'},
{'role':'user', 'content':'Hi, my name is Andrea'},
{'role':'assistant', 'content': "Nice to meet you, Andrea! How can I assist you today?"},
{'role':'user', 'content':'Do you remember my name?'}  ]
संचालित द्वारा

हम अपनी call_chatgpt() फ़ंक्शन को थोड़ा संशोधित कर सकते हैं ताकि बातचीत इतिहास को एक इनपुट पैरामीटर के रूप में शामिल किया जा सके:

def call_chatgpt_with_memory(messages, model="gpt-3.5-turbo"):
   response = openai.ChatCompletion.create(
       model=model,
       messages=messages,
   )
   return response.choices[0].message["content"]
संचालित द्वारा

आइए इस नई इम्प्लीमेंटेशन को आज़माएँ!

messages =  [ 
{'role':'system', 'content':'You are friendly chatbot.'},
{'role':'user', 'content':'Hi, my name is Andrea'},
{'role':'assistant', 'content': "Nice to meet you, Andrea! How can I assist you today?"},
{'role':'user', 'content':'Do you remember my name?'}  ]

response = call_chatgpt_with_memory(messages)
print(response)

# Output: Yes, your name is Andrea.
संचालित द्वारा

बहुत बढ़िया! हमने मॉडल को अपनी पिछली बातचीतों के बारे में जागरूक बनाए रखने में सफलता पाई है ताकि हम वास्तव में मॉडल के साथ बातचीत कर सकें। फिर भी, हमें अपने messages सूची को स्वतः अपडेट करने का तरीका खोजना होगा।

स्वचालित बातचीत इतिहास

हम अपनी API कॉल फ़ंक्शन पर थोड़ा और काम करके संदेशों के स्वतः संग्रहण को हासिल कर सकते हैं:

def chatgpt_conversation(prompt):
   context.append({'role':'user', 'content':f"{prompt}"})
   response = call_chatgpt_with_memory(context)
   context.append({'role':'assistant',
   'content':f"{response}"})
   return response
संचालित द्वारा

अब आज़माते हैं!

chatgpt_conversation("Hello, my name is Andrea")

# Output: 'Nice to meet you, Andrea! How can I assist you today?'
संचालित द्वारा

और एक फ़ॉलो-अप इंटरैक्शन:

chatgpt_conversation("Do you remember my name?")

# Output: 'Yes, your name is Andrea.'
संचालित द्वारा

अब बातचीत इतिहास स्वतः अपडेट हो रहा है। अंत में, बस ध्यान दें कि कोई भी समय messages सूची को प्रिंट करके बातचीत इतिहास—और उसकी संरचना—देखी जा सकती है।

print(messages)

# Output:
[{'role': 'user', 'content': 'Hello, my name is Andrea'},
{'role': 'assistant', 'content': 'Nice to meet you, Andrea! How can I assist you today?'},
{'role': 'user', 'content': 'Do you remember my name?'},
{'role': 'assistant', 'content': 'Yes, your name is Andrea.'}]
संचालित द्वारा

LangChain फ्रेमवर्क

अब तक, हम सहमत होंगे कि हमारी इम्प्लीमेंटेशन एक उपयोगी चैटबॉट तक ले जाती है, लेकिन यह शायद इसका सबसे अनुकूलित संस्करण नहीं है।

हर एक पिछले प्रॉम्प्ट और कम्प्लीशन संदेशों को लगातार फीड करना जल्दी ही टोकनों के विशाल संग्रह तक पहुँच सकता है, और ChatGPT को नवीनतम कम्प्लीशन लौटाने से पहले उन सभी को प्रोसेस करना होगा।

अब तक, हमने चैटबॉट को कुछ हद तक मेमोरी देने के लिए पिछली बातचीतों को एक साथ बाँधने हेतु .append ऑपरेशनों का उपयोग किया है। फिर भी, मेमोरी प्रबंधन, LangChain जैसे समर्पित पैकेजों का उपयोग करके अधिक प्रभावी ढंग से किया जा सकता है।

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

LangChain फ्रेमवर्क के बारे में अधिक जानकारी के लिए, मैं परिचयात्मक लेख Introduction to LangChain for Data Engineering & Data Applications की सिफारिश करता/करती हूँ।

LangChain के साथ सरल बातचीत इतिहास

इस अनुभाग में, हम देखेंगे कि इसके बजाय चैटबॉट बनाने के लिए LangChain फ्रेमवर्क का उपयोग कैसे करें।

langchain लाइब्रेरी ऊपर उपयोग की गई openai लाइब्रेरी का विकल्प है, क्योंकि langchain.llms मॉड्यूल आपको केवल दो सरल लाइनों में ChatGPT के साथ इंटरैक्ट करने देता है:

# OpenAI key from environment
from langchain.llms import OpenAI
llm = OpenAI()संचालित द्वारा

एक बार llm मॉडल लोड हो जाने के बाद, आइए उस मेमोरी ऑब्जेक्ट को इम्पोर्ट करें जो हमारा बातचीत इतिहास संग्रहीत करेगा। चैटबॉट के साथ प्रत्येक पिछली बातचीत को सहेजने के लिए, LangChain तथाकथित ConversationBufferMemory प्रदान करता है:

from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
संचालित द्वारा

अब अंततः तथाकथित ConversationChain को इम्पोर्ट करने का समय है, एक रैपर जो llm और memory का उपयोग करके उपयोगकर्ता प्रॉम्प्ट को ChatGPT तक पहुँचाएगा और उसके कम्प्लीशनों को लौटाएगा:

from langchain.chains import ConversationChain

conversation = ConversationChain(
   llm=llm,
   memory=memory
)
संचालित द्वारा

अंत में, उपयोगकर्ता प्रॉम्प्ट को ChatGPT तक भेजने के लिए, हम .predict मेथड का इस प्रकार उपयोग कर सकते हैं:

conversation.predict(input="Hello, my name is Andrea")

# Output: "Hi Andrea, I'm an AI created to help you with whatever you may need. What can I do for you today?"
संचालित द्वारा

आइए verbose=True सेट करें ताकि हम वह जानकारी देख सकें जिसे मॉडल कम्प्लीशन प्रदान करने के लिए उपयोग करता है। इसे एक फ़ॉलो-अप इंटरैक्शन में आज़माते हैं:

कम्प्लीशन बनाते समय ChatGPT के लिए उपलब्ध संदर्भ का स्क्रीनशॉट। हरे रंग में वर्बोज़ आउटपुट।

अंत में, जाँच करते हैं कि यह पिछली बातचीतों को पूरी तरह याद रखता है:

कम्प्लीशन बनाते समय ChatGPT के लिए उपलब्ध संदर्भ का स्क्रीनशॉट। हरे रंग में वर्बोज़ आउटपुट।

बातचीत इतिहास भरना

हम memory.save_context() मेथड का उपयोग करके चैटबॉट को अतिरिक्त संदर्भ फीड कर सकते हैं। इस तरह, हम बिना बातचीत में यह जानकारी दिए भी अपने चैटबॉट को किसी भी वांछित सामग्री के बारे में जागरूक बना सकते हैं। LangChain में, इस उद्देश्य के लिए कीवर्ड्स input और output हैं। उदाहरण के लिए,

memory.save_context({"input": "Hi"},
                   {"output": "What's up"})
memory.save_context({"input": "Not much, just hanging"},
                   {"output": "Cool"})
संचालित द्वारा

इसके अलावा, हम किसी भी समय print(memory.buffer) या memory.load_memory_variables({}) चलाकर मेमोरी सामग्री भी देख सकते हैं।

LangChain मेमोरी प्रकार

LangChain, ChatGPT के लिए विभिन्न प्रकार की मेमोरीज़ को इम्प्लीमेंट करता है। ऊपर उपयोग की गई ConversationBufferMemory हर एक इंटरैक्शन का ट्रैक रखती है। फिर भी, हमने पहले ही चर्चा की है कि हर नई बातचीत में पूरे बातचीत इतिहास के साथ ChatGPT को प्रॉम्प्ट करना तेज़ी से प्रोसेस करने के लिए टोकनों की बहुत बड़ी संख्या तक पहुँच सकता है।

ध्यान रखें कि ChatGPT के प्रति इंटरैक्शन टोकन सीमा होने के अलावा, इसका उपयोग-लागत भी टोकनों की संख्या पर निर्भर करता है। हर नई बातचीत में पूरे बातचीत इतिहास को प्रोसेस करना समय के साथ महँगा होने की संभावना है।

बातचीत इतिहास के निरंतर प्रोसेसिंग से बचने के लिए, LangChain ChatGPT की मेमोरी को प्रबंधित करने के अन्य अनुकूलित तरीके प्रदान करता है। हम अगले अनुभाग में सबसे उन्नत प्रकारों में से एक का अन्वेषण करेंगे।

LangChain के साथ उन्नत बातचीत इतिहास

मेमोरी को प्रबंधित करने का एक उन्नत तरीका, हर पिछली बातचीत को संग्रहीत करने के बजाय, उन बातचीतों का सारांश संग्रहीत करना है।

यह प्रकार मेरी पसंदीदा मेमोरी है क्योंकि यह वास्तव में अनुकूलित मेमोरी प्रबंधन तक ले जा सकती है, बिना किसी पिछली बातचीत का बलिदान किए।

आइए इसे अमल में लाएँ!

# OpenAI key from environment
from langchain.llms import OpenAI
llm = OpenAI()

from langchain.memory import ConversationSummaryBufferMemory
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
संचालित द्वारा

बस ध्यान दें कि इस प्रकार की मेमोरी, पिछली बातचीतों का सारांश तैयार करने के लिए परिभाषित llm का उपयोग करती है।

इसके अलावा, यह मेमोरी अधिकतम टोकन संख्या (max_token_limit) तक पूर्ण बातचीतों को संग्रहीत कर सकती है। इस सीमा से ऊपर, यह उन संदेशों की जानकारी को सारांश में समाहित कर लेती है।

इसे परखने के लिए, चलिए टोकनों की बड़ी संख्या वाली एक बातचीत बनाते हैं। निम्न schedule पर विचार करें:

schedule = "There is a meeting at 8am with your product team. \
You will need your powerpoint presentation prepared. \
9am-12pm have time to work on your LangChain \
project which will go quickly because Langchain is such a powerful tool. \
At Noon, lunch at the italian resturant with a customer who is driving \
from over an hour away to meet you to understand the latest in AI. \
Be sure to bring your laptop to show the latest LLM demo."

memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
memory.save_context({"input": "Hello"}, {"output": "What's up"})
memory.save_context({"input": "Not much, just hanging"}, {"output": "Cool"})
memory.save_context({"input": "What is on the schedule today?"}, {"output": f"{schedule}"})
संचालित द्वारा

अब, हमें केवल पिछले उदाहरणों की तरह llm और memory दिए जाने पर एक नई बातचीत श्रृंखला घोषित करनी है।

conversation = ConversationChain(
   llm=llm,
   memory=memory,
   verbose=True
)
संचालित द्वारा

हम .predict का उपयोग करके ChatGPT को प्रॉम्प्ट कर सकते हैं:

कम्प्लीशन बनाते समय ChatGPT के लिए उपलब्ध संदर्भ का स्क्रीनशॉट। हरे रंग में वर्बोज़ आउटपुट।

जैसा कि हम देख सकते हैं, चैटबॉट मूल बातचीत इतिहास का एक सारांश रखता है, जिससे हर फ़ॉलो-अप इंटरैक्शन में ChatGPT द्वारा प्रोसेस किए जाने वाले टोकनों की संख्या कम होती है।

यही है! अब हम अपने अनुकूलित चैटबॉट से घंटों बात कर सकते हैं!

अपने नोटबुक में अधिक सुखद प्रश्नोत्तर अनुभव के लिए verbose=False सेट करें।

निष्कर्ष

इस लेख में, हमने देखा कि सुविख्यात ChatGPT मॉडल का उपयोग करके संदर्भ-सचेत चैटबॉट कैसे बनाया जाए।

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

हमने चैटबॉट बातचीत इतिहास को प्रबंधित करने के दो मुख्य दृष्टिकोण देखे। पहला, मूल ChatGPT API का उपयोग करके, जो एक कार्यात्मक नेटिव चैटबॉट देता है। दूसरा, समर्पित LangChain फ्रेमवर्क और एक अनुकूलित मेमोरी प्रकार की इम्प्लीमेंटेशन का उपयोग करके।

अब बारी आपकी है! इस लेख में प्रस्तुत बिल्डिंग ब्लॉक्स का उपयोग करके अपने विशिष्ट उपयोग-केस के अनुरूप एक चैटबॉट को कस्टमाइज़ करने का समय है!

यदि आप LangChain और ChatGPT दोनों का उपयोग करके अन्य अनुप्रयोग बनाना चाहते हैं, तो Building AI Applications with LangChain and GPT वेबिनार आपके लिए है। तेज़ी से NLP पर पकड़ बनानी है? तो Natural Language Processing in Python पर मौजूद मॉड्यूल देखें!