Update app.py

app.py

@@ -1,240 +1,630 @@
-import os
 import gradio as gr
-import pandas as pd
-import numpy as np
-from ai_chatbot import AIChatbot
-from database_recommender import CourseRecommender
-import warnings
-import logging
-
-# Suppress warnings
-warnings.filterwarnings('ignore')
-logging.getLogger('tensorflow').setLevel(logging.ERROR)
-
-# Initialize components
-try:
-    chatbot = AIChatbot()
-    print("✅ Chatbot initialized successfully")
-except Exception as e:
-    print(f"⚠️  Warning: Could not initialize chatbot: {e}")
-    chatbot = None
-
-try:
-    recommender = CourseRecommender()
-    print("✅ Recommender initialized successfully")
-except Exception as e:
-    print(f"⚠️  Warning: Could not initialize recommender: {e}")
-    recommender = None
-
-def chat_with_bot(message, history):
-    """Handle chatbot interactions"""
-    if chatbot is None:
-        return "Sorry, the chatbot is not available at the moment. Please try again later."
-    
-    if not message.strip():
-        return "Please enter a message to start the conversation."
-    
-    # Get answer from chatbot
-    answer, confidence = chatbot.find_best_match(message)
-    
-    # For general conversation, just return the answer
-    # For FAQ questions, include suggested questions
-    if confidence > 0.7:  # High confidence FAQ match
-        suggested_questions = chatbot.get_suggested_questions(message)
-        if suggested_questions:
-            response = f"{answer}\n\n**Related Questions:**\n"
-            for i, q in enumerate(suggested_questions, 1):
-                response += f"{i}. {q}\n"
-            return response
-    
-    # For general conversation or low confidence, just return the answer
-    return answer
+import requests
+import json
+import re
+from typing import List, Tuple, Optional
+from difflib import SequenceMatcher
+import string
 
-def get_course_recommendations(stanine, gwa, strand, hobbies):
-    """Get course recommendations"""
-    if recommender is None:
-        return "Sorry, the recommendation system is not available at the moment. Please try again later."
-    
-    try:
-        # Validate and convert inputs
-        try:
-            stanine = int(stanine.strip()) if stanine else 0
-        except (ValueError, AttributeError):
-            return "❌ Stanine score must be a valid number between 1 and 9"
+class AIChatbot:
+    def __init__(self, database_url: str = "https://database-dhe2.onrender.com"):
+        self.database_url = database_url
+        self.conversation_history = []
         
