update history chat

NLP_model/chatbot.py

@@ -6,26 +6,14 @@ from langchain_community.vectorstores import FAISS
 from langchain.chains import RetrievalQA, ConversationalRetrievalChain
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain.prompts import PromptTemplate
+from langchain_ollama import OllamaLLM
 from pinecone import Pinecone, ServerlessSpec
 from langchain_pinecone import PineconeVectorStore
 from dotenv import load_dotenv
 import threading
 from datetime import datetime
-import time
 from langchain.schema import HumanMessage, AIMessage
 from langchain_google_genai import GoogleGenerativeAIEmbeddings
-import functools
-import hashlib
-import logging
-import random
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-)
-logger = logging.getLogger(__name__)
-
 # Load environment variables
 load_dotenv()
 
@@ -41,38 +29,38 @@ os.environ["PINECONE_API_KEY"] = pinecone_api_key
 
 genai.configure(api_key=google_api_key)
 
-# Lấy model chatbot
+#lấy model chatbot
 model = ChatGoogleGenerativeAI(model="gemini-1.5-flash-8b-latest",
                              temperature=0.8)
+# model = OllamaLLM(model="llama2")
+# print("Llama2 đã được tải thành công!")
 
-# Lấy model embedding
+#lấy model embedding
 embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
 
+
 # Biến lưu history cho từng user (dạng chuỗi)
 user_histories = {}
 history_lock = threading.Lock()
 
