Update ai_chatbot.py

ai_chatbot.py

@@ -1,155 +1,140 @@
+import requests
+import json
 from sentence_transformers import SentenceTransformer
 import numpy as np
-from typing import List, Dict, Tuple
-import re
-import os
-import requests
+from sklearn.metrics.pairwise import cosine_similarity
+from recommender import CourseRecommender
 
-class AIChatbot:
+class Chatbot:
     def __init__(self):
-        # Load the pre-trained model (can use a smaller model for more speed)
+        self.qa_pairs = []
+        self.question_embeddings = []
         self.model = SentenceTransformer('all-MiniLM-L6-v2')
-        # Warm up the model to avoid first-request slowness
-        _ = self.model.encode(["Hello, world!"])
-        self.faq_embeddings = None
-        self.faqs = None
-        self.load_faqs()
+        self.database_url = "https://database-46m3.onrender.com"
+        self.recommender = CourseRecommender()
+        self.load_qa_data()
     
-    def load_faqs(self):
-        """Disable FAQs entirely; operate as a general-conversation bot."""
-        self.faqs = []
-        self.faq_embeddings = None
+    def load_qa_data(self):
+        """Load Q&A pairs from the faqs table in the database"""
+        try:
+            # Connect to the faqs table endpoint
+            faqs_url = f"{self.database_url}/faqs"
+            response = requests.get(faqs_url)
+            if response.status_code == 200:
+                data = response.json()
+                # Assuming the database returns a list of FAQ objects
+                if isinstance(data, list):
+                    self.qa_pairs = data
+                else:
+                    # If it's a single object, wrap it in a list
+                    self.qa_pairs = [data]
+                
+                # Generate embeddings for all questions
+                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")
+            else:
+                print(f"Failed to load data from faqs table. Status code: {response.status_code}")
+                self._load_fallback_data()
+        except Exception as e:
+            print(f"Error loading FAQ data: {str(e)}")
+            self._load_fallback_data()
     