+        # Simple conversation patterns
+        self.greeting_patterns = [
+            r'\b(hi|hello|hey|good morning|good afternoon|good evening)\b',
+            r'\b(how are you|how\'s it going|what\'s up)\b'
+        ]
+        
+        self.help_patterns = [
+            r'\b(help|assist|support|guide)\b',
+            r'\b(what can you do|what do you do|your capabilities)\b'
+        ]
+        
+        self.thanks_patterns = [
+            r'\b(thank you|thanks|appreciate|grateful)\b'
+        ]
+        
+        self.goodbye_patterns = [
+            r'\b(bye|goodbye|see you|farewell|exit|quit)\b'
+        ]
+
+    def is_greeting(self, message: str) -> bool:
+        """Check if the message is a greeting"""
+        message_lower = message.lower()
+        for pattern in self.greeting_patterns:
+            if re.search(pattern, message_lower):
+                return True
+        return False
+
+    def is_help_request(self, message: str) -> bool:
+        """Check if the message is asking for help"""
+        message_lower = message.lower()
+        for pattern in self.help_patterns:
+            if re.search(pattern, message_lower):
+                return True
+        return False
+
+    def is_thanks(self, message: str) -> bool:
+        """Check if the message is expressing thanks"""
+        message_lower = message.lower()
+        for pattern in self.thanks_patterns:
+            if re.search(pattern, message_lower):
+                return True
+        return False
+
+    def is_goodbye(self, message: str) -> bool:
+        """Check if the message is a goodbye"""
+        message_lower = message.lower()
+        for pattern in self.goodbye_patterns:
+            if re.search(pattern, message_lower):
+                return True
+        return False
+
+    def get_greeting_response(self) -> str:
+        """Generate a greeting response"""
+        responses = [
+            "Hello! I'm your AI assistant. How can I help you today?",
+            "Hi there! I'm here to assist you with any questions you might have.",
+            "Hello! Welcome! I can help you with general conversation or answer specific questions from our database.",
+            "Hey! Nice to meet you! What can I do for you today?"
+        ]
+        import random
+        return random.choice(responses)
+
+    def get_help_response(self) -> str:
+        """Generate a help response"""
+        return """I'm an AI chatbot that can help you in two ways:
+
+1. **General Conversation**: I can chat with you about various topics, answer greetings, and have friendly conversations.
+
+2. **Specific Questions**: I can search our database for specific information and provide detailed answers to your questions.
+
+**Smart Learning**: If I can't find an answer to your question, I'll automatically save it for review so we can improve our knowledge base and provide better answers in the future.
+
+Just type your question or start a conversation, and I'll do my best to help you!"""
+
+    def get_thanks_response(self) -> str:
+        """Generate a thanks response"""
+        responses = [
+            "You're welcome! I'm happy to help.",
+            "My pleasure! Feel free to ask if you need anything else.",
+            "Glad I could assist you! Is there anything else you'd like to know?",
+            "You're very welcome! I'm here whenever you need help."
+        ]
+        import random
+        return random.choice(responses)
+
+    def get_goodbye_response(self) -> str:
+        """Generate a goodbye response"""
+        responses = [
+            "Goodbye! Have a great day!",
+            "See you later! Take care!",
+            "Farewell! Feel free to come back anytime.",
+            "Bye! I enjoyed chatting with you!"
+        ]
+        import random
+        return random.choice(responses)
+
+    def save_unanswered_question(self, question: str) -> bool:
+        """Save unanswered question to the database"""
         try:
-            gwa = float(gwa.strip()) if gwa else 0
-        except (ValueError, AttributeError):
-            return "❌ GWA must be a valid number between 75 and 100"
+            # Try different possible endpoints for saving unanswered questions
+            endpoints = [
+                f"{self.database_url}/unanswered_questions",
+                f"{self.database_url}/api/unanswered_questions",
+                f"{self.database_url}/save_question",
+                f"{self.database_url}/api/save_question"
+            ]
+            
+            for endpoint in endpoints:
+                try:
+                    # Try POST request with JSON body - matching your table structure
+                    response = requests.post(
+                        endpoint, 
+                        json={
+                            "question": question,
+                            "created_at": self._get_timestamp()
+                        }, 
+                        headers={"Content-Type": "application/json"},
+                        timeout=10
+                    )
+                    if response.status_code in [200, 201]:
+                        return True
+                except:
+                    try:
+                        # Try GET request with query parameters
+                        response = requests.get(
+                            endpoint, 
+                            params={
+                                "question": question,
+                                "created_at": self._get_timestamp()
+                            },
+                            timeout=10
+                        )
+                        if response.status_code in [200, 201]:
+                            return True
+                    except:
+                        continue
+            
+            return False
+            
+        except Exception as e:
+            print(f"Error saving unanswered question: {e}")
+            return False
+
+    def _get_timestamp(self) -> str:
+        """Get current timestamp in ISO format"""
+        from datetime import datetime
+        return datetime.now().isoformat()
+
+    def _normalize_text(self, text: str) -> str:
+        """Normalize text for better matching"""
+        # Convert to lowercase
+        text = text.lower()
+        # Remove punctuation
+        text = text.translate(str.maketrans('', '', string.punctuation))
+        # Remove extra whitespace
+        text = ' '.join(text.split())
+        return text
+
+    def _extract_keywords(self, text: str) -> List[str]:
+        """Extract important keywords from text with enhanced processing"""
+        # Extended stop words to ignore
+        stop_words = {
+            'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by',
+            'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did',
+            'will', 'would', 'could', 'should', 'may', 'might', 'can', 'what', 'how', 'when', 'where', 'why',
+            'who', 'which', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they',
+            'me', 'him', 'her', 'us', 'them', 'my', 'your', 'his', 'her', 'its', 'our', 'their',
+            'there', 'here', 'some', 'any', 'all', 'each', 'every', 'much', 'many', 'more', 'most',
+            'very', 'just', 'only', 'also', 'even', 'still', 'yet', 'so', 'too', 'well', 'now', 'then'
+        }
+        
+        # Normalize and split into words
+        words = self._normalize_text(text).split()
+        
+        # Enhanced keyword extraction
+        keywords = []
+        for word in words:
+            # Filter out stop words and very short words
+            if word not in stop_words and len(word) > 2:
+                # Add the word
+                keywords.append(word)
+                # Add common variations and stems
+                if word.endswith('s') and len(word) > 3:
+                    keywords.append(word[:-1])  # Remove 's' for plurals
+                if word.endswith('ing') and len(word) > 4:
+                    keywords.append(word[:-3])  # Remove 'ing'
+                if word.endswith('ed') and len(word) > 3:
+                    keywords.append(word[:-2])  # Remove 'ed'
+        
+        return list(set(keywords))  # Remove duplicates
+
+    def _calculate_similarity(self, text1: str, text2: str) -> float:
+        """Calculate similarity between two texts using advanced methods"""
+        norm1 = self._normalize_text(text1)
+        norm2 = self._normalize_text(text2)
         
