Updated app.py and added UI improvements

app.py

@@ -3,21 +3,587 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import re
+import json
+import math
+import datetime
+from typing import Dict, List, Any, Optional, Union
+import time
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
+# --- Advanced Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("Advanced Agent initialized.")
+        # Initialize knowledge base and tools
+        self._init_knowledge_base()
+        self._init_tools()
+        
+    def _init_knowledge_base(self):
+        """Initialize the agent's knowledge base."""
+        self.knowledge_base = {
+            # General knowledge categories
+            "general_knowledge": {
+                "planets": ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"],
+                "elements": {
+                    "H": {"name": "Hydrogen", "atomic_number": 1},
+                    "He": {"name": "Helium", "atomic_number": 2},
+                    "O": {"name": "Oxygen", "atomic_number": 8},
+                    "C": {"name": "Carbon", "atomic_number": 6},
+                    "N": {"name": "Nitrogen", "atomic_number": 7},
+                    "Fe": {"name": "Iron", "atomic_number": 26},
+                    "Au": {"name": "Gold", "atomic_number": 79}
+                },
+                "countries": {
+                    "USA": {"capital": "Washington D.C.", "continent": "North America"},
+                    "UK": {"capital": "London", "continent": "Europe"},
+                    "France": {"capital": "Paris", "continent": "Europe"},
+                    "Japan": {"capital": "Tokyo", "continent": "Asia"},
+                    "Brazil": {"capital": "Brasília", "continent": "South America"},
+                    "Australia": {"capital": "Canberra", "continent": "Australia"},
+                    "Egypt": {"capital": "Cairo", "continent": "Africa"}
+                }
+            },
+            
+            # Tech and programming knowledge
+            "tech": {
+                "programming_languages": {
+                    "Python": {"paradigm": "multi-paradigm", "typing": "dynamic", "year": 1991},
+                    "JavaScript": {"paradigm": "multi-paradigm", "typing": "dynamic", "year": 1995},
+                    "Java": {"paradigm": "object-oriented", "typing": "static", "year": 1995},
+                    "C++": {"paradigm": "multi-paradigm", "typing": "static", "year": 1985},
+                    "Go": {"paradigm": "concurrent", "typing": "static", "year": 2009},
+                    "Rust": {"paradigm": "multi-paradigm", "typing": "static", "year": 2010}
+                },
+                "frameworks": {
+                    "web": ["React", "Angular", "Vue", "Django", "Flask", "Express", "Spring"],
+                    "ml": ["TensorFlow", "PyTorch", "scikit-learn", "Keras", "Hugging Face Transformers"],
+                    "mobile": ["React Native", "Flutter", "Xamarin", "SwiftUI", "Kotlin"]
+                },
+                "databases": {
+                    "relational": ["MySQL", "PostgreSQL", "SQLite", "Oracle", "SQL Server"],
+                    "nosql": ["MongoDB", "Cassandra", "Redis", "Elasticsearch", "DynamoDB"]
+                }
+            },
+            
+            # Definitions for common terms
+            "definitions": {
+                "algorithm": "A step-by-step procedure or formula for solving a problem or accomplishing a task.",
+                "api": "Application Programming Interface - a set of rules that allows different software applications to communicate with each other.",
+                "cloud computing": "The delivery of computing services over the internet to offer faster innovation, flexible resources, and economies of scale.",
+                "machine learning": "A subset of AI that enables systems to learn and improve from experience without being explicitly programmed.",
+                "neural network": "A computing system inspired by biological neural networks that can learn to perform tasks by considering examples.",
+                "blockchain": "A distributed, decentralized, public ledger that records transactions across many computers.",
+                "devops": "A set of practices that combines software development and IT operations to shorten the development lifecycle.",
+                "agile": "An iterative approach to project management and software development that helps teams deliver value to their customers faster.",
+                "rest": "Representational State Transfer - an architectural style for designing networked applications.",
+                "git": "A distributed version control system for tracking changes in source code during software development."
+            },
+            
+            # Common question patterns and responses
+            "question_patterns": {
+                "greeting": ["hello", "hi", "hey", "greetings"],
+                "identity": ["who are you", "what are you", "your name", "who created you"],
+                "capabilities": ["what can you do", "help me", "your capabilities", "your functions"],
+                "math": ["calculate", "compute", "solve", "equation", "math problem"],
+                "time": ["time", "date", "day", "today", "current time"],
+                "weather": ["weather", "temperature", "forecast", "rain", "sunny"],
+                "definition": ["define", "meaning of", "what is", "what are", "definition"],
+                "comparison": ["difference between", "compare", "versus", "vs", "similarities"],
+                "recommendation": ["recommend", "suggest", "best", "top", "advice"],
+                "how_to": ["how to", "how do i", "steps to", "guide", "tutorial"],
+                "why": ["why is", "why do", "why does", "reason for", "explain why"]
+            }
+        }
+        
+        # Response templates for different question types
+        self.response_templates = {
+            "greeting": "Hello! I'm an advanced AI assistant. How can I help you today?",
+            "identity": "I'm an advanced AI assistant designed to help answer your questions and provide information on various topics.",
+            "capabilities": "I can answer questions, provide explanations, solve problems, offer recommendations, and assist with various topics including math, definitions, comparisons, and more.",
+            "unknown": "I don't have enough information to answer that question accurately. Could you provide more details or rephrase your question?",
+            "clarification": "I'm not sure I understand your question completely. Could you rephrase it or provide more context?",
+            "math_response": "Based on my calculations, {result}.",
+            "definition_response": "The term '{term}' refers to {definition}.",
+            "comparison_response": "When comparing {item1} and {item2}: {differences}",
+            "recommendation_response": "Based on your request, I would recommend {recommendations}.",
+            "how_to_response": "Here's how to {task}: {steps}",
+            "why_response": "The reason for {subject} is {explanation}."
+        }
+    
+    def _init_tools(self):
+        """Initialize the agent's tools for answering different types of questions."""
+        self.tools = {
+            "math_solver": self._solve_math_problem,
+            "definition_finder": self._answer_definition,
+            "comparison_maker": self._compare_items,
+            "recommendation_engine": self._make_recommendation,
+            "how_to_guide": self._create_how_to,
+            "why_explainer": self._explain_why,
+            "general_knowledge": self._answer_general_knowledge,
+            "time_handler": self._handle_time_questions,
+            "advanced_math": self._handle_advanced_math,
+            "code_generator": self._generate_code_examples
+        }
+    
+    def _categorize_question(self, question: str) -> str:
+        """Determine the category of the question."""
+        question_lower = question.lower()
+        
+        # Check each category
+        for category, keywords in self.knowledge_base["question_patterns"].items():
+            for keyword in keywords:
+                if keyword in question_lower:
+                    return category
+        
+        # Check for general knowledge questions
+        if any(word in question_lower for word in ["what", "who", "where", "when", "list", "name", "tell me about"]):
+            return "general_knowledge"
+        
+        # If no category matches
+        return "unknown"
+    
+    def _extract_math_expression(self, question: str) -> Optional[str]:
+        """Extract mathematical expressions from the question."""
+        # Look for basic arithmetic patterns
+        math_patterns = [
+            r'(\d+\s*[\+\-\*\/]\s*\d+)',  # Simple operations like "2 + 2"
+            r'(\d+\s*[\+\-\*\/]\s*\d+\s*[\+\-\*\/]\s*\d+)',  # More complex like "2 + 3 * 4"
+            r'what is (\d+\s*[\+\-\*\/]\s*\d+)',  # "What is 2 + 2"
+            r'calculate (\d+\s*[\+\-\*\/]\s*\d+)'  # "Calculate 2 + 2"
+        ]
+        
+        for pattern in math_patterns:
+            match = re.search(pattern, question.lower())
+            if match:
+                return match.group(1)
+        
+        return None
+    
+    def _solve_math_problem(self, question: str) -> str:
+        """Safely evaluate a mathematical expression."""
+        expression = self._extract_math_expression(question)
+        if not expression:
+            return "I couldn't identify a mathematical expression in your question."
+        
+        try:
+            # Replace × with * and ÷ with /
+            expression = expression.replace('×', '*').replace('÷', '/')
+            # Remove any non-math characters
+            expression = re.sub(r'[^0-9\+\-\*\/\(\)\.\s]', '', expression)
+            result = eval(expression)
+            return f"{expression} = {result}"
+        except Exception as e:
+            return f"I couldn't evaluate the expression '{expression}'. Error: {str(e)}"
+    
+    def _answer_definition(self, question: str) -> str:
+        """Generate a definition response."""
+        # Extract the term being defined
+        patterns = [
+            r'define\s+([a-zA-Z\s]+)',
+            r'what\s+is\s+([a-zA-Z\s]+)',
+            r'meaning\s+of\s+([a-zA-Z\s]+)'
+        ]
+        
+        term = None
+        for pattern in patterns:
+            match = re.search(pattern, question.lower())
+            if match:
+                term = match.group(1).strip()
+                break
+        
+        if not term:
+            return self.response_templates["clarification"]
+        
+        # Check if we have a definition for the term
+        for key, definition in self.knowledge_base["definitions"].items():
+            if term in key or key in term:
+                return self.response_templates["definition_response"].format(term=key, definition=definition)
+        
+        return f"I don't have a specific definition for '{term}' in my knowledge base."
+    
+    def _compare_items(self, question: str) -> str:
+        """Compare two items mentioned in the question."""
+        # Extract items to compare
+        patterns = [
+            r'difference between ([a-zA-Z\s]+) and ([a-zA-Z\s]+)',
+            r'compare ([a-zA-Z\s]+) and ([a-zA-Z\s]+)',
+            r'([a-zA-Z\s]+) vs ([a-zA-Z\s]+)'
+        ]
+        
+        item1 = None
+        item2 = None
+        for pattern in patterns:
+            match = re.search(pattern, question.lower())
+            if match:
+                item1 = match.group(1).strip()
+                item2 = match.group(2).strip()
+                break
+        
+        if not item1 or not item2:
+            return "I couldn't identify the items you want to compare. Please specify them clearly."
+        
+        # Check if we can compare programming languages
+        tech_info = self.knowledge_base["tech"]["programming_languages"]
+        if item1 in tech_info and item2 in tech_info:
+            lang1 = tech_info[item1]
+            lang2 = tech_info[item2]
+            differences = []
+            
+            if lang1["paradigm"] != lang2["paradigm"]:
+                differences.append(f"{item1} follows {lang1['paradigm']} paradigm while {item2} follows {lang2['paradigm']} paradigm")
+            
+            if lang1["typing"] != lang2["typing"]:
+                differences.append(f"{item1} uses {lang1['typing']} typing while {item2} uses {lang2['typing']} typing")
+            
+            if lang1["year"] != lang2["year"]:
+                differences.append(f"{item1} was created in {lang1['year']} while {item2} was created in {lang2['year']}")
+            
+            if differences:
+                return self.response_templates["comparison_response"].format(
+                    item1=item1,
+                    item2=item2,
+                    differences=". ".join(differences) + "."
+                )
+        
+        return f"I don't have enough information to compare {item1} and {item2} in detail."
+    
+    def _make_recommendation(self, question: str) -> str:
+        """Make recommendations based on the question."""
+        question_lower = question.lower()
+        
+        # Recommend programming language
+        if "programming language" in question_lower:
+            if "web" in question_lower:
+                return "For web development, I would recommend JavaScript with frameworks like React or Vue.js for frontend, and Node.js, Python (Django/Flask), or Ruby on Rails for backend."
+            elif "data science" in question_lower or "machine learning" in question_lower:
+                return "For data science and machine learning, Python is highly recommended due to its extensive libraries like TensorFlow, PyTorch, scikit-learn, and pandas."
+            elif "mobile" in question_lower:
+                return "For mobile development, consider Swift for iOS, Kotlin for Android, or cross-platform frameworks like React Native or Flutter."
+            else:
+                return "For general purpose programming, Python is great for beginners due to its readability. Java and C# are excellent for enterprise applications. Rust and Go are modern languages with great performance characteristics."
+        
+        # Recommend database
+        elif "database" in question_lower:
+            if "scalability" in question_lower or "large scale" in question_lower:
+                return "For highly scalable applications, consider NoSQL databases like MongoDB, Cassandra, or cloud-based solutions like Amazon DynamoDB or Google Firestore."
+            elif "relational" in question_lower or "sql" in question_lower:
+                return "For relational data, PostgreSQL is an excellent open-source choice with advanced features. MySQL is also popular and well-supported. For smaller applications, SQLite is a lightweight option."
+            else:
+                return "For most applications, PostgreSQL is a versatile choice. If you need schema flexibility, consider MongoDB. For caching and real-time data, Redis is excellent."
+        
+        return "I need more specific information about what you're looking for to provide a tailored recommendation."
+    
+    def _create_how_to(self, question: str) -> str:
+        """Create a how-to guide based on the question."""
+        question_lower = question.lower()
+        
+        # Extract the task
+        match = re.search(r'how to ([a-zA-Z\s]+)', question_lower)
+        if not match:
+            return "Could you specify what you want to learn how to do?"
+        
+        task = match.group(1).strip()
+        
+        # Common how-to guides
+        how_to_guides = {
+            "learn programming": """
+1. Choose a programming language (Python is great for beginners)
+2. Set up your development environment
+3. Learn the basic syntax and concepts
+4. Practice with small projects
+5. Use online resources like tutorials, documentation, and courses
+6. Join programming communities for support
+7. Build increasingly complex projects
+8. Learn about algorithms and data structures
+9. Contribute to open source projects
+            """,
+            "create a website": """
+1. Define the purpose and goals of your website
+2. Choose a domain name and hosting provider
+3. Decide between using a website builder, CMS, or coding from scratch
+4. Design the layout and user interface
+5. Create and organize your content
+6. Add functionality with plugins or custom code
+7. Test your website on different devices and browsers
+8. Optimize for search engines (SEO)
+9. Launch your website
+10. Maintain and update regularly
+            """,
+            "learn machine learning": """
+1. Master the prerequisites: Python, statistics, and linear algebra
+2. Understand the basic concepts and terminology
+3. Learn about data preprocessing and visualization
+4. Study supervised learning algorithms (regression, classification)
+5. Explore unsupervised learning techniques (clustering, dimensionality reduction)
+6. Practice with datasets from Kaggle or UCI Machine Learning Repository
+7. Learn a machine learning library like scikit-learn
+8. Study deep learning fundamentals
+9. Experiment with neural network frameworks like TensorFlow or PyTorch
+10. Work on real-world projects and participate in competitions
+            """
+        }
+        
+        # Check if we have a guide for this task
+        for guide_task, steps in how_to_guides.items():
+            if task in guide_task or guide_task in task:
+                return self.response_templates["how_to_response"].format(task=task, steps=steps)
+        
+        return f"I don't have a specific guide for how to {task}. Could you ask about a more specific topic?"
+    
+    def _explain_why(self, question: str) -> str:
+        """Explain why something happens or exists."""
+        question_lower = question.lower()
+        
+        # Extract the subject
+        patterns = [
+            r'why is ([a-zA-Z\s]+)',
+            r'why do ([a-zA-Z\s]+)',
+            r'why does ([a-zA-Z\s]+)',
+            r'explain why ([a-zA-Z\s]+)'
+        ]
+        
+        subject = None
+        for pattern in patterns:
+            match = re.search(pattern, question_lower)
+            if match:
+                subject = match.group(1).strip()
+                break
+        
+        if not subject:
+            return "Could you clarify what you want me to explain?"
+        
+        # Common explanations
+        explanations = {
+            "sky blue": "The sky appears blue because molecules in the air scatter blue light from the sun more than they scatter red light. This is called Rayleigh scattering.",
+            "water wet": "Water is wet in the sense that it makes other materials wet. Wetness is the ability of a liquid to adhere to the surface of a solid.",
+            "programming important": "Programming is important because it enables us to create software that solves problems, automates tasks, and powers much of modern technology and infrastructure.",
+            "python popular": "Python is popular due to its readability, versatility, extensive libraries, strong community support, and applications in growing fields like data science and machine learning.",
+            "computers use binary": "Computers use binary (0s and 1s) because digital electronics are based on two states: on and off. This binary system simplifies hardware design and is the foundation of all digital computing."
+        }
+        
+        # Check if we have an explanation for this subject
+        for key, explanation in explanations.items():
+            if subject in key or key in subject:
+                return self.response_templates["why_response"].format(subject=subject, explanation=explanation)
+        
+        return f"I don't have a specific explanation for why {subject}. Could you ask about something more specific?"
+    
+    def _answer_general_knowledge(self, question: str) -> str:
+        """Answer general knowledge questions."""
+        question_lower = question.lower()
+        
+        # Check for questions about planets
+        if any(planet.lower() in question_lower for planet in self.knowledge_base["general_knowledge"]["planets"]):
+            if "how many" in question_lower and "planets" in question_lower:
+                return f"There are 8 recognized planets in our solar system: {', '.join(self.knowledge_base['general_knowledge']['planets'])}."
+            
+            for planet in self.knowledge_base["general_knowledge"]["planets"]:
+                if planet.lower() in question_lower:
+                    if planet == "Earth":
+                        return "Earth is the third planet from the Sun and the only astronomical object known to harbor life."
+                    elif planet == "Mars":
+                        return "Mars is the fourth planet from the Sun and the second-smallest planet in the Solar System, often called the 'Red Planet'."
+                    elif planet == "Jupiter":
+                        return "Jupiter is the fifth planet from the Sun and the largest in the Solar System, characterized by its Great Red Spot."
+                    else:
+                        return f"{planet} is one of the planets in our solar system."
+        
+        # Check for questions about elements
+        if "element" in question_lower:
+            for symbol, data in self.knowledge_base["general_knowledge"]["elements"].items():
+                if symbol.lower() in question_lower or data["name"].lower() in question_lower:
+                    return f"{data['name']} (symbol: {symbol}) is a chemical element with atomic number {data['atomic_number']}."
+        
+        # Check for questions about countries
+        if "capital" in question_lower or "country" in question_lower:
+            for country, data in self.knowledge_base["general_knowledge"]["countries"].items():
+                if country.lower() in question_lower:
+                    return f"The capital of {country} is {data['capital']}, and it's located in {data['continent']}."
+                elif data["capital"].lower() in question_lower:
+                    return f"{data['capital']} is the capital of {country}, which is located in {data['continent']}."
+        
+        # Check for programming language questions
+        if "programming language" in question_lower:
+            for lang, data in self.knowledge_base["tech"]["programming_languages"].items():
+                if lang.lower() in question_lower:
+                    return f"{lang} is a {data['paradigm']} programming language with {data['typing']} typing, created in {data['year']}."
+        
+        return "I don't have specific information about that in my knowledge base."
+    
+    def _handle_time_questions(self, question: str) -> str:
+        """Handle questions about time and date."""
+        question_lower = question.lower()
+        current_time = datetime.datetime.now()
+        
+        if "time" in question_lower:
+            return f"The current time is {current_time.strftime('%H:%M:%S')}."
+        
+        elif "date" in question_lower or "today" in question_lower or "day" in question_lower:
+            return f"Today is {current_time.strftime('%A, %B %d, %Y')}."
+        
+        elif "month" in question_lower:
+            return f"The current month is {current_time.strftime('%B')}."
+        
+        elif "year" in question_lower:
+            return f"The current year is {current_time.strftime('%Y')}."
+        
+        return f"The current date and time is {current_time.strftime('%A, %B %d, %Y %H:%M:%S')}."
+    
+    def _handle_advanced_math(self, question: str) -> str:
+        """Handle more advanced mathematical operations."""
+        question_lower = question.lower()
+        
+        # Check for square root
+        sqrt_match = re.search(r'square root of (\d+)', question_lower)
+        if sqrt_match:
+            number = int(sqrt_match.group(1))
+            result = math.sqrt(number)
+            return f"The square root of {number} is {result}."
+        
+        # Check for exponentiation
+        exp_match = re.search(r'(\d+) to the power of (\d+)', question_lower)
+        if exp_match:
+            base = int(exp_match.group(1))
+            exponent = int(exp_match.group(2))
+            result = math.pow(base, exponent)
+            return f"{base} to the power of {exponent} is {result}."
+        
+        # Check for logarithm
+        log_match = re.search(r'log(?:arithm)? of (\d+)', question_lower)
+        if log_match:
+            number = int(log_match.group(1))
+            result = math.log10(number)
+            return f"The logarithm (base 10) of {number} is {result}."
+        
+        # Check for trigonometric functions
+        trig_patterns = {
+            r'sin(?:e)? of (\d+)': ('sine', math.sin),
+            r'cos(?:ine)? of (\d+)': ('cosine', math.cos),
+            r'tan(?:gent)? of (\d+)': ('tangent', math.tan)
+        }
+        
+        for pattern, (name, func) in trig_patterns.items():
+            match = re.search(pattern, question_lower)
+            if match:
+                angle = int(match.group(1))
+                # Convert to radians if needed
+                if "degrees" in question_lower or "degree" in question_lower:
+                    angle_rad = math.radians(angle)
+                    result = func(angle_rad)
+                    return f"The {name} of {angle} degrees is {result}."
+                else:
+                    result = func(angle)
+                    return f"The {name} of {angle} radians is {result}."
+        
+        return "I couldn't identify a specific advanced math operation in your question."
+    
+    def _generate_code_examples(self, question: str) -> str:
+        """Generate code examples based on the question."""
+        question_lower = question.lower()
+        
+        # Python examples
+        if "python" in question_lower:
+            if "hello world" in question_lower:
+                return "Here's a Python Hello World example:\n```python\nprint(\"Hello, World!\")\n```"
+            
+            elif "function" in question_lower or "def" in question_lower:
+                return "Here's how to define a function in Python:\n```python\ndef greet(name):\n    # Return a greeting message\n    return f\"Hello, {name}!\"\n\n# Example usage\nmessage = greet(\"Alice\")\nprint(message)  # Output: Hello, Alice!\n```"
+            
+            elif "class" in question_lower or "object" in question_lower:
+                return "Here's how to define a class in Python:\n```python\nclass Person:\n    def __init__(self, name, age):\n        self.name = name\n        self.age = age\n    \n    def greet(self):\n        return f\"Hello, my name is {self.name} and I am {self.age} years old.\"\n\n# Example usage\nperson = Person(\"Alice\", 30)\nprint(person.greet())  # Output: Hello, my name is Alice and I am 30 years old.\n```"
+            
+            elif "list" in question_lower or "array" in question_lower:
+                return "Here's how to work with lists in Python:\n```python\n# Create a list\nfruits = [\"apple\", \"banana\", \"cherry\"]\n\n# Access elements\nprint(fruits[0])  # Output: apple\n\n# Modify elements\nfruits[1] = \"blueberry\"\nprint(fruits)  # Output: ['apple', 'blueberry', 'cherry']\n\n# Add elements\nfruits.append(\"orange\")\nprint(fruits)  # Output: ['apple', 'blueberry', 'cherry', 'orange']\n\n# Remove elements\nfruits.remove(\"cherry\")\nprint(fruits)  # Output: ['apple', 'blueberry', 'orange']\n\n# List comprehension\nsquares = [x**2 for x in range(5)]\nprint(squares)  # Output: [0, 1, 4, 9, 16]\n```"
+            
+            elif "dictionary" in question_lower or "dict" in question_lower:
+                return "Here's how to work with dictionaries in Python:\n```python\n# Create a dictionary\nperson = {\n    \"name\": \"Alice\",\n    \"age\": 30,\n    \"city\": \"New York\"\n}\n\n# Access values\nprint(person[\"name\"])  # Output: Alice\n\n# Modify values\nperson[\"age\"] = 31\nprint(person)  # Output: {'name': 'Alice', 'age': 31, 'city': 'New York'}\n\n# Add new key-value pairs\nperson[\"email\"] = \"alice@example.com\"\nprint(person)  # Output: {'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'}\n\n# Remove key-value pairs\ndel person[\"city\"]\nprint(person)  # Output: {'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}\n\n# Dictionary comprehension\nsquares = {x: x**2 for x in range(5)}\nprint(squares)  # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}\n```"
+        
+        # JavaScript examples
+        elif "javascript" in question_lower or "js" in question_lower:
+            if "hello world" in question_lower:
+                return "Here's a JavaScript Hello World example:\n```javascript\nconsole.log(\"Hello, World!\");\n```"
+            
+            elif "function" in question_lower:
+                return "Here's how to define functions in JavaScript:\n```javascript\n// Function declaration\nfunction greet(name) {\n    return `Hello, ${name}!`;\n}\n\n// Arrow function\nconst greetArrow = (name) => `Hello, ${name}!`;\n\n// Example usage\nconsole.log(greet(\"Alice\"));  // Output: Hello, Alice!\nconsole.log(greetArrow(\"Bob\"));  // Output: Hello, Bob!\n```"
+            
+            elif "class" in question_lower or "object" in question_lower:
+                return "Here's how to define a class in JavaScript:\n```javascript\nclass Person {\n    constructor(name, age) {\n        this.name = name;\n        this.age = age;\n    }\n    \n    greet() {\n        return `Hello, my name is ${this.name} and I am ${this.age} years old.`;\n    }\n}\n\n// Example usage\nconst person = new Person(\"Alice\", 30);\nconsole.log(person.greet());  // Output: Hello, my name is Alice and I am 30 years old.\n```"
+            
+            elif "array" in question_lower or "list" in question_lower:
+                return "Here's how to work with arrays in JavaScript:\n```javascript\n// Create an array\nconst fruits = [\"apple\", \"banana\", \"cherry\"];\n\n// Access elements\nconsole.log(fruits[0]);  // Output: apple\n\n// Modify elements\nfruits[1] = \"blueberry\";\nconsole.log(fruits);  // Output: ['apple', 'blueberry', 'cherry']\n\n// Add elements\nfruits.push(\"orange\");\nconsole.log(fruits);  // Output: ['apple', 'blueberry', 'cherry', 'orange']\n\n// Remove elements\nfruits.splice(fruits.indexOf(\"cherry\"), 1);\nconsole.log(fruits);  // Output: ['apple', 'blueberry', 'orange']\n\n// Array methods\nconst numbers = [1, 2, 3, 4, 5];\nconst doubled = numbers.map(x => x * 2);\nconsole.log(doubled);  // Output: [2, 4, 6, 8, 10]\n```"
+            
+            elif "object" in question_lower or "dict" in question_lower:
+                return "Here's how to work with objects in JavaScript:\n```javascript\n// Create an object\nconst person = {\n    name: \"Alice\",\n    age: 30,\n    city: \"New York\"\n};\n\n// Access properties\nconsole.log(person.name);  // Output: Alice\n\n// Modify properties\nperson.age = 31;\nconsole.log(person);  // Output: {name: 'Alice', age: 31, city: 'New York'}\n\n// Add new properties\nperson.email = \"alice@example.com\";\nconsole.log(person);  // Output: {name: 'Alice', age: 31, city: 'New York', email: 'alice@example.com'}\n\n// Remove properties\ndelete person.city;\nconsole.log(person);  // Output: {name: 'Alice', age: 31, email: 'alice@example.com'}\n\n// Object destructuring\nconst { name, age } = person;\nconsole.log(name, age);  // Output: Alice 31\n```"
+        
+        return "I can provide code examples, but I need more specific information about what programming language and concept you're interested in."
+    
+    def _generate_response(self, question: str, category: str) -> str:
+        """Generate a response based on the question category."""
+        if category == "greeting":
+            return self.response_templates["greeting"]
+        
+        elif category == "identity":
+            return self.response_templates["identity"]
+        
+        elif category == "capabilities":
+            return self.response_templates["capabilities"]
+        
+        elif category == "math":
+            # Try advanced math first, then fall back to basic math
+            advanced_result = self.tools["advanced_math"](question)
+            if "couldn't identify" not in advanced_result:
+                return advanced_result
+            return self.tools["math_solver"](question)
+        
+        elif category == "time":
+            return self.tools["time_handler"](question)
+        
+        elif category == "definition":
+            return self.tools["definition_finder"](question)
+        
+        elif category == "comparison":
+            return self.tools["comparison_maker"](question)
+        
+        elif category == "recommendation":
+            return self.tools["recommendation_engine"](question)
+        
+        elif category == "how_to":
+            # Check if it's a coding question
+            if any(lang in question.lower() for lang in ["code", "program", "python", "javascript", "java", "c++", "function", "class"]):
+                return self.tools["code_generator"](question)
+            return self.tools["how_to_guide"](question)
+        
+        elif category == "why":
+            return self.tools["why_explainer"](question)
+        
+        elif category == "general_knowledge":
+            return self.tools["general_knowledge"](question)
+        
+        else:
+            return self.response_templates["unknown"]
+    
     def __call__(self, question: str) -> str:
+        """Process the question and return an answer."""
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        
+        # Handle empty or very short questions
+        if not question or len(question.strip()) < 3:
+            return "Please provide a valid question with more details so I can help you better."
+        
+        # Categorize the question
+        category = self._categorize_question(question)
+        print(f"Question categorized as: {category}")
+        
+        # Generate response based on category
+        answer = self._generate_response(question, category)
+        
+        print(f"Agent returning answer: {answer[:50]}...")
+        return answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """