Update app.py

app.py

@@ -1,427 +1,285 @@
 import gradio as gr
 import requests
-import json
 import re
 import xml.etree.ElementTree as ET
-import numpy as np
 import random
-import hashlib
 from datetime import datetime
 from collections import defaultdict, Counter
-import time
 
-class QuestionAnsweringAI:
+class SimpleQAAI:
     def __init__(self):
-        # Token database e vocabulary
-        self.vocabulary = {}
-        self.token_to_id = {}
-        self.vocab_size = 0
-        
-        # Neural Network parameters
-        self.embedding_dim = 256
-        self.hidden_dim = 512
-        self.context_length = 32
-        
-        # Knowledge systems
         self.knowledge_base = defaultdict(list)
-        self.qa_patterns = defaultdict(list)
-        self.context_memory = []
-        
-        # Network weights
-        self.embeddings = None
-        self.hidden_weights = None
-        self.output_weights = None
-        
-        # Pattern storage
-        self.bigram_counts = defaultdict(Counter)
-        self.trigram_counts = defaultdict(Counter)
-        self.sentence_starts = []
-        
-        # Data sources
-        self.data_sources = {
-            "news_rss": [
-                "https://feeds.reuters.com/reuters/worldNews",
-                "https://feeds.bbci.co.uk/news/world/rss.xml",
-                "https://feeds.bbci.co.uk/news/technology/rss.xml"
-            ]
+        self.qa_patterns = {}
+        self.vocabulary = set()
+        self.total_tokens = 0
+        self.is_trained = False
+        
+        # Initialize with basic Q&A patterns
+        self.initialize_basic_knowledge()
+        
+    def initialize_basic_knowledge(self):
+        """Initialize with basic Q&A knowledge"""
+        basic_qa = {
+            "what is artificial intelligence": "Artificial intelligence is a technology that enables machines to perform tasks that typically require human intelligence, such as learning, reasoning, and problem-solving.",
+            "how do computers work": "Computers work by processing data through electronic circuits, following programmed instructions to perform calculations and operations.",
+            "where is paris": "Paris is located in France and serves as the capital city of the country.",
+            "why is education important": "Education is important because it develops knowledge, critical thinking skills, and prepares people for careers and civic participation.",
+            "what is machine learning": "Machine learning is a subset of artificial intelligence that allows systems to automatically learn and improve from data without being explicitly programmed.",
+            "how does the internet work": "The internet works through a global network of interconnected computers that communicate using standardized protocols to share information.",
+            "what is climate change": "Climate change refers to long-term shifts in global weather patterns and temperatures, largely attributed to human activities.",
+            "why renewable energy": "Renewable energy is important because it provides sustainable power sources that don't deplete natural resources and help reduce environmental impact."
         }
         
-        # Training state
-        self.total_tokens_collected = 0
-        self.epochs_trained = 0
-        self.learning_rate = 0.001
-        self.max_response_length = 50
-        
-        self.initialize_network()
+        for question, answer in basic_qa.items():
+            self.qa_patterns[question] = answer
+            words = question.split() + answer.split()
+            self.vocabulary.update(words)
         
-    def initialize_network(self):
-        """Initialize neural network"""
-        self.embeddings = np.random.normal(0, 0.1, (10000, self.embedding_dim))
-        self.hidden_weights = np.random.normal(0, 0.1, (self.embedding_dim * self.context_length, self.hidden_dim))
-        self.hidden_bias = np.zeros(self.hidden_dim)
-        self.output_weights = np.random.normal(0, 0.1, (self.hidden_dim, 10000))
-        self.output_bias = np.zeros(10000)
-        print("🧠 Neural Network initialized")
+        self.total_tokens = sum(len(answer.split()) for answer in basic_qa.values())
+        print(f"🧠 Initialized with {len(basic_qa)} Q&A patterns")
     
-    def collect_training_data(self, max_tokens=20000):
+    def collect_training_data(self):
         """Collect training data from public sources"""
-        print("🕷️ Collecting Q&A training data...")
-        
-        collected_texts = []
-        
-        # Collect news data
-        news_texts = self.scrape_news_feeds()
-        collected_texts.extend(news_texts)
-        print(f"📰 Collected {len(news_texts)} news articles")
+        print("🕷️ Collecting training data...")
         
-        # Create structured Q&A patterns
-        qa_patterns = self.create_qa_patterns()
-        collected_texts.extend(qa_patterns)
-        print(f"❓ Generated {len(qa_patterns)} Q&A patterns")
+        collected_data = []
         
-        # Filter for quality
-        quality_texts = [text for text in collected_texts if len(text) > 30]
+        # Try to collect from news sources
+        news_data = self.fetch_news_data()
+        collected_data.extend(news_data)
         
-        # Tokenize
-        all_tokens = []
-        for text in quality_texts:
-            tokens = self.tokenize_text(text)
-            all_tokens.extend(tokens)
-            if len(all_tokens) >= max_tokens:
-                break
-        
-        self.total_tokens_collected = len(all_tokens)
-        print(f"🎯 Collected {self.total_tokens_collected:,} tokens")
-        
-        # Build systems
-        self.build_vocabulary(all_tokens)
-        self.build_knowledge_base(quality_texts)
-        self.extract_patterns(all_tokens)
-        
-        return all_tokens
+        # Process collected data
+        if collected_data:
+            self.process_collected_data(collected_data)
+            self.is_trained = True
+            return f"✅ Training completed! Collected {len(collected_data)} articles and {self.total_tokens} total tokens."
+        else:
+            # Use fallback training
+            self.is_trained = True
+            return "✅ Training completed using built-in knowledge patterns!"
     
-    def scrape_news_feeds(self):
-        """Scrape news RSS feeds"""
-        texts = []
+    def fetch_news_data(self):
+        """Fetch data from news sources"""
+        news_sources = [
+            "https://feeds.reuters.com/reuters/worldNews",
+            "https://feeds.bbci.co.uk/news/world/rss.xml"
+        ]
+        
+        articles = []
         
-        for rss_url in self.data_sources["news_rss"]:
+        for source in news_sources:
             try:
-                response = requests.get(rss_url, timeout=5)
+                response = requests.get(source, timeout=5)
                 if response.status_code == 200:
                     root = ET.fromstring(response.content)
-                    for item in root.findall(".//item")[:3]:
+                    for item in root.findall(".//item")[:3]:  # Limit to 3 per source
                         title = item.find("title")
-                        description = item.find("description")
-                        if title is not None:
-                            text = title.text
-                            if description is not None:
-                                text += ". " + description.text
-                            texts.append(self.clean_text(text))
-            except:
+                        if title is not None and title.text:
+                            clean_title = re.sub(r'[^\w\s]', ' ', title.text).strip()
+                            if len(clean_title) > 10:
+                                articles.append(clean_title)
+                print(f"📰 Collected {len(articles)} articles from {source}")
+            except Exception as e:
+                print(f"⚠️ Failed to collect from {source}: {str(e)}")
                 continue
         
-        return texts
-    
-    def create_qa_patterns(self):
-        """Create structured Q&A patterns"""
-        patterns = []
-        
-        # Question-answer templates
-        qa_templates = [
-            ("What is artificial intelligence?", "Artificial intelligence is a technology that enables machines to perform tasks requiring human intelligence."),
-            ("How do computers work?", "Computers work by processing data through electronic circuits and following programmed instructions."),
-            ("Where is Paris located?", "Paris is located in France and serves as the capital city."),
-            ("Why is education important?", "Education is important because it develops knowledge, skills, and critical thinking abilities."),
-            ("What is machine learning?", "Machine learning is a subset of AI that allows systems to learn from data without explicit programming."),
-            ("How does the internet work?", "The internet works through interconnected networks that enable global communication and data sharing."),
-            ("What is climate change?", "Climate change refers to long-term changes in global weather patterns and temperatures."),
-            ("Why do we need renewable energy?", "Renewable energy is needed to reduce environmental impact and ensure sustainable power sources.")
-        ]
-        
-        for question, answer in qa_templates:
-            pattern = f"Question: {question} Answer: {answer}"
-            patterns.append(pattern)
-        
-        return patterns
-    
-    def clean_text(self, text):
-        """Clean and normalize text"""
-        if not text:
-            return ""
-        
-        # Remove HTML tags and normalize
-        text = re.sub(r'<[^>]+>', ' ', text)
-        text = re.sub(r'\s+', ' ', text)
-        text = re.sub(r'[^\w\s\.\,\!\?\;\:\-\(\)\"\']+', ' ', text)
-        
-        return text.strip()
-    
-    def tokenize_text(self, text):
-        """Tokenize text into tokens"""
-        tokens = re.findall(r'\w+|[.!?;,]', text.lower())
-        return tokens
-    
-    def build_vocabulary(self, tokens):
-        """Build vocabulary from tokens"""
-        token_counts = Counter(tokens)
-        filtered_tokens = {token: count for token, count in token_counts.items() if count >= 2}
-        
-        vocab_list = ['<PAD>', '<UNK>', '<START>', '<END>'] + list(filtered_tokens.keys())
-        
-        self.vocabulary = {i: token for i, token in enumerate(vocab_list)}
-        self.token_to_id = {token: i for i, token in enumerate(vocab_list)}
-        self.vocab_size = len(vocab_list)
-        
-        print(f"📚 Built vocabulary: {self.vocab_size:,} tokens")
-    
-    def build_knowledge_base(self, texts):
-        """Build knowledge base from texts"""
-        for text in texts:
-            sentences = re.split(r'[.!?]+', text)
-            for sentence in sentences:
-                sentence = sentence.strip()
-                if len(sentence) > 20:
-                    # Extract main topic (simple approach)
-                    words = sentence.split()
-                    for word in words:
-                        if word[0].isupper() and len(word) > 3:
-                            topic = word.lower()
-                            self.knowledge_base[topic].append(sentence)
-                            break
+        return articles
     
-    def extract_patterns(self, tokens):
-        """Extract patterns for generation"""
-        token_ids = [self.token_to_id.get(token, 1) for token in tokens]
-        
-        # Build bigrams
-        for i in range(len(token_ids) - 1):
-            current_token = token_ids[i]
-            next_token = token_ids[i + 1]
-            self.bigram_counts[current_token][next_token] += 1
-        
-        print(f"📊 Extracted {len(self.bigram_counts):,} bigram patterns")
-    
-    def train_system(self, training_tokens, epochs=3):
-        """Train the Q&A system"""
-        print(f"🎓 Training system for {epochs} epochs...")
-        
-        token_ids = [self.token_to_id.get(token, 1) for token in training_tokens]
-        
-        for epoch in range(epochs):
-            print(f"Training epoch {epoch + 1}/{epochs}")
-            
-            # Simple training simulation
-            total_batches = min(100, len(token_ids) // 10)
+    def process_collected_data(self, data):
+        """Process collected data into knowledge base"""
+        for text in data:
+            # Extract key topics and add to knowledge base
+            words = text.lower().split()
+            self.vocabulary.update(words)
             
-            for batch in range(total_batches):
-                if batch % 25 == 0:
-                    print(f"  Batch {batch + 1}/{total_batches}")
-            
-            self.epochs_trained += 1
-        
-        print("✅ Training completed!")
+            # Simple topic extraction
+            if any(word in text.lower() for word in ['technology', 'ai', 'computer']):
+                self.knowledge_base['technology'].append(text)
+            elif any(word in text.lower() for word in ['climate', 'environment', 'energy']):
+                self.knowledge_base['environment'].append(text)
+            elif any(word in text.lower() for word in ['economy', 'market', 'business']):
+                self.knowledge_base['economy'].append(text)
+            else:
+                self.knowledge_base['general'].append(text)
+        
+        # Update token count
+        self.total_tokens += sum(len(text.split()) for text in data)
+        print(f"📚 Processed data into {len(self.knowledge_base)} knowledge categories")
     
     def answer_question(self, question):
-        """Answer a question using trained knowledge"""
+        """Answer a question using available knowledge"""
         if not question.strip():
-            return "Hello! I'm an AI that learns from data. Ask me a question!"
+            return "Hello! I'm an AI that learns from data. Ask me a question and I'll try to answer based on what I've learned!"
         
-        # Add to memory
-        self.context_memory.append(question)
-        if len(self.context_memory) > 5:
-            self.context_memory.pop(0)
+        question_clean = question.lower().strip()
         
-        # Classify question type
-        question_type = self.classify_question(question)
+        # Direct pattern matching
+        for pattern, answer in self.qa_patterns.items():
+            if self.calculate_similarity(question_clean, pattern) > 0.6:
+                return f"Based on my training: {answer}"
         
-        # Find relevant knowledge
-        relevant_knowledge = self.find_relevant_knowledge(question)
+        # Topic-based responses
+        topic_response = self.get_topic_response(question_clean)
+        if topic_response:
+            return topic_response
         
-        # Generate response
-        response = self.generate_response(question, question_type, relevant_knowledge)
-        
-        return response
-    
-    def classify_question(self, question):
-        """Classify question type"""
-        question_lower = question.lower()
-        
-        if any(word in question_lower for word in ['what', 'define', 'explain']):
-            return 'definition'
-        elif any(word in question_lower for word in ['where', 'location']):
-            return 'location'
-        elif any(word in question_lower for word in ['how', 'method']):
-            return 'process'
-        elif any(word in question_lower for word in ['why', 'reason']):
-            return 'explanation'
-        else:
-            return 'general'
+        # Fallback response
+        return self.generate_fallback_response(question_clean)
     
-    def find_relevant_knowledge(self, question):
-        """Find relevant knowledge for question"""
-        question_words = set(question.lower().split())
-        relevant_facts = []
+    def calculate_similarity(self, text1, text2):
+        """Calculate similarity between two texts"""
+        words1 = set(text1.split())
+        words2 = set(text2.split())
         
-        for topic, facts in self.knowledge_base.items():
-            if topic in question.lower():
-                relevant_facts.extend(facts[:2])
+        if not words1 or not words2:
+            return 0.0
         
-        # Also search by word overlap
-        for topic, facts in self.knowledge_base.items():
-            for fact in facts:
-                fact_words = set(fact.lower().split())
-                overlap = len(question_words.intersection(fact_words))
-                if overlap >= 2:
-                    relevant_facts.append(fact)
-                    if len(relevant_facts) >= 3:
-                        break
+        intersection = len(words1.intersection(words2))
+        union = len(words1.union(words2))
         
-        return relevant_facts[:3]
+        return intersection / union if union > 0 else 0.0
     
-    def generate_response(self, question, question_type, knowledge):
-        """Generate response using patterns and knowledge"""
+    def get_topic_response(self, question):
+        """Get response based on topic matching"""
+        topic_keywords = {
+            'technology': ['technology', 'computer', 'ai', 'artificial', 'machine', 'internet', 'digital'],
+            'environment': ['climate', 'environment', 'energy', 'renewable', 'carbon', 'sustainability'],
+            'economy': ['economy', 'economic', 'market', 'business', 'finance', 'money'],
+            'education': ['education', 'learning', 'school', 'university', 'knowledge', 'study']
+        }
+        
+        # Find matching topic
+        for topic, keywords in topic_keywords.items():
+            if any(keyword in question for keyword in keywords):
+                if topic in self.knowledge_base and self.knowledge_base[topic]:
+                    return f"Based on recent information about {topic}: {self.knowledge_base[topic][0][:150]}..."
+                else:
+                    return self.get_topic_template_response(topic, question)
         
-        # Response templates
+        return None
+    
+    def get_topic_template_response(self, topic, question):
+        """Get template response for a topic"""
         templates = {
-            'definition': "Based on my training data, this refers to",
-            'location': "From geographical information I've learned,",
-            'process': "According to technical sources,",
-            'explanation': "The reason is that",
-            'general': "From my knowledge base,"
+            'technology': "Technology is rapidly evolving and transforming how we work, communicate, and solve problems. Modern technological advances include artificial intelligence, machine learning, and digital innovations.",
+            'environment': "Environmental issues like climate change require urgent attention. Solutions include renewable energy adoption, sustainable practices, and reduced carbon emissions.",
+            'economy': "Economic factors influence global markets, employment, and business growth. Understanding economic principles helps in making informed decisions.",
+            'education': "Education plays a crucial role in personal development and societal progress. It provides knowledge, skills, and opportunities for growth."
         }
         
-        starter = templates.get(question_type, "Based on what I've learned,")
+        base_response = templates.get(topic, "This is an important topic that involves multiple factors and considerations.")
         
-        if knowledge:
-            # Use relevant knowledge
-            response = f"{starter} {knowledge[0][:150]}..."
-            if len(knowledge) > 1:
-                response += f" Additionally, {knowledge[1][:100]}..."
+        if '?' in question:
+            return f"Regarding your question about {topic}: {base_response}"
         else:
-            # Fallback responses
-            fallbacks = {
-                'definition': f"{starter} a concept that involves multiple factors and considerations.",
-                'location': f"{starter} this refers to a specific place or region.",
-                'process': f"{starter} this involves a series of steps and procedures.",
-                'explanation': f"{starter} multiple factors contribute to this.",
-                'general': f"{starter} this is a topic with various aspects to consider."
-            }
-            response = fallbacks.get(question_type, f"{starter} this is an interesting topic that requires further analysis.")
-        
-        # Ensure proper ending
-        if not response.endswith('.'):
-            response += '.'
+            return f"About {topic}: {base_response}"
+    
+    def generate_fallback_response(self, question):
+        """Generate fallback response for unknown questions"""
+        fallback_responses = [
+            "That's an interesting question. Based on general knowledge, this topic involves various factors that need consideration.",
+            "From what I understand, this subject has multiple aspects worth exploring further.",
+            "This is a complex topic that relates to several areas of knowledge and research.",
+            "Based on my training data, this question touches on important concepts that merit detailed analysis."
+        ]
         
-        return response[:300]  # Limit response length
+        return random.choice(fallback_responses)
     
-    def get_stats(self):
-        """Get system statistics"""
-        return {
-            "tokens_collected": self.total_tokens_collected,
-            "vocabulary_size": self.vocab_size,
-            "epochs_trained": self.epochs_trained,
-            "knowledge_topics": len(self.knowledge_base),
-            "bigram_patterns": len(self.bigram_counts),
-            "memory_items": len(self.context_memory)
-        }
+    def get_system_status(self):
+        """Get current system status"""
+        status = "🤖 **SIMPLE Q&A AI STATUS**\n\n"
+        
+        if self.is_trained:
+            status += "✅ **System is trained and ready**\n\n"
+        else:
+            status += "⏳ **System ready for training**\n\n"
+        
+        status += "**📊 Statistics:**\n"
+        status += f"• **Total tokens processed:** {self.total_tokens:,}\n"
+        status += f"• **Vocabulary size:** {len(self.vocabulary):,} words\n"
+        status += f"• **Q&A patterns:** {len(self.qa_patterns)} direct patterns\n"
+        status += f"• **Knowledge categories:** {len(self.knowledge_base)}\n"
+        status += f"• **Training status:** {'Completed' if self.is_trained else 'Pending'}\n"
+        
+        status += "\n**🎯 Capabilities:**\n"
+        status += "• Answers questions using pattern matching\n"
+        status += "• Learns from news articles and data\n"
+        status += "• Handles multiple topics and domains\n"
+        status += "• Provides fallback responses for unknown queries\n"
+        
+        return status
 
-# Initialize system
-qa_system = QuestionAnsweringAI()
+# Initialize the AI system
+ai_system = SimpleQAAI()
 
-def train_qa_system():
-    """Train the Q&A system"""
+def start_training():
+    """Start the training process"""
     try:
-        # Collect data
-        tokens = qa_system.collect_training_data(max_tokens=15000)
-        
-        if len(tokens) > 50:
-            # Train system
-            qa_system.train_system(tokens, epochs=2)
-            return "✅ Q&A System training completed successfully!"
-        else:
-            return "❌ Insufficient data collected for training"
+        result = ai_system.collect_training_data()
+        return result
     except Exception as e:
-        return f"❌ Training error: {str(e)}"
+        return f"❌ Training failed: {str(e)}"
 
-def chat_with_ai(message, history):
-    """Chat interface function"""
-    if not message.strip():
-        response = "Hi! I'm an AI that learns from data and answers questions. What would you like to know?"
-    else:
-        response = qa_system.answer_question(message)
+def chat_function(message, history):
+    """Handle chat interactions"""
+    if not message:
+        return history, ""
     
-    history.append([message, response])
-    return history, ""
+    try:
+        response = ai_system.answer_question(message)
+        history.append([message, response])
+        return history, ""
+    except Exception as e:
+        error_response = f"Sorry, I encountered an error: {str(e)}"
+        history.append([message, error_response])
+        return history, ""
 
-def get_system_status():
-    """Get current system status"""
-    stats = qa_system.get_stats()
-    
-    status = "🤖 **QUESTION ANSWERING AI STATUS**\n\n"
-    
-    if stats['tokens_collected'] == 0:
-        status += "⏳ **System not trained yet**\nClick 'Start Training' to begin\n\n"
-    else:
-        status += "✅ **System trained and operational**\n\n"
-    
-    status += "**📊 Statistics:**\n"
-    status += f"• **Tokens collected:** {stats['tokens_collected']:,}\n"
-    status += f"• **Vocabulary size:** {stats['vocabulary_size']:,}\n"
-    status += f"• **Knowledge topics:** {stats['knowledge_topics']:,}\n"
-    status += f"• **Training epochs:** {stats['epochs_trained']}\n"
-    status += f"• **Pattern database:** {stats['bigram_patterns']:,} patterns\n"
-    status += f"• **Conversation memory:** {stats['memory_items']} messages\n"
-    
-    status += "\n**🎯 Capabilities:**\n"
-    status += "• Answers questions using learned knowledge\n"
-    status += "• Processes natural language queries\n"
-    status += "• Maintains conversation context\n"
-    status += "• Uses pattern matching for responses\n"
-    
-    return status
+def refresh_status():
+    """Refresh system status"""
+    return ai_system.get_system_status()
 
 # Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+with gr.Blocks(theme=gr.themes.Soft(), title="Simple Q&A AI") as app:
     
     gr.HTML("""
     <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
-        <h1>🤖 Question Answering AI</h1>
-        <p><b>AI that learns from data and answers questions</b></p>
-        <p>Collects tokens from internet → Organizes neural patterns → Generates intelligent responses</p>
+        <h1>🤖 Simple Question Answering AI</h1>
+        <p><b>Learn from data and answer questions intelligently</b></p>
+        <p>Stable • Fast • Reliable</p>
     </div>
     """)
     
     with gr.Row():
-        with gr.Column(scale=2):
-            gr.HTML("<h3>💬 Chat with AI</h3>")
+        with gr.Column(scale=3):
+            gr.Markdown("### 💬 Chat with AI")
             
             chatbot = gr.Chatbot(
-                label="Question Answering AI Chat",
-                height=400,
-                show_label=True
+                value=[],
+                label="AI Assistant",
+                height=400
             )
             
             msg_input = gr.Textbox(
-                label="Your question",
+                label="Your Question",
                 placeholder="Ask me anything: What is AI? How does technology work?",
                 lines=2
             )
             
             with gr.Row():
                 send_btn = gr.Button("💬 Send", variant="primary")
-                clear_btn = gr.Button("🔄 Clear", variant="secondary")
+                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
         
         with gr.Column(scale=1):
-            gr.HTML("<h3>⚙️ System Status</h3>")
+            gr.Markdown("### ⚙️ System Control")
             
-            status_output = gr.Textbox(
+            status_box = gr.Textbox(
                 label="System Status",
-                lines=18,
-                interactive=False,
-                value=get_system_status()
+                value=ai_system.get_system_status(),
+                lines=16,
+                interactive=False
             )
             
-            train_btn = gr.Button("🚀 Start Training", variant="secondary")
+            train_btn = gr.Button("🚀 Start Training", variant="primary")
             refresh_btn = gr.Button("🔄 Refresh Status", variant="secondary")
     
     # Example questions
@@ -429,58 +287,43 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         examples=[
             "What is artificial intelligence?",
             "How do computers work?",
-            "Where is Paris located?",
             "Why is education important?",
-            "Explain machine learning",
-            "How does the internet work?",
             "What is climate change?",
-            "Why do we need renewable energy?"
+            "How does the internet work?",
+            "What is machine learning?"
         ],
         inputs=msg_input,
-        label="🎯 Example Questions"
+        label="📝 Try these questions"
     )
     
-    gr.HTML("""
-    <div style="margin-top: 20px; padding: 15px; background-color: #f0f0f0; border-radius: 8px;">
-        <h4>🧠 How It Works:</h4>
-        <ol>
-            <li><b>Data Collection:</b> Gathers text from news feeds and creates Q&A patterns</li>
-            <li><b>Knowledge Building:</b> Extracts facts and builds searchable knowledge base</li>
-            <li><b>Pattern Learning:</b> Learns language patterns from collected data</li>
-            <li><b>Question Processing:</b> Classifies questions and finds relevant knowledge</li>
-            <li><b>Response Generation:</b> Creates intelligent answers using learned patterns</li>
-        </ol>
-        <p><b>🎯 Result:</b> An AI that can answer questions using knowledge learned from data!</p>
-    </div>
-    """)
-    
     # Event handlers
     send_btn.click(
-        chat_with_ai,
+        fn=chat_function,
         inputs=[msg_input, chatbot],
         outputs=[chatbot, msg_input]
     )
     
     msg_input.submit(
-        chat_with_ai,
+        fn=chat_function,
         inputs=[msg_input, chatbot],
         outputs=[chatbot, msg_input]
     )
     
     clear_btn.click(
-        lambda: ([], ""),
+        fn=lambda: ([], ""),
         outputs=[chatbot, msg_input]
     )
     
     train_btn.click(
-        train_qa_system,
-        outputs=[status_output]
+        fn=start_training,
+        outputs=[status_box]
     )
     
     refresh_btn.click(
-        get_system_status,
-        outputs=[status_output]
+        fn=refresh_status,
+        outputs=[status_box]
     )
 
+# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()