-        # Validate ranges
-        if not (1 <= stanine <= 9):
-            return "❌ Stanine score must be between 1 and 9"
+        # Method 1: Sequence matcher on normalized text
+        sequence_similarity = SequenceMatcher(None, norm1, norm2).ratio()
         
-        if not (75 <= gwa <= 100):
-            return "❌ GWA must be between 75 and 100"
+        # Method 2: Enhanced keyword overlap with stemming
+        keywords1 = set(self._extract_keywords(text1))
+        keywords2 = set(self._extract_keywords(text2))
         
-        if not strand:
-            return "❌ Please select a strand"
+        keyword_similarity = 0.0
+        if keywords1 and keywords2:
+            intersection = keywords1.intersection(keywords2)
+            union = keywords1.union(keywords2)
+            keyword_similarity = len(intersection) / len(union) if union else 0.0
         
-        if not hobbies or not hobbies.strip():
-            return "❌ Please enter your hobbies/interests"
+        # Method 3: Substring containment (both directions)
+        contains_similarity = 0.0
+        if norm1 in norm2:
+            contains_similarity = max(contains_similarity, 0.9 * (len(norm1) / len(norm2)))
+        if norm2 in norm1:
+            contains_similarity = max(contains_similarity, 0.9 * (len(norm2) / len(norm1)))
         