-# Cache for responses
-response_cache = {}
-cache_lock = threading.Lock()
-# Maximum cache size và thời gian sống (30 phút)
-MAX_CACHE_SIZE = 100
-CACHE_TTL = 1800  # 30 phút tính bằng giây
-
 # Create a prompt template with conversation history
 prompt = PromptTemplate(
     template = """Goal:
 You are a professional tour guide assistant that assists users in finding information about places in Da Nang, Vietnam.
 You can provide details on restaurants, cafes, hotels, attractions, and other local venues. You have to chat with users, who are Da Nang tourists. 
 
+
 Return Format:
-Respond in friendly, natural, and concise English like a real tour guide. 
+- Respond in clear, natural, and concise English.
+- If you do not have enough information to answer user's question, reply with "I don't know", and explain that you are not sure about the information.
+- When sufficient information is available in the Context, provide a specific and informative answer.
+- Let's support users like a real tour guide, not a bot. The information in context is your own knowledge.
+- You just care about time that user mention when they ask about Solana event.
 
 Warning:
-Let's support users like a real tour guide, not a bot. The information in context is your own knowledge.
-Your knowledge is provided in the Context. All of information in Context is about Da Nang, Vietnam.
-You just care about current time that user mention when user ask about Solana event.
-If you do not have enough information to answer user's question, reply with "I don't know. I don't have information about that".
+- Your knowledge is provided in the Context. All of information in Context is about Da Nang, Vietnam.
+- Do not fabricate or guess information.
+- Answer with "I don't know" if you don't have enough information.
 
 Context:
 {context}
@@ -103,8 +91,8 @@ def update_history(user_id, new_entry):
         # Store only the last 30 interactions by keeping the 60 most recent lines
         # (assuming 2 lines per interaction: 1 for user, 1 for bot)
         history_lines = current_history.split('\n')
-        if len(history_lines) > 20:
-            history_lines = history_lines[-20:]
+        if len(history_lines) > 60:
+            history_lines = history_lines[-60:]
             current_history = '\n'.join(history_lines)
         
         updated_history = current_history + new_entry + "\n"
@@ -137,145 +125,73 @@ def string_to_message_history(history_str):
             
     return messages
 
-# Singleton pattern để chỉ khởi tạo retriever một lần
-_retriever_instance = None
-_retriever_lock = threading.Lock()
-
 def get_chain():
-    """Get the retrieval chain with Pinecone vector store (singleton pattern)"""
-    global _retriever_instance
-    
-    # Nếu đã có instance, trả về ngay
-    if _retriever_instance is not None:
-        return _retriever_instance
-    
-    # Thread-safe khởi tạo
-    with _retriever_lock:
-        # Kiểm tra lại trong trường hợp một thread khác đã khởi tạo
-        if _retriever_instance is not None:
-            return _retriever_instance
-            
-        try:
-            start_time = time.time()
-            pc = Pinecone(
-                api_key=os.environ["PINECONE_API_KEY"]
-            )
-            
-            # Get the vector store from the existing index
-            vectorstore = PineconeVectorStore.from_existing_index(
-                index_name="testbot768",
-                embedding=embeddings,
-                text_key="text"
-            )
-            
-            _retriever_instance = vectorstore.as_retriever(search_kwargs={"k": 3})
-            logger.info(f"Pinecone retriever initialized in {time.time() - start_time:.2f} seconds")
-            return _retriever_instance
-        except Exception as e:
-            logger.error(f"Error getting vector store from Pinecone: {e}")
-            # Fallback to a local vector store or return None
-            try:
-                # Try to load a local FAISS index if it exists
-                start_time = time.time()
-                vectorstore = FAISS.load_local("faiss_index", embeddings)
-                _retriever_instance = vectorstore.as_retriever(search_kwargs={"k": 3})
-                logger.info(f"FAISS retriever initialized in {time.time() - start_time:.2f} seconds")
-                return _retriever_instance
-            except Exception as faiss_error:
-                logger.error(f"Error getting FAISS vector store: {faiss_error}")
-                return None
-
-def clean_cache():
-    """Clean expired cache entries"""
-    with cache_lock:
-        current_time = time.time()
-        expired_keys = [k for k, v in response_cache.items() if current_time - v['timestamp'] > CACHE_TTL]
+    """Get the retrieval chain with Pinecone vector store"""
+    try:
+        pc = Pinecone(
+            api_key=os.environ["PINECONE_API_KEY"]
+        )
         
-        for key in expired_keys:
-            del response_cache[key]
-            
-        # Nếu cache vẫn quá lớn, xóa các mục cũ nhất
-        if len(response_cache) > MAX_CACHE_SIZE:
-            # Sắp xếp theo thời gian và giữ lại MAX_CACHE_SIZE mục mới nhất
-            sorted_items = sorted(response_cache.items(), key=lambda x: x[1]['timestamp'])
-            items_to_remove = sorted_items[:len(sorted_items) - MAX_CACHE_SIZE]
+        # Get the vector store from the existing index
+        vectorstore = PineconeVectorStore.from_existing_index(
+            index_name="testbot768",
+            embedding=embeddings,
+            text_key="text"
+        )
+        
+        retrieve = vectorstore.as_retriever(search_kwargs={"k": 3})
             
-            for key, _ in items_to_remove:
-                del response_cache[key]
-
-def generate_cache_key(request, user_id):
-    """Generate a unique cache key from the request and user_id"""
-    # Tạo một chuỗi kết hợp để hash
-    combined = f"{request.strip().lower()}:{user_id}"
-    # Tạo MD5 hash
-    return hashlib.md5(combined.encode()).hexdigest()
+        return retrieve
+    except Exception as e:
+        print(f"Error getting vector store: {e}")
+        return None
 
 def chat(request, user_id="default_user"):
     """Process a chat request from a specific user"""
-    start_time = time.time()
-    
-    # Định kỳ xóa các mục cache hết hạn
-    if random.random() < 0.1:  # 10% cơ hội mỗi lần gọi
-        clean_cache()
-    
-    # Tạo cache key
-    cache_key = generate_cache_key(request, user_id)
-    
-    # Kiểm tra cache
-    with cache_lock:
-        if cache_key in response_cache:
-            cache_data = response_cache[cache_key]
-            # Kiểm tra thời gian sống
-            if time.time() - cache_data['timestamp'] <= CACHE_TTL:
-                logger.info(f"Cache hit for user {user_id}, request: '{request[:30]}...'")
-                # Cập nhật timestamp để reset TTL
-                cache_data['timestamp'] = time.time()
-                # Vẫn cập nhật lịch sử trò chuyện
-                new_entry = f"User: {request}\nBot: {cache_data['response']}"
-                update_history(user_id, new_entry)
-                return cache_data['response']
     try:
+        # Get retrieval chain
         retriever = get_chain()
         if not retriever:
             return "Error: Could not initialize retriever"
         
+        # Get current conversation history as string
+        conversation_history_str = get_history(user_id)
+        
+        # Convert string history to LangChain message format
+        message_history = string_to_message_history(conversation_history_str)
+        
+        # Get current time
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         
-        retrieved_docs = retriever.get_relevant_documents(request)
-        context = "\n".join([doc.page_content for doc in retrieved_docs])
-        # context = context + "\n(Current time: " + current_time + ")"
-        # print("Context:", context)
+        # Add timestamp to question
+        question_with_time = f"{request}\n(Current time: {current_time})"
+        # print("User question:", question_with_time)
         
-        # print(prompt.format(
-        #         context=context,
-        #         question=request,
-        #         chat_history=get_history(user_id)
-        #     ))
-        response = model.invoke(
-            prompt.format(
-                context=context,
-                question=request,
-                chat_history=get_history(user_id)
-            )
+        # Create a ConversationalRetrievalChain
+        # Get relevant documents from retriever
+        retrieved_docs = retriever.get_relevant_documents(question_with_time)
+        print("Retrieved documents page content:", [doc.page_content for doc in retrieved_docs])
+        
+        conversation_chain = ConversationalRetrievalChain.from_llm(
+            llm=model,
+            retriever=retriever,
+            combine_docs_chain_kwargs={"prompt": prompt}
         )
-        answer = str(response.content)
         
-        new_entry = f"User: {request}\nBot: {answer}"
-        update_history(user_id, new_entry)
-        # print(get_history(user_id))
+        # Call the chain with question and converted message history
+        response = conversation_chain({"question": question_with_time, "chat_history": message_history})
+        answer = str(response['answer'])
         
-        # Lưu vào cache
-        with cache_lock:
-            response_cache[cache_key] = {
-                'response': answer,
-                'timestamp': time.time()
-            }
+        # Update conversation history string
+        new_entry = f"User: {question_with_time}\nBot: {answer}"
+        update_history(user_id, new_entry)
+        print(get_history(user_id))
         
-        logger.info(f"Total processing time: {time.time() - start_time:.2f} seconds")
+        print(answer)
         return answer
     except Exception as e:
-        logger.error(f"Error in chat: {e}")
-        return f"I don't know how to answer that right now. Let me forward this to the admin team."
+        print(f"Error in chat: {e}")
+        return f"I encountered an error: {str(e)}"
 
 def clear_memory(user_id="default_user"):
     """Clear the conversation history for a specific user"""
@@ -283,4 +199,4 @@ def clear_memory(user_id="default_user"):
         if user_id in user_histories:
             del user_histories[user_id]
             return f"Conversation history cleared for user {user_id}"
-        return f"No conversation history found for user {user_id}" 
+        return f"No conversation history found for user {user_id}"

mongodb.py

@@ -0,0 +1,71 @@
+import os
+from pymongo import MongoClient
+import logging
+from dotenv import load_dotenv
+
+# Load biến môi trường từ .env (nếu có)
+load_dotenv()
+
+# Cấu hình logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Lấy thông tin kết nối MongoDB từ biến môi trường
+MONGODB_URI = os.getenv("MONGODB_URI")
+MONGODB_DB = os.getenv("MONGODB_DB")
+MONGODB_COLLECTION = os.getenv("MONGODB_COLLECTION")
+
+# Kết nối MongoDB sử dụng pymongo
+client = MongoClient(MONGODB_URI)
+db = client[MONGODB_DB]
+collection = db[MONGODB_COLLECTION]
+
+
+def get_chat_history(user_id: int) -> str:
+    """
+    Lấy lịch sử chat cho user_id cho trước từ MongoDB và ghép thành chuỗi theo định dạng:
+    
+    Bot: ...
+    User: ...
+    Bot: ...
+    ...
+    
+    Giả sử:
+      - Các document chứa trường "user_id" để lọc theo user_id.
+      - Trường "factor" xác định nguồn tin (nếu factor == "user" thì là tin của User,
+        còn lại coi là tin của Bot/RAG).
+      - Trường "timestamp" dùng để sắp xếp theo thời gian (nếu có).
+    """
+    try:
+        # Truy vấn tất cả các document có user_id, sắp xếp theo timestamp tăng dần
+        # Nếu không có trường timestamp, có thể sort theo _id
+        docs = list(collection.find({"user_id": user_id}).sort("timestamp", 1).limit(15))
+        if not docs:
+            logger.info(f"Không tìm thấy dữ liệu cho user_id: {user_id}")
+            return ""
+        
+        conversation_lines = []
+        for doc in docs:
+            factor = doc.get("factor", "").lower()
+            action = doc.get("action", "").lower()
+            message = doc.get("message", "")
+            
+            if action == "freely asking":
+                conversation_lines.append(f"User: {message}")
+            elif action == "response":
+                conversation_lines.append(f"Bot: {message}")
+        
+        # Ghép các dòng thành chuỗi, mỗi dòng cách nhau bằng xuống dòng
+        return "\n".join(conversation_lines)
+    except Exception as e:
+        logger.error(f"Lỗi khi lấy lịch sử chat cho user_id {user_id}: {e}")
+        return ""
+
+# if __name__ == '__main__':
+#     user_id = int(input("Nhập user_id cần lấy lịch sử chat: ").strip())
+#     history = get_chat_history(user_id)
+#     if history:
+#         print("\nLịch sử trò chuyện:")
+#         print(history)
+#     else:
+#         print(f"Không tìm thấy lịch sử chat cho user_id: {user_id}")