Update chatbot.py

chatbot.py

@@ -2,6 +2,8 @@ import os
 import time
 import json
 from groq import Groq
+from langchain.memory import ConversationBufferMemory
+from langchain_openai import ChatOpenAI
 from langchain_community.document_loaders import CSVLoader
 from langchain_community.vectorstores import FAISS
 from deep_translator import GoogleTranslator
@@ -12,17 +14,14 @@ class Comsatsbot:
         self.llm = llm
         self.api_keys = api_keys
         self.client = None
-        self.models = [
-            "llama3-groq-70b-8192-tool-use-preview",
-            "llama-3.1-70b-versatile",
-            "llama3-70b-8192"
-        ]
+        self.models = ["llama3-70b-8192"]  # use a single known working model
+        self.memory = ConversationBufferMemory(llm=self.llm, max_token_limit=3000)
         self.chats_collection = chats_collection
         self.index_path = index_path
         self.hf = hf
-        self.paths = paths
         self.faiss_index = None
         self.faiss_retriever = None
+        self.paths = paths
         self.initialize_faiss_index()
 
     def load_data(self, paths):
@@ -48,10 +47,7 @@ class Comsatsbot:
         return None
 
     def create_chat_record(self, chat_id):
-        self.chats_collection.insert_one({
-            "_id": chat_id,
-            "history": []
-        })
+        self.chats_collection.insert_one({"_id": chat_id, "history": []})
 
     def update_chat(self, chat_id, question, answer):
         self.chats_collection.update_one(
@@ -82,18 +78,13 @@ class Comsatsbot:
         context_text = "\n".join([doc.page_content for doc in context])
 
         prompt = f'''
-        Kindly use the proper emojis where we need to use in responses.       
-        You are a comsats assistant to help the user with comsats university-related queries. Your answer should be very concise and to the point with a short answer. Don't repeat irrelevant text. 
-        Answer the following Question: {question}
-        Kindly generate a concise and to-the-point answer. Use the provided context and chat history. If you don’t find the answer, just say "I don’t know" and don’t make it up.
-        Use emojis when appropriate (e.g., confusion, repeated questions, happy, sad situations). Avoid using them in simple academic or factual responses.
-        Format URLs as: [Click here to visit "website name"](https://comsats.edu.pk)
-
-        University details:
-        Comsats Attock Campus Provides BS Computer Science, BS Software Engineering, BS Artificial Intelligence, BS English, BS Math, BS Electrical Engineering, BS Computer Engineering, BS BBA.
-        Departments: CS (CS, AI, SE), Math (Math, BBA, English), EE (EE, CE).
-        Facilities: Cricket ground, football ground, two canteens (one near Math & EE, one near CS), mosque near CS, 9 lecture theaters (LT), Math classrooms (CR), EE labs.
-        NTS test accepted. CGPA system: 4.0 for 85%, 3.66 for 79–84%, etc.
+        You are a comsats assistant. Answer concisely and with emojis only where appropriate.
+        Don't mention context/history explicitly. Use friendly tone and only say "I don’t know" if no relevant answer is found.
+
+        University Info:
+        Comsats Attock Campus offers CS, SE, AI, English, Math, EE, CE, BBA.
+        Departments: CS, Math, EE. Facilities: grounds, canteens, mosque, LT rooms, labs.
+        Admissions via NTS. CGPA: 4.0 (85%), 3.66 (79-84%), etc.
 
         Context:
         {context_text}
@@ -103,56 +94,30 @@ class Comsatsbot:
 
         Question: {question}
         '''
-        while True:
-            for api_key in self.api_keys:
-                self.client = Groq(api_key=api_key)
-                for model in self.models:
-                    try:
-                        chat_completion = self.client.chat.completions.create(
-                            messages=[
-                                {"role": "system", "content": prompt},
-                                {"role": "user", "content": f"Answer the following question: {question}"}
-                            ],
-                            model=model,
-                            max_tokens=1024,
-                        )
-                        return chat_completion.choices[0].message.content
-                    except Exception:
-                        time.sleep(2)
-                        continue
-        return "Sorry, unable to provide an answer at this time."
 
-    def detect_language(self, question):
         for api_key in self.api_keys:
             self.client = Groq(api_key=api_key)
             for model in self.models:
                 try:
                     chat_completion = self.client.chat.completions.create(
                         messages=[
-                            {
-                                "role": "system",
-                                "content": """
-                                    You are an expert agent, and your task is to detect the language. 
-                                    Return a JSON: {'detected_language': 'urdu' or 'english'}
-                                """
-                            },
-                            {
-                                "role": "user",
-                                "content": f"Detect the language for: {question}"
-                            }
+                            {"role": "system", "content": prompt},
+                            {"role": "user", "content": f"Answer the following question: {question}"}
                         ],
                         model=model,
-                        max_tokens=256,
-                        response_format={"type": "json_object"},
+                        max_tokens=1024,
                     )
-                    response = json.loads(chat_completion.choices[0].message.content)
-                    return response['detected_language'].lower()
-                except Exception:
+                    result = chat_completion.choices[0].message.content
+                    print("Returning answer:", result)
+                    return result
+                except Exception as e:
+                    print(f"Error with {model}: {e}")
                     time.sleep(2)
                     continue
-        return "english"
 
-    def translate_urdu(self, text):
+        return "Sorry 😔 I'm currently facing technical issues. Please try again later."
+
+    def detect_language(self, question):
         for api_key in self.api_keys:
             self.client = Groq(api_key=api_key)
             for model in self.models:
@@ -162,33 +127,42 @@ class Comsatsbot:
                             {
                                 "role": "system",
                                 "content": """
-                                    Translate the following text into proper Urdu. Return a JSON: 
-                                    {'text': 'translated urdu text'}
+                                    You are an expert agent, and your task is to detect the language.
+                                    Return a JSON: {'detected_language': 'urdu' or 'english'}
                                 """
                             },
                             {
                                 "role": "user",
-                                "content": f"Translate this: {text}"
+                                "content": f"Detect the language for: {question}"
                             }
                         ],
                         model=model,
-                        max_tokens=512,
+                        max_tokens=256,
                         response_format={"type": "json_object"},
                     )
                     response = json.loads(chat_completion.choices[0].message.content)
-                    return response['text']
-                except Exception:
+                    return response['detected_language'].lower()
+                except Exception as e:
+                    print(f"Language detection error: {e}")
                     time.sleep(2)
                     continue
-        return text
+        return "english"
+
+    def translate_urdu(self, text):
+        try:
+            return GoogleTranslator(source='ur', target='en').translate(text)
+        except:
+            return text
 
     def response(self, question, chat_id):
         chat_history = self.load_chat(chat_id)
+        for entry in chat_history:
+            self.memory.save_context({"input": entry["question"]}, {"output": entry["answer"]})
 
         language = self.detect_language(question)
 
         if language == 'urdu':
-            question_translation = GoogleTranslator(source='ur', target='en').translate(question)
+            question_translation = self.translate_urdu(question)
             context = self.faiss_retriever.invoke(question_translation)
         else:
             context = self.faiss_retriever.invoke(question)