Update app.py

app.py

@@ -1,5 +1,8 @@
 import gradio as gr
 import os
+import json
+import uuid
+from datetime import datetime
 from groq import Groq
 
 # Set up Groq API key
@@ -9,107 +12,719 @@ if not GROQ_API_KEY:
 
 client = Groq(api_key=GROQ_API_KEY)
 
-# System prompt
+# Default system prompt
 SYSTEM_PROMPT = (
     "You are an intelligent, friendly, and highly adaptable Teaching Assistant Chatbot. "
     "Your mission is to help users of all ages and skill levels—from complete beginners to seasoned professionals—learn Python, Data Science, and Artificial Intelligence. "
     "You explain concepts clearly using real-world analogies, examples, and interactive exercises. "
-    "You ask questions to assess the learner’s level, adapt accordingly, and provide learning paths tailored to their pace and goals. "
+    "You ask questions to assess the learner's level, adapt accordingly, and provide learning paths tailored to their pace and goals. "
     "Your responses are structured, engaging, and supportive. "
     "You can explain code snippets, generate exercises and quizzes, and recommend projects. "
     "You never overwhelm users with jargon. Instead, you scaffold complex concepts in simple, digestible steps."
 )
 
-def chat_with_groq(user_input, user_data):
+# Define learning paths
+LEARNING_PATHS = {
+    "python_beginner": {
+        "title": "Python Fundamentals",
+        "description": "Learn Python basics from variables to functions",
+        "modules": [
+            "Variables & Data Types", 
+            "Control Flow", 
+            "Functions", 
+            "Data Structures", 
+            "File I/O"
+        ]
+    },
+    "python_intermediate": {
+        "title": "Intermediate Python",
+        "description": "Advance your Python skills with OOP and more",
+        "modules": [
+            "Object-Oriented Programming", 
+            "Modules & Packages", 
+            "Error Handling", 
+            "List Comprehensions", 
+            "Decorators & Generators"
+        ]
+    },
+    "data_science_beginner": {
+        "title": "Data Science Foundations",
+        "description": "Begin your data science journey",
+        "modules": [
+            "Numpy Basics", 
+            "Pandas Fundamentals", 
+            "Data Visualization", 
+            "Basic Statistics", 
+            "Intro to Machine Learning"
+        ]
+    },
+    "data_science_advanced": {
+        "title": "Advanced Data Science",
+        "description": "Master complex data science concepts",
+        "modules": [
+            "Advanced ML Algorithms", 
+            "Feature Engineering", 
+            "Time Series Analysis", 
+            "Natural Language Processing", 
+            "Deep Learning Basics"
+        ]
+    },
+    "ai_specialization": {
+        "title": "AI Specialization",
+        "description": "Focus on artificial intelligence concepts",
+        "modules": [
+            "Neural Networks", 
+            "Computer Vision", 
+            "Advanced NLP", 
+            "Reinforcement Learning", 
+            "AI Ethics"
+        ]
+    }
+}
+
+# Learning resources
+LEARNING_RESOURCES = {
+    "python": [
+        {"title": "Python Documentation", "url": "https://docs.python.org/3/"},
+        {"title": "Real Python", "url": "https://realpython.com/"},
+        {"title": "Python for Everybody", "url": "https://www.py4e.com/"},
+        {"title": "Automate the Boring Stuff with Python", "url": "https://automatetheboringstuff.com/"}
+    ],
+    "data_science": [
+        {"title": "Kaggle Learn", "url": "https://www.kaggle.com/learn"},
+        {"title": "Towards Data Science", "url": "https://towardsdatascience.com/"},
+        {"title": "DataCamp", "url": "https://www.datacamp.com/"},
+        {"title": "Machine Learning Mastery", "url": "https://machinelearningmastery.com/"}
+    ],
+    "ai": [
+        {"title": "Fast.ai", "url": "https://www.fast.ai/"},
+        {"title": "DeepLearning.AI", "url": "https://www.deeplearning.ai/"},
+        {"title": "TensorFlow Tutorials", "url": "https://www.tensorflow.org/tutorials"},
+        {"title": "PyTorch Tutorials", "url": "https://pytorch.org/tutorials/"}
+    ]
+}
+
+# Practice project ideas
+PROJECT_IDEAS = {
+    "python_beginner": [
+        "To-Do List Application",
+        "Simple Calculator",
+        "Password Generator",
+        "Hangman Game",
+        "Basic File Organizer"
+    ],
+    "python_intermediate": [
+        "Weather App with API",
+        "Personal Blog with Flask",
+        "Web Scraper for News Articles",
+        "Data Visualization Dashboard",
+        "Task Automation Scripts"
+    ],
+    "data_science": [
+        "Housing Price Prediction",
+        "Customer Segmentation Analysis",
+        "Sentiment Analysis of Reviews",
+        "Stock Price Forecasting",
+        "A/B Test Analysis Dashboard"
+    ],
+    "ai": [
+        "Image Classification System",
+        "Chatbot with NLP",
+        "Recommendation Engine",
+        "Text Summarization Tool",
+        "Object Detection Application"
+    ]
+}
+
+# User session data store
+SESSION_DATA = {}
+
+def save_session(session_id, data):
+    """Save session data to SESSION_DATA global dictionary"""
+    if session_id in SESSION_DATA:
+        SESSION_DATA[session_id].update(data)
+    else:
+        SESSION_DATA[session_id] = data
+    
+    # Add timestamp for session tracking
+    SESSION_DATA[session_id]["last_activity"] = datetime.now().isoformat()
+
+def load_session(session_id):
+    """Load session data from SESSION_DATA global dictionary"""
+    return SESSION_DATA.get(session_id, {})
+
+def recommend_learning_path(age, goals, knowledge_level, interests):
+    """Recommend personalized learning paths based on user profile"""
+    paths = []
+    
+    # Simple recommendation logic based on profile
+    if "beginner" in knowledge_level.lower():
+        if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
+            paths.append("python_beginner")
+        if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
+            paths.append("data_science_beginner")
+    elif "intermediate" in knowledge_level.lower() or "advanced" in knowledge_level.lower():
+        if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
+            paths.append("python_intermediate")
+        if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
+            paths.append("data_science_advanced")
+        if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
+            paths.append("ai_specialization")
+    
+    # Default path if no matches
+    if not paths:
+        paths = ["python_beginner"]
+    
+    return [LEARNING_PATHS[path] for path in paths if path in LEARNING_PATHS]
+
+def get_recommended_resources(interests):
+    """Get recommended learning resources based on interests"""
+    resources = []
+    if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
+        resources.extend(LEARNING_RESOURCES["python"])
+    if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
+        resources.extend(LEARNING_RESOURCES["data_science"])
+    if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
+        resources.extend(LEARNING_RESOURCES["ai"])
+    
+    # If no specific interests match, provide general resources
+    if not resources:
+        for category in LEARNING_RESOURCES:
+            resources.extend(LEARNING_RESOURCES[category][:1])  # Add first resource from each category
+    
+    return resources
+
+def get_project_ideas(learning_paths):
+    """Get project ideas based on recommended learning paths"""
+    ideas = []
+    for path in learning_paths:
+        path_id = next((k for k, v in LEARNING_PATHS.items() if v["title"] == path["title"]), None)
+        if path_id:
+            if path_id.startswith("python"):
+                category = "python_beginner" if "beginner" in path_id else "python_intermediate"
+                ideas.extend(PROJECT_IDEAS[category])
+            elif path_id.startswith("data_science"):
+                ideas.extend(PROJECT_IDEAS["data_science"])
+            elif path_id.startswith("ai"):
+                ideas.extend(PROJECT_IDEAS["ai"])
+    
+    # If no specific paths match, provide some general project ideas
+    if not ideas:
+        ideas = PROJECT_IDEAS["python_beginner"][:2] + PROJECT_IDEAS["data_science"][:2]
+    
+    return ideas[:5]  # Return up to 5 project ideas
+
+def generate_quiz(topic, difficulty):
+    """Generate a quiz based on the topic and difficulty"""
+    # In a real application, you might use the LLM to generate quizzes
+    # Here we're using a template approach for simplicity
+    quiz_prompt = f"""
+    Generate a {difficulty} level quiz on {topic} with 3 multiple-choice questions.
+    For each question, provide 4 options and indicate the correct answer.
+    Format the quiz nicely with clear question numbering and option lettering.
+    """
+    
+    # Use Groq to generate the quiz
+    quiz_messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": quiz_prompt}
+    ]
+    
+    quiz_response = client.chat.completions.create(
+        messages=quiz_messages,
+        model="llama-3.3-70b-versatile",
+        stream=False
+    )
+    
+    return quiz_response.choices[0].message.content
+
+def create_study_plan(topic, time_available, goals):
+    """Create a personalized study plan"""
+    plan_prompt = f"""
+    Create a structured study plan for learning {topic} with {time_available} hours per week available for study.
+    The learner's goal is: {goals}
+    
+    Include:
+    1. Weekly breakdown of topics
+    2. Time allocation for theory vs practice
+    3. Recommended resources for each week
+    4. Milestone projects or assessments
+    5. Tips for effective learning
+    """
+    
+    # Use Groq to generate the study plan
+    plan_messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": plan_prompt}
+    ]
+    
+    plan_response = client.chat.completions.create(
+        messages=plan_messages,
+        model="llama-3.3-70b-versatile",
+        stream=False
+    )
+    
+    return plan_response.choices[0].message.content
+
+def chat_with_groq(user_input, session_id):
+    """Chat with Groq LLM using session context"""
+    user_data = load_session(session_id)
+    
+    # Build context from session data if available
+    context = ""
+    if user_data:
+        context = f"""
+        User Profile:
+        - Age: {user_data.get('age', 'Unknown')}
+        - Knowledge Level: {user_data.get('knowledge_level', 'Unknown')}
+        - Learning Goals: {user_data.get('goals', 'Unknown')}
+        - Interests: {user_data.get('interests', 'Unknown')}
+        - Available Study Time: {user_data.get('study_time', 'Unknown')} hours per week
+        - Preferred Learning Style: {user_data.get('learning_style', 'Unknown')}
+        
+        Based on this profile, tailor your response appropriately.
+        """
+    
+    # Add chat history context if available
+    chat_history = user_data.get('chat_history', [])
+    if chat_history:
+        context += "\n\nRecent conversation context (most recent first):\n"
+        # Include up to 3 most recent exchanges
+        for i, (q, a) in enumerate(reversed(chat_history[-3:])):
+            context += f"User: {q}\nYou: {a}\n\n"
+    
+    # Combine everything for the LLM
+    full_prompt = f"{context}\n\nUser's current question: {user_input}"
+    
     messages = [
         {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": user_input}
+        {"role": "user", "content": full_prompt}
     ]
+    
     chat_completion = client.chat.completions.create(
         messages=messages,
         model="llama-3.3-70b-versatile",
         stream=False
     )
-    return chat_completion.choices[0].message.content
+    
+    response = chat_completion.choices[0].message.content
+    
+    # Update chat history
+    if 'chat_history' not in user_data:
+        user_data['chat_history'] = []
+    user_data['chat_history'].append((user_input, response))
+    save_session(session_id, user_data)
+    
+    return response
 
-def user_onboarding(age, goals, knowledge_level):
-    return (
-        "Welcome! Based on your goals and knowledge level, we will tailor the learning experience for you.\n"
-        "Let's start learning Python, Data Science, or AI!"
-    )
+def format_learning_paths(paths):
+    """Format learning paths for display"""
+    if not paths:
+        return "No specific learning paths recommended yet. Please complete your profile."
+    
+    result = "### Recommended Learning Paths\n\n"
+    for i, path in enumerate(paths, 1):
+        result += f"**{i}. {path['title']}**\n"
+        result += f"{path['description']}\n\n"
+        result += "**Modules:**\n"
+        for module in path['modules']:
+            result += f"- {module}\n"
+        result += "\n"
+    
+    return result
+
+def format_resources(resources):
+    """Format resources for display"""
+    if not resources:
+        return "No resources recommended yet. Please complete your profile."
+    
+    result = "### Recommended Learning Resources\n\n"
+    for i, resource in enumerate(resources, 1):
+        result += f"{i}. [{resource['title']}]({resource['url']})\n"
+    
+    return result
 
-def chatbot_interface(age, goals, knowledge_level, user_message):
-    if not age or not goals or not knowledge_level:
-        return user_onboarding(age, goals, knowledge_level)
+def format_project_ideas(ideas):
+    """Format project ideas for display"""
+    if not ideas:
+        return "No project ideas recommended yet. Please complete your profile."
+    
+    result = "### Recommended Practice Projects\n\n"
+    for i, idea in enumerate(ideas, 1):
+        result += f"{i}. {idea}\n"
+    
+    return result
+
+def user_onboarding(session_id, age, goals, knowledge_level, interests, study_time, learning_style):
+    """Process user profile and provide initial recommendations"""
+    # Save user profile data
     user_data = {
-        "age": age,
-        "goals": goals,
-        "knowledge_level": knowledge_level
+        'age': age,
+        'goals': goals,
+        'knowledge_level': knowledge_level,
+        'interests': interests,
+        'study_time': study_time,
+        'learning_style': learning_style
     }
-    return chat_with_groq(user_message, user_data)
+    save_session(session_id, user_data)
+    
+    # Generate recommendations
+    learning_paths = recommend_learning_path(age, goals, knowledge_level, interests)
+    resources = get_recommended_resources(interests)
+    project_ideas = get_project_ideas(learning_paths)
+    
+    # Save recommendations to session
+    user_data.update({
+        'recommended_paths': learning_paths,
+        'recommended_resources': resources,
+        'recommended_projects': project_ideas
+    })
+    save_session(session_id, user_data)
+    
+    # Format welcome message with personalized recommendations
+    welcome_message = f"""
+    # Welcome to Your Personalized Learning Journey!
+
+    Thank you for providing your profile. Based on your information, I've prepared some tailored recommendations to start your learning journey.
+    
+    ## Your Profile Summary:
+    - **Age:** {age}
+    - **Knowledge Level:** {knowledge_level}
+    - **Learning Goals:** {goals}
+    - **Interests:** {interests}
+    - **Available Study Time:** {study_time} hours per week
+    - **Preferred Learning Style:** {learning_style}
+    
+    {format_learning_paths(learning_paths)}
+    
+    {format_resources(resources)}
+    
+    {format_project_ideas(project_ideas)}
+    
+    ## Next Steps:
+    1. Browse through the recommended learning paths and resources
+    2. Ask me any questions about the topics you're interested in
+    3. Request exercises, explanations, or code samples
+    4. Try one of the project ideas to apply your knowledge
+    
+    I'm here to help you every step of the way! What would you like to explore first?
+    """
+    
+    return welcome_message
+
+def chatbot_interface(session_id, user_message):
+    """Main chatbot interface function"""
+    user_data = load_session(session_id)
+    
+    if not user_data or not user_data.get('age'):
+        return "Please complete your profile first by going to the Profile tab."
+    
+    response = chat_with_groq(user_message, session_id)
+    return response
+
+def generate_recommendations(session_id):
+    """Generate or refresh recommendations based on current profile"""
+    user_data = load_session(session_id)
+    
+    if not user_data or not user_data.get('age'):
+        return "Please complete your profile first by going to the Profile tab."
+    
+    # Generate fresh recommendations
+    learning_paths = recommend_learning_path(
+        user_data.get('age', ''), 
+        user_data.get('goals', ''), 
+        user_data.get('knowledge_level', ''),
+        user_data.get('interests', '')
+    )
+    resources = get_recommended_resources(user_data.get('interests', ''))
+    project_ideas = get_project_ideas(learning_paths)
+    
+    # Save recommendations to session
+    user_data.update({
+        'recommended_paths': learning_paths,
+        'recommended_resources': resources,
+        'recommended_projects': project_ideas
+    })
+    save_session(session_id, user_data)
+    
+    # Format recommendations
+    recommendations = f"""
+    # Your Personalized Learning Recommendations
+    
+    {format_learning_paths(learning_paths)}
+    
+    {format_resources(resources)}
+    
+    {format_project_ideas(project_ideas)}
+    """
+    
+    return recommendations
+
+def handle_quiz_request(session_id, topic, difficulty):
+    """Handle quiz generation request"""
+    user_data = load_session(session_id)
+    
+    if not user_data or not user_data.get('age'):
+        return "Please complete your profile first by going to the Profile tab."
+    
+    quiz = generate_quiz(topic, difficulty)
+    return quiz
+
+def handle_study_plan_request(session_id, topic, time_available):
+    """Handle study plan generation request"""
+    user_data = load_session(session_id)
+    
+    if not user_data or not user_data.get('age'):
+        return "Please complete your profile first by going to the Profile tab."
+    
+    goals = user_data.get('goals', 'improving skills')
+    study_plan = create_study_plan(topic, time_available, goals)
+    return study_plan
 
 def create_chatbot():
-    with gr.Blocks(css="""
-        .gradio-container { background-color: #f0f4f8; font-family: 'Segoe UI', sans-serif; }
-        #title { font-size: 32px; font-weight: bold; text-align: center; padding-top: 20px; color: #2c3e50; }
-        #subtitle { font-size: 18px; text-align: center; margin-bottom: 20px; color: #34495e; }
-        .input-card, .output-card {
+    """Create the Gradio interface for the chatbot"""
+    # Generate a random session ID for the user
+    session_id = str(uuid.uuid4())
+    
+    # Define theme colors and styling
+    primary_color = "#4a6fa5"
+    secondary_color = "#6c757d"
+    success_color = "#28a745"
+    light_color = "#f8f9fa"
+    dark_color = "#343a40"
+    
+    custom_css = f"""
+        :root {{
+            --primary-color: {primary_color};
+            --secondary-color: {secondary_color};
+            --success-color: {success_color};
+            --light-color: {light_color};
+            --dark-color: {dark_color};
+        }}
+        .gradio-container {{ 
+            background-color: var(--light-color); 
+            font-family: 'Inter', 'Segoe UI', sans-serif; 
+        }}
+        #title {{ 
+            font-size: 32px; 
+            font-weight: bold; 
+            text-align: center; 
+            padding-top: 20px; 
+            color: var(--primary-color);
+            margin-bottom: 0;
+        }}
+        #subtitle {{ 
+            font-size: 18px; 
+            text-align: center; 
+            margin-bottom: 20px; 
+            color: var(--secondary-color); 
+        }}
+        .card {{
             background-color: white;
             padding: 20px;
             border-radius: 12px;
-            box-shadow: 0 4px 10px rgba(0,0,0,0.05);
+            box-shadow: 0 4px 10px rgba(0,0,0,0.08);
             margin-bottom: 20px;
-        }
-        .gr-button { font-size: 16px !important; padding: 10px 20px !important; }
-    """) as demo:
+        }}
+        .tabs {{
+            margin-top: 20px;
+        }}
+        .gr-button-primary {{ 
+            background-color: var(--primary-color) !important; 
+        }}
+        .gr-button-secondary {{ 
+            background-color: var(--secondary-color) !important; 
+        }}
+        .gr-button-success {{ 
+            background-color: var(--success-color) !important; 
+        }}
+        .footer {{
+            text-align: center;
+            margin-top: 30px;
+            padding: 10px;
+            font-size: 14px;
+            color: var(--secondary-color);
+        }}
+        .progress-module {{
+            padding: 10px;
+            margin: 5px 0;
+            border-radius: 5px;
+            background-color: #e9ecef;
+        }}
+        .progress-module.completed {{
+            background-color: #d4edda;
+        }}
+    """
+    
+    with gr.Blocks(css=custom_css, theme=gr.themes.Soft(primary_hue="blue")) as demo:
+        gr.HTML("<div id='title'>🎓 AI Teaching Assistant Pro</div>")
+        gr.HTML("<div id='subtitle'>Your personalized learning companion for Python, Data Science & AI</div>")
+        
+        # Tabs for different sections
+        with gr.Tabs(elem_classes=["tabs"]) as tabs:
+            # Profile Tab
+            with gr.Tab("Profile & Goals"):
+                with gr.Column(elem_classes=["card"]):
+                    gr.HTML("<h3>Complete Your Learning Profile</h3>")
+                    
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            age_input = gr.Textbox(
+                                label="Age", 
+                                placeholder="e.g. 20",
+                                lines=1
+                            )
+                        with gr.Column(scale=2):
+                            knowledge_level_input = gr.Dropdown(
+                                choices=["Beginner", "Intermediate", "Advanced", "Expert"],
+                                label="Knowledge Level",
+                                value="Beginner"
+                            )
+                    
+                    goals_input = gr.Textbox(
+                        label="Learning Goals", 
+                        placeholder="e.g. I want to become a data scientist and work with machine learning models",
+                        lines=2
+                    )
+                    
+                    interests_input = gr.Textbox(
+                        label="Specific Interests", 
+                        placeholder="e.g. Python, data visualization, neural networks",
+                        lines=2
+                    )
+                    
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            study_time_input = gr.Dropdown(
+                                choices=["1-3", "4-6", "7-10", "10+"],
+                                label="Hours Available Weekly",
+                                value="4-6"
+                            )
+                        with gr.Column(scale=2):
+                            learning_style_input = gr.Dropdown(
+                                choices=["Visual", "Reading/Writing", "Hands-on Projects", "Video Tutorials", "Interactive Exercises", "Combination"],
+                                label="Preferred Learning Style",
+                                value="Combination"
+                            )
+                    
+                    profile_submit_btn = gr.Button("Save Profile & Generate Recommendations", variant="primary")
+                    profile_output = gr.Markdown(label="Personalized Recommendations")
+            
+            # Chat Tab
+            with gr.Tab("Learning Assistant"):
+                with gr.Row():
+                    with gr.Column(elem_classes=["card"]):
+                        chat_input = gr.Textbox(
+                            label="Ask a Question",
+                            placeholder="Ask anything about Python, Data Science, AI...",
+                            lines=3
+                        )
+                        
+                        with gr.Row():
+                            chat_submit_btn = gr.Button("Send Message", variant="primary")
+                            chat_clear_btn = gr.Button("Clear Chat", variant="secondary")
+                        
+                        chat_output = gr.Markdown(label="Assistant Response")
+            
+            # Resources Tab
+            with gr.Tab("Resources & Recommendations"):
+                with gr.Column(elem_classes=["card"]):
+                    gr.HTML("<h3>Your Learning Resources</h3>")
+                    refresh_recommendations_btn = gr.Button("Refresh Recommendations", variant="primary")
+                    recommendations_output = gr.Markdown(label="Personalized Recommendations")
+            
+            # Practice Tab
+            with gr.Tab("Practice & Assessment"):
+                with gr.Column(elem_classes=["card"]):
+                    gr.HTML("<h3>Generate a Quiz</h3>")
+                    
+                    with gr.Row():
+                        quiz_topic_input = gr.Textbox(
+                            label="Quiz Topic", 
+                            placeholder="e.g. Python Lists",
+                            lines=1
+                        )
+                        quiz_difficulty_input = gr.Dropdown(
+                            choices=["Beginner", "Intermediate", "Advanced"],
+                            label="Difficulty Level",
+                            value="Beginner"
+                        )
+                    
+                    generate_quiz_btn = gr.Button("Generate Quiz", variant="primary")
+                    quiz_output = gr.Markdown(label="Quiz")
+            
+            # Study Plan Tab
+            with gr.Tab("Study Plan"):
+                with gr.Column(elem_classes=["card"]):
+                    gr.HTML("<h3>Generate a Personalized Study Plan</h3>")
+                    
+                    with gr.Row():
+                        plan_topic_input = gr.Textbox(
+                            label="Study Topic", 
+                            placeholder="e.g. Data Science",
+                            lines=1
+                        )
+                        plan_time_input = gr.Dropdown(
+                            choices=["1-3", "4-6", "7-10", "10+"],
+                            label="Hours Available Weekly",
+                            value="4-6"
+                        )
+                    
+                    generate_plan_btn = gr.Button("Generate Study Plan", variant="primary")
+                    plan_output = gr.Markdown(label="Personalized Study Plan")
+        
+        gr.HTML("""<div class="footer">
+            AI Teaching Assistant Pro | Version 2.0 | © 2025 | Powered by Groq AI
+        </div>""")
         
-        gr.HTML("<div id='title'>🎓 AI Teaching Assistant Chatbot</div>")
-        gr.HTML("<div id='subtitle'>Helping you learn Python, Data Science & AI at your pace!</div>")
-
-        with gr.Row():
-            with gr.Column(elem_classes=["input-card"]):
-                age_input = gr.Textbox(label="Age", placeholder="e.g. 20", interactive=True)
-                goals_input = gr.Textbox(label="Learning Goals", placeholder="e.g. I want to become a data analyst", interactive=True)
-                knowledge_level_input = gr.Dropdown(
-                    choices=["Beginner", "Intermediate", "Advanced"],
-                    label="Knowledge Level",
-                    interactive=True
-                )
-
-        with gr.Column(elem_classes=["input-card"]):
-            user_message_input = gr.Textbox(
-                label="Your Question or Message",
-                placeholder="Ask anything about Python, Data Science, AI...",
-                lines=5,
-                interactive=True
-            )
-
-        with gr.Column(elem_classes=["output-card"]):
-            chatbot_output = gr.Textbox(
-                label="Chatbot Response",
-                placeholder="Chatbot response will appear here.",
-                lines=12,
-                max_lines=30,
-                interactive=False
-            )
-
-        with gr.Row():
-            submit_button = gr.Button("Submit", variant="primary")
-            clear_button = gr.Button("Clear", variant="secondary")
-
-        submit_button.click(
+        # Event handlers
+        profile_submit_btn.click(
+            user_onboarding,
+            inputs=[
+                gr.State(session_id), 
+                age_input, 
+                goals_input, 
+                knowledge_level_input,
+                interests_input,
+                study_time_input,
+                learning_style_input
+            ],
+            outputs=profile_output
+        )
+        
+        chat_submit_btn.click(
             chatbot_interface,
-            inputs=[age_input, goals_input, knowledge_level_input, user_message_input],
-            outputs=chatbot_output
+            inputs=[gr.State(session_id), chat_input],
+            outputs=chat_output
         )
-
-        clear_button.click(
-            fn=lambda: ("", "", "", "", ""),
+        
+        chat_clear_btn.click(
+            lambda: "",
             inputs=[],
-            outputs=[age_input, goals_input, knowledge_level_input, user_message_input, chatbot_output]
+            outputs=[chat_output, chat_input]
         )
-
-    demo.launch()
+        
+        refresh_recommendations_btn.click(
+            generate_recommendations,
+            inputs=[gr.State(session_id)],
+            outputs=recommendations_output
+        )
+        
+        generate_quiz_btn.click(
+            handle_quiz_request,
+            inputs=[gr.State(session_id), quiz_topic_input, quiz_difficulty_input],
+            outputs=quiz_output
+        )
+        
+        generate_plan_btn.click(
+            handle_study_plan_request,
+            inputs=[gr.State(session_id), plan_topic_input, plan_time_input],
+            outputs=plan_output
+        )
+    
+    return demo
 
 # Run the chatbot
-create_chatbot()
+if __name__ == "__main__":
+    app = create_chatbot()
+    app.launch()