২.৩: মেমরি কম্পোনেন্ট

কাস্টমার: আমার অর্ডার #12345 কোথায় আছে?
চ্যাটবট: আপনার অর্ডার শিপিং-এ আছে এবং আগামীকাল পৌঁছাবে।
কাস্টমার: ধন্যবাদ। এটাতে কি ফ্রি শিপিং ছিল?

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

# .env ফাইল থেকে API কি লোড করুন
load_dotenv()

# LLM সেটআপ করুন
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7,
    api_key=os.getenv("OPENAI_API_KEY")
)

# কনভার্সেশন বাফার মেমরি তৈরি করুন
memory = ConversationBufferMemory()

# কনভার্সেশন চেইন তৈরি করুন
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# প্রথম প্রম্পট
response1 = conversation.predict(input="আমার নাম করিম। আপনার নাম কি?")
print("AI:", response1)

# দ্বিতীয় প্রম্পট
response2 = conversation.predict(input="আমি বাংলাদেশের ঢাকায় থাকি। আপনি কোথায় থাকেন?")
print("AI:", response2)

# তৃতীয় প্রম্পট
response3 = conversation.predict(input="আমার শহর সম্পর্কে কিছু বলুন।")
print("AI:", response3)

# মেমরি দেখুন
print("\nমেমরি কনটেন্ট:")
print(memory.buffer)

Human: [ইউজার ইনপুট 1]
AI: [AI রেসপন্স 1]
Human: [ইউজার ইনপুট 2]
AI: [AI রেসপন্স 2]
...
Human: [বর্তমান ইউজার ইনপুট]

from langchain.memory import ConversationBufferWindowMemory

# উইন্ডো সাইজ 2 সহ কনভার্সেশন বাফার উইন্ডো মেমরি তৈরি করুন
window_memory = ConversationBufferWindowMemory(k=2)

