Update chatbot.py

chatbot.py

@@ -1,6 +1,7 @@
 import os
 import time
 import json
+import logging
 from groq import Groq
 from langchain.memory import ConversationBufferMemory
 from langchain_openai import ChatOpenAI
@@ -8,9 +9,13 @@ from langchain_community.document_loaders import CSVLoader
 from langchain_community.vectorstores import FAISS
 from deep_translator import GoogleTranslator
 
+# Set up logging
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
 class Comsatsbot:
     def __init__(self, hf, llm, api_keys, chats_collection, paths, index_path='faiss_kb'):
+        logger.info("Initializing Comsatsbot...")
         self.llm = llm
         self.api_keys = api_keys
         self.client = None
@@ -29,53 +34,71 @@ class Comsatsbot:
         self.initialize_faiss_index()
 
     def load_data(self, paths):
+        logger.info(f"Loading data from paths: {paths}")
         documents = []
         for path in paths:
             loader = CSVLoader(file_path=path)
             data = loader.load()
             documents.extend(data)
+        logger.debug(f"Loaded {len(documents)} documents.")
         return documents
 
     def initialize_faiss_index(self):
+        logger.info("Initializing FAISS index...")
         if os.path.exists(self.index_path):
+            logger.info(f"FAISS index found at {self.index_path}. Loading...")
             self.faiss_index = FAISS.load_local(self.index_path, self.hf, allow_dangerous_deserialization=True)
         else:
+            logger.info(f"FAISS index not found. Creating a new one...")
             documents = self.load_data(self.paths)
             self.faiss_index = FAISS.from_documents(documents, self.hf)
             self.faiss_index.save_local(self.index_path)
         self.faiss_retriever = self.faiss_index.as_retriever(search_kwargs={"k": 5})
+        logger.info("FAISS index initialized successfully.")
 
     def retrieve_answer(self, query):
+        logger.info(f"Retrieving answer for query: {query}")
         if self.faiss_retriever:
-            return self.faiss_retriever.invoke(query)
+            result = self.faiss_retriever.invoke(query)
+            logger.debug(f"Retrieved answer: {result}")
+            return result
+        logger.warning("FAISS retriever is not initialized.")
         return None
 
     def create_chat_record(self, chat_id):
+        logger.info(f"Creating new chat record for chat_id: {chat_id}")
         self.chats_collection.insert_one({
             "_id": chat_id,
             "history": []
         })
 
     def update_chat(self, chat_id, question, answer):
+        logger.info(f"Updating chat history for chat_id: {chat_id}")
         self.chats_collection.update_one(
             {"_id": chat_id},
             {"$push": {"history": {"question": question, "answer": answer}}}
         )
 
     def load_chat(self, chat_id):
+        logger.info(f"Loading chat history for chat_id: {chat_id}")
         chat_record = self.chats_collection.find_one({"_id": chat_id})
         if not chat_record:
+            logger.error(f"Chat ID {chat_id} does not exist.")
             raise KeyError(f"Chat ID {chat_id} does not exist.")
         return chat_record.get('history', [])
 
     def new_chat(self, chat_id):
+        logger.info(f"Creating new chat with ID: {chat_id}")
         if self.chats_collection.find_one({"_id": chat_id}):
+            logger.error(f"Chat ID {chat_id} already exists.")
             raise KeyError(f"Chat ID {chat_id} exists already.")
         self.create_chat_record(chat_id)
         return "success"
 
     def delete_chat(self, chat_id):
+        logger.info(f"Deleting chat record for chat_id: {chat_id}")
         if not self.chats_collection.find_one({"_id": chat_id}):
+            logger.error(f"Chat ID {chat_id} does not exist.")
             raise KeyError(f"Chat ID {chat_id} does not exist.")
         self.chats_collection.delete_one({"_id": chat_id})
         return "success"
