Update app.py

app.py

@@ -22,6 +22,88 @@ SYSTEM_PROMPT = (
     "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."
 )
+
+# 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"
+        ]
+    },
+    "generative_ai": {
+        "title": "Generative AI",
+        "description": "Learn how to build and work with generative AI systems",
+        "modules": [
+            "Generative Models Overview", 
+            "GANs & Diffusion Models", 
+            "Large Language Models", 
+            "Prompt Engineering", 
+            "Fine-tuning & RLHF"
+        ]
+    },
+    "agentic_ai": {
+        "title": "Agentic AI Systems",
+        "description": "Explore AI systems that can act autonomously",
+        "modules": [
+            "Foundations of AI Agents", 
+            "Planning & Decision Making", 
+            "Tool-using AI Systems", 
+            "Multi-agent Architectures", 
+            "Human-AI Collaboration"
+        ]
+    }
+}
+
 # Learning resources
 LEARNING_RESOURCES = {
     "python_beginner": [
@@ -67,6 +149,7 @@ LEARNING_RESOURCES = {
         {"title": "Berkeley CS285: Deep Reinforcement Learning", "url": "https://rail.eecs.berkeley.edu/deeprlcourse/"}
     ]
 }
+
 # Practice project ideas
 PROJECT_IDEAS = {
     "python_beginner": [
@@ -119,6 +202,7 @@ PROJECT_IDEAS = {
         "Autonomous Data Analysis System"
     ]
 }
+
 # User session data store
 SESSION_DATA = {}
 
@@ -146,13 +230,31 @@ def recommend_learning_path(age, goals, knowledge_level, interests):
             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():
+    elif "intermediate" 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")
+        if any(topic in interests.lower() for topic in ["generative", "gpt", "llm", "diffusion"]):
+            paths.append("generative_ai")
+    elif "advanced" in knowledge_level.lower() or "expert" in knowledge_level.lower():
+        if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
+            paths.append("ai_specialization")
+        if any(topic in interests.lower() for topic in ["generative", "gpt", "llm", "diffusion"]):
+            paths.append("generative_ai")
+        if any(topic in interests.lower() for topic in ["agent", "autonomous", "planning"]):
+            paths.append("agentic_ai")
+    
+    # Check for specific mentions of generative or agentic AI regardless of level
+    if any(topic in interests.lower() for topic in ["generative", "gpt", "llm", "diffusion"]):
+        if "generative_ai" not in paths:
+            paths.append("generative_ai")
+            
+    if any(topic in interests.lower() for topic in ["agent", "autonomous", "planning"]):
+        if "agentic_ai" not in paths:
+            paths.append("agentic_ai")
     
     # Default path if no matches
     if not paths:
@@ -160,42 +262,76 @@ def recommend_learning_path(age, goals, knowledge_level, interests):
     
     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"""
+def get_recommended_resources(interests, knowledge_level, recommended_paths):
+    """Get recommended learning resources based on interests and recommended paths"""
     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
+    # Get path IDs from recommended paths
+    path_ids = []
+    for path in recommended_paths:
+        path_id = next((k for k, v in LEARNING_PATHS.items() if v["title"] == path["title"]), None)
+        if path_id:
+            path_ids.append(path_id)
+    
+    # Add resources for each recommended path
+    for path_id in path_ids:
+        if path_id in LEARNING_RESOURCES:
+            resources.extend(LEARNING_RESOURCES[path_id])
+    
+    # If no specific paths match, provide resources based on interests and level
+    if not resources:
+        if "beginner" in knowledge_level.lower():
+            if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
+                resources.extend(LEARNING_RESOURCES["python_beginner"])
+            if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
+                resources.extend(LEARNING_RESOURCES["data_science_beginner"])
+        elif "intermediate" in knowledge_level.lower():
+            if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
+                resources.extend(LEARNING_RESOURCES["python_intermediate"])
+            if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
+                resources.extend(LEARNING_RESOURCES["data_science_advanced"])
+        elif "advanced" in knowledge_level.lower() or "expert" in knowledge_level.lower():
+            if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
+                resources.extend(LEARNING_RESOURCES["ai_specialization"])
+    
+    # If still no resources, provide general resources
+    if not resources:
+        for category in ["python_beginner", "data_science_beginner"]:
+            resources.extend(LEARNING_RESOURCES[category][:2])
+    
+    # Remove duplicates while preserving order
+    unique_resources = []
+    seen_titles = set()
+    for resource in resources:
+        if resource["title"] not in seen_titles:
+            seen_titles.add(resource["title"])
+            unique_resources.append(resource)
+    
+    return unique_resources
 
-def get_project_ideas(learning_paths):
+def get_project_ideas(recommended_paths):
     """Get project ideas based on recommended learning paths"""
     ideas = []
-    for path in learning_paths:
+    
+    # Get project ideas for each recommended path
+    for path in recommended_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 path_id and path_id in PROJECT_IDEAS:
+            ideas.extend(PROJECT_IDEAS[path_id])
     
     # If no specific paths match, provide some general project ideas
     if not ideas:
-        ideas = PROJECT_IDEAS["python_beginner"][:2] + PROJECT_IDEAS["data_science"][:2]
+        ideas = PROJECT_IDEAS["python_beginner"][:2] + PROJECT_IDEAS["data_science_beginner"][:2]
+    
+    # Remove duplicates while preserving order
+    unique_ideas = []
+    seen_ideas = set()
+    for idea in ideas:
+        if idea not in seen_ideas:
+            seen_ideas.add(idea)
+            unique_ideas.append(idea)
     
-    return ideas[:5]  # Return up to 5 project ideas
+    return unique_ideas[:5]  # Return up to 5 project ideas
 
 def generate_quiz(topic, difficulty):
     """Generate a quiz based on the topic and difficulty"""
@@ -221,11 +357,12 @@ def generate_quiz(topic, difficulty):
     
     return quiz_response.choices[0].message.content
 
-def create_study_plan(topic, time_available, goals):
+def create_study_plan(topic, time_available, goals, knowledge_level):
     """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}
+    The learner's knowledge level is: {knowledge_level}
     
     Include:
     1. Weekly breakdown of topics
@@ -233,6 +370,8 @@ def create_study_plan(topic, time_available, goals):
     3. Recommended resources for each week
     4. Milestone projects or assessments
     5. Tips for effective learning
+    
+    Make this plan specific, actionable, and tailored to the knowledge level.
     """
     
     # Use Groq to generate the study plan
@@ -353,7 +492,7 @@ def user_onboarding(session_id, age, goals, knowledge_level, interests, study_ti
     
     # Generate recommendations
     learning_paths = recommend_learning_path(age, goals, knowledge_level, interests)
-    resources = get_recommended_resources(interests)
+    resources = get_recommended_resources(interests, knowledge_level, learning_paths)
     project_ideas = get_project_ideas(learning_paths)
     
     # Save recommendations to session
@@ -419,7 +558,11 @@ def generate_recommendations(session_id):
         user_data.get('knowledge_level', ''),
         user_data.get('interests', '')
     )
-    resources = get_recommended_resources(user_data.get('interests', ''))
+    resources = get_recommended_resources(
+        user_data.get('interests', ''),
+        user_data.get('knowledge_level', ''),
+        learning_paths
+    )
     project_ideas = get_project_ideas(learning_paths)
     
     # Save recommendations to session
@@ -461,9 +604,60 @@ def handle_study_plan_request(session_id, topic, time_available):
         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)
+    knowledge_level = user_data.get('knowledge_level', 'Beginner')
+    study_plan = create_study_plan(topic, time_available, goals, knowledge_level)
+    
+    # Save the generated study plan to the session
+    if 'study_plans' not in user_data:
+        user_data['study_plans'] = {}
+    
+    study_plan_id = f"{topic}_{time_available}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    user_data['study_plans'][study_plan_id] = {
+        'topic': topic,
+        'time_available': time_available,
+        'plan': study_plan,
+        'created_at': datetime.now().isoformat()
+    }
+    save_session(session_id, user_data)
+    
     return study_plan
 
+def add_generative_ai_info():
+    """Return information about Generative AI"""
+    return """
+    ## What is Generative AI?
+    
+    Generative AI refers to artificial intelligence systems that can create new content, such as text, images, code, audio, video, or 3D models. Unlike traditional AI systems that are designed to recognize patterns or make predictions, generative AI creates original outputs based on the patterns it has learned during training.
+    
+    ### Key Concepts in Generative AI:
+    
+    - **Large Language Models (LLMs)**: Text generation systems like GPT-4, LLaMA, Claude, etc.
+    - **Diffusion Models**: For image generation (DALL-E, Midjourney, Stable Diffusion)
+    - **Prompt Engineering**: The art of crafting inputs to get desired outputs
+    - **Fine-tuning**: Adapting pre-trained models for specific domains or tasks
+    - **RLHF (Reinforcement Learning from Human Feedback)**: Method for aligning AI with human preferences
+    
+    Learning generative AI involves understanding these foundation models, how they work, and how to effectively use and customize them for various applications.
+    """
+
+def add_agentic_ai_info():
+    """Return information about Agentic AI"""
+    return """
+    ## What is Agentic AI?
+    
+    Agentic AI refers to AI systems that can act autonomously to achieve specified goals. Unlike passive AI systems that respond only when prompted, agentic AI can take initiative, make decisions, use tools, and perform sequences of actions to accomplish tasks.
+    
+    ### Key Concepts in Agentic AI:
+    
+    - **Planning & Decision Making**: AI systems that can formulate and execute plans
+    - **Tool Use**: AI that can leverage external tools and APIs
+    - **Autonomous Execution**: Systems that can work without constant human supervision
+    - **Multi-agent Systems**: Multiple AI agents collaborating or competing
+    - **Memory & Context Management**: How agents maintain state across interactions
+    
+    Agentic AI represents an evolution from AI as a passive tool to AI as an active collaborator that can work independently while remaining aligned with human goals and values.
+    """
+
 def create_chatbot():
     """Create the Gradio interface for the chatbot"""
     # Generate a random session ID for the user
@@ -537,6 +731,13 @@ def create_chatbot():
         .progress-module.completed {{
             background-color: #d4edda;
         }}
+        .info-box {{
+            background-color: #e7f5fe;
+            border-left: 4px solid var(--primary-color);
+            padding: 15px;
+            margin: 15px 0;
+            border-radius: 4px;
+        }}
     """
     
     with gr.Blocks(css=custom_css, theme=gr.themes.Soft(primary_hue="blue")) as demo: