लैंगचेन भाग 4 - लैंगचेन में मेमोरी और स्टोरेज का लाभ उठाना: एक व्यापक गाइड

कोड यहां पाया जा सकता है: GitHub - jamesbour/blog_tutorials:

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

इस गाइड में, हम अधिक स्मार्ट, अधिक प्रतिक्रियाशील एप्लिकेशन बनाने के लिए लैंगचेन में मेमोरी और स्टोरेज का लाभ उठाने की बारीकियों पर गौर करेंगे।

1. लैंगचेन में मेमोरी के साथ कार्य करना

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

1.1. मेमोरी के प्रकार

लैंगचेन विभिन्न परिदृश्यों को संबोधित करने के लिए विभिन्न मेमोरी प्रकार प्रदान करता है। यहां, हम दो प्रमुख प्रकारों पर ध्यान केंद्रित करेंगे:

कन्वर्सेशनबफरमेमोरी

यह मेमोरी प्रकार अल्पकालिक संदर्भ प्रतिधारण, बातचीत में हाल की बातचीत को कैप्चर करने और याद करने के लिए आदर्श है।

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "What's the weather like?"}, {"output": "I'm sorry, I don't have real-time weather information. Is there anything else I can help you with?"})

print(memory.load_memory_variables({}))

बातचीतसारांशमेमोरी

लंबी बातचीत के लिए, ConversationSummaryMemory एक बेहतरीन विकल्प है। यह मुख्य बिंदुओं को संक्षेप में प्रस्तुत करता है, बिना अत्यधिक विवरण के संदर्भ को बनाए रखता है।

from langchain.memory import ConversationSummaryMemory
from langchain.llms import Ollama 

llm = Ollama(model='phi3',temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "I'm looking for a good Italian restaurant"}, {"output": "Great! I'd be happy to help you find a good Italian restaurant. Do you have any specific preferences or requirements, such as location, price range, or specific dishes you're interested in?"})

print(memory.load_memory_variables({}))

1.2. अपने उपयोग के मामले के लिए सही मेमोरी प्रकार का चयन करना

उपयुक्त मेमोरी प्रकार का चयन कई कारकों पर निर्भर करता है:

• अवधि और जटिलता: लघु सत्र ConversationBufferMemory के साथ विस्तृत संदर्भ प्रतिधारण से लाभान्वित होते हैं, जबकि दीर्घकालिक इंटरैक्शन के लिए ConversationSummaryMemory के माध्यम से संक्षेपण की आवश्यकता हो सकती है।
• विस्तार बनाम अवलोकन: निर्धारित करें कि क्या विस्तृत इंटरैक्शन इतिहास या उच्च-स्तरीय सारांश आपके आवेदन के लिए अधिक मूल्यवान हैं।
• प्रदर्शन: मेमोरी आकार और पुनर्प्राप्ति गति के बीच व्यापार-बंद पर विचार करें।

उपयोग मामले:

• ConversationBufferMemory: त्वरित ग्राहक सहायता या FAQ-शैली इंटरैक्शन के लिए आदर्श।
• बातचीतसारांशमेमोरी: परियोजना प्रबंधन या चल रहे ग्राहक इंटरैक्शन जैसे दीर्घकालिक कार्यों के लिए सबसे उपयुक्त।

1.3. मेमोरी को जंजीरों और एजेंटों में एकीकृत करना

बातचीत क्षमताओं को बढ़ाने के लिए मेमोरी को लैंगचेन श्रृंखलाओं और एजेंटों में सहजता से एकीकृत किया जा सकता है।

from langchain.chains import ConversationChain  
from langchain.memory import ConversationBufferMemory
# llm = OpenAI(temperature=0)
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?")

यह उदाहरण दिखाता है कि कैसे ConversationBufferMemory का उपयोग पिछली बातचीत को याद रखने के लिए किया जा सकता है, जिससे अधिक स्वाभाविक बातचीत संभव हो सके।

2. डेटा को कायम रखना और पुनर्प्राप्त करना

निरंतर भंडारण सुनिश्चित करता है कि बातचीत का इतिहास और संदर्भ पूरे सत्र में बनाए रखा जाता है, जिससे बातचीत में निरंतरता बनी रहती है।

2.1. वार्तालाप इतिहास और स्थिति का भंडारण

बुनियादी दृढ़ता के लिए, आप JSON के साथ फ़ाइल-आधारित भंडारण का उपयोग कर सकते हैं:

import json

class PersistentMemory:
    def __init__(self, file_path):
        self.file_path = file_path
        self.load_memory()

    def load_memory(self):
        try:
            with open(self.file_path, 'r') as f:
                self.chat_memory = json.load(f)
        except FileNotFoundError:
            self.chat_memory = {'messages': []}

    def save_memory(self):
        with open(self.file_path, 'w') as f:
            json.dump({'messages': self.chat_memory['messages']}, f)

# Usage
memory = PersistentMemory(file_path='conversation_history.json')
print(memory.chat_memory)

यह विधि आपको वार्तालाप इतिहास को सरल, मानव-पठनीय प्रारूप में जारी रखने की अनुमति देती है।

2.2. डेटाबेस और स्टोरेज सिस्टम के साथ एकीकरण

अधिक स्केलेबल और कुशल भंडारण के लिए, SQLite जैसे डेटाबेस के साथ एकीकृत करने की अनुशंसा की जाती है:

import sqlite3

class SQLiteMemory:
    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = sqlite3.connect(db_path)
        self.create_table()

    def create_table(self):
        cursor = self.conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS conversations
            (id INTEGER PRIMARY KEY, input TEXT, output TEXT)
        ''')
        self.conn.commit()

    def save_context(self, inputs, outputs):
        cursor = self.conn.cursor()
        cursor.execute('INSERT INTO conversations (input, output) VALUES (?, ?)',
                       (inputs['input'], outputs['output']))
        self.conn.commit()

    def load_memory_variables(self, inputs):
        cursor = self.conn.cursor()
        cursor.execute('SELECT input, output FROM conversations ORDER BY id DESC LIMIT 10')
        rows = cursor.fetchall()
        history = "\\n".join([f"Human: {row[0]}\\nAI: {row[1]}" for row in reversed(rows)])
        return {"history": history }

# Usage
memory = SQLiteMemory('conversation_history.db')

print(memory.load_memory_variables({}))

3 मेमोरी उपयोग और प्रदर्शन को अनुकूलित करना

यह सुनिश्चित करने के लिए कि आपका एप्लिकेशन उत्तरदायी बना रहे, इन अनुकूलन रणनीतियों पर विचार करें:

• कुशल डेटा संरचनाएं: निश्चित आकार के बफ़र्स को प्रबंधित करने के लिए डेक जैसी संरचनाओं का उपयोग करें।
• कैशिंग रणनीतियाँ: बार-बार एक्सेस किए गए डेटा के लिए कैशिंग लागू करके डेटाबेस क्वेरीज़ को कम करें।
• डेटा प्रूनिंग: प्रबंधनीय मेमोरी आकार को बनाए रखने के लिए पुराने डेटा को नियमित रूप से छांटना या सारांशित करना।

यहां बुनियादी कैशिंग के साथ मेमोरी क्लास का एक उदाहरण दिया गया है:

import time

class CachedSQLiteMemory(SQLiteMemory):
    def __init__(self, db_path, cache_ttl=60):
        super().__init__(db_path)
        self.cache = None
        self.cache_time = 0
        self.cache_ttl = cache_ttl

    def load_memory_variables(self, inputs):
        current_time = time.time()
        if self.cache is None or (current_time - self.cache_time) > self.cache_ttl:
            var = self.cache
            self.cache = super().load_memory_variables(inputs)
            self.cache_time = current_time
            return self.cache

memory = CachedSQLiteMemory('conversation_history.db', cache_ttl=30)

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

निष्कर्ष

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

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

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

यदि आप मेरे लेखन का समर्थन करना चाहेंगे या मेरे लिए बीयर खरीदना चाहेंगे:
https://buymeacoffee.com/bmores