-    def save_unanswered_question(self, question):
-        """Log unanswered questions to console (can be extended to save to file)"""
-        print(f"Unanswered question logged: {question}")
-        # In a real implementation, you could save this to a file or send to an admin
-
-    def _tokenize(self, text: str):
-        if not text:
-            return []
-        return [t for t in re.findall(r"[a-z0-9]+", text.lower()) if len(t) > 2]
-
-    def _overlap_ratio(self, q_tokens, faq_tokens):
-        if not q_tokens or not faq_tokens:
-            return 0.0
-        q_set = set(q_tokens)
-        f_set = set(faq_tokens)
-        inter = len(q_set & f_set)
-        denom = max(len(q_set), 1)
-        return inter / denom
-
-    def _wh_class(self, text: str) -> str:
-        if not text:
-            return ''
-        s = text.strip().lower()
-        # simple heuristic classification by leading wh-word
-        for key in ['who', 'where', 'when', 'what', 'how', 'why', 'which']:
-            if s.startswith(key + ' ') or s.startswith(key + "?"):
-                return key
-        # also check presence if not leading
-        for key in ['who', 'where', 'when', 'what', 'how', 'why', 'which']:
-            if f' {key} ' in f' {s} ':
-                return key
-        return ''
-
-    def find_best_match(self, question: str, threshold: float = 0.7) -> Tuple[str, float]:
-        print(f"find_best_match called with: {question}")  # Debug print
-        # Always act as a general-conversation bot
-        return self._generate_general_response(question)
+    def _load_fallback_data(self):
+        """Load fallback data if database is unavailable"""
+        self.qa_pairs = [
+            {"question": "What is artificial intelligence?", "answer": "Artificial Intelligence (AI) is a branch of computer science that aims to create machines capable of intelligent behavior."},
+            {"question": "How does machine learning work?", "answer": "Machine learning is a subset of AI that enables computers to learn and improve from experience without being explicitly programmed."},
+            {"question": "What is deep learning?", "answer": "Deep learning is a subset of machine learning that uses neural networks with multiple layers to model and understand complex patterns in data."},
+            {"question": "What is natural language processing?", "answer": "Natural Language Processing (NLP) is a field of AI that focuses on the interaction between computers and humans through natural language."},
+            {"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")
     
-    def _generate_general_response(self, question: str) -> Tuple[str, float]:
-        """Generate general conversation responses for non-FAQ questions"""
-        question_lower = question.lower().strip()
-        
-        # Greeting responses
-        if any(greeting in question_lower for greeting in ['hello', 'hi', 'hey', 'good morning', 'good afternoon', 'good evening']):
-            return "Hello! I'm the PSAU AI assistant. I'm here to help you with questions about university admissions, courses, and general information about Pangasinan State University. How can I assist you today?", 0.8
+    def find_best_match(self, user_input, threshold=0.7):
+        """Find the best matching question using semantic similarity"""
+        if not self.qa_pairs:
+            return None, 0
         
-        # Thank you responses
-        if any(thanks in question_lower for thanks in ['thank you', 'thanks', 'thank', 'appreciate']):
-            return "You're very welcome! I'm happy to help. Is there anything else you'd like to know about PSAU or university admissions?", 0.9
+        # Encode the user input
+        user_embedding = self.model.encode([user_input])
         
-        # Goodbye responses
-        if any(goodbye in question_lower for goodbye in ['bye', 'goodbye', 'see you', 'farewell']):
-            return "Goodbye! It was nice chatting with you. Feel free to come back anytime if you have more questions about PSAU. Good luck with your academic journey!", 0.9
+        # Calculate cosine similarity with all questions
+        similarities = cosine_similarity(user_embedding, self.question_embeddings)[0]
         
-        # How are you responses
-        if any(how in question_lower for how in ['how are you', 'how do you do', 'how is it going']):
-            return "I'm doing great, thank you for asking! I'm here and ready to help you with any questions about PSAU admissions, courses, or university life. What would you like to know?", 0.8
+        # Find the best match
+        best_match_idx = np.argmax(similarities)
+        best_similarity = similarities[best_match_idx]
         
-        # What can you do responses
-        if any(what in question_lower for what in ['what can you do', 'what do you do', 'what are your capabilities']):
-            return "I can help you with:\n• University admission requirements and procedures\n• Course information and recommendations\n• General questions about PSAU\n• Academic guidance and support\n• Information about campus life\n\nWhat specific information are you looking for?", 0.9
-        
-        # About PSAU responses
-        if any(about in question_lower for about in ['about psa', 'about psu', 'about pangasinan state', 'tell me about']):
-            return "Pangasinan State University (PSAU) is a premier state university in the Philippines offering quality education across various fields. We provide undergraduate and graduate programs in areas like Computer Science, Business, Education, Nursing, and more. We're committed to academic excellence and student success. What would you like to know more about?", 0.8
+        if best_similarity >= threshold:
+            return self.qa_pairs[best_match_idx], best_similarity
+        else:
+            return None, best_similarity
+    
+    def get_response(self, user_input):
+        """Get response for user input"""
+        if not user_input.strip():
+            return "Please enter a message."
         
-        # Help responses
-        if any(help in question_lower for help in ['help', 'assist', 'support']):
-            return "I'm here to help! I can assist you with:\n• Admission requirements and deadlines\n• Course information and recommendations\n• Academic programs and majors\n• Campus facilities and services\n• General university information\n\nJust ask me any question and I'll do my best to help you!", 0.9
+        best_match, similarity = self.find_best_match(user_input)
         
-        # Default general response
-        return "I understand you're asking about something, but I'm specifically designed to help with PSAU-related questions like admissions, courses, and university information. Could you rephrase your question to be more specific about what you'd like to know about Pangasinan State University? I'm here to help with academic guidance and university-related inquiries!", 0.6
+        if best_match:
+            return {
+                'answer': best_match.get('answer', 'No answer found'),
+                'confidence': float(similarity),
+                'matched_question': best_match.get('question', ''),
+                'status': 'success'
+            }
+        else:
+            return {
+                'answer': "I'm sorry, I couldn't find a relevant answer to your question. Could you please rephrase it or ask something else?",
+                'confidence': float(similarity),
+                'matched_question': '',
+                'status': 'no_match'
+            }
     
-    def get_suggested_questions(self, question: str, num_suggestions: int = 3) -> List[str]:
-        """No suggestions when FAQs are disabled."""
-        return []
+    def get_qa_count(self):
+        """Get the number of loaded Q&A pairs"""
+        return len(self.qa_pairs)
     
-    def add_faq(self, question: str, answer: str) -> bool:
-        """No-op when FAQs are disabled."""
-        return False
-
-
-# ===== UI helpers for Hugging Face integration =====
-def chat_with_bot_via_gateway(chatbot: "AIChatbot", message: str, history: List[Tuple[str, str]], gateway_base_url: str | None = None) -> str:
-    if chatbot is None:
-        return "Sorry, the chatbot is not available at the moment. Please try again later."
-    if not message or not message.strip():
-        return "Please enter a message to start the conversation."
-
-    base_url = gateway_base_url or os.environ.get('GATEWAY_BASE_URL', 'https://database-46m3.onrender.com')
-
-    try:
-        resp = requests.get(f"{base_url}/faqs", params={"question": message}, timeout=10)
-        if resp.ok:
-            data = resp.json()
-            if data.get('answer'):
-                return data['answer']
-    except Exception as e:
-        print(f"FAQ gateway error: {e}")
-
-    answer, confidence = chatbot.find_best_match(message)
-
-    try:
-        if confidence < 0.7 and (not answer or 'specifically designed' in (answer or '').lower()):
-            requests.post(f"{base_url}/unanswered_questions", json={"question": message}, timeout=10)
-    except Exception as e:
-        print(f"Log unanswered error: {e}")
-
-    return answer
-
-
-def get_faqs_via_gateway(gateway_base_url: str | None = None) -> str:
-    base_url = gateway_base_url or os.environ.get('GATEWAY_BASE_URL', 'https://database-46m3.onrender.com')
-    try:
-        sample_questions = [
-            "What are the admission requirements?",
-            "How to apply?",
-            "Where is the campus located?"
-        ]
-        items: List[Dict[str, str]] = []
-        for q in sample_questions:
-            r = requests.get(f"{base_url}/faqs", params={"question": q}, timeout=10)
-            if r.ok and r.json().get('answer'):
-                items.append({"question": q, "answer": r.json()['answer']})
-        if not items:
-            return "No FAQs available at the moment."
-        faq_text = "## 📚 Frequently Asked Questions\n\n"
-        for i, faq in enumerate(items, 1):
-            faq_text += f"**{i}. {faq['question']}**\n"
-            faq_text += f"{faq['answer']}\n\n"
-        return faq_text
-    except Exception as e:
-        return f"Could not load FAQs from gateway: {e}"
+    def get_course_recommendations(self, stanine, gwa, strand, hobbies):
+        """Get course recommendations using the recommender system"""
+        try:
+            # Validate inputs
+            stanine = int(stanine) if isinstance(stanine, str) else stanine
+            gwa = float(gwa) if isinstance(gwa, str) else gwa
+            
+            if not (1 <= stanine <= 9):
+                return "❌ Stanine score must be between 1 and 9"
+            if not (75 <= gwa <= 100):
+                return "❌ GWA must be between 75 and 100"
+            if not strand:
+                return "❌ Please select a strand"
+            if not hobbies or not str(hobbies).strip():
+                return "❌ Please enter your hobbies/interests"
+            
+            # Get recommendations
+            recommendations = self.recommender.recommend_courses(
+                stanine=stanine,
+                gwa=gwa,
+                strand=strand,
+                hobbies=str(hobbies)
+            )
+            
+            if not recommendations:
+                return "No recommendations available at the moment."
+            
+            # Format response (without confidence scores)
+            response = f"## 🎯 Course Recommendations for You\n\n"
+            response += f"**Profile:** Stanine {stanine}, GWA {gwa}, {strand} Strand\n"
+            response += f"**Interests:** {hobbies}\n\n"
+            
+            for i, rec in enumerate(recommendations, 1):
+                response += f"### {i}. {rec['code']} - {rec['name']}\n\n"
+            
+            return response
+            
+        except Exception as e:
+            return f"❌ Error getting recommendations: {str(e)}"