# কনভার্সেশন চেইন তৈরি করুন
window_conversation = ConversationChain(
    llm=llm,
    memory=window_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nConversationBufferWindowMemory উদাহরণ:")
window_conversation.predict(input="আমার নাম করিম।")
window_conversation.predict(input="আমি একজন সফটওয়্যার ইঞ্জিনিয়ার।")
window_conversation.predict(input="আমি বাংলাদেশের ঢাকায় থাকি।")
response = window_conversation.predict(input="আমার পেশা কি?")
print("AI:", response)

# মেমরি দেখুন
print("\nউইন্ডো মেমরি কনটেন্ট:")
print(window_memory.buffer)

from langchain.memory import ConversationTokenBufferMemory
from langchain_openai import OpenAI

# টোকেন লিমিট 100 সহ কনভার্সেশন টোকেন বাফার মেমরি তৈরি করুন
token_memory = ConversationTokenBufferMemory(
    llm=OpenAI(),  # টোকেন কাউন্টিং-এর জন্য LLM প্রয়োজন
    max_token_limit=100
)

# কনভার্সেশন চেইন তৈরি করুন
token_conversation = ConversationChain(
    llm=llm,
    memory=token_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nConversationTokenBufferMemory উদাহরণ:")
token_conversation.predict(input="আমার নাম করিম।")
token_conversation.predict(input="আমি একজন সফটওয়্যার ইঞ্জিনিয়ার।")
token_conversation.predict(input="আমি বাংলাদেশের ঢাকায় থাকি।")
response = token_conversation.predict(input="আমার পেশা কি?")
print("AI:", response)

# মেমরি দেখুন
print("\nটোকেন মেমরি কনটেন্ট:")
print(token_memory.buffer)

from langchain.memory import ConversationSummaryMemory

# কনভার্সেশন সামারি মেমরি তৈরি করুন
summary_memory = ConversationSummaryMemory(llm=llm)

# কনভার্সেশন চেইন তৈরি করুন
summary_conversation = ConversationChain(
    llm=llm,
    memory=summary_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nConversationSummaryMemory উদাহরণ:")
summary_conversation.predict(input="আমার নাম করিম। আমি একজন সফটওয়্যার ইঞ্জিনিয়ার।")
summary_conversation.predict(input="আমি বাংলাদেশের ঢাকায় থাকি এবং AI নিয়ে কাজ করি।")
summary_conversation.predict(input="আমি LangChain শিখছি কারণ আমি একটি AI চ্যাটবট তৈরি করতে চাই।")
response = summary_conversation.predict(input="আমার পেশা এবং আগ্রহ সম্পর্কে কি মনে আছে?")
print("AI:", response)

# সামারি দেখুন
print("\nসামারি মেমরি কনটেন্ট:")
print(summary_memory.buffer)
print("\nMoving Summary:")
print(summary_memory.moving_summary_buffer)

from langchain.memory import ConversationSummaryBufferMemory

# কনভার্সেশন সামারি বাফার মেমরি তৈরি করুন
summary_buffer_memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=100
)

# কনভার্সেশন চেইন তৈরি করুন
summary_buffer_conversation = ConversationChain(
    llm=llm,
    memory=summary_buffer_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nConversationSummaryBufferMemory উদাহরণ:")
summary_buffer_conversation.predict(input="আমার নাম করিম। আমি একজন সফটওয়্যার ইঞ্জিনিয়ার।")
summary_buffer_conversation.predict(input="আমি বাংলাদেশের ঢাকায় থাকি এবং AI নিয়ে কাজ করি।")
summary_buffer_conversation.predict(input="আমি LangChain শিখছি কারণ আমি একটি AI চ্যাটবট তৈরি করতে চাই।")
summary_buffer_conversation.predict(input="আমি পাইথন, জাভাস্ক্রিপ্ট, এবং টেনসরফ্লো ব্যবহার করি।")
summary_buffer_conversation.predict(input="আমি আমার চ্যাটবটে RAG ইমপ্লিমেন্ট করতে চাই।")
response = summary_buffer_conversation.predict(input="আমার পেশা এবং দক্ষতা সম্পর্কে কি মনে আছে?")
print("AI:", response)

# সামারি বাফার দেখুন
print("\nসামারি বাফার মেমরি কনটেন্ট:")
print(summary_buffer_memory.buffer)
print("\nMoving Summary:")
print(summary_buffer_memory.moving_summary_buffer)

from langchain.memory import ConversationEntityMemory
from pprint import pprint

# এন্টিটি মেমরি তৈরি করুন
entity_memory = ConversationEntityMemory(llm=llm)

# কনভার্সেশন চেইন তৈরি করুন
entity_conversation = ConversationChain(
    llm=llm,
    memory=entity_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nEntityMemory উদাহরণ:")
entity_conversation.predict(input="আমার নাম করিম এবং আমি ঢাকা বিশ্ববিদ্যালয়ে পড়ি।")
entity_conversation.predict(input="আমার বন্ধু রহিম ঢাকা মেডিকেল কলেজে পড়ে।")
entity_conversation.predict(input="আমি কম্পিউটার সায়েন্স নিয়ে পড়াশোনা করি।")
entity_conversation.predict(input="রহিম মেডিসিন নিয়ে পড়াশোনা করে।")
response = entity_conversation.predict(input="আমি এবং রহিম কোথায় পড়াশোনা করি?")
print("AI:", response)

# এন্টিটি মেমরি দেখুন
print("\nএন্টিটি মেমরি কনটেন্ট:")
pprint(entity_memory.entity_store.store)

from langchain.memory.chat_memory import BaseChatMemory
from langchain.schema import HumanMessage, AIMessage
from typing import Dict, List, Any

class TimestampedChatMemory(BaseChatMemory):
    """
    টাইমস্ট্যাম্প সহ চ্যাট মেমরি - প্রতিটি মেসেজের সাথে টাইমস্ট্যাম্প স্টোর করে।
    """

    # মেমরি স্টোরেজ
    chat_history: List[Dict[str, Any]] = []

    @property
    def memory_variables(self) -> List[str]:
        """মেমরি ভেরিয়েবল নাম রিটার্ন করে"""
        return ["chat_history"]

    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """মেমরি ভেরিয়েবল লোড করে"""
        # ফরম্যাটেড চ্যাট হিস্টোরি তৈরি করুন
        formatted_history = ""
        for message in self.chat_history:
            role = message["role"]
            content = message["content"]
            timestamp = message["timestamp"]
            formatted_history += f"{role} ({timestamp}): {content}\n"

        return {"chat_history": formatted_history}

    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
        """কনভার্সেশন কনটেক্সট সেভ করে"""
        # ইউজার মেসেজ সেভ করুন
        from datetime import datetime
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        # ইনপুট কি নাম পান
        input_key = list(inputs.keys())[0]

        self.chat_history.append({
            "role": "Human",
            "content": inputs[input_key],
            "timestamp": timestamp
        })

        # AI মেসেজ সেভ করুন
        output_key = list(outputs.keys())[0]
        self.chat_history.append({
            "role": "AI",
            "content": outputs[output_key],
            "timestamp": timestamp
        })

    def clear(self) -> None:
        """মেমরি ক্লিয়ার করে"""
        self.chat_history = []

# টাইমস্ট্যাম্পড মেমরি ব্যবহার করুন
timestamped_memory = TimestampedChatMemory()

# কনভার্সেশন চেইন তৈরি করুন
timestamped_conversation = ConversationChain(
    llm=llm,
    memory=timestamped_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nTimestampedChatMemory উদাহরণ:")
timestamped_conversation.predict(input="আমার নাম করিম।")
timestamped_conversation.predict(input="আমি AI নিয়ে কাজ করি।")
response = timestamped_conversation.predict(input="আমার নাম কি?")
print("AI:", response)

# মেমরি দেখুন
print("\nটাইমস্ট্যাম্পড মেমরি কনটেন্ট:")
print(timestamped_memory.load_memory_variables({})["chat_history"])

from langchain.memory.chat_memory import BaseChatMemory
from langchain.schema import HumanMessage, AIMessage
from typing import Dict, List, Any

class TopicBasedMemory(BaseChatMemory):
    """
    টপিক-বেসড মেমরি - কনভার্সেশনকে বিভিন্ন টপিকে ভাগ করে এবং প্রতিটি টপিকের জন্য আলাদা মেমরি রাখে।
    """

    # টপিক-বেসড মেমরি স্টোরেজ
    topic_memories: Dict[str, List[Dict[str, str]]] = {}
    current_topic: str = "general"
    llm: Any  # LLM রেফারেন্স

    def __init__(self, llm=None, **kwargs):
        super().__init__(**kwargs)
        self.llm = llm
        self.topic_memories = {"general": []}

    @property
    def memory_variables(self) -> List[str]:
        """মেমরি ভেরিয়েবল নাম রিটার্ন করে"""
        return ["chat_history", "current_topic", "all_topics"]

    def _detect_topic(self, message: str) -> str:
        """মেসেজের টপিক ডিটেক্ট করে"""
        if not self.llm:
            return "general"

        # LLM ব্যবহার করে টপিক ডিটেক্ট করুন
        prompt = f"""
        নিম্নলিখিত মেসেজের টপিক নির্ধারণ করুন। নিম্নলিখিত টপিকগুলির মধ্যে একটি বেছে নিন:
        {', '.join(self.topic_memories.keys())}

        যদি কোনো নতুন টপিক হয়, তাহলে একটি নতুন টপিক নাম সাজেস্ট করুন।

        মেসেজ: {message}

        টপিক:
        """

        response = self.llm.predict(prompt)

        # রেসপন্স প্রসেস করুন
        detected_topic = response.strip().lower()

        # যদি নতুন টপিক হয়, তাহলে যোগ করুন
        if detected_topic not in self.topic_memories:
            self.topic_memories[detected_topic] = []

        return detected_topic

    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """মেমরি ভেরিয়েবল লোড করে"""
        # বর্তমান টপিকের চ্যাট হিস্টোরি ফরম্যাট করুন
        formatted_history = ""
        for message in self.topic_memories.get(self.current_topic, []):
            role = message["role"]
            content = message["content"]
            formatted_history += f"{role}: {content}\n"

        # সমস্ত টপিক লিস্ট করুন
        all_topics = list(self.topic_memories.keys())

        return {
            "chat_history": formatted_history,
            "current_topic": self.current_topic,
            "all_topics": all_topics
        }

    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
        """কনভার্সেশন কনটেক্সট সেভ করে"""
        # ইনপুট কি নাম পান
        input_key = list(inputs.keys())[0]
        user_message = inputs[input_key]

        # টপিক ডিটেক্ট করুন
        self.current_topic = self._detect_topic(user_message)

        # ইউজার মেসেজ সেভ করুন
        self.topic_memories[self.current_topic].append({
            "role": "Human",
            "content": user_message
        })

        # AI মেসেজ সেভ করুন
        output_key = list(outputs.keys())[0]
        self.topic_memories[self.current_topic].append({
            "role": "AI",
            "content": outputs[output_key]
        })

    def clear(self) -> None:
        """মেমরি ক্লিয়ার করে"""
        self.topic_memories = {"general": []}
        self.current_topic = "general"

# টপিক-বেসড মেমরি ব্যবহার করুন
topic_memory = TopicBasedMemory(llm=llm)

# কনভার্সেশন চেইন তৈরি করুন
topic_conversation = ConversationChain(
    llm=llm,
    memory=topic_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nTopicBasedMemory উদাহরণ:")
topic_conversation.predict(input="আমার নাম করিম।")
topic_conversation.predict(input="আমি AI নিয়ে কাজ করি।")
topic_conversation.predict(input="বাংলাদেশের রাজধানী কি?")
topic_conversation.predict(input="ঢাকার জনসংখ্যা কত?")
topic_conversation.predict(input="LangChain কি?")
topic_conversation.predict(input="LangChain-এ কি কি কম্পোনেন্ট আছে?")
response = topic_conversation.predict(input="আমার নাম কি এবং আমি কি নিয়ে কাজ করি?")
print("AI:", response)

# মেমরি দেখুন
print("\nটপিক-বেসড মেমরি কনটেন্ট:")
print("বর্তমান টপিক:", topic_memory.current_topic)
print("সমস্ত টপিক:", topic_memory.topic_memories.keys())
for topic, messages in topic_memory.topic_memories.items():
    print(f"\nটপিক: {topic}")
    for message in messages:
        print(f"{message['role']}: {message['content']}")

from langchain.memory import ConversationTokenBufferMemory
from langchain_openai import OpenAI

# টোকেন লিমিট সহ মেমরি তৈরি করুন
token_memory = ConversationTokenBufferMemory(
    llm=OpenAI(),
    max_token_limit=200
)

# কনভার্সেশন চেইন তৈরি করুন
token_conversation = ConversationChain(
    llm=llm,
    memory=token_memory,
    verbose=True
)

# কয়েকটি লম্বা প্রম্পট চালান
print("\nটোকেন কাউন্টিং উদাহরণ:")
token_conversation.predict(input="আমার নাম করিম এবং আমি একজন সফটওয়্যার ইঞ্জিনিয়ার। আমি বাংলাদেশের ঢাকায় থাকি।")
token_conversation.predict(input="আমি AI এবং মেশিন লার্নিং নিয়ে কাজ করি। আমি পাইথন, জাভাস্ক্রিপ্ট, এবং টেনসরফ্লো ব্যবহার করি।")
token_conversation.predict(input="আমি LangChain শিখছি কারণ আমি একটি AI চ্যাটবট তৈরি করতে চাই। আমি RAG ইমপ্লিমেন্ট করতে চাই।")
response = token_conversation.predict(input="আমার পেশা কি?")
print("AI:", response)

# মেমরি দেখুন
print("\nটোকেন মেমরি কনটেন্ট:")
print(token_memory.buffer)

from langchain.memory import VectorStoreRetrieverMemory
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# এমবেডিংস তৈরি করুন
embeddings = OpenAIEmbeddings()

# ভেক্টর স্টোর তৈরি করুন
vectorstore = FAISS.from_texts([""], embeddings)

# রিট্রিভার তৈরি করুন
retriever = vectorstore.as_retriever(search_kwargs=dict(k=1))

# ভেক্টর স্টোর মেমরি তৈরি করুন
vector_memory = VectorStoreRetrieverMemory(retriever=retriever)

# মেমরি পপুলেট করুন
vector_memory.save_context(
    {"input": "আমার নাম করিম।"},
    {"output": "হ্যালো করিম, আপনাকে জানতে পেরে খুশি হলাম।"}
)
vector_memory.save_context(
    {"input": "আমি একজন সফটওয়্যার ইঞ্জিনিয়ার।"},
    {"output": "সফটওয়্যার ইঞ্জিনিয়ারিং একটি দারুণ পেশা।"}
)
vector_memory.save_context(
    {"input": "আমি ঢাকায় থাকি।"},
    {"output": "ঢাকা বাংলাদেশের রাজধানী।"}
)
vector_memory.save_context(
    {"input": "আমি AI নিয়ে কাজ করি।"},
    {"output": "AI একটি আকর্ষণীয় ফিল্ড।"}
)

# রিলেভেন্ট মেমরি রিট্রিভ করুন
print("\nরিলেভেন্সি-বেসড মেমরি উদাহরণ:")
print("প্রশ্ন: আমার পেশা কি?")
relevant_memory = vector_memory.load_memory_variables({"input": "আমার পেশা কি?"})
print("রিলেভেন্ট মেমরি:", relevant_memory["history"])

print("\nপ্রশ্ন: আমি কোথায় থাকি?")
relevant_memory = vector_memory.load_memory_variables({"input": "আমি কোথায় থাকি?"})
print("রিলেভেন্ট মেমরি:", relevant_memory["history"])

from langchain.memory import CombinedMemory

# বিভিন্ন মেমরি কম্পোনেন্ট তৈরি করুন
conv_memory = ConversationBufferMemory(memory_key="chat_history")
summary_memory = ConversationSummaryMemory(llm=llm, memory_key="summary")

# কম্বাইন্ড মেমরি তৈরি করুন
combined_memory = CombinedMemory(memories=[conv_memory, summary_memory])

# কনভার্সেশন চেইন তৈরি করুন
combined_conversation = ConversationChain(
    llm=llm,
    memory=combined_memory,
    verbose=True
)

# কয়েকটি প্রম্পট চালান
print("\nCombinedMemory উদাহরণ:")
combined_conversation.predict(input="আমার নাম করিম।")
combined_conversation.predict(input="আমি একজন সফটওয়্যার ইঞ্জিনিয়ার।")
combined_conversation.predict(input="আমি ঢাকায় থাকি।")
response = combined_conversation.predict(input="আমার সম্পর্কে কি মনে আছে?")
print("AI:", response)

# মেমরি দেখুন
print("\nকম্বাইন্ড মেমরি কনটেন্ট:")
print("চ্যাট হিস্টোরি:", conv_memory.buffer)
print("সামারি:", summary_memory.buffer)

from langchain.memory import ConversationSummaryBufferMemory

# কম্প্রেশন সহ মেমরি তৈরি করুন
compressed_memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=100,
    return_messages=True
)

# কনভার্সেশন চেইন তৈরি করুন
compressed_conversation = ConversationChain(
    llm=llm,
    memory=compressed_memory,
    verbose=True
)

# কয়েকটি লম্বা প্রম্পট চালান
print("\nমেমরি কম্প্রেশন উদাহরণ:")
compressed_conversation.predict(input="আমার নাম করিম এবং আমি একজন সফটওয়্যার ইঞ্জিনিয়ার। আমি বাংলাদেশের ঢাকায় থাকি।")
compressed_conversation.predict(input="আমি AI এবং মেশিন লার্নিং নিয়ে কাজ করি। আমি পাইথন, জাভাস্ক্রিপ্ট, এবং টেনসরফ্লো ব্যবহার করি।")
compressed_conversation.predict(input="আমি LangChain শিখছি কারণ আমি একটি AI চ্যাটবট তৈরি করতে চাই। আমি RAG ইমপ্লিমেন্ট করতে চাই।")
compressed_conversation.predict(input="আমার হবি হল প্রোগ্রামিং, বই পড়া, এবং ভ্রমণ করা। আমি সাম্প্রতিক সময়ে নেপাল ভ্রমণ করেছি।")
response = compressed_conversation.predict(input="আমার পেশা এবং হবি কি?")
print("AI:", response)

# মেমরি দেখুন
print("\nকম্প্রেসড মেমরি কনটেন্ট:")
print("মেসেজ:", compressed_memory.buffer)
print("মুভিং সামারি:", compressed_memory.moving_summary_buffer)

from langchain.memory import MongoDBChatMessageHistory
from langchain.memory import ConversationBufferMemory

# মঙ্গোডিবি কানেকশন স্ট্রিং (এখানে ডেমো উদ্দেশ্যে)
connection_string = "mongodb://localhost:27017"

# মঙ্গোডিবি মেসেজ হিস্টোরি তৈরি করুন (এখানে কোড শুধু উদাহরণ হিসেবে দেখানো হয়েছে)
# message_history = MongoDBChatMessageHistory(
#     connection_string=connection_string,
#     session_id="user-123",
#     database_name="langchain",
#     collection_name="conversations"
# )

# # মেসেজ হিস্টোরি থেকে মেমরি তৈরি করুন
# mongodb_memory = ConversationBufferMemory(
#     memory_key="chat_history",
#     chat_memory=message_history
# )

# # কনভার্সেশন চেইন তৈরি করুন
# mongodb_conversation = ConversationChain(
#     llm=llm,
#     memory=mongodb_memory,
#     verbose=True
# )

print("\nডাটাবেস-ব্যাকড মেমরি উদাহরণ:")
print("এই উদাহরণে, আমরা মঙ্গোডিবি ব্যবহার করে মেমরি স্টোর করি।")
print("এটি পারসিস্টেন্ট স্টোরেজ প্রদান করে, যাতে অ্যাপ্লিকেশন রিস্টার্ট করার পরেও মেমরি থাকে।")
print("এটি মাল্টিপল ইউজার এবং সেশন ম্যানেজ করতেও সাহায্য করে।")

# multi_user_chatbot.py
from langchain.memory import ConversationSummaryBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI
from typing import Dict, Any
from dotenv import load_dotenv
import os
import json

# .env ফাইল থেকে API কি লোড করুন
load_dotenv()

class MultiUserChatbot:
    """
    মাল্টি-ইউজার চ্যাটবট যা প্রতিটি ইউজারের জন্য আলাদা মেমরি রাখে।
    """

    def __init__(self, model_name="gpt-3.5-turbo", temperature=0.7, memory_type="summary_buffer"):
        """চ্যাটবট ইনিশিয়ালাইজ করুন"""
        self.llm = ChatOpenAI(
            model=model_name,
            temperature=temperature,
            api_key=os.getenv("OPENAI_API_KEY")
        )

        self.memory_type = memory_type
        self.user_memories = {}
        self.user_chains = {}

    def _create_memory(self, user_id):
        """ইউজারের জন্য মেমরি তৈরি করুন"""
        if self.memory_type == "summary_buffer":
            return ConversationSummaryBufferMemory(
                llm=self.llm,
                max_token_limit=500,
                return_messages=True
            )
        else:
            # ডিফল্ট: কনভার্সেশন বাফার মেমরি
            return ConversationBufferMemory()

    def _get_or_create_chain(self, user_id):
        """ইউজারের জন্য কনভার্সেশন চেইন পান বা তৈরি করুন"""
        if user_id not in self.user_chains:
            # নতুন মেমরি তৈরি করুন
            memory = self._create_memory(user_id)
            self.user_memories[user_id] = memory

            # নতুন চেইন তৈরি করুন
            self.user_chains[user_id] = ConversationChain(
                llm=self.llm,
                memory=memory,
                verbose=False
            )

        return self.user_chains[user_id]

    def chat(self, user_id, message):
        """ইউজারের মেসেজের রেসপন্স দিন"""
        # ইউজারের চেইন পান
        chain = self._get_or_create_chain(user_id)

        # মেসেজ প্রসেস করুন
        response = chain.predict(input=message)

        return response

    def get_conversation_history(self, user_id):
        """ইউজারের কনভার্সেশন হিস্টোরি রিটার্ন করুন"""
        if user_id in self.user_memories:
            memory = self.user_memories[user_id]
            return memory.buffer
        return "কোন কনভার্সেশন হিস্টোরি নেই।"

    def clear_history(self, user_id):
        """ইউজারের কনভার্সেশন হিস্টোরি ক্লিয়ার করুন"""
        if user_id in self.user_memories:
            self.user_memories[user_id].clear()
            return True
        return False

    def save_histories(self, filename="chat_histories.json"):
        """সমস্ত ইউজারের চ্যাট হিস্টোরি সেভ করুন"""
        histories = {}

        for user_id, memory in self.user_memories.items():
            histories[user_id] = memory.buffer

        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(histories, f, ensure_ascii=False, indent=4)

        return f"{len(histories)} ইউজারের চ্যাট হিস্টোরি সেভ করা হয়েছে।"

    def load_histories(self, filename="chat_histories.json"):
        """সমস্ত ইউজারের চ্যাট হিস্টোরি লোড করুন"""
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                histories = json.load(f)

            # প্রতিটি ইউজারের হিস্টোরি লোড করুন
            for user_id, history in histories.items():
                # ইউজারের চেইন পান বা তৈরি করুন
                chain = self._get_or_create_chain(user_id)

                # হিস্টোরি লোড করুন
                self.user_memories[user_id].buffer = history

            return f"{len(histories)} ইউজারের চ্যাট হিস্টোরি লোড করা হয়েছে।"

        except FileNotFoundError:
            return "চ্যাট হিস্টোরি ফাইল পাওয়া যায়নি।"

# চ্যাটবট ব্যবহার করুন
if __name__ == "__main__":
    # চ্যাটবট তৈরি করুন
    chatbot = MultiUserChatbot()

    print("মাল্টি-ইউজার চ্যাটবট")
    print("=" * 50)
    print("ইউজার আইডি এবং মেসেজ দিয়ে চ্যাট করুন।")
    print("'exit' লিখে বের হন।")
    print("'switch <user_id>' লিখে ইউজার পরিবর্তন করুন।")
    print("'history' লিখে বর্তমান ইউজারের হিস্টোরি দেখুন।")
    print("'clear' লিখে বর্তমান ইউজারের হিস্টোরি ক্লিয়ার করুন।")
    print("=" * 50)

    current_user = "user-1"
    print(f"বর্তমান ইউজার: {current_user}")

    while True:
        user_input = input(f"{current_user} > ")

        if user_input.lower() == 'exit':
            break

        elif user_input.lower().startswith('switch '):
            current_user = user_input.split(' ')[1]
            print(f"ইউজার পরিবর্তন করা হয়েছে: {current_user}")

        elif user_input.lower() == 'history':
            history = chatbot.get_conversation_history(current_user)
            print("\nকনভার্সেশন হিস্টোরি:")
            print(history)

        elif user_input.lower() == 'clear':
            chatbot.clear_history(current_user)
            print("কনভার্সেশন হিস্টোরি ক্লিয়ার করা হয়েছে।")

        elif user_input.lower() == 'save':
            result = chatbot.save_histories()
            print(result)

        elif user_input.lower() == 'load':
            result = chatbot.load_histories()
            print(result)

        else:
            response = chatbot.chat(current_user, user_input)
            print(f"AI: {response}")