Create app.py

app.py

@@ -0,0 +1,745 @@
+import pandas as pd
+import numpy as np
+import json
+from typing import Dict, List, Optional, Union, Any
+import os
+import requests
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.tree import Tree
+from rich import box
+import time
+from tqdm import tqdm
+import openai
+import gradio as gr
+from huggingface_hub import HfApi, HfFolder
+
+# Load environment variables from .env file
+load_dotenv()
+
+class CourseRecommender:
+    def __init__(self, dataframe: pd.DataFrame):
+        """
+        Initialize the course recommender with course data
+        """
+        self.courses = dataframe.drop(columns=['Unnamed: 1', 'Unnamed: 5'], errors='ignore')
+        self._preprocess_data()
+        self.console = Console()
+
+        # Initialize OpenAI client
+        api_key = os.getenv("OPENAI_API_KEY")
+        if api_key:
+            self.openai_client = openai.OpenAI(api_key=api_key)
+            self.ai_enabled = True
+        else:
+            self.console.print("[yellow]Warning: OpenAI API key not found. AI-enhanced features will be disabled.[/yellow]")
+            self.ai_enabled = False
+
+    def _preprocess_data(self):
+        """
+        Preprocess the course data for better recommendations
+        """
+        text_columns = ['Course Name', 'Description', 'Skills', 'Difficulty Level']
+        for col in text_columns:
+            if col in self.courses.columns:
+                self.courses[col] = self.courses[col].astype(str).str.lower()
+
+        self.courses['Course Rating'] = pd.to_numeric(self.courses['Course Rating'], errors='coerce').fillna(0)
+        self.courses['keyword_match_score'] = 0
+
+        # Add course ID for easy reference
+        self.courses['Course ID'] = range(1, len(self.courses) + 1)
+
+    def recommend_courses(self, topic: Optional[str] = None, skill_level: Optional[str] = None,
+                          top_n: int = 5, personalized: bool = False, user_goals: Optional[str] = None) -> pd.DataFrame:
+        """
+        Recommend courses based on topic, skill level, and optional user goals
+
+        Parameters:
+        - topic: Subject area of interest
+        - skill_level: User's current proficiency level
+        - top_n: Number of recommendations to return
+        - personalized: Whether to use AI for personalized recommendations
+        - user_goals: Specific learning objectives or career goals
+        """
+        filtered_courses = self.courses.copy()
+
+        # Show processing indicator
+        with self.console.status("[bold green]Finding the best courses for you...", spinner="dots"):
+            time.sleep(1)  # Simulate processing time
+
+            if topic:
+                topic = topic.lower()
+                filtered_courses['keyword_match_score'] = (
+                    filtered_courses['Course Name'].str.contains(topic).astype(int) * 3 +
+                    filtered_courses['Description'].str.contains(topic).astype(int) * 2 +
+                    filtered_courses['Skills'].str.contains(topic).astype(int)
+                )
+                filtered_courses = filtered_courses[filtered_courses['keyword_match_score'] > 0]
+
+            if skill_level:
+                skill_level = skill_level.lower()
+                difficulty_map = {
+                    'beginner': ['beginner', 'intro', 'basic', 'level 1', 'fundamentals'],
+                    'intermediate': ['intermediate', 'mid-level', 'level 2', 'advanced beginner'],
+                    'advanced': ['advanced', 'expert', 'professional', 'level 3', 'master']
+                }
+                filtered_courses = filtered_courses[
+                    filtered_courses['Difficulty Level'].apply(
+                        lambda x: any(diff in str(x) for diff in difficulty_map.get(skill_level, [skill_level]))
+                    )
+                ]
+
+            if personalized and user_goals and self.ai_enabled:
+                # Use AI to enhance recommendation scores based on user goals
+                for idx, course in filtered_courses.iterrows():
+                    relevance_score = self._get_ai_relevance_score(course, topic, user_goals)
+                    filtered_courses.at[idx, 'ai_relevance_score'] = relevance_score
+            else:
+                filtered_courses['ai_relevance_score'] = 0
+
+            if not filtered_courses.empty:
+                filtered_courses['recommendation_score'] = (
+                    filtered_courses['Course Rating'] * 0.4 +
+                    filtered_courses['keyword_match_score'] * 0.3 +
+                    filtered_courses['ai_relevance_score'] * 0.2 +
+                    np.random.rand(len(filtered_courses)) * 0.1
+                )
+                filtered_courses = filtered_courses.sort_values('recommendation_score', ascending=False)
+
+        return filtered_courses.head(top_n)
+
+    def _get_ai_relevance_score(self, course: pd.Series, topic: str, user_goals: str) -> float:
+        """
+        Use AI to determine how relevant a course is to user's specific goals
+        """
+        try:
+            prompt = f"""
+            Rate how relevant this course is to a learner with these goals on a scale of 0-10:
+
+            Topic of interest: {topic}
+            User's learning goals: {user_goals}
+
+            Course details:
+            - Name: {course['Course Name']}
+            - Description: {course['Description']}
+            - Skills taught: {course['Skills']}
+            - Difficulty: {course['Difficulty Level']}
+
+            Return only a number from 0-10.
+            """
+
+            response = self.openai_client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": "You are an educational advisor helping match courses to learner goals."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=10,
+                temperature=0.3
+            )
+
+            try:
+                score = float(response.choices[0].message.content.strip())
+                return min(max(score, 0), 10) / 10  # Normalize to 0-1 range
+            except ValueError:
+                return 0.5  # Default value if parsing fails
+
+        except Exception as e:
+            self.console.print(f"[red]Error getting AI relevance score: {e}[/red]")
+            return 0.5
+
+    def generate_roadmap(self, topic: str, skill_level: Optional[str] = None,
+                         user_goals: Optional[str] = None, detailed: bool = False) -> Dict:
+        """
+        Generate a personalized learning roadmap based on the topic and user goals
+
+        Parameters:
+        - topic: Subject area of interest
+        - skill_level: User's current proficiency level
+        - user_goals: Specific learning objectives or career goals
+        - detailed: Whether to generate a more detailed roadmap with AI
+        """
+        self.console.print(Panel(f"[bold cyan]Generating your personalized learning roadmap for [green]{topic}[/green]...[/bold cyan]"))
+
+        # Display a progress bar for visual effect
+        for _ in tqdm(range(5), desc="Processing roadmap data"):
+            time.sleep(0.3)
+
+        if detailed and self.ai_enabled and user_goals:
+            roadmap = self._generate_ai_roadmap(topic, skill_level, user_goals)
+        else:
+            # Fallback to static roadmap if AI is not available
+            roadmap = self._generate_default_roadmap(topic)
+
+        return roadmap
+
+    def _generate_ai_roadmap(self, topic: str, skill_level: str, user_goals: str) -> Dict:
+        """
+        Use AI to generate a personalized and detailed learning roadmap with improved structure
+        """
+        try:
+            # Enhanced prompt with more specific structure and guidance
+            prompt = f"""
+            Create a comprehensive learning roadmap for someone wanting to master {topic}.
+
+            Learner information:
+            - Current skill level: {skill_level}
+            - Learning goals: {user_goals}
+
+            The roadmap should be detailed, actionable, and specifically tailored to the learner's
+            skill level and goals. Provide a clear progression path that breaks down the journey 
+            into logical stages with specific concepts to learn at each stage.
+
+            Format the response as a JSON object with exactly this structure:
+            {{
+                "learningPath": [
+                    {{
+                        "step": "Step name (be specific)",
+                        "difficulty": "Beginner/Intermediate/Advanced",
+                        "description": "Detailed description of this learning stage (2-3 sentences)",
+                        "time_estimate": "Estimated completion time (weeks/months)",
+                        "key_concepts": ["Specific concept 1", "Specific concept 2", "Specific concept 3"],
+                        "milestones": ["Practical milestone 1", "Practical milestone 2"],
+                        "practice_activities": ["Activity 1", "Activity 2"]
+                    }},
+                    // 3-5 steps total, progressing from fundamentals to mastery
+                ],
+                "projectSuggestions": [
+                    {{
+                        "name": "Project name (be specific to {topic})",
+                        "description": "Detailed project description (2-3 sentences)",
+                        "complexity": "Low/Medium/High",
+                        "skills_practiced": ["Skill 1", "Skill 2", "Skill 3"],
+                        "resources": ["Specific resource 1", "Specific resource 2"],
+                        "estimated_time": "Project completion time estimate"
+                    }},
+                    // 3-4 projects of increasing complexity
+                ],
+                "resources": {{
+                    "books": ["Specific book title 1", "Specific book title 2", "Specific book title 3"],
+                    "online_courses": ["Specific course 1", "Specific course 2"],
+                    "communities": ["Specific community 1", "Specific community 2"],
+                    "tools": ["Specific tool 1", "Specific tool 2", "Specific tool 3"],
+                    "practice_platforms": ["Specific platform 1", "Specific platform 2"]
+                }},
+                "career_insights": [
+                    "Specific insight about {topic} career opportunities",
+                    "Skill demand information",
+                    "Industry application of {topic} skills"
+                ]
+            }}
+
+            Ensure all content is specific to {topic} (not generic) and appropriate for a {skill_level} 
+            with these goals: {user_goals}. Focus on practical, actionable advice.
+            """
+
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o",  # Using more capable model for better roadmaps
+                messages=[
+                    {"role": "system", "content": "You are an expert educational curriculum designer with deep knowledge across technical and non-technical subjects. You create detailed, actionable learning plans that are practical and tailored to individual needs."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=2500,
+                temperature=0.5,
+                response_format={"type": "json_object"}  # Enforce JSON response
+            )
+
+            try:
+                roadmap_text = response.choices[0].message.content
+                roadmap = json.loads(roadmap_text)
+                return roadmap
+            except json.JSONDecodeError as e:
+                self.console.print(f"[yellow]Warning: Could not parse AI response as JSON: {e}. Using default roadmap.[/yellow]")
+                return self._generate_default_roadmap(topic)
+
+        except Exception as e:
+            self.console.print(f"[red]Error generating AI roadmap: {e}[/red]")
+            return self._generate_default_roadmap(topic)
+
+    def _generate_default_roadmap(self, topic: str) -> Dict:
+        """
+        Generate a default roadmap when AI generation fails or is not available
+        """
+        return {
+            "learningPath": [
+                {
+                    "step": f"Foundations of {topic}",
+                    "difficulty": "Beginner",
+                    "description": f"Build core knowledge and fundamental skills in {topic}. Focus on understanding basic principles and becoming familiar with essential tools.",
+                    "time_estimate": "4-6 weeks",
+                    "key_concepts": [f"{topic} basics", "Core principles", "Fundamental tools and techniques"],
+                    "milestones": [f"Complete first {topic} exercise", f"Build simple {topic} project"],
+                    "practice_activities": [f"Daily {topic} exercises", "Follow beginner tutorials"]
+                },
+                {
+                    "step": f"{topic} Skill Development",
+                    "difficulty": "Intermediate",
+                    "description": f"Deepen understanding of {topic} and apply more advanced concepts. Focus on building practical skills through hands-on projects and implementation.",
+                    "time_estimate": "8-12 weeks",
+                    "key_concepts": [f"Advanced {topic} techniques", "Applied projects", "Specialized tools"],
+                    "milestones": [f"Complete medium complexity {topic} project", "Solve real-world problems"],
+                    "practice_activities": ["Implement sample projects", "Participate in forums/discussions"]
+                },
+                {
+                    "step": f"{topic} Mastery & Specialization",
+                    "difficulty": "Advanced",
+                    "description": f"Develop expert-level skills in {topic} with focus on real-world application. Specialize in specific areas and build a professional portfolio.",
+                    "time_estimate": "12-16 weeks",
+                    "key_concepts": ["Industry best practices", "Complex problem-solving", "Portfolio development"],
+                    "milestones": ["Create capstone project", "Contribute to community"],
+                    "practice_activities": ["Build complex projects", "Mentor beginners"]
+                }
+            ],
+            "projectSuggestions": [
+                {
+                    "name": f"Beginner Project: {topic} Fundamentals Application",
+                    "description": f"Apply basic {topic} concepts in a simple project to practice fundamentals and gain confidence.",
+                    "complexity": "Low",
+                    "skills_practiced": [f"Basic {topic} principles", "Problem-solving", "Tool familiarity"],
+                    "resources": ["Online tutorials", "Documentation", "Starter templates"],
+                    "estimated_time": "1-2 weeks"
+                },
+                {
+                    "name": f"Intermediate Project: Interactive {topic} Application",
+                    "description": f"Create a more complex application using intermediate {topic} skills with greater functionality and sophistication.",
+                    "complexity": "Medium",
+                    "skills_practiced": [f"Intermediate {topic} techniques", "Code organization", "Testing"],
+                    "resources": ["GitHub repositories", "Online coding platforms", "Community forums"],
+                    "estimated_time": "3-4 weeks"
+                },
+                {
+                    "name": f"Capstone Project: Advanced {topic} Implementation",
+                    "description": f"Apply all learned skills in a comprehensive {topic} project that showcases mastery and solves a real-world problem.",
+                    "complexity": "High",
+                    "skills_practiced": [f"Advanced {topic} mastery", "System design", "Optimization"],
+                    "resources": ["Industry case studies", "Research papers", "Expert communities"],
+                    "estimated_time": "6-8 weeks"
+                }
+            ],
+            "resources": {
+                "books": [f"Introduction to {topic}", f"Advanced {topic} Techniques", f"Mastering {topic}"],
+                "online_courses": [f"{topic} for Beginners", f"Professional {topic} Masterclass"],
+                "communities": ["Stack Overflow", "Reddit", f"{topic} Discord Servers"],
+                "tools": [f"{topic} Development Environment", "Version Control", "Testing Frameworks"],
+                "practice_platforms": ["Codecademy", "Exercism", "LeetCode"]
+            },
+            "career_insights": [
+                f"Proficiency in {topic} is valuable for roles in software development, data science, and IT operations",
+                f"Entry-level {topic} positions typically require demonstrated project experience",
+                f"{topic} specialists can pursue careers in consulting, education, or product development"
+            ]
+        }
+
+    def get_course_details(self, course: pd.Series) -> Dict[str, str]:
+        """
+        Get detailed course information
+        """
+        return {
+            "name": course.get('Course Name', 'N/A'),
+            "difficulty": course.get('Difficulty Level', 'N/A'),
+            "rating": str(course.get('Course Rating', 'N/A')),
+            "url": course.get('Course URL', '#'),
+            "skills": course.get('Skills', 'N/A'),
+            "description": course.get('Description', 'No description available'),
+            "id": str(course.get('Course ID', '0'))
+        }
+
+    def display_roadmap(self, roadmap: Dict):
+        """
+        Display the learning roadmap in a beautiful format using rich
+        """
+        self.console.print("\n")
+        self.console.print(Panel("[bold cyan]YOUR PERSONALIZED LEARNING JOURNEY[/bold cyan]",
+                               box=box.DOUBLE, expand=False))
+
+        # Create a tree for learning path
+        learning_tree = Tree("[bold yellow]Learning Path[/bold yellow]")
+        for stage in roadmap["learningPath"]:
+            stage_node = learning_tree.add(f"[bold green]{stage['step']}[/bold green] ({stage['difficulty']}) - {stage['time_estimate']}")
+            stage_node.add(f"[italic]{stage['description']}[/italic]")
+
+            concepts_node = stage_node.add("[bold blue]Key Concepts:[/bold blue]")
+            for concept in stage.get("key_concepts", []):
+                concepts_node.add(concept)
+
+            if "milestones" in stage:
+                milestones_node = stage_node.add("[bold magenta]Milestones:[/bold magenta]")
+                for milestone in stage["milestones"]:
+                    milestones_node.add(milestone)
+                    
+            if "practice_activities" in stage:
+                activities_node = stage_node.add("[bold cyan]Practice Activities:[/bold cyan]")
+                for activity in stage["practice_activities"]:
+                    activities_node.add(activity)
+
+        self.console.print(learning_tree)
+        self.console.print("\n")
+
+        # Project suggestions table
+        project_table = Table(title="Recommended Projects", box=box.ROUNDED)
+        project_table.add_column("Project Name", style="cyan", no_wrap=True)
+        project_table.add_column("Description", style="white")
+        project_table.add_column("Complexity", style="magenta")
+        project_table.add_column("Est. Time", style="yellow")
+
+        for project in roadmap["projectSuggestions"]:
+            project_table.add_row(
+                project["name"],
+                project["description"],
+                project["complexity"],
+                project.get("estimated_time", "N/A")
+            )
+
+        self.console.print(project_table)
+        self.console.print("\n")
+
+        # Resources panel
+        resources = roadmap.get("resources", {})
+        resources_text = ""
+
+        resource_categories = {
+            "books": "Recommended Books",
+            "online_courses": "Online Courses",
+            "communities": "Communities",
+            "tools": "Essential Tools",
+            "practice_platforms": "Practice Platforms"
+        }
+        
+        for category, title in resource_categories.items():
+            if category in resources and resources[category]:
+                resources_text += f"[bold yellow]{title}:[/bold yellow]\n"
+                for item in resources[category]:
+                    resources_text += f"• {item}\n"
+                resources_text += "\n"
+
+        self.console.print(Panel(resources_text, title="[bold cyan]Learning Resources[/bold cyan]",
+                               box=box.ROUNDED, expand=False))
+                               
+        # Career insights
+        if "career_insights" in roadmap and roadmap["career_insights"]:
+            career_text = "[bold yellow]Career Insights:[/bold yellow]\n"
+            for insight in roadmap["career_insights"]:
+                career_text += f"• {insight}\n"
+                
+            self.console.print(Panel(career_text, title="[bold cyan]Career Opportunities[/bold cyan]",
+                               box=box.ROUNDED, expand=False))
+
+    def display_recommended_courses(self, courses: pd.DataFrame):
+        """
+        Display recommended courses in a beautiful format
+        """
+        if courses.empty:
+            self.console.print("[yellow]No courses match your criteria. Try broader search terms.[/yellow]")
+            return
+
+        table = Table(title="Recommended Courses", box=box.ROUNDED)
+        table.add_column("ID", style="dim")
+        table.add_column("Course Name", style="cyan")
+        table.add_column("Rating", style="yellow")
+        table.add_column("Difficulty", style="green")
+
+        for _, course in courses.iterrows():
+            table.add_row(
+                str(course.get('Course ID', 'N/A')),
+                course.get('Course Name', 'N/A').title(),
+                f"{course.get('Course Rating', 0):.1f} ★",
+                course.get('Difficulty Level', 'N/A').title()
+            )
+
+        self.console.print(table)
+        self.console.print("\n[dim]Use the course ID to get more details about a specific course.[/dim]")
+        
+    def roadmap_to_markdown(self, roadmap: Dict, topic: str, skill_level: str) -> str:
+        """
+        Convert a roadmap to markdown format for export or display
+        """
+        markdown = f"# Personalized Learning Roadmap: {topic.title()}\n\n"
+        markdown += f"*Skill Level: {skill_level.title()}*\n\n"
+        
+        # Learning Path
+        markdown += "## Learning Path\n\n"
+        for i, stage in enumerate(roadmap["learningPath"]):
+            markdown += f"### {i+1}. {stage['step']} ({stage['difficulty']}) - {stage['time_estimate']}\n\n"
+            markdown += f"{stage['description']}\n\n"
+            
+            markdown += "**Key Concepts:**\n"
+            for concept in stage.get("key_concepts", []):
+                markdown += f"- {concept}\n"
+            markdown += "\n"
+            
+            if "milestones" in stage:
+                markdown += "**Milestones:**\n"
+                for milestone in stage["milestones"]:
+                    markdown += f"- {milestone}\n"
+                markdown += "\n"
+                
+            if "practice_activities" in stage:
+                markdown += "**Practice Activities:**\n"
+                for activity in stage["practice_activities"]:
+                    markdown += f"- {activity}\n"
+                markdown += "\n"
+        
+        # Project Suggestions
+        markdown += "## Recommended Projects\n\n"
+        for i, project in enumerate(roadmap["projectSuggestions"]):
+            markdown += f"### {i+1}. {project['name']} ({project['complexity']})\n\n"
+            markdown += f"{project['description']}\n\n"
+            
+            if "skills_practiced" in project:
+                markdown += "**Skills Practiced:**\n"
+                for skill in project["skills_practiced"]:
+                    markdown += f"- {skill}\n"
+                markdown += "\n"
+                
+            markdown += "**Resources:**\n"
+            for resource in project.get("resources", []):
+                markdown += f"- {resource}\n"
+            markdown += "\n"
+            
+            if "estimated_time" in project:
+                markdown += f"**Estimated Time:** {project['estimated_time']}\n\n"
+        
+        # Resources
+        markdown += "## Learning Resources\n\n"
+        resources = roadmap.get("resources", {})
+        
+        resource_categories = {
+            "books": "Recommended Books",
+            "online_courses": "Online Courses",
+            "communities": "Communities",
+            "tools": "Essential Tools",
+            "practice_platforms": "Practice Platforms"
+        }
+        
+        for category, title in resource_categories.items():
+            if category in resources and resources[category]:
+                markdown += f"### {title}\n"
+                for item in resources[category]:
+                    markdown += f"- {item}\n"
+                markdown += "\n"
+        
+        # Career Insights
+        if "career_insights" in roadmap and roadmap["career_insights"]:
+            markdown += "## Career Opportunities\n\n"
+            for insight in roadmap["career_insights"]:
+                markdown += f"- {insight}\n"
+                
+        return markdown
+
+def load_courses(file_path: str = 'Coursera.csv') -> CourseRecommender:
+    """
+    Load courses from CSV and create a CourseRecommender instance
+    """
+    console = Console()
+
+    try:
+        with console.status("[bold green]Loading course data...", spinner="dots"):
+            df = pd.read_csv(file_path)
+            time.sleep(1)  # Simulate loading time for visual effect
+            console.print(f"[green]Successfully loaded {len(df)} courses![/green]")
+        return CourseRecommender(df)
+    except FileNotFoundError:
+        console.print(f"[red]Error: {file_path} file not found.[/red]")
+        return None
+    except Exception as e:
+        console.print(f"[red]An error occurred while reading the CSV: {e}[/red]")
+        return None
+
+def main():
+    console = Console()
+
+    # Print welcome message
+    console.print(Panel.fit(
+        "[bold cyan]Course Recommender & Learning Roadmap Generator[/bold cyan]\n"
+        "[yellow]Find the perfect courses and create your personalized learning journey[/yellow]",
+        box=box.DOUBLE))
+
+    recommender = load_courses()
+    if recommender:
+        console.print("[bold]Let's find the perfect learning path for you![/bold]\n")
+
+        topic = console.input("[bold green]Enter the topic you want to learn about: [/bold green]")
+        skill_level = console.input("[bold green]Enter your skill level (Beginner, Intermediate, Advanced): [/bold green]")
+
+        use_ai = False
+        user_goals = None
+
+        if recommender.ai_enabled:
+            use_ai = console.input("[bold green]Would you like AI-enhanced personalized recommendations? (y/n): [/bold green]").lower() == 'y'
+            if use_ai:
+                user_goals = console.input("[bold green]What are your learning goals or career objectives with this topic? [/bold green]")
+
+        # Generate and display roadmap
+        roadmap = recommender.generate_roadmap(topic, skill_level, user_goals, detailed=use_ai)
+        recommender.display_roadmap(roadmap)
+        
+        # Option to export roadmap
+        export = console.input("\n[bold green]Would you like to export this roadmap to a markdown file? (y/n): [/bold green]").lower() == 'y'
+        if export:
+            markdown = recommender.roadmap_to_markdown(roadmap, topic, skill_level)
+            filename = f"{topic.lower().replace(' ', '_')}_roadmap.md"
+            with open(filename, "w") as f:
+                f.write(markdown)
+            console.print(f"[green]Roadmap exported to {filename}[/green]")
+
+        console.print("\n[bold]Press Enter to see recommended courses...[/bold]")
+        input()
+
+        # Get and display recommended courses
+        recommended_courses = recommender.recommend_courses(topic, skill_level, personalized=use_ai, user_goals=user_goals)
+        recommender.display_recommended_courses(recommended_courses)
+
+        # Allow user to view detailed course info
+        while True:
+            course_id = console.input("\n[bold green]Enter a course ID for more details (or 'q' to quit): [/bold green]")
+            if course_id.lower() == 'q':
+                break
+
+            try:
+                course_id = int(course_id)
+                course = recommended_courses[recommended_courses['Course ID'] == course_id]
+                if not course.empty:
+                    details = recommender.get_course_details(course.iloc[0])
+
+                    console.print(Panel(
+                        f"[bold cyan]{details['name'].title()}[/bold cyan]\n\n"
+                        f"[yellow]Rating:[/yellow] {details['rating']} ★\n"
+                        f"[yellow]Difficulty:[/yellow] {details['difficulty'].title()}\n\n"
+                        f"[yellow]Skills:[/yellow] {details['skills'].title()}\n\n"
+                        f"[yellow]Description:[/yellow]\n{details['description']}\n\n"
+                        f"[link={details['url']}]View Course[/link]",
+                        title="Course Details", box=box.ROUNDED, width=100
+                    ))
+                else:
+                    console.print("[yellow]Course ID not found. Please try again.[/yellow]")
+            except ValueError:
+                console.print("[yellow]Please enter a valid course ID.[/yellow]")
+
+    console.print(Panel("[bold cyan]Thank you for using the Course Recommender![/bold cyan]", box=box.ROUNDED))
+
+# Gradio interface for Hugging Face deployment
+def create_gradio_interface(recommender: CourseRecommender):
+    """
+    Create a Gradio interface for the course recommender
+    """
+    def recommend_and_generate(topic, skill_level, goals, use_ai):
+        try:
+            # Generate roadmap
+            roadmap = recommender.generate_roadmap(
+                topic=topic, 
+                skill_level=skill_level, 
+                user_goals=goals if goals else None, 
+                detailed=use_ai
+            )
+            
+            # Get course recommendations
+            recommended_courses = recommender.recommend_courses(
+                topic=topic, 
+                skill_level=skill_level, 
+                personalized=use_ai, 
+                user_goals=goals if goals else None
+            )
+            
+            # Convert roadmap to markdown
+            roadmap_md = recommender.roadmap_to_markdown(roadmap, topic, skill_level)
+            
+            # Format course recommendations as markdown
+            courses_md = "# Recommended Courses\n\n"
+            for i, (_, course) in enumerate(recommended_courses.iterrows()):
+                courses_md += f"## {i+1}. {course.get('Course Name', 'N/A').title()}\n\n"
+                courses_md += f"**Rating:** {course.get('Course Rating', 0):.1f} ★\n\n"
+                courses_md += f"**Difficulty:** {course.get('Difficulty Level', 'N/A').title()}\n\n"
+                courses_md += f"**Skills:** {course.get('Skills', 'N/A').title()}\n\n"
+                courses_md += f"**Description:**\n{course.get('Description', 'No description available')}\n\n"
+                if 'Course URL' in course and course['Course URL'] != '#':
+                    courses_md += f"[View Course]({course['Course URL']})\n\n"
+                courses_md += "---\n\n"
+            
+            return roadmap_md, courses_md
+        except Exception as e:
+            return f"Error: {str(e)}", "Could not generate course recommendations"
+    
+    with gr.Blocks(title="Learning Roadmap Generator") as demo:
+        gr.Markdown("# 🎓 Learning Roadmap & Course Recommender")
+        gr.Markdown("Generate a personalized learning roadmap and course recommendations.")
+        
+        with gr.Row():
+            with gr.Column():
+                topic_input = gr.Textbox(label="Topic you want to learn", placeholder="e.g. Python, Data Science, Machine Learning")
+                skill_level = gr.Dropdown(
+                    ["Beginner", "Intermediate", "Advanced"], 
+                    label="Your current skill level"
+                )
+                goals_input = gr.Textbox(
+                    label="Your learning goals (optional)", 
+                    placeholder="e.g. Career change, specific project, skill enhancement",
+                    lines=3
+                )
+                use_ai = gr.Checkbox(label="Use AI for enhanced personalization", value=recommender.ai_enabled)
+                
+                submit_btn = gr.Button("Generate Learning Roadmap", variant="primary")
+            
+        with gr.Row():
+            with gr.Column():
+                roadmap_output = gr.Markdown(label="Your Learning Roadmap")
+            with gr.Column():
+                courses_output = gr.Markdown(label="Recommended Courses")
+        
+        submit_btn.click(
+            recommend_and_generate,
+            inputs=[topic_input, skill_level, goals_input, use_ai],
+            outputs=[roadmap_output, courses_output]
+        )
+        
+    return demo
+
+def deploy_to_huggingface():
+    """
+    Deploy the application to Hugging Face Spaces
+    """
+    try:
+        # Load environment variables
+        load_dotenv()
+        
+        # Initialize HuggingFace API
+        hf_token = os.getenv("HF_TOKEN")
+        if not hf_token:
+            print("Error: HF_TOKEN not found in environment variables")
+            return
+            
+        api = HfApi(token=hf_token)
+        
+        # Create recommender
+        recommender = load_courses()
+        if not recommender:
+            print("Error: Could not load course data")
+            return
+            
+        # Create and launch Gradio interface
+        demo = create_gradio_interface(recommender)
+        
+        # Launch the app
+        demo.launch(share=True)
+        
+    except Exception as e:
+        print(f"Error deploying to Hugging Face: {e}")
+
+if __name__ == "__main__":
+    # Check if this is being run on Hugging Face Spaces
+    if os.getenv("SPACE_ID"):
+        # Initialize for Hugging Face
+        try:
+            recommender = load_courses()
+            if recommender:
+                demo = create_gradio_interface(recommender)
+                demo.launch()
+            else:
+                print("Error: Could not load course data")
+        except Exception as e:
+            print(f"Error initializing Gradio app: {e}")
+    else:
+        # Run the CLI version
+        main()