-        # Get recommendations
-        recommendations = recommender.recommend_courses(
-            stanine=stanine,
-            gwa=gwa,
-            strand=strand,
-            hobbies=hobbies
+        # Method 4: Word order similarity
+        words1 = norm1.split()
+        words2 = norm2.split()
+        word_order_similarity = 0.0
+        if words1 and words2:
+            # Check for common word sequences
+            common_sequences = 0
+            max_len = min(len(words1), len(words2))
+            for i in range(max_len):
+                if words1[i] == words2[i]:
+                    common_sequences += 1
+            word_order_similarity = common_sequences / max_len if max_len > 0 else 0.0
+        
+        # Method 5: Semantic similarity using word relationships
+        semantic_similarity = self._calculate_semantic_similarity(keywords1, keywords2)
+        
+        # Method 6: Length similarity (shorter queries should match longer answers)
+        length_similarity = 0.0
+        if len(norm1) > 0 and len(norm2) > 0:
+            length_ratio = min(len(norm1), len(norm2)) / max(len(norm1), len(norm2))
+            length_similarity = length_ratio * 0.3  # Lower weight for length
+        
+        # Method 7: Phrase matching (for common phrases)
+        phrase_similarity = self._calculate_phrase_similarity(norm1, norm2)
+        
+        # Combine all methods with optimized weights
+        final_similarity = (
+            sequence_similarity * 0.25 +
+            keyword_similarity * 0.30 +
+            contains_similarity * 0.20 +
+            word_order_similarity * 0.10 +
+            semantic_similarity * 0.10 +
+            length_similarity * 0.03 +
+            phrase_similarity * 0.02
         )
         
-        if not recommendations:
-            return "No recommendations available at the moment."
+        return min(final_similarity, 1.0)  # Cap at 1.0
+
+    def _calculate_semantic_similarity(self, keywords1: set, keywords2: set) -> float:
+        """Calculate semantic similarity using word relationships"""
+        if not keywords1 or not keywords2:
+            return 0.0
+        
+        # Common semantic relationships
+        semantic_groups = {
+            'money': {'cost', 'price', 'tuition', 'fee', 'payment', 'money', 'financial', 'aid', 'scholarship'},
+            'time': {'deadline', 'when', 'time', 'date', 'schedule', 'duration', 'period'},
+            'contact': {'contact', 'phone', 'email', 'address', 'office', 'reach', 'call'},
+            'requirements': {'requirement', 'need', 'required', 'must', 'prerequisite', 'condition'},
+            'application': {'apply', 'application', 'submit', 'process', 'procedure'},
+            'programs': {'program', 'course', 'major', 'degree', 'study', 'academic'},
+            'admission': {'admission', 'admit', 'accept', 'enroll', 'entry', 'enter'}
+        }
         
-        # Format recommendations
-        response = f"## 🎯 Course Recommendations for You\n\n"
-        response += f"**Profile:** Stanine {stanine}, GWA {gwa}, {strand} Strand\n"
-        response += f"**Interests:** {hobbies}\n\n"
+        # Check if keywords belong to the same semantic group
+        semantic_score = 0.0
+        for group, words in semantic_groups.items():
+            group1_match = any(keyword in words for keyword in keywords1)
+            group2_match = any(keyword in words for keyword in keywords2)
+            if group1_match and group2_match:
+                semantic_score += 0.3
         
-        for i, rec in enumerate(recommendations, 1):
-            response += f"### {i}. {rec['code']} - {rec['name']}\n"
-            response += f"**Match Score:** {rec.get('rating', rec.get('probability', 0)):.1f}%\n\n"
+        return min(semantic_score, 1.0)
+
+    def _calculate_phrase_similarity(self, text1: str, text2: str) -> float:
+        """Calculate similarity based on common phrases"""
+        # Common phrases that should match
+        common_phrases = [
+            ('admission requirements', 'requirements admission'),
+            ('financial aid', 'aid financial'),
+            ('tuition cost', 'cost tuition'),
+            ('application deadline', 'deadline application'),
+            ('contact admissions', 'admissions contact'),
+            ('gpa requirement', 'requirement gpa'),
+            ('academic requirements', 'requirements academic')
+        ]
         
-        return response
+        phrase_score = 0.0
+        for phrase1, phrase2 in common_phrases:
+            if (phrase1 in text1 and phrase1 in text2) or (phrase2 in text1 and phrase2 in text2):
+                phrase_score += 0.5
+            elif (phrase1 in text1 and phrase2 in text2) or (phrase2 in text1 and phrase1 in text2):
+                phrase_score += 0.4
         
-    except Exception as e:
-        return f"❌ Error getting recommendations: {str(e)}"
-
-def get_faqs():
-    """Get available FAQs"""
-    if chatbot and chatbot.faqs:
-        faq_text = "## 📚 Frequently Asked Questions\n\n"
-        for i, faq in enumerate(chatbot.faqs, 1):
-            faq_text += f"**{i}. {faq['question']}**\n"
-            faq_text += f"{faq['answer']}\n\n"
-        return faq_text
-    return "No FAQs available at the moment."
-
-def get_available_courses():
-    """Get available courses"""
-    if recommender and recommender.courses:
-        course_text = "## 🎓 Available Courses\n\n"
-        for code, name in recommender.courses.items():
-            course_text += f"**{code}** - {name}\n"
-        return course_text
-    return "No courses available at the moment."
+        return min(phrase_score, 1.0)
 
-# Create Gradio interface
-with gr.Blocks(title="PSAU AI Chatbot & Course Recommender", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        """
-        # 🤖 PSAU AI Chatbot & Course Recommender
+    def _find_best_match(self, user_question: str, database_questions: List[str], threshold: float = 0.25) -> Optional[str]:
+        """Find the best matching question from database with improved logic"""
+        if not database_questions:
+            return None
         
-        Welcome to the Pangasinan State University AI-powered admission assistant! 
-        Get instant answers to your questions and receive personalized course recommendations.
-        """
-    )
-    
-    with gr.Tabs():
-        # Chatbot Tab
-        with gr.Tab("🤖 AI Chatbot"):
-            gr.Markdown("""
-            **Chat with the PSAU AI Assistant!**
+        best_match = None
+        best_score = 0.0
+        all_scores = []
+        
+        # Calculate similarity for all questions
+        for db_question in database_questions:
+            similarity = self._calculate_similarity(user_question, db_question)
+            all_scores.append((db_question, similarity))
+            if similarity > best_score:
+                best_score = similarity
+                best_match = db_question
+        
+        # Sort by similarity score
+        all_scores.sort(key=lambda x: x[1], reverse=True)
+        
+        # If the best score is above threshold, return it
+        if best_score >= threshold:
+            return best_match
+        
+        # If no single match is above threshold, try adaptive threshold
+        if all_scores:
+            # Use the top score if it's reasonably close to threshold
+            top_score = all_scores[0][1]
+            if top_score >= threshold * 0.8:  # 80% of threshold
+                return all_scores[0][0]
+        
+        # Last resort: if user question is very short, be more lenient
+        if len(user_question.split()) <= 3 and all_scores:
+            # For short queries, use a lower threshold
+            if all_scores[0][1] >= 0.15:
+                return all_scores[0][0]
+        
+        return None
+
+    def fetch_from_database(self, question: str) -> str:
+        """Fetch answer from the database with smart matching"""
+        try:
+            # First, try to get all available questions for smart matching
+            all_questions = self._get_all_questions()
             
-            I can help you with:
-            • University admission questions
-            • Course information and guidance  
-            • General conversation
-            • Academic support
+            # If we have all questions, try smart matching first
+            if all_questions:
+                best_match = self._find_best_match(question, all_questions)
+                if best_match:
+                    # Try to get answer for the best matching question
+                    answer = self._get_answer_for_question(best_match)
+                    if answer and not self._is_no_answer_response(answer):
+                        return answer
             
-            Just type your message below and I'll respond naturally!
-            """)
+            # Fallback to original method if smart matching doesn't work
+            endpoints = [
+                f"{self.database_url}/faqs",
+                f"{self.database_url}/search",
+                f"{self.database_url}/query",
+                f"{self.database_url}/api/faq"
+            ]
             
-            chatbot_interface = gr.ChatInterface(
-                fn=chat_with_bot,
-                title="PSAU AI Assistant",
-                description="Chat with me about university admissions, courses, or just say hello!",
-                examples=[
-                    "Hello!",
-                    "What are the admission requirements?",
-                    "How are you?",
-                    "What courses are available?",
-                    "Tell me about PSAU",
-                    "What can you help me with?",
-                    "Thank you",
-                    "Goodbye"
-                ],
-                cache_examples=True
-            )
-        
-        # Course Recommender Tab
-        with gr.Tab("🎯 Course Recommender"):
-            gr.Markdown("""
-            Get personalized course recommendations based on your academic profile and interests!
+            for endpoint in endpoints:
+                try:
+                    # Try GET request with query parameter
+                    response = requests.get(endpoint, params={"question": question}, timeout=10)
+                    if response.status_code == 200:
+                        data = response.json()
+                        if isinstance(data, dict):
+                            answer = data.get('answer', data.get('response', str(data)))
+                            # Check if we got a meaningful answer
+                            if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                return answer
+                        elif isinstance(data, list) and len(data) > 0:
+                            answer = str(data[0])
+                            if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                return answer
+                        else:
+                            answer = str(data)
+                            if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                return answer
+                except:
+                    try:
+                        # Try POST request with JSON body
+                        response = requests.post(
+                            endpoint, 
+                            json={"question": question}, 
+                            headers={"Content-Type": "application/json"},
+                            timeout=10
+                        )
+                        if response.status_code == 200:
+                            data = response.json()
+                            if isinstance(data, dict):
+                                answer = data.get('answer', data.get('response', str(data)))
+                                # Check if we got a meaningful answer
+                                if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                    return answer
+                            elif isinstance(data, list) and len(data) > 0:
+                                answer = str(data[0])
+                                if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                    return answer
+                            else:
+                                answer = str(data)
+                                if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                    return answer
+                    except:
+                        continue
             
-            **Input Guidelines:**
-            - **Stanine Score**: Enter a number between 1-9 (from your entrance exam)
-            - **GWA**: Enter your General Weighted Average (75-100)
-            - **Strand**: Select your senior high school strand
-            - **Hobbies**: Describe your interests and hobbies in detail
-            """)
+            # If no answer found, save the question as unanswered
+            self.save_unanswered_question(question)
+            return "I'm sorry, I couldn't find a specific answer to your question in our database. I've saved your question for review, and we'll work on providing a better answer in the future. Could you try rephrasing your question or ask me something else?"
             
-            with gr.Row():
-                with gr.Column():
-                    stanine_input = gr.Textbox(
-                        label="Stanine Score (1-9)",
-                        placeholder="Enter your stanine score (1-9)",
-                        info="Your stanine score from entrance examination",
-                        value="7"
-                    )
-                    gwa_input = gr.Textbox(
-                        label="GWA (75-100)",
-                        placeholder="Enter your GWA (75-100)",
-                        info="Your General Weighted Average",
-                        value="85.0"
-                    )
-                    strand_input = gr.Dropdown(
-                        choices=["STEM", "ABM", "HUMSS"],
-                        value="STEM",
-                        label="High School Strand",
-                        info="Your senior high school strand"
-                    )
-                    hobbies_input = gr.Textbox(
-                        label="Hobbies & Interests",
-                        placeholder="e.g., programming, gaming, business, teaching, healthcare...",
-                        info="Describe your interests and hobbies"
-                    )
-                    
-                    recommend_btn = gr.Button("Get Recommendations", variant="primary")
-                
-                with gr.Column():
-                    recommendations_output = gr.Markdown()
+        except requests.exceptions.Timeout:
+            # Save the question even if there's a timeout
+            self.save_unanswered_question(question)
+            return "I'm sorry, the database is taking too long to respond. I've saved your question for review. Please try again in a moment."
+        except requests.exceptions.ConnectionError:
+            # Save the question even if there's a connection error
+            self.save_unanswered_question(question)
+            return "I'm sorry, I'm having trouble connecting to our database right now. I've saved your question for review. Please try again later."
+        except Exception as e:
+            # Save the question even if there's an unexpected error
+            self.save_unanswered_question(question)
+            return f"I encountered an error while searching our database: {str(e)}. I've saved your question for review. Please try again."
+
+    def _get_all_questions(self) -> List[str]:
+        """Get all available questions from the database for smart matching"""
+        try:
+            # Try different endpoints to get all questions
+            endpoints = [
+                f"{self.database_url}/questions",
+                f"{self.database_url}/faq/all",
+                f"{self.database_url}/api/questions",
+                f"{self.database_url}/all_questions"
+            ]
+            
+            for endpoint in endpoints:
+                try:
+                    response = requests.get(endpoint, timeout=10)
+                    if response.status_code == 200:
+                        data = response.json()
+                        if isinstance(data, list):
+                            return [str(item) for item in data]
+                        elif isinstance(data, dict) and 'questions' in data:
+                            return [str(q) for q in data['questions']]
+                except:
+                    continue
+            
+            return []
+        except:
+            return []
+
+    def _get_answer_for_question(self, question: str) -> Optional[str]:
+        """Get answer for a specific question"""
+        try:
+            endpoints = [
+                f"{self.database_url}/faqs",
+                f"{self.database_url}/search",
+                f"{self.database_url}/query",
+                f"{self.database_url}/api/faq"
+            ]
+            
+            for endpoint in endpoints:
+                try:
+                    response = requests.get(endpoint, params={"question": question}, timeout=10)
+                    if response.status_code == 200:
+                        data = response.json()
+                        if isinstance(data, dict):
+                            return data.get('answer', data.get('response', str(data)))
+                        elif isinstance(data, list) and len(data) > 0:
+                            return str(data[0])
+                        else:
+                            return str(data)
+                except:
+                    try:
+                        response = requests.post(
+                            endpoint, 
+                            json={"question": question}, 
+                            headers={"Content-Type": "application/json"},
+                            timeout=10
+                        )
+                        if response.status_code == 200:
+                            data = response.json()
+                            if isinstance(data, dict):
+                                return data.get('answer', data.get('response', str(data)))
+                            elif isinstance(data, list) and len(data) > 0:
+                                return str(data[0])
+                            else:
+                                return str(data)
+                    except:
+                        continue
             
-            recommend_btn.click(
-                fn=get_course_recommendations,
-                inputs=[stanine_input, gwa_input, strand_input, hobbies_input],
-                outputs=recommendations_output
-            )
-        
-        # Information Tab
-        with gr.Tab("📚 Information"):
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### FAQ Section")
-                    faq_btn = gr.Button("Show FAQs")
-                    faq_output = gr.Markdown()
-                    faq_btn.click(fn=get_faqs, outputs=faq_output)
-                
-                with gr.Column():
-                    gr.Markdown("### Available Courses")
-                    courses_btn = gr.Button("Show Courses")
-                    courses_output = gr.Markdown()
-                    courses_btn.click(fn=get_available_courses, outputs=courses_output)
+            return None
+        except:
+            return None
+
+    def _is_no_answer_response(self, answer: str) -> bool:
+        """Check if the response indicates no answer was found"""
+        no_answer_indicators = [
+            "no answer",
+            "not found",
+            "no results",
+            "no data",
+            "empty",
+            "null",
+            "none",
+            "i don't know",
+            "i don't have",
+            "cannot find",
+            "unable to find"
+        ]
+        
+        answer_lower = answer.lower().strip()
+        return any(indicator in answer_lower for indicator in no_answer_indicators)
+
+    def chat(self, message: str, history: List[List[str]]) -> str:
+        """Main chat function"""
+        if not message.strip():
+            return "Please enter a message so I can help you!"
+        
+        # Store conversation history
+        self.conversation_history.append(("user", message))
+        
+        # Check for conversation patterns
+        if self.is_greeting(message):
+            response = self.get_greeting_response()
+        elif self.is_help_request(message):
+            response = self.get_help_response()
+        elif self.is_thanks(message):
+            response = self.get_thanks_response()
+        elif self.is_goodbye(message):
+            response = self.get_goodbye_response()
+        else:
+            # Try to fetch from database
+            response = self.fetch_from_database(message)
+        
+        # Store bot response
+        self.conversation_history.append(("bot", response))
+        
+        return response
+
+# Initialize the chatbot
+chatbot = AIChatbot()
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(
+        title="AI Chatbot",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 800px !important;
+            margin: auto !important;
+        }
+        .chat-message {
+            padding: 10px;
+            margin: 5px 0;
+            border-radius: 10px;
+        }
+        """
+    ) as interface:
+        
+        gr.Markdown(
+            """
+            # 🤖 AI Chatbot Assistant
+            
+            Welcome! I'm your AI assistant that can help you with:
+            - **General conversation** and friendly chat
+            - **Specific questions** answered from our knowledge database
+            
+            Just type your message below and I'll do my best to help you!
+            """
+        )
+        
+        # Chat interface
+        chatbot_interface = gr.ChatInterface(
+            fn=chatbot.chat,
+            title="Chat with AI Assistant",
+            description="Ask me anything or just have a conversation!",
+            examples=[
+                "Hello!",
+                "What can you help me with?",
+                "How do I contact support?",
+                "What are your services?",
+                "Thank you for your help!"
+            ],
+            cache_examples=False,
+            retry_btn="🔄 Retry",
+            undo_btn="↩️ Undo",
+            clear_btn="🗑️ Clear",
+            submit_btn="Send",
+            stop_btn="⏹️ Stop",
+            additional_inputs=None
+        )
+        
+        # Footer
+        gr.Markdown(
+            """
+            ---
+            **Note**: This chatbot can handle general conversation and search our database for specific information. 
+            If you don't get the answer you're looking for, try rephrasing your question!
+            """
+        )
+    
+    return interface
 
+# Launch the application
 if __name__ == "__main__":
-    demo.launch(
+    interface = create_interface()
+    interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        debug=True
     )