@@ -83,40 +106,32 @@ class Comsatsbot:
     def get_system_prompt(self):
         return """
 You are a comsats assistant to help the user with comsats university-related queries. Your response should be concise, direct, and to the point. Avoid any unnecessary explanations. Always consider the provided context and chat history to generate the answer. 
-
 Use emojis only when required based on the user's tone and emotions. Do not overuse them. Here's when you should use emojis:
 - **Happy emotions**: Use 😊 or 😄 when the user expresses satisfaction or asks for something positive.
 - **Sad emotions**: Use 😔 when the user is asking about something disappointing or negative.
 - **Surprise**: Use 😯 when the user expresses surprise.
 - **Anger or frustration**: Use 😡 when the user expresses frustration or dissatisfaction.
-
 If the user asks the same question repeatedly or asks an illogical question, feel free to use emojis to subtly convey frustration, confusion, or amusement.
-
 Do not include the phrase "According to the provided context" or "Based on the chat history". Simply generate the answer like a human would, without referencing where the information comes from. 
-
 If the question requires a URL, format it like this:
 [Click here to visit COMSATS](https://comsats.edu.pk).
-
 Your task is to help students at COMSATS University, Attock campus, with their university-related queries. The following are key details about the university:
 - Departments: CS, AI, SE, Math, BBA, EE, CE, English.
 - Facilities: Cricket ground, football ground, two canteens (near CS and Math/EE), mosque near CS department, LT rooms in CS, classrooms in Math, and labs in EE.
 - Admission: Accepts NTS test, CGPA requirements: 85% for CGPA 4.0, 79-84% for CGPA 3.66.
 - Available degrees: BS Computer Science, BS Software Engineering, BS Artificial Intelligence, BS English, BS Math, BS Electrical Engineering, BS Computer Engineering, BS BBA.
-
 Consider the following chat history for additional context to answer the question:
 {history}
-
 When answering:
 - Answer in a conversational and friendly tone.
 - Be concise and to the point, while still being helpful.
 - If you don’t know the answer from the context or chat history, simply say "I don’t know the answer to this 😔".
-
 Context ends here. Now, answer the following question:
-
 {question}
         """
 
     def generate_response(self, question, history, context):
+        logger.info(f"Generating response for question: {question}")
         prompt = self.get_system_prompt().format(question=question, history=history, context=context)
 
         while True:
@@ -124,6 +139,7 @@ Context ends here. Now, answer the following question:
                 self.client = Groq(api_key=api_key)
                 for model in self.models:
                     try:
+                        logger.info(f"Calling model {model} for response...")
                         chat_completion = self.client.chat.completions.create(
                             messages=[ 
                                 {"role": "system", "content": prompt},
@@ -132,13 +148,18 @@ Context ends here. Now, answer the following question:
                             model=model,
                             max_tokens=1024,
                         )
-                        return chat_completion.choices[0].message.content
-                    except Exception:
+                        response = chat_completion.choices[0].message.content
+                        logger.debug(f"Received response: {response}")
+                        return response
+                    except Exception as e:
+                        logger.error(f"Error with model {model}: {e}")
                         time.sleep(2)
                         continue
+        logger.warning("Unable to generate a response.")
         return "Sorry, unable to provide an answer at this time."
 
     def detect_language(self, question):
+        logger.info(f"Detecting language for question: {question}")
         for api_key in self.api_keys:
             self.client = Groq(api_key=api_key)
             for model in self.models:
@@ -162,13 +183,18 @@ Context ends here. Now, answer the following question:
                         response_format={"type": "json_object"},
                     )
                     response = json.loads(chat_completion.choices[0].message.content)
-                    return response['detected_language'].lower()
-                except Exception:
+                    detected_language = response['detected_language'].lower()
+                    logger.debug(f"Detected language: {detected_language}")
+                    return detected_language
+                except Exception as e:
+                    logger.error(f"Error detecting language: {e}")
                     time.sleep(2)
                     continue
+        logger.warning("Unable to detect language.")
         return "english"
 
     def translate_urdu(self, text):
+        logger.info(f"Translating text to Urdu: {text}")
         for api_key in self.api_keys:
             self.client = Groq(api_key=api_key)
             for model in self.models:
@@ -192,13 +218,17 @@ Context ends here. Now, answer the following question:
                         response_format={"type": "json_object"},
                     )
                     response = json.loads(chat_completion.choices[0].message.content)
-                    return response['text']
-                except Exception:
+                    translated_text = response['text']
+                    logger.debug(f"Translated text: {translated_text}")
+                    return translated_text
+                except Exception as e:
+                    logger.error(f"Error translating text: {e}")
                     time.sleep(2)
                     continue
         return text
 
     def response(self, question, chat_id):
+        logger.info(f"Processing response for question: {question} (chat_id: {chat_id})")
         chat_history = self.load_chat(chat_id)
 
         for entry in chat_history: