Update chatbot.py

chatbot.py

@@ -9,11 +9,60 @@ class Chatbot:
     def __init__(self):
         self.qa_pairs = []
         self.question_embeddings = []
-        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.model = None
         self.database_url = "https://database-46m3.onrender.com"
-        self.recommender = CourseRecommender()
+        self.recommender = None
+        self.load_model()
+        self.load_recommender()
         self.load_qa_data()
     
+    def load_model(self):
+        """Load the sentence transformer model with error handling"""
+        import time
+        import os
+        
+        # List of models to try in order of preference
+        models_to_try = [
+            'all-MiniLM-L6-v2',
+            'paraphrase-MiniLM-L6-v2',
+            'all-MiniLM-L12-v2'
+        ]
+        
+        for model_name in models_to_try:
+            try:
+                print(f"Loading sentence transformer model: {model_name}...")
+                
+                # Try with cache directory first
+                cache_dir = os.path.join(os.getcwd(), 'model_cache')
+                os.makedirs(cache_dir, exist_ok=True)
+                
+                self.model = SentenceTransformer(model_name, cache_folder=cache_dir)
+                print(f"✅ Model {model_name} loaded successfully")
+                return
+                
+            except Exception as e:
+                print(f"❌ Error loading {model_name}: {str(e)}")
+                continue
+        
+        # If all models fail, try without cache
+        try:
+            print("Trying without cache directory...")
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            print("✅ Model loaded successfully without cache")
+        except Exception as e:
+            print(f"❌ Final attempt failed: {str(e)}")
+            raise Exception("Could not load any sentence transformer model")
+    
+    def load_recommender(self):
+        """Load the course recommender with error handling"""
+        try:
+            print("Loading course recommender...")
+            self.recommender = CourseRecommender()
+            print("✅ Recommender loaded successfully")
+        except Exception as e:
+            print(f"❌ Error loading recommender: {str(e)}")
+            self.recommender = None
+    
     def load_qa_data(self):
         """Load Q&A pairs from the faqs table in the database"""
         try:
@@ -29,10 +78,13 @@ class Chatbot:
                     # If it's a single object, wrap it in a list
                     self.qa_pairs = [data]
                 
-                # Generate embeddings for all questions
+                # Generate embeddings for all questions if model is available
                 questions = [item.get('question', '') for item in self.qa_pairs]
-                self.question_embeddings = self.model.encode(questions)
-                print(f"Loaded {len(self.qa_pairs)} FAQ pairs from database")
+                if self.model is not None:
+                    self.question_embeddings = self.model.encode(questions)
+                    print(f"Loaded {len(self.qa_pairs)} FAQ pairs with embeddings from database")
+                else:
+                    print(f"Loaded {len(self.qa_pairs)} FAQ pairs from database (using fallback matching)")
             else:
                 print(f"Failed to load data from faqs table. Status code: {response.status_code}")
                 self._load_fallback_data()
@@ -50,28 +102,48 @@ class Chatbot:
             {"question": "What is a neural network?", "answer": "A neural network is a computing system inspired by biological neural networks that constitute animal brains. It consists of interconnected nodes (neurons) that process information."}
         ]
         questions = [item['question'] for item in self.qa_pairs]
-        self.question_embeddings = self.model.encode(questions)
-        print("Loaded fallback Q&A data")
+        if self.model is not None:
+            self.question_embeddings = self.model.encode(questions)
+            print("Loaded fallback Q&A data with embeddings")
+        else:
+            print("Loaded fallback Q&A data (using fallback matching)")
     
     def find_best_match(self, user_input, threshold=0.7):
-        """Find the best matching question using semantic similarity"""
+        """Find the best matching question using semantic similarity or fallback text matching"""
         if not self.qa_pairs:
             return None, 0
         
-        # Encode the user input
-        user_embedding = self.model.encode([user_input])
-        
-        # Calculate cosine similarity with all questions
-        similarities = cosine_similarity(user_embedding, self.question_embeddings)[0]
-        
-        # Find the best match
-        best_match_idx = np.argmax(similarities)
-        best_similarity = similarities[best_match_idx]
-        
-        if best_similarity >= threshold:
-            return self.qa_pairs[best_match_idx], best_similarity
+        if self.model is not None and len(self.question_embeddings) > 0:
+            # Use AI model for semantic matching
+            user_embedding = self.model.encode([user_input])
+            similarities = cosine_similarity(user_embedding, self.question_embeddings)[0]
+            best_match_idx = np.argmax(similarities)
+            best_similarity = similarities[best_match_idx]
+            
+            if best_similarity >= threshold:
+                return self.qa_pairs[best_match_idx], best_similarity
+            else:
+                return None, best_similarity
         else:
-            return None, best_similarity
+            # Fallback to simple text matching
+            user_input_lower = user_input.lower()
+            best_match = None
+            best_score = 0
+            
+            for qa_pair in self.qa_pairs:
+                question = qa_pair.get('question', '').lower()
+                # Simple keyword matching
+                common_words = set(user_input_lower.split()) & set(question.split())
+                if common_words:
+                    score = len(common_words) / max(len(user_input_lower.split()), len(question.split()))
+                    if score > best_score and score >= 0.3:  # Lower threshold for fallback
+                        best_score = score
+                        best_match = qa_pair
+            
+            if best_match:
+                return best_match, best_score
+            else:
+                return None, 0
     
     def get_response(self, user_input):
         """Get response for user input"""
@@ -115,6 +187,9 @@ class Chatbot:
             if not hobbies or not str(hobbies).strip():
                 return "❌ Please enter your hobbies/interests"
             
+            if self.recommender is None:
+                return "❌ Course recommendation system is not available at the moment. Please try again later."
+            
             # Get recommendations
             recommendations = self.recommender.recommend_courses(
                 stanine=stanine,