ai_chatbot.py

import requests
import json
from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from recommender import CourseRecommender

class Chatbot:
    def __init__(self):
        self.qa_pairs = []
        self.question_embeddings = []
        self.model = SentenceTransformer('all-MiniLM-L6-v2')
        self.database_url = "https://database-46m3.onrender.com"
        self.recommender = CourseRecommender()
        self.load_qa_data()
    
    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 _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 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
        
        # 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
        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."
        
        best_match, similarity = self.find_best_match(user_input)
        
        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_qa_count(self):
        """Get the number of loaded Q&A pairs"""
        return len(self.qa_pairs)
    
    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)}"