Upload 12 files

src/agentic_optimizer.py

@@ -0,0 +1,413 @@
+"""
+Agentic Curriculum Optimizer
+Runs 100% locally, no API costs
+"""
+
+import json
+import sqlite3
+import networkx as nx
+import numpy as np
+from dataclasses import dataclass, asdict
+from typing import Dict, List, Tuple, Optional
+from datetime import datetime
+import pickle
+import torch
+from sentence_transformers import SentenceTransformer
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+import schedule
+import time
+
+@dataclass
+class StudentProfile:
+    student_id: str
+    completed_courses: List[str]
+    current_gpa: float
+    interests: List[str]
+    career_goals: str
+    learning_style: str
+    time_commitment: int
+    preferred_difficulty: str
+
+@dataclass
+class PlanFeedback:
+    student_id: str
+    plan_id: str
+    timestamp: datetime
+    actual_gpa: float
+    difficulty_rating: int  # 1-5
+    satisfaction: int  # 1-5
+    completed_courses: List[str]
+    dropped_courses: List[str]
+
+class CurriculumAgent:
+    """
+    Autonomous agent that:
+    1. Monitors student progress
+    2. Adapts recommendations based on feedback
+    3. Proactively suggests adjustments
+    4. Learns from outcomes
+    """
+    
+    def __init__(self, db_path="curriculum_agent.db"):
+        self.db_path = db_path
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Models (local, no API)
+        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')  # Smaller for local
+        self.graph = None
+        self.courses = {}
+        
+        # Initialize database for memory
+        self._init_database()
+        
+        # Agent state
+        self.active_plans = {}
+        self.feedback_history = []
+        
+    def _init_database(self):
+        """Create tables for agent memory"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        
+        # Student profiles
+        c.execute('''CREATE TABLE IF NOT EXISTS students
+                    (id TEXT PRIMARY KEY, 
+                     profile TEXT,
+                     created_at TIMESTAMP)''')
+        
+        # Generated plans
+        c.execute('''CREATE TABLE IF NOT EXISTS plans
+                    (id TEXT PRIMARY KEY,
+                     student_id TEXT,
+                     plan_data TEXT,
+                     created_at TIMESTAMP,
+                     performance_score REAL)''')
+        
+        # Feedback for learning
+        c.execute('''CREATE TABLE IF NOT EXISTS feedback
+                    (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                     plan_id TEXT,
+                     student_id TEXT,
+                     feedback_data TEXT,
+                     timestamp TIMESTAMP)''')
+        
+        # Agent learning patterns
+        c.execute('''CREATE TABLE IF NOT EXISTS patterns
+                    (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                     pattern_type TEXT,
+                     pattern_data TEXT,
+                     success_rate REAL,
+                     discovered_at TIMESTAMP)''')
+        
+        conn.commit()
+        conn.close()
+    
+    def perceive(self) -> Dict:
+        """
+        PERCEPTION: Gather information about environment
+        """
+        perceptions = {
+            "active_students": self._get_active_students(),
+            "recent_feedback": self._get_recent_feedback(),
+            "course_updates": self._check_course_updates(),
+            "success_patterns": self._analyze_success_patterns()
+        }
+        return perceptions
+    
+    def decide(self, perceptions: Dict) -> List[Dict]:
+        """
+        DECISION: Determine what actions to take
+        """
+        decisions = []
+        
+        # Decision 1: Which students need plan updates?
+        for student_id in perceptions["active_students"]:
+            if self._needs_plan_update(student_id, perceptions):
+                decisions.append({
+                    "action": "update_plan",
+                    "student_id": student_id,
+                    "reason": "Poor performance feedback"
+                })
+        
+        # Decision 2: Identify at-risk students
+        at_risk = self._identify_at_risk_students(perceptions["recent_feedback"])
+        for student_id in at_risk:
+            decisions.append({
+                "action": "intervention",
+                "student_id": student_id,
+                "reason": "Risk of dropping out"
+            })
+        
+        # Decision 3: Optimize based on patterns
+        if perceptions["success_patterns"]:
+            decisions.append({
+                "action": "update_algorithm",
+                "patterns": perceptions["success_patterns"]
+            })
+        
+        return decisions
+    
+    def act(self, decisions: List[Dict]) -> List[Dict]:
+        """
+        ACTION: Execute decisions
+        """
+        results = []
+        
+        for decision in decisions:
+            if decision["action"] == "update_plan":
+                new_plan = self._regenerate_plan(decision["student_id"])
+                results.append({
+                    "action": "plan_updated",
+                    "student_id": decision["student_id"],
+                    "plan": new_plan
+                })
+                
+            elif decision["action"] == "intervention":
+                intervention = self._create_intervention(decision["student_id"])
+                results.append({
+                    "action": "intervention_created",
+                    "student_id": decision["student_id"],
+                    "intervention": intervention
+                })
+                
+            elif decision["action"] == "update_algorithm":
+                self._update_planning_algorithm(decision["patterns"])
+                results.append({
+                    "action": "algorithm_updated",
+                    "patterns_applied": len(decision["patterns"])
+                })
+        
+        return results
+    
+    def learn(self, results: List[Dict]):
+        """
+        LEARNING: Update knowledge based on outcomes
+        """
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        
+        for result in results:
+            if result["action"] == "plan_updated":
+                # Track plan performance
+                self._track_plan_performance(result["student_id"], result["plan"])
+                
+            elif result["action"] == "intervention_created":
+                # Monitor intervention effectiveness
+                self._monitor_intervention(result["student_id"], result["intervention"])
+        
+        # Discover new patterns
+        patterns = self._discover_patterns()
+        for pattern in patterns:
+            c.execute("INSERT INTO patterns (pattern_type, pattern_data, success_rate, discovered_at) VALUES (?, ?, ?, ?)",
+                     (pattern["type"], json.dumps(pattern["data"]), pattern["success_rate"], datetime.now()))
+        
+        conn.commit()
+        conn.close()
+    
+    def run_autonomous_cycle(self):
+        """
+        Main agent loop - runs continuously
+        """
+        while True:
+            print(f"\n[{datetime.now()}] Agent Cycle Starting...")
+            
+            # 1. PERCEIVE
+            perceptions = self.perceive()
+            print(f"Perceptions: {len(perceptions['active_students'])} active students")
+            
+            # 2. DECIDE
+            decisions = self.decide(perceptions)
+            print(f"Decisions: {len(decisions)} actions to take")
+            
+            # 3. ACT
+            results = self.act(decisions)
+            print(f"Results: {len(results)} actions completed")
+            
+            # 4. LEARN
+            self.learn(results)
+            print("Learning cycle complete")
+            
+            # Wait before next cycle (in production, this could be daily)
+            time.sleep(60)  # Run every minute for demo
+    
+    # --- Helper Methods ---
+    
+    def _get_active_students(self) -> List[str]:
+        """Get list of active students"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        c.execute("SELECT id FROM students")
+        students = [row[0] for row in c.fetchall()]
+        conn.close()
+        return students
+    
+    def _get_recent_feedback(self) -> List[Dict]:
+        """Get recent feedback"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        c.execute("SELECT feedback_data FROM feedback ORDER BY timestamp DESC LIMIT 10")
+        feedback = [json.loads(row[0]) for row in c.fetchall()]
+        conn.close()
+        return feedback
+    
+    def _check_course_updates(self) -> Dict:
+        """Check for course changes (mock for demo)"""
+        return {"updated_courses": [], "new_prerequisites": {}}
+    
+    def _analyze_success_patterns(self) -> List[Dict]:
+        """Identify successful patterns"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        c.execute("SELECT pattern_data, success_rate FROM patterns WHERE success_rate > 0.7")
+        patterns = [{"data": json.loads(row[0]), "success_rate": row[1]} for row in c.fetchall()]
+        conn.close()
+        return patterns
+    
+    def _needs_plan_update(self, student_id: str, perceptions: Dict) -> bool:
+        """Determine if student needs plan update"""
+        # Check if recent feedback shows issues
+        for feedback in perceptions["recent_feedback"]:
+            if feedback.get("student_id") == student_id:
+                if feedback.get("satisfaction", 5) < 3:
+                    return True
+        return False
+    
+    def _identify_at_risk_students(self, feedback: List[Dict]) -> List[str]:
+        """Identify students at risk"""
+        at_risk = []
+        for fb in feedback:
+            if fb.get("difficulty_rating", 0) > 4 or fb.get("dropped_courses", []):
+                at_risk.append(fb.get("student_id"))
+        return at_risk
+    
+    def _regenerate_plan(self, student_id: str) -> Dict:
+        """Generate new plan for student"""
+        # This would use your existing optimizer
+        return {"plan": "new_optimized_plan", "adjustments": ["reduced_difficulty"]}
+    
+    def _create_intervention(self, student_id: str) -> Dict:
+        """Create intervention plan"""
+        return {
+            "type": "academic_support",
+            "recommendations": ["tutoring", "reduced_courseload", "advisor_meeting"]
+        }
+    
+    def _update_planning_algorithm(self, patterns: List[Dict]):
+        """Update planning based on learned patterns"""
+        # This would adjust your optimizer's weights/rules
+        print(f"Updating algorithm with {len(patterns)} patterns")
+    
+    def _track_plan_performance(self, student_id: str, plan: Dict):
+        """Track how well plans perform"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        c.execute("UPDATE plans SET performance_score = ? WHERE student_id = ?",
+                 (0.0, student_id))  # Would calculate actual score
+        conn.commit()
+        conn.close()
+    
+    def _monitor_intervention(self, student_id: str, intervention: Dict):
+        """Monitor intervention effectiveness"""
+        print(f"Monitoring intervention for {student_id}")
+    
+    def _discover_patterns(self) -> List[Dict]:
+        """Discover new patterns from data"""
+        # Example: Find that students who take CS2500 before CS2510 do better
+        patterns = []
+        
+        # Analyze database for patterns
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        
+        # Example pattern discovery
+        c.execute("""
+            SELECT COUNT(*) FROM feedback 
+            WHERE feedback_data LIKE '%CS2500%CS2510%' 
+            AND json_extract(feedback_data, '$.satisfaction') > 4
+        """)
+        
+        result = c.fetchone()
+        if result and result[0] > 5:  # If pattern appears frequently
+            patterns.append({
+                "type": "course_sequence",
+                "data": {"sequence": ["CS2500", "CS2510"]},
+                "success_rate": 0.85
+            })
+        
+        conn.close()
+        return patterns
+
+
+class LocalAgentRunner:
+    """
+    Manages the agent without external dependencies
+    """
+    
+    def __init__(self, curriculum_data_path: str):
+        self.agent = CurriculumAgent()
+        
+        # Load curriculum data
+        with open(curriculum_data_path, 'rb') as f:
+            graph = pickle.load(f)
+        self.agent.graph = graph
+        self.agent.courses = dict(graph.nodes(data=True))
+        
+    def add_student(self, profile: StudentProfile) -> str:
+        """Add a student to track"""
+        conn = sqlite3.connect(self.agent.db_path)
+        c = conn.cursor()
+        
+        student_id = f"STU_{datetime.now().timestamp()}"
+        c.execute("INSERT INTO students (id, profile, created_at) VALUES (?, ?, ?)",
+                 (student_id, json.dumps(asdict(profile)), datetime.now()))
+        
+        conn.commit()
+        conn.close()
+        
+        return student_id
+    
+    def submit_feedback(self, feedback: PlanFeedback):
+        """Submit feedback for learning"""
+        conn = sqlite3.connect(self.agent.db_path)
+        c = conn.cursor()
+        
+        c.execute("INSERT INTO feedback (plan_id, student_id, feedback_data, timestamp) VALUES (?, ?, ?, ?)",
+                 (feedback.plan_id, feedback.student_id, json.dumps(asdict(feedback)), feedback.timestamp))
+        
+        conn.commit()
+        conn.close()
+    
+    def start_agent(self):
+        """Start the autonomous agent"""
+        print("Starting Curriculum Agent...")
+        print("Agent will monitor students and adapt plans automatically")
+        print("Press Ctrl+C to stop")
+        
+        try:
+            self.agent.run_autonomous_cycle()
+        except KeyboardInterrupt:
+            print("\nAgent stopped")
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize agent
+    runner = LocalAgentRunner("neu_graph_analyzed_clean.pkl")
+    
+    # Add a test student
+    student = StudentProfile(
+        student_id="test_001",
+        completed_courses=["CS1800", "CS2500"],
+        current_gpa=3.5,
+        interests=["AI", "Machine Learning"],
+        career_goals="ML Engineer",
+        learning_style="Visual",
+        time_commitment=40,
+        preferred_difficulty="moderate"
+    )
+    
+    student_id = runner.add_student(student)
+    print(f"Added student: {student_id}")
+    
+    # Start autonomous agent
+    runner.start_agent()

src/config.py

@@ -0,0 +1,113 @@
+"""
+Configuration for different compute environments
+Switch between configs based on available hardware
+"""
+
+import torch
+import os
+
+class Config:
+    """Base configuration"""
+    # Data paths
+    CURRICULUM_DATA = "neu_graph_analyzed_clean.pkl"
+    AGENT_DB = "curriculum_agent.db"
+    
+    # Model settings (override in subclasses)
+    LLM_MODEL = None
+    EMBEDDING_MODEL = None
+    DEVICE = None
+    QUANTIZATION = None
+    
+    # Agent settings
+    AGENT_CYCLE_MINUTES = 60
+    MAX_COURSES_PER_SEMESTER = 4
+    
+    @classmethod
+    def get_device(cls):
+        if cls.DEVICE == "auto":
+            return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        return torch.device(cls.DEVICE)
+
+
+class H200Config(Config):
+    """Config for H200 GPU (80GB)"""
+    LLM_MODEL = "meta-llama/Llama-3.1-70B-Instruct"
+    EMBEDDING_MODEL = "BAAI/bge-large-en-v1.5"
+    DEVICE = "cuda"
+    QUANTIZATION = None  # No need to quantize with 80GB
+
+
+class ColabConfig(Config):
+    """Config for Google Colab T4 (16GB)"""
+    LLM_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
+    EMBEDDING_MODEL = "BAAI/bge-base-en-v1.5"
+    DEVICE = "cuda"
+    QUANTIZATION = "4bit"
+
+
+class LocalGPUConfig(Config):
+    """Config for local GPU (8-12GB)"""
+    LLM_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
+    EMBEDDING_MODEL = "sentence-transformers/all-mpnet-base-v2"
+    DEVICE = "cuda"
+    QUANTIZATION = "4bit"
+
+
+class CPUConfig(Config):
+    """Config for CPU only (no GPU)"""
+    LLM_MODEL = "microsoft/phi-2"  # 2.7B params
+    EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"  # 22M params
+    DEVICE = "cpu"
+    QUANTIZATION = None
+
+
+class MinimalConfig(Config):
+    """Minimal config for testing/development"""
+    LLM_MODEL = None  # No LLM, just embeddings
+    EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+    DEVICE = "cpu"
+    QUANTIZATION = None
+
+
+def get_config():
+    """
+    Auto-detect best configuration
+    """
+    # Check environment variable first
+    env_config = os.environ.get("CURRICULUM_CONFIG", "").lower()
+    
+    if env_config == "h200":
+        return H200Config
+    elif env_config == "colab":
+        return ColabConfig
+    elif env_config == "cpu":
+        return CPUConfig
+    elif env_config == "minimal":
+        return MinimalConfig
+    
+    # Auto-detect based on hardware
+    if torch.cuda.is_available():
+        gpu_mem = torch.cuda.get_device_properties(0).total_memory / 1e9  # GB
+        
+        if gpu_mem > 70:
+            print(f"Detected high-end GPU ({gpu_mem:.1f}GB), using H200Config")
+            return H200Config
+        elif gpu_mem > 14:
+            print(f"Detected mid-range GPU ({gpu_mem:.1f}GB), using ColabConfig")
+            return ColabConfig
+        else:
+            print(f"Detected small GPU ({gpu_mem:.1f}GB), using LocalGPUConfig")
+            return LocalGPUConfig
+    else:
+        print("No GPU detected, using CPUConfig")
+        return CPUConfig
+
+
+# Usage example
+if __name__ == "__main__":
+    config = get_config()
+    print(f"Selected config: {config.__name__}")
+    print(f"LLM: {config.LLM_MODEL}")
+    print(f"Embedder: {config.EMBEDDING_MODEL}")
+    print(f"Device: {config.DEVICE}")
+    print(f"Quantization: {config.QUANTIZATION}")

src/curriculum_analyzer.py

@@ -0,0 +1,127 @@
+"""
+Curriculum Analyzer and Data Enrichment Tool (with Pre-filtering)
+Analyzes, CLEANS, and enriches scraped NEU curriculum data.
+"""
+import pickle
+import json
+import argparse
+import networkx as nx
+import re
+from collections import defaultdict
+
+def get_course_level(cid):
+    """Extracts the numerical part of a course ID for level checking."""
+    match = re.search(r'\d+', cid)
+    return int(match.group(0)) if match else 9999
+
+class CurriculumAnalyzer:
+    def __init__(self, graph_path, courses_path):
+        self.graph_path = graph_path
+        self.courses_path = courses_path
+        self.graph = None
+        self.courses = None
+        self.load_data()
+
+    def load_data(self):
+        print("📚 Loading raw curriculum data...")
+        try:
+            with open(self.graph_path, 'rb') as f:
+                self.graph = pickle.load(f)
+            with open(self.courses_path, 'rb') as f:
+                self.courses = pickle.load(f)
+            
+            # Merge course metadata into the graph nodes
+            for course_id, course_data in self.courses.items():
+                if self.graph.has_node(course_id):
+                    self.graph.nodes[course_id].update(course_data)
+
+            print(f"✅ Loaded raw data with {self.graph.number_of_nodes()} courses.")
+        except FileNotFoundError as e:
+            print(f"❌ Error: Data file not found. {e}")
+            exit(1)
+
+    def pre_filter_graph(self):
+        """
+        Permanently removes irrelevant courses from the graph.
+        This is the most important step for creating logical plans.
+        """
+        print("\n🧹 Pre-filtering graph to remove irrelevant courses...")
+        
+        # Define what subjects are considered relevant for a tech-focused degree
+        RELEVANT_SUBJECTS = {
+            "CS", "DS", "CY",
+        }
+        
+        nodes_to_remove = []
+        for node, data in self.graph.nodes(data=True):
+            subject = data.get('subject')
+            level = get_course_level(node)
+            
+            # Mark for removal if subject is irrelevant OR it's a grad course (>= 5000)
+            if subject not in RELEVANT_SUBJECTS or level >= 5000:
+                nodes_to_remove.append(node)
+
+        self.graph.remove_nodes_from(nodes_to_remove)
+        print(f"✅ Graph filtered. Removed {len(nodes_to_remove)} irrelevant courses. Remaining: {self.graph.number_of_nodes()}")
+
+    def calculate_and_add_complexity(self):
+        """Calculates complexity scores for the remaining courses."""
+        print("\n🧮 Calculating complexity scores for filtered graph...")
+        if not self.graph.nodes():
+            return
+
+        foundation_courses = [n for n, d in self.graph.in_degree() if d == 0]
+        
+        complexity_scores = {}
+        for node in self.graph.nodes():
+            # Calculate depth (longest path from a foundation course)
+            depth = 0
+            if foundation_courses:
+                paths = [nx.shortest_path_length(self.graph, source, node) 
+                         for source in foundation_courses if nx.has_path(self.graph, source, node)]
+                if paths:
+                    depth = max(paths) # Use max path for a better sense of progression
+
+            in_deg = self.graph.in_degree(node)
+            out_deg = self.graph.out_degree(node)
+            
+            # Formula: (prereqs * 10) + (unlocks * 5) + (depth * 3)
+            score = (in_deg * 10) + (out_deg * 5) + (depth * 3)
+            complexity_scores[node] = {
+                'complexity': score,
+                'depth': depth,
+                'prereq_count': in_deg,
+                'unlocks_count': out_deg
+            }
+
+        nx.set_node_attributes(self.graph, complexity_scores)
+        print("✅ Complexity scores calculated and added.")
+
+    def save_enriched_graph(self, output_path):
+        """Saves the final, clean, and enriched graph."""
+        print(f"\n💾 Saving CLEAN and enriched graph to {output_path}...")
+        with open(output_path, 'wb') as f:
+            pickle.dump(self.graph, f)
+        print("✅ Graph saved.")
+
+def main(args):
+    """Main execution flow."""
+    analyzer = CurriculumAnalyzer(args.graph, args.courses)
+    
+    # Run the new cleaning step first!
+    analyzer.pre_filter_graph()
+    
+    analyzer.calculate_and_add_complexity()
+    
+    analyzer.save_enriched_graph(args.output_graph)
+    
+    print("\n✨ Analysis and cleaning complete!")
+    print(f"➡️ In the Streamlit app, upload the new clean file: '{args.output_graph}'")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="NEU Curriculum Analyzer and Data Enrichment Tool")
+    parser.add_argument('--graph', required=True, help="Path to the RAW curriculum graph from the scraper.")
+    parser.add_argument('--courses', required=True, help="Path to the RAW courses data from the scraper.")
+    parser.add_argument('--output-graph', default='neu_graph_analyzed_clean.pkl', help="Path to save the new CLEANED and enriched graph.")
+    args = parser.parse_args()
+    main(args)

src/curriculum_optimizer.py

@@ -0,0 +1,654 @@
+"""
+Fixed Hybrid Curriculum Optimizer
+Actually personalizes plans based on student profile
+"""
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from sentence_transformers import SentenceTransformer, util
+import networkx as nx
+import numpy as np
+from typing import Dict, List, Set, Tuple
+from dataclasses import dataclass
+import re
+import json
+import random
+
+@dataclass
+class StudentProfile:
+    completed_courses: List[str]
+    time_commitment: int
+    preferred_difficulty: str
+    career_goals: str
+    interests: List[str]
+    current_gpa: float = 3.5
+    learning_style: str = "Visual"
+
+class HybridOptimizer:
+    """
+    Fixed optimizer that actually personalizes plans
+    """
+    
+    # Core sequences by track - now with difficulty tiers
+    TRACK_SEQUENCES = {
+        "ai_ml": {
+            "foundations": ["CS1800", "CS2500", "CS2510", "CS2800"],
+            "core_easy": ["CS3000", "CS3500", "DS3000"],
+            "core_medium": ["CS3000", "CS3500", "CS3200", "DS3000"],
+            "core_hard": ["CS3000", "CS3500", "CS3200", "CS3650", "DS3000"],
+            "specialized_easy": ["CS4100", "DS4400"],
+            "specialized_medium": ["CS4100", "DS4400", "CS4120"],
+            "specialized_hard": ["CS4100", "DS4400", "CS4120", "CS4180", "DS4440"],
+            "math": ["MATH1341", "MATH1342", "MATH2331", "MATH3081"]
+        },
+        "systems": {
+            "foundations": ["CS1800", "CS2500", "CS2510", "CS2800"],
+            "core_easy": ["CS3000", "CS3500", "CS3650"],
+            "core_medium": ["CS3000", "CS3500", "CS3650", "CS3700"],
+            "core_hard": ["CS3000", "CS3500", "CS3650", "CS3700", "CS4700"],
+            "specialized_easy": ["CS4730", "CS4750"],
+            "specialized_medium": ["CS4730", "CS4750", "CS4770"],
+            "specialized_hard": ["CS4730", "CS4750", "CS4770", "CS4400"],
+            "math": ["MATH1341", "MATH1342"]
+        },
+        "security": {
+            "foundations": ["CS1800", "CS2500", "CS2510", "CS2800"],
+            "core_easy": ["CS3000", "CS3650", "CY2550"],
+            "core_medium": ["CS3000", "CS3650", "CS3700", "CY2550"],
+            "core_hard": ["CS3000", "CS3650", "CS3700", "CY2550", "CY3740"],
+            "specialized_easy": ["CY4740", "CY4760"],
+            "specialized_medium": ["CY4740", "CY4760", "CY4770"],
+            "specialized_hard": ["CY4740", "CY4760", "CY4770", "CS4700"],
+            "math": ["MATH1342", "MATH3527"]
+        }
+    }
+    
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Use smaller model for efficiency
+        self.model_name = "meta-llama/Llama-3.1-8B-Instruct"
+        self.embedding_model_name = 'BAAI/bge-large-en-v1.5'
+        
+        self.llm = None
+        self.tokenizer = None
+        self.embedding_model = None
+        self.curriculum_graph = None
+        self.courses = {}
+        
+    def load_models(self):
+        """Load embedding model and optionally LLM"""
+        print("Loading embedding model...")
+        self.embedding_model = SentenceTransformer(self.embedding_model_name, device=self.device)
+        
+    def load_llm(self):
+        """Load LLM separately for when needed"""
+        if self.device.type == 'cuda' and self.llm is None:
+            print("Loading LLM for intelligent planning...")
+            quant_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                quantization_config=quant_config,
+                device_map="auto"
+            )
+        
+    def load_data(self, graph: nx.DiGraph):
+        """Load and preprocess curriculum data"""
+        self.curriculum_graph = graph
+        self.courses = dict(graph.nodes(data=True))
+        
+        # Filter valid courses
+        self.valid_courses = []
+        course_texts = []
+        
+        for cid, data in self.courses.items():
+            # Skip labs/recitations
+            name = data.get('name', '')
+            if any(skip in name for skip in ['Lab', 'Recitation', 'Seminar', 'Practicum']):
+                continue
+                
+            # Skip grad level
+            if self._get_level(cid) >= 5000:
+                continue
+                
+            self.valid_courses.append(cid)
+            course_texts.append(f"{name} {data.get('description', '')}")
+        
+        # Precompute embeddings
+        print(f"Computing embeddings for {len(self.valid_courses)} courses...")
+        self.course_embeddings = self.embedding_model.encode(
+            course_texts, 
+            convert_to_tensor=True,
+            show_progress_bar=True
+        )
+        
+    def generate_llm_plan(self, student: StudentProfile) -> Dict:
+        """Generate AI-powered plan with LLM course selection"""
+        print("--- Generating AI-Optimized Plan ---")
+        
+        # Ensure LLM is loaded
+        self.load_llm()
+        
+        if not self.llm:
+            print("LLM not available, falling back to enhanced rule-based plan")
+            return self.generate_enhanced_rule_plan(student)
+        
+        # Step 1: Identify track
+        track = self._identify_track(student)
+        print(f"Identified track: {track}")
+        
+        # Step 2: Get LLM-suggested courses
+        llm_suggestions = self._get_llm_course_suggestions(student, track)
+        
+        # Step 3: Build plan using LLM suggestions + rules
+        plan = self._build_llm_guided_plan(student, track, llm_suggestions)
+        
+        # Step 4: Generate explanation
+        explanation = self._generate_explanation(student, plan, track, "AI-optimized")
+        
+        return self._finalize_plan(plan, explanation)
+    
+    def generate_simple_plan(self, student: StudentProfile) -> Dict:
+        """Generate rule-based plan that considers student preferences"""
+        print("--- Generating Enhanced Rule-Based Plan ---")
+        return self.generate_enhanced_rule_plan(student)
+    
+    def generate_enhanced_rule_plan(self, student: StudentProfile) -> Dict:
+        """Enhanced rule-based plan that actually uses student profile"""
+        
+        # Step 1: Identify track
+        track = self._identify_track(student)
+        
+        # Step 2: Adjust plan based on student preferences
+        difficulty_level = self._map_difficulty(student.preferred_difficulty)
+        courses_per_semester = self._calculate_course_load(student.time_commitment)
+        
+        # Step 3: Get semantic scores for electives
+        semantic_scores = self._compute_semantic_scores(student)
+        
+        # Step 4: Build personalized deterministic plan
+        plan = self._build_personalized_plan(
+            student, track, difficulty_level, 
+            courses_per_semester, semantic_scores
+        )
+        
+        # Step 5: Generate explanation
+        explanation = f"Personalized {track} track ({difficulty_level} difficulty, {courses_per_semester} courses/semester)"
+        
+        return self._finalize_plan(plan, explanation)
+    
+    def _get_llm_course_suggestions(self, student: StudentProfile, track: str) -> List[str]:
+        """Use LLM to suggest personalized course priorities"""
+        
+        # Get available specialized courses for this track
+        track_courses = self.TRACK_SEQUENCES.get(track, self.TRACK_SEQUENCES["ai_ml"])
+        all_specialized = (
+            track_courses.get("specialized_easy", []) +
+            track_courses.get("specialized_medium", []) +
+            track_courses.get("specialized_hard", [])
+        )
+        
+        # Create course options text
+        course_options = []
+        for cid in all_specialized[:10]:  # Limit to avoid token limits
+            if cid in self.courses:
+                name = self.courses[cid].get('name', cid)
+                desc = self.courses[cid].get('description', '')[:100]
+                course_options.append(f"{cid}: {name} - {desc}")
+        
+        prompt = f"""You are a curriculum advisor. Given this student profile, rank the TOP 5 most relevant courses from the options below.
+
+Student Profile:
+- Career Goal: {student.career_goals}
+- Interests: {', '.join(student.interests)}
+- Time Commitment: {student.time_commitment} hours/week
+- Preferred Difficulty: {student.preferred_difficulty}
+- Current GPA: {student.current_gpa}
+
+Available Courses:
+{chr(10).join(course_options)}
+
+Return ONLY the top 5 course IDs in order of priority, one per line. Example:
+CS4100
+DS4400
+CS4120
+CS4180
+DS4440"""
+
+        try:
+            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=2048).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.llm.generate(
+                    **inputs,
+                    max_new_tokens=100,
+                    temperature=0.3,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            response = self.tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+            
+            # Extract course IDs
+            suggested_courses = []
+            for line in response.strip().split('\n'):
+                line = line.strip()
+                # Look for course ID pattern
+                match = re.search(r'([A-Z]{2,4}\d{4})', line)
+                if match:
+                    suggested_courses.append(match.group(1))
+            
+            return suggested_courses[:5]
+            
+        except Exception as e:
+            print(f"LLM suggestion failed: {e}")
+            return all_specialized[:5]  # Fallback
+    
+    def _build_llm_guided_plan(
+        self, 
+        student: StudentProfile, 
+        track: str,
+        llm_suggestions: List[str]
+    ) -> Dict:
+        """Build plan using LLM suggestions for specialized courses"""
+        
+        completed = set(student.completed_courses)
+        plan = {}
+        track_courses = self.TRACK_SEQUENCES.get(track, self.TRACK_SEQUENCES["ai_ml"])
+        
+        # Create personalized course queue
+        difficulty_level = self._map_difficulty(student.preferred_difficulty)
+        courses_per_semester = self._calculate_course_load(student.time_commitment)
+        
+        required_queue = (
+            track_courses["foundations"] + 
+            track_courses.get(f"core_{difficulty_level}", track_courses["core_easy"])
+        )
+        
+        # Add LLM-suggested specialized courses
+        specialized_queue = llm_suggestions[:3]  # Top 3 suggestions
+        
+        # Build semester plan
+        for sem_num in range(1, 9):
+            year = ((sem_num - 1) // 2) + 1
+            is_fall = (sem_num % 2) == 1
+            
+            available = self._get_available_courses(completed, year)
+            selected = []
+            
+            # Priority 1: Required courses
+            for course in required_queue[:]:
+                if course in available and len(selected) < courses_per_semester:
+                    selected.append(course)
+                    required_queue.remove(course)
+                    available.remove(course)
+            
+            # Priority 2: LLM-suggested specialized courses
+            for course in specialized_queue[:]:
+                if course in available and len(selected) < courses_per_semester:
+                    selected.append(course)
+                    specialized_queue.remove(course)
+                    available.remove(course)
+            
+            # Priority 3: Math courses (early years)
+            if year <= 2:
+                for math_course in track_courses.get("math", []):
+                    if math_course in available and len(selected) < courses_per_semester:
+                        selected.append(math_course)
+                        available.remove(math_course)
+            
+            # Priority 4: High-scoring electives
+            if len(selected) < courses_per_semester and available:
+                semantic_scores = self._compute_semantic_scores(student)
+                remaining_electives = [(cid, self._score_elective(cid, semantic_scores, completed)) 
+                                     for cid in available]
+                remaining_electives.sort(key=lambda x: x[1], reverse=True)
+                
+                for cid, score in remaining_electives:
+                    if len(selected) >= courses_per_semester:
+                        break
+                    selected.append(cid)
+            
+            # Add to plan
+            if selected:
+                year_key = f"year_{year}"
+                if year_key not in plan:
+                    plan[year_key] = {}
+                
+                sem_type = 'fall' if is_fall else 'spring'
+                plan[year_key][sem_type] = selected[:courses_per_semester]
+                completed.update(selected)
+        
+        return plan
+    
+    def _build_personalized_plan(
+        self, 
+        student: StudentProfile,
+        track: str,
+        difficulty_level: str,
+        courses_per_semester: int,
+        semantic_scores: Dict[str, float]
+    ) -> Dict:
+        """Build plan considering student preferences"""
+        
+        completed = set(student.completed_courses)
+        plan = {}
+        track_courses = self.TRACK_SEQUENCES.get(track, self.TRACK_SEQUENCES["ai_ml"])
+        
+        # Create difficulty-appropriate course sequence
+        required_queue = (
+            track_courses["foundations"] + 
+            track_courses.get(f"core_{difficulty_level}", track_courses["core_easy"]) +
+            track_courses.get(f"specialized_{difficulty_level}", track_courses["specialized_easy"])[:2]
+        )
+        
+        for sem_num in range(1, 9):
+            year = ((sem_num - 1) // 2) + 1
+            is_fall = (sem_num % 2) == 1
+            
+            available = self._get_available_courses(completed, year)
+            selected = []
+            
+            # Apply GPA-based difficulty adjustment
+            if student.current_gpa < 3.0 and difficulty_level == "hard":
+                # Reduce course load for struggling students
+                max_courses = min(courses_per_semester, 3)
+            elif student.current_gpa > 3.7 and student.time_commitment > 35:
+                # Allow higher course load for high achievers with time
+                max_courses = min(courses_per_semester + 1, 5)
+            else:
+                max_courses = courses_per_semester
+            
+            # Priority 1: Required courses from queue
+            for course in required_queue[:]:
+                if course in available and len(selected) < max_courses:
+                    selected.append(course)
+                    required_queue.remove(course)
+                    available.remove(course)
+            
+            # Priority 2: Math requirements (adjusted by difficulty)
+            if year <= 2:
+                math_courses = track_courses.get("math", [])
+                if difficulty_level == "easy":
+                    math_courses = math_courses[:2]  # Fewer math courses for easy track
+                
+                for math_course in math_courses:
+                    if math_course in available and len(selected) < max_courses:
+                        selected.append(math_course)
+                        available.remove(math_course)
+            
+            # Priority 3: Interest-aligned electives
+            if len(selected) < max_courses and available:
+                # Score and sort remaining courses
+                elective_scores = [
+                    (cid, self._score_elective_personalized(cid, semantic_scores, student, completed))
+                    for cid in available
+                ]
+                elective_scores.sort(key=lambda x: x[1], reverse=True)
+                
+                for cid, score in elective_scores:
+                    if len(selected) >= max_courses:
+                        break
+                    selected.append(cid)
+            
+            # Add to plan
+            if selected:
+                year_key = f"year_{year}"
+                if year_key not in plan:
+                    plan[year_key] = {}
+                
+                sem_type = 'fall' if is_fall else 'spring'
+                plan[year_key][sem_type] = selected[:max_courses]
+                completed.update(selected)
+        
+        return plan
+    
+    def _map_difficulty(self, preferred_difficulty: str) -> str:
+        """Map UI difficulty to internal levels"""
+        mapping = {
+            "easy": "easy",
+            "moderate": "medium", 
+            "challenging": "hard"
+        }
+        return mapping.get(preferred_difficulty.lower(), "medium")
+    
+    def _calculate_course_load(self, time_commitment: int) -> int:
+        """Calculate courses per semester based on time commitment"""
+        if time_commitment < 20:
+            return 3  # Part-time
+        elif time_commitment < 30:
+            return 4  # Standard
+        elif time_commitment < 40:
+            return 4  # Standard-heavy
+        else:
+            return 4  # Max (prerequisites limit anyway)
+    
+    def _score_elective_personalized(
+        self,
+        course_id: str,
+        semantic_scores: Dict[str, float],
+        student: StudentProfile,
+        completed: Set[str]
+    ) -> float:
+        """Enhanced elective scoring with personalization"""
+        
+        score = 0.0
+        
+        # Semantic alignment (40%)
+        score += semantic_scores.get(course_id, 0) * 0.4
+        
+        # Unlocks future courses (20%)
+        if course_id in self.curriculum_graph:
+            unlocks = len(list(self.curriculum_graph.successors(course_id)))
+            score += min(unlocks / 5, 1.0) * 0.2
+        
+        # Subject relevance (15%)
+        subject = self.courses.get(course_id, {}).get('subject', '')
+        subject_scores = {"CS": 1.0, "DS": 0.9, "IS": 0.6, "MATH": 0.7, "CY": 0.8}
+        score += subject_scores.get(subject, 0.3) * 0.15
+        
+        # Difficulty preference alignment (15%)
+        course_level = self._get_level(course_id)
+        if student.preferred_difficulty == "easy" and course_level < 3000:
+            score += 0.15
+        elif student.preferred_difficulty == "moderate" and 3000 <= course_level < 4000:
+            score += 0.15
+        elif student.preferred_difficulty == "challenging" and course_level >= 4000:
+            score += 0.15
+        
+        # GPA-based difficulty adjustment (10%)
+        if student.current_gpa > 3.5 and course_level >= 4000:
+            score += 0.1  # High achievers get bonus for advanced courses
+        elif student.current_gpa < 3.0 and course_level < 3000:
+            score += 0.1  # Struggling students get bonus for foundational courses
+        
+        return score
+    
+    def _identify_track(self, student: StudentProfile) -> str:
+        """Use embeddings to identify best track"""
+        
+        profile_text = f"{student.career_goals} {' '.join(student.interests)}"
+        profile_emb = self.embedding_model.encode(profile_text, convert_to_tensor=True)
+        
+        track_descriptions = {
+            "ai_ml": "artificial intelligence machine learning deep learning neural networks data science NLP computer vision LLM",
+            "systems": "operating systems distributed systems networks compilers databases performance optimization backend",
+            "security": "cybersecurity cryptography penetration testing security vulnerabilities network security ethical hacking"
+        }
+        
+        best_track = "ai_ml"
+        best_score = -1
+        
+        for track, description in track_descriptions.items():
+            track_emb = self.embedding_model.encode(description, convert_to_tensor=True)
+            score = float(util.cos_sim(profile_emb, track_emb))
+            if score > best_score:
+                best_score = score
+                best_track = track
+        
+        return best_track
+    
+    def _compute_semantic_scores(self, student: StudentProfile) -> Dict[str, float]:
+        """Compute semantic alignment for all courses"""
+        
+        query_text = f"{student.career_goals} {' '.join(student.interests)}"
+        query_emb = self.embedding_model.encode(query_text, convert_to_tensor=True)
+        
+        similarities = util.cos_sim(query_emb, self.course_embeddings)[0]
+        
+        scores = {}
+        for idx, cid in enumerate(self.valid_courses):
+            scores[cid] = float(similarities[idx])
+            
+        return scores
+    
+    def _get_available_courses(self, completed: Set[str], year: int) -> List[str]:
+        """Get schedulable courses with year restrictions"""
+        
+        available = []
+        max_level = 2999 if year == 1 else 3999 if year == 2 else 9999
+        
+        for cid in self.valid_courses:
+            if cid in completed:
+                continue
+                
+            if self._get_level(cid) > max_level:
+                continue
+                
+            # Check prerequisites
+            if cid in self.curriculum_graph:
+                prereqs = set(self.curriculum_graph.predecessors(cid))
+                if not prereqs.issubset(completed):
+                    continue
+            
+            available.append(cid)
+            
+        return available
+    
+    def _score_elective(
+        self,
+        course_id: str,
+        semantic_scores: Dict[str, float],
+        completed: Set[str]
+    ) -> float:
+        """Basic elective scoring"""
+        
+        score = 0.0
+        
+        # Semantic alignment (50%)
+        score += semantic_scores.get(course_id, 0) * 0.5
+        
+        # Unlocks future courses (30%)
+        if course_id in self.curriculum_graph:
+            unlocks = len(list(self.curriculum_graph.successors(course_id)))
+            score += min(unlocks / 5, 1.0) * 0.3
+        
+        # Subject relevance (20%)
+        subject = self.courses.get(course_id, {}).get('subject', '')
+        subject_scores = {"CS": 1.0, "DS": 0.9, "IS": 0.6, "MATH": 0.7, "CY": 0.8}
+        score += subject_scores.get(subject, 0.3) * 0.2
+        
+        return score
+    
+    def _generate_explanation(self, student: StudentProfile, plan: Dict, track: str, plan_type: str) -> str:
+        """Generate explanation using LLM if available"""
+        
+        if not self.llm:
+            return f"{plan_type} {track} track plan for {student.career_goals}"
+        
+        # Count courses
+        total_courses = sum(
+            len(plan.get(f"year_{y}", {}).get(sem, []))
+            for y in range(1, 5)
+            for sem in ["fall", "spring"]
+        )
+        
+        prompt = f"""Explain this curriculum plan in 1-2 sentences:
+Plan Type: {plan_type}
+Track: {track}
+Student Goal: {student.career_goals}
+Interests: {', '.join(student.interests[:2])}
+Difficulty: {student.preferred_difficulty}
+Time Commitment: {student.time_commitment}h/week
+Total Courses: {total_courses}
+
+Be specific about how the plan matches their preferences."""
+
+        try:
+            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.llm.generate(
+                    **inputs,
+                    max_new_tokens=150,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            explanation = self.tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+            return explanation.strip()
+            
+        except Exception as e:
+            print(f"Explanation generation failed: {e}")
+            return f"{plan_type} {track} track plan optimized for {student.career_goals}"
+    
+    def _get_level(self, course_id: str) -> int:
+        """Extract course level"""
+        match = re.search(r'\d+', course_id)
+        return int(match.group()) if match else 9999
+    
+    def _finalize_plan(self, plan: Dict, explanation: str) -> Dict:
+        """Add structure and metrics to plan"""
+        
+        structured = {"reasoning": explanation}
+        
+        # Ensure all years present
+        for year in range(1, 5):
+            year_key = f"year_{year}"
+            if year_key not in plan:
+                plan[year_key] = {}
+            
+            structured[year_key] = {
+                "fall": plan[year_key].get("fall", []),
+                "spring": plan[year_key].get("spring", []),
+                "summer": "co-op" if year in [2, 3] else []
+            }
+        
+        # Calculate complexity metrics
+        complexities = []
+        for year_key in structured:
+            if year_key.startswith("year_"):
+                for sem in ["fall", "spring"]:
+                    courses = structured[year_key].get(sem, [])
+                    if courses:
+                        sem_complexity = sum(
+                            self.courses.get(c, {}).get('complexity', 50)
+                            for c in courses
+                        )
+                        complexities.append(sem_complexity)
+        
+        structured["complexity_analysis"] = {
+            "average_semester_complexity": float(np.mean(complexities)) if complexities else 0,
+            "peak_semester_complexity": float(np.max(complexities)) if complexities else 0,
+            "total_complexity": float(np.sum(complexities)) if complexities else 0,
+            "balance_score (std_dev)": float(np.std(complexities)) if complexities else 0
+        }
+        
+        return {"pathway": structured}
+
+# Backward compatibility wrapper
+class CurriculumOptimizer(HybridOptimizer):
+    """Compatibility wrapper"""
+    
+    def __init__(self):
+        super().__init__()
+    
+    def generate_plan(self, student: StudentProfile) -> Dict:
+        """Default plan generation - uses enhanced rules"""
+        return self.generate_enhanced_rule_plan(student)

src/inspect_graph.py

@@ -0,0 +1,88 @@
+import pickle
+import networkx as nx
+import argparse
+
+def inspect_graph(graph_path: str):
+    """
+    Loads a curriculum graph and runs diagnostic checks to verify its integrity.
+    """
+    try:
+        with open(graph_path, 'rb') as f:
+            graph = pickle.load(f)
+        print(f"✅ Successfully loaded graph '{graph_path}'")
+        print(f"   - Total Courses (Nodes): {graph.number_of_nodes()}")
+        print(f"   - Prerequisite Links (Edges): {graph.number_of_edges()}")
+    except FileNotFoundError:
+        print(f"❌ ERROR: File not found at '{graph_path}'. Please check the path.")
+        return
+    except Exception as e:
+        print(f"❌ ERROR: Could not load or parse the pickle file. Reason: {e}")
+        return
+
+    print("\n--- 🧐 DIAGNOSTIC CHECKS ---")
+
+    # --- Check 1: Critical Prerequisite Links ---
+    print("\n## 1. Verifying Critical Prerequisite Links...")
+    critical_links = [
+        ("CS1800", "CS2800"), # Discrete -> Logic & Comp
+        ("CS2500", "CS2510"), # Fundies 1 -> Fundies 2
+        ("CS2510", "CS3500"), # Fundies 2 -> OOD
+        ("CS2510", "CS3000")  # Fundies 2 -> Algorithms
+    ]
+    all_links_ok = True
+    for prereq, course in critical_links:
+        if graph.has_node(prereq) and graph.has_node(course):
+            if graph.has_edge(prereq, course):
+                print(f"  [PASS] Prerequisite link exists: {prereq} -> {course}")
+            else:
+                print(f"  [FAIL] CRITICAL LINK MISSING: The graph has no link from {prereq} to {course}.")
+                all_links_ok = False
+        else:
+            print(f"  [WARN] One or both courses in link {prereq} -> {course} are not in the graph.")
+            all_links_ok = False
+    
+    if all_links_ok:
+        print("  -> All critical prerequisite links seem to be intact.")
+
+    # --- Check 2: Foundational Courses ---
+    print("\n## 2. Analyzing Foundational Courses (courses with no prerequisites)...")
+    foundations = [n for n, d in graph.in_degree() if d == 0]
+    if foundations:
+        print(f"  Found {len(foundations)} foundational courses.")
+        cs_foundations = [c for c in foundations if c.startswith("CS")]
+        if cs_foundations:
+            print(f"  -> Foundational CS courses: {', '.join(cs_foundations[:5])}...")
+        else:
+            print("  [WARN] No foundational courses with a 'CS' prefix were found. This is unusual.")
+    else:
+        print("  [FAIL] No foundational courses found. The graph may have a cycle or is structured incorrectly.")
+
+    # --- Check 3: Key Course Inspection ---
+    print("\n## 3. Inspecting Key Courses...")
+    courses_to_inspect = ["CS2500", "CS2510", "CS3500"]
+    for course_id in courses_to_inspect:
+        if graph.has_node(course_id):
+            prereqs = list(graph.predecessors(course_id))
+            unlocks = list(graph.successors(course_id))
+            print(f"\n  - Course: {course_id} ({graph.nodes[course_id].get('name', 'N/A')})")
+            print(f"    - Prerequisites (What it needs): {prereqs or 'None'}")
+            print(f"    - Unlocks (What it leads to): {unlocks or 'None'}")
+        else:
+            print(f"\n  - Course: {course_id} -> [NOT FOUND IN GRAPH]")
+
+    print("\n--- ախ DIAGNOSIS ---")
+    if not all_links_ok:
+        print("Your graph is missing critical prerequisite information.")
+        print("The planner cannot create a logical schedule without these links.")
+        print("This issue likely originates in `neu_scraper.py` or how it parses prerequisite data from the API.")
+    else:
+        print("The graph structure for critical courses appears to be correct.")
+        print("If plans are still illogical, the issue may lie in the complexity/depth attributes or the planner's sorting logic.")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Curriculum Graph Diagnostic Tool")
+    # CORRECTED: Use a variable name for the argument
+    parser.add_argument("graph_path", help="Path to the .pkl graph file to inspect.")
+    args = parser.parse_args()
+    # CORRECTED: Use the correct variable to access the argument
+    inspect_graph(args.graph_path)

src/interactive_visualizer.py

@@ -0,0 +1,400 @@
+"""
+Interactive Curriculum Visualizer - FIXED VERSION
+Creates CurricularAnalytics-style network graphs
+"""
+import streamlit as st
+import networkx as nx
+import plotly.graph_objects as go
+import pickle
+import json
+from typing import Dict, List, Tuple
+import numpy as np
+
+class CurriculumVisualizer:
+    """
+    Creates interactive curriculum dependency graphs
+    Similar to CurricularAnalytics.org
+    """
+    
+    def __init__(self, graph: nx.DiGraph):
+        self.graph = graph
+        self.courses = dict(graph.nodes(data=True))
+        self.positions = None
+        self.layers = None
+        
+    def calculate_metrics(self, course_id: str) -> Dict:
+        """Calculate blocking factor, delay factor, centrality"""
+        
+        # Blocking Factor: courses this blocks
+        blocking = len(list(nx.descendants(self.graph, course_id)))
+        
+        # Correctly calculate the delay factor by finding the longest path
+        delay = 0
+        sinks = [n for n, d in self.graph.out_degree() if d == 0]
+        
+        max_len = 0
+        for sink in sinks:
+            try:
+                paths = list(nx.all_simple_paths(self.graph, source=course_id, target=sink))
+                if paths:
+                    current_max = max(len(p) for p in paths)
+                    if current_max > max_len:
+                        max_len = current_max
+            except (nx.NetworkXNoPath, nx.NodeNotFound):
+                continue
+        delay = max_len
+        
+        # Centrality: betweenness centrality
+        centrality_dict = nx.betweenness_centrality(self.graph)
+        centrality = centrality_dict.get(course_id, 0) * 100
+        
+        # Complexity (from your analyzer)
+        complexity = self.courses[course_id].get('complexity', 0)
+        
+        return {
+            'blocking': blocking,
+            'delay': delay,
+            'centrality': round(centrality, 1),
+            'complexity': complexity
+        }
+    
+    def create_hierarchical_layout(self) -> Dict:
+        """Create semester-based layout like CurricularAnalytics"""
+        
+        # Topological sort to get course ordering
+        try:
+            topo_order = list(nx.topological_sort(self.graph))
+        except nx.NetworkXError:
+            # Has cycles, use DFS order
+            topo_order = list(nx.dfs_preorder_nodes(self.graph))
+        
+        # Calculate depth for each node (semester level)
+        depths = {}
+        for node in topo_order:
+            predecessors = list(self.graph.predecessors(node))
+            if not predecessors:
+                depths[node] = 0
+            else:
+                depths[node] = max(depths.get(p, 0) for p in predecessors) + 1
+        
+        # Group by depth (semester)
+        layers = {}
+        for node, depth in depths.items():
+            if depth not in layers:
+                layers[depth] = []
+            layers[depth].append(node)
+        
+        # Create positions
+        positions = {}
+        max_width = max(len(nodes) for nodes in layers.values()) if layers else 1
+        
+        for depth, nodes in layers.items():
+            width = len(nodes)
+            spacing = 2.0 / (width + 1) if width > 0 else 1
+            
+            for i, node in enumerate(nodes):
+                x = (i + 1) * spacing - 1  # Center around 0
+                y = -depth * 2  # Vertical spacing
+                positions[node] = (x, y)
+        
+        self.positions = positions
+        self.layers = layers
+        return positions
+    
+    def create_interactive_plot(self, highlight_path: List[str] = None) -> go.Figure:
+        """Create Plotly interactive network graph"""
+        
+        if not self.positions:
+            self.create_hierarchical_layout()
+        
+        # Create edge traces
+        edge_traces = []
+        
+        for edge in self.graph.edges():
+            if edge[0] not in self.positions or edge[1] not in self.positions:
+                continue
+            x0, y0 = self.positions[edge[0]]
+            x1, y1 = self.positions[edge[1]]
+            
+            # Check if edge is on critical path
+            is_critical = False
+            if highlight_path and edge[0] in highlight_path and edge[1] in highlight_path:
+                try:
+                    idx0 = highlight_path.index(edge[0])
+                    idx1 = highlight_path.index(edge[1])
+                    is_critical = idx1 == idx0 + 1
+                except ValueError:
+                    is_critical = False
+            
+            edge_trace = go.Scatter(
+                x=[x0, x1, None],
+                y=[y0, y1, None],
+                mode='lines',
+                line=dict(
+                    width=3 if is_critical else 1,
+                    color='red' if is_critical else '#888'
+                ),
+                hoverinfo='none',
+                showlegend=False
+            )
+            edge_traces.append(edge_trace)
+        
+        # Create node trace
+        node_x = []
+        node_y = []
+        node_text = []
+        node_color = []
+        node_size = []
+        
+        for node in self.graph.nodes():
+            if node not in self.positions:
+                continue
+            x, y = self.positions[node]
+            node_x.append(x)
+            node_y.append(y)
+            
+            # Get course info
+            course_data = self.courses.get(node, {})
+            metrics = self.calculate_metrics(node)
+            
+            # Create hover text
+            hover_text = f"""
+            <b>{node}: {course_data.get('name', 'Unknown')}</b><br>
+            Credits: {course_data.get('credits', 4)}<br>
+            <br><b>Metrics:</b><br>
+            Complexity: {metrics['complexity']}<br>
+            Blocking Factor: {metrics['blocking']}<br>
+            Delay Factor: {metrics['delay']}<br>
+            Centrality: {metrics['centrality']}<br>
+            Prerequisites: {', '.join(self.graph.predecessors(node)) or 'None'}
+            """
+            node_text.append(hover_text)
+            
+            # Color by complexity
+            node_color.append(metrics['complexity'])
+            
+            # Size by blocking factor
+            node_size.append(15 + metrics['blocking'] * 2)
+        
+        node_trace = go.Scatter(
+            x=node_x,
+            y=node_y,
+            mode='markers+text',
+            text=[node for node in self.graph.nodes() if node in self.positions],
+            textposition="top center",
+            textfont=dict(size=10),
+            hovertext=node_text,
+            hoverinfo='text',
+            marker=dict(
+                showscale=True,
+                colorscale='Viridis',
+                size=node_size,
+                color=node_color,
+                colorbar=dict(
+                    thickness=15,
+                    title=dict(text="Complexity", side="right"), 
+                    xanchor="left"
+                ),
+                line=dict(width=2, color='white')
+            )
+        )
+        
+        # Create figure
+        fig = go.Figure(data=edge_traces + [node_trace])
+        
+        # FIXED: Updated layout with proper title syntax (no more titlefont_size)
+        fig.update_layout(
+            title=dict(
+                text="Interactive Curriculum Map", 
+                font=dict(size=20)
+            ),
+            showlegend=False,
+            hovermode='closest',
+            margin=dict(b=0, l=0, r=0, t=40),
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            plot_bgcolor='white',
+            height=800
+        )
+        
+        return fig
+    
+    def find_critical_path(self) -> List[str]:
+        """Find the longest path (critical path) in curriculum"""
+        
+        if not nx.is_directed_acyclic_graph(self.graph):
+            return []
+        
+        # Find all paths from sources to sinks
+        sources = [n for n in self.graph.nodes() if self.graph.in_degree(n) == 0]
+        sinks = [n for n in self.graph.nodes() if self.graph.out_degree(n) == 0]
+        
+        longest_path = []
+        max_length = 0
+        
+        for source in sources:
+            for sink in sinks:
+                try:
+                    paths = list(nx.all_simple_paths(self.graph, source, sink))
+                    for path in paths:
+                        if len(path) > max_length:
+                            max_length = len(path)
+                            longest_path = path
+                except nx.NetworkXNoPath:
+                    continue
+        
+        return longest_path
+    
+    def export_to_curricular_analytics_format(self, plan: Dict) -> Dict:
+        """Export plan in CurricularAnalytics JSON format"""
+        
+        ca_format = {
+            "curriculum": {
+                "name": "Generated Curriculum",
+                "courses": [],
+                "dependencies": []
+            },
+            "metrics": {}
+        }
+        
+        # Add courses
+        for course_id in self.graph.nodes():
+            course_data = self.courses.get(course_id, {})
+            metrics = self.calculate_metrics(course_id)
+            
+            ca_format["curriculum"]["courses"].append({
+                "id": course_id,
+                "name": course_data.get('name', ''),
+                "credits": course_data.get('credits', 4),
+                "complexity": metrics['complexity'],
+                "blocking_factor": metrics['blocking'],
+                "delay_factor": metrics['delay'],
+                "centrality": metrics['centrality']
+            })
+        
+        # Add dependencies
+        for edge in self.graph.edges():
+            ca_format["curriculum"]["dependencies"].append({
+                "source": edge[0],
+                "target": edge[1],
+                "type": "prerequisite"
+            })
+        
+        return ca_format
+
+def run_visualizer():
+    """Streamlit app for visualization"""
+    
+    st.set_page_config(page_title="Curriculum Visualizer", layout="wide")
+    st.title("🗺️ Interactive Curriculum Visualizer")
+    
+    # Sidebar
+    with st.sidebar:
+        st.header("Controls")
+        
+        # File upload
+        uploaded_file = st.file_uploader("Upload curriculum graph", type=['pkl'])
+        
+        # Display options
+        show_critical = st.checkbox("Highlight Critical Path", value=True)
+        show_metrics = st.checkbox("Show Metrics Panel", value=True)
+        
+        # Filter options
+        st.subheader("Filter Courses")
+        min_complexity = st.slider("Min Complexity", 0, 200, 0)
+        subjects = st.multiselect("Subjects", ["CS", "DS", "MATH", "IS", "CY"])
+    
+    # Main content
+    if uploaded_file:
+        # Load graph
+        graph = pickle.load(uploaded_file)
+        visualizer = CurriculumVisualizer(graph)
+        
+        # Apply filters
+        if subjects:
+            nodes_to_keep = [
+                n for n in graph.nodes() 
+                if graph.nodes[n].get('subject') in subjects
+            ]
+            filtered_graph = graph.subgraph(nodes_to_keep).copy()
+            visualizer = CurriculumVisualizer(filtered_graph)
+        
+        # Create visualization
+        col1, col2 = st.columns([3, 1] if show_metrics else [1])
+        
+        with col1:
+            # Find critical path
+            critical_path = []
+            if show_critical:
+                critical_path = visualizer.find_critical_path()
+                if critical_path:
+                    st.info(f"Critical Path: {' → '.join(critical_path[:5])}...")
+            
+            # Create and display plot
+            fig = visualizer.create_interactive_plot(critical_path)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        if show_metrics:
+            with col2:
+                st.subheader("📊 Curriculum Metrics")
+                
+                # Overall metrics
+                total_courses = visualizer.graph.number_of_nodes()
+                total_prereqs = visualizer.graph.number_of_edges()
+                
+                st.metric("Total Courses", total_courses)
+                st.metric("Total Prerequisites", total_prereqs)
+                if total_courses > 0:
+                    st.metric("Avg Prerequisites", f"{total_prereqs/total_courses:.1f}")
+                
+                st.divider()
+                
+                # Most complex courses
+                st.subheader("Most Complex Courses")
+                complexities = []
+                for node in visualizer.graph.nodes():
+                    metrics = visualizer.calculate_metrics(node)
+                    complexities.append((node, metrics['complexity']))
+                
+                complexities.sort(key=lambda x: x[1], reverse=True)
+                
+                for course, complexity in complexities[:5]:
+                    name = visualizer.courses.get(course, {}).get('name', course)
+                    st.write(f"**{course}**: {name}")
+                    st.progress(min(complexity/200, 1.0) if complexity else 0.0)
+                
+                # Export button
+                st.divider()
+                if st.button("Export to CA Format"):
+                    ca_json = visualizer.export_to_curricular_analytics_format({})
+                    st.download_button(
+                        "Download JSON",
+                        json.dumps(ca_json, indent=2),
+                        "curriculum_analytics.json",
+                        "application/json"
+                    )
+    else:
+        # Demo/instruction
+        st.info("Upload a curriculum graph file to visualize")
+        
+        with st.expander("About this Visualizer"):
+            st.write("""
+            This tool creates interactive curriculum dependency graphs similar to CurricularAnalytics.org.
+            
+            **Features:**
+            - Hierarchical layout by semester level
+            - Color coding by complexity
+            - Node size by blocking factor
+            - Critical path highlighting
+            - Interactive hover details
+            - Export to CurricularAnalytics format
+            
+            **Metrics Calculated:**
+            - **Blocking Factor**: Number of courses this prerequisite blocks
+            - **Delay Factor**: Length of longest path through this course
+            - **Centrality**: Importance in the curriculum network
+            - **Complexity**: Combined metric from all factors
+            """)
+
+if __name__ == "__main__":
+    run_visualizer()

src/neu_graph_analyzed_clean.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a06bd2aea94fbc0bb21db9f16fcb4cf201046f764cbd97f78eadd3ad5d73a4a
+size 173978

src/neu_scraper.py

@@ -0,0 +1,235 @@
+"""
+NEU Course Catalog Scraper using SearchNEU GraphQL API (With Proper Pagination)
+
+Fetches ALL courses for given subjects using first/offset pagination.
+
+Usage:
+    python neu_scraper.py --term 202510 --subjects CS DS IS CY --prefix neu_api
+"""
+import requests
+import pickle
+import networkx as nx
+import time
+import logging
+from typing import List, Dict, Set, Any
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+class NEUGraphQLScraper:
+    def __init__(self, term_id: str, api_url: str = "https://searchneu.com/graphql"):
+        self.term_id = term_id
+        self.api_url = api_url
+        self.headers = {"Content-Type": "application/json"}
+        self.courses_data_cache: Dict[str, Dict] = {}
+        self.all_course_ids: Set[str] = set()
+        self.graph = nx.DiGraph()
+
+    def get_all_courses_by_subject(self, subject: str, batch_size: int = 100) -> List[Dict]:
+        """Fetch ALL courses for a specific subject via GraphQL with pagination."""
+        all_courses = []
+        offset = 0
+        page = 1
+        
+        while True:
+            query = """
+            query searchQuery($termId: String!, $query: String!, $first: Int, $offset: Int) {
+              search(termId: $termId, query: $query, first: $first, offset: $offset) {
+                totalCount
+                nodes {
+                  __typename
+                  ... on ClassOccurrence {
+                    subject
+                    classId
+                    name
+                    desc
+                    prereqs
+                    coreqs
+                    minCredits
+                    maxCredits
+                  }
+                }
+              }
+            }
+            """
+            variables = {
+                "termId": self.term_id, 
+                "query": subject, 
+                "first": batch_size, 
+                "offset": offset
+            }
+            
+            try:
+                resp = requests.post(self.api_url, json={"query": query, "variables": variables}, headers=self.headers)
+                resp.raise_for_status()
+                data = resp.json()
+                
+                if "errors" in data:
+                    logger.error(f"GraphQL errors for subject {subject}: {data['errors']}")
+                    break
+                    
+                search_data = data.get("data", {}).get("search", {})
+                nodes = search_data.get("nodes", [])
+                
+                # Extract ClassOccurrence nodes
+                page_courses = [c for c in nodes if c.get("__typename") == "ClassOccurrence"]
+                all_courses.extend(page_courses)
+                
+                logger.info(f"Page {page}: Found {len(page_courses)} courses, Total so far: {len(all_courses)}")
+                
+                # Check if we've reached the end
+                if len(page_courses) < batch_size:
+                    break
+                    
+                offset += batch_size
+                page += 1
+                
+                # Add a small delay to avoid overwhelming the API
+                time.sleep(0.1)
+                
+            except Exception as e:
+                logger.error(f"Error fetching page {page} for subject {subject}: {e}")
+                break
+        
+        logger.info(f"Total courses found for {subject}: {len(all_courses)}")
+        return all_courses
+
+    def get_course_data_by_id(self, subject: str, classId: str) -> Dict:
+        """Fetch a specific course by its subject and classId."""
+        query = """
+        query searchQuery($termId: String!, $query: String!) {
+          search(termId: $termId, query: $query) {
+            nodes {
+              __typename
+              ... on ClassOccurrence {
+                subject
+                classId
+                name
+                desc
+                prereqs
+                coreqs
+                minCredits
+                maxCredits
+              }
+            }
+          }
+        }
+        """
+        variables = {"termId": self.term_id, "query": f"{subject}{classId}"}
+        try:
+            resp = requests.post(self.api_url, json={"query": query, "variables": variables}, headers=self.headers)
+            resp.raise_for_status()
+            data = resp.json()
+            
+            nodes = data.get("data", {}).get("search", {}).get("nodes", [])
+            for c in nodes:
+                if c.get("subject") == subject and c.get("classId") == classId:
+                    return c
+            return {}
+        except Exception as e:
+            logger.error(f"Error fetching course {subject}{classId}: {e}")
+            return {}
+
+    def _recursive_parse_prereqs(self, prereq_obj: Any) -> Set[str]:
+        """Extract course IDs from nested prereq/coreq structures."""
+        ids = set()
+        if not isinstance(prereq_obj, dict):
+            return ids
+            
+        # Handle direct course references (the actual structure we see)
+        if "classId" in prereq_obj and "subject" in prereq_obj:
+            ids.add(f"{prereq_obj['subject']}{prereq_obj['classId']}")
+            return ids
+            
+        # Handle logical operators (and/or) with nested values
+        if prereq_obj.get("type") in ["and", "or"]:
+            for val in prereq_obj.get("values", []):
+                ids |= self._recursive_parse_prereqs(val)
+                
+        # Handle nested values in other structures
+        elif "values" in prereq_obj:
+            for val in prereq_obj.get("values", []):
+                ids |= self._recursive_parse_prereqs(val)
+                
+        return ids
+
+    def scrape_full_catalog(self, subjects: List[str]):
+        """Scrape all courses for the given subjects."""
+        logger.info(f"Fetching complete catalog for subjects: {subjects}")
+        
+        all_courses = []
+        for subject in subjects:
+            logger.info(f"Fetching courses for subject: {subject}")
+            courses = self.get_all_courses_by_subject(subject)
+            all_courses.extend(courses)
+            
+            # Add a small delay to be respectful to the API
+            time.sleep(0.5)
+        
+        # Cache all courses
+        for c in all_courses:
+            cid = f"{c['subject']}{c['classId']}"
+            self.courses_data_cache[cid] = c
+            self.all_course_ids.add(cid)
+            
+        logger.info(f"Discovered {len(all_courses)} total courses in catalog")
+
+    def build_graph(self):
+        """Build NetworkX graph from scraped course data and requisites."""
+        logger.info("Building course graph")
+        
+        # Add all courses as nodes
+        for cid, cdata in self.courses_data_cache.items():
+            self.graph.add_node(cid, **{
+                "name": cdata.get("name", ""),
+                "subject": cdata.get("subject", ""),
+                "classId": cdata.get("classId", ""),
+                "description": cdata.get("desc", ""), # Corrected from 'desc'
+                "minCredits": cdata.get("minCredits", 0),
+                "maxCredits": cdata.get("maxCredits", 0)
+            })
+        
+        # Add edges ONLY for prerequisites
+        for cid, cdata in self.courses_data_cache.items():
+            prereqs = cdata.get("prereqs", {})
+            if prereqs:
+                prereq_ids = self._recursive_parse_prereqs(prereqs)
+                for pid in prereq_ids:
+                    if pid in self.graph:
+                        self.graph.add_edge(pid, cid, relationship="prerequisite")
+
+    def save_data(self, prefix: str):
+        """Save graph and courses to pickle files with timestamp."""
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        gfile = f"{prefix}_graph_{ts}.pkl"
+        cfile = f"{prefix}_courses_{ts}.pkl"
+        
+        with open(gfile, "wb") as gf:
+            pickle.dump(self.graph, gf)
+        with open(cfile, "wb") as cf:
+            pickle.dump(self.courses_data_cache, cf)
+            
+        logger.info(f"Data saved: {gfile}, {cfile}")
+        
+        # Also save some stats
+        logger.info(f"Graph stats: {self.graph.number_of_nodes()} nodes, {self.graph.number_of_edges()} edges")
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Full NEU API Catalog Scraper")
+    parser.add_argument("--term", required=True, help="Term ID e.g. 202510")
+    parser.add_argument("--subjects", nargs="+", required=True, help="Subjects to scrape (e.g., CS DS IS CY)")
+    parser.add_argument("--prefix", default="neu_api", help="Output prefix")
+    parser.add_argument("--batch-size", type=int, default=100, help="Number of courses per page")
+    args = parser.parse_args()
+
+    scraper = NEUGraphQLScraper(term_id=args.term)
+    scraper.scrape_full_catalog(args.subjects)
+    scraper.build_graph()
+    scraper.save_data(args.prefix)
+    logger.info("Scraping complete.")
+
+if __name__ == "__main__":
+    main()

src/prompts.py

@@ -0,0 +1,48 @@
+def get_semester_selection_prompt(profile_str: str, courses_str: str, num_courses: int = 4) -> str:
+    """Generate optimized prompt for LLM course selection"""
+    
+    return f"""You are an expert academic advisor for computer science students.
+
+TASK: Select exactly {num_courses} courses for the upcoming semester.
+
+STUDENT PROFILE:
+{profile_str}
+
+AVAILABLE COURSES:
+{courses_str}
+
+SELECTION CRITERIA:
+1. Prerequisites must be satisfied (from completed courses list)
+2. Prioritize courses that align with student's career goals
+3. Balance workload - mix harder and easier courses
+4. Consider logical progression (foundations before advanced)
+5. Focus on CS, DS, IS courses for AI/ML career path
+
+OUTPUT FORMAT (must be valid JSON):
+{{
+    "courses": ["COURSE_ID_1", "COURSE_ID_2", "COURSE_ID_3", "COURSE_ID_4"],
+    "reasoning": "One sentence explaining the selection"
+}}
+
+Return ONLY the JSON object, no other text."""
+
+def get_plan_optimization_prompt(student_profile: dict, available_courses: list, semester_num: int) -> str:
+    """Generate prompt for full degree plan optimization"""
+    
+    return f"""Create semester {semester_num} schedule for an AI/ML-focused student.
+
+COMPLETED: {', '.join(student_profile.get('completed_courses', []))}
+GOAL: {student_profile.get('career_goals', 'AI Engineer')}
+INTERESTS: {', '.join(student_profile.get('interests', []))}
+
+MUST FOLLOW RULES:
+- Take foundations first: CS1800, CS2500, CS2510, CS2800, CS3000, CS3500
+- Year 1: Focus on 1000-2000 level courses
+- Year 2: Add 3000 level courses  
+- Year 3-4: Include 4000+ level courses
+- Avoid labs, recitations, seminars (they're auto-enrolled)
+
+AVAILABLE COURSES:
+{chr(10).join(available_courses[:20])}
+
+OUTPUT: JSON with "courses" array (4 course IDs) and "reasoning" string."""

src/requirements (1).txt

@@ -0,0 +1,13 @@
+Flask
+Flask-CORS
+PyMuPDF
+sentence-transformers
+faiss-cpu
+numpy
+langchain
+langchain_community
+requests # To communicate with Ollama API
+python-dotenv # Optional, for managing environment variables like OLLAMA_BASE_URL
+scikit-learn # For cosine similarity if needed outside FAISS
+nltk # For sentence tokenization
+

src/run.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Unified runner that works on any hardware
+Automatically adapts to available resources
+"""
+
+import sys
+import argparse
+from config import get_config
+
+def run_streamlit_app():
+    """Run the standard Streamlit UI"""
+    import streamlit.web.cli as stcli
+    sys.argv = ["streamlit", "run", "ui.py"]
+    sys.exit(stcli.main())
+
+def run_agent_mode():
+    """Run the autonomous agent"""
+    from agentic_optimizer import LocalAgentRunner, StudentProfile
+    
+    print("Starting Agentic Mode...")
+    runner = LocalAgentRunner("neu_graph_analyzed_clean.pkl")
+    
+    # Demo: Add a test student
+    student = StudentProfile(
+        student_id="demo",
+        completed_courses=["CS1800", "CS2500"],
+        current_gpa=3.5,
+        interests=["AI", "Machine Learning"],
+        career_goals="ML Engineer",
+        learning_style="Visual",
+        time_commitment=40,
+        preferred_difficulty="moderate"
+    )
+    
+    student_id = runner.add_student(student)
+    print(f"Tracking student: {student_id}")
+    
+    # Start agent
+    runner.start_agent()
+
+def run_api_server():
+    """Run as REST API server"""
+    from fastapi import FastAPI, HTTPException
+    from pydantic import BaseModel
+    import uvicorn
+    import pickle
+    
+    # Load optimizer
+    from curriculum_optimizer import HybridOptimizer, StudentProfile
+    
+    app = FastAPI(title="Curriculum Optimizer API")
+    
+    # Load model once
+    optimizer = HybridOptimizer()
+    optimizer.load_models()
+    
+    with open("neu_graph_analyzed_clean.pkl", 'rb') as f:
+        graph = pickle.load(f)
+    optimizer.load_data(graph)
+    
+    class PlanRequest(BaseModel):
+        completed_courses: list
+        gpa: float = 3.5
+        interests: list
+        career_goals: str
+        learning_style: str = "Visual"
+        time_commitment: int = 40
+        preferred_difficulty: str = "moderate"
+    
+    @app.post("/generate_plan")
+    async def generate_plan(request: PlanRequest):
+        profile = StudentProfile(
+            completed_courses=request.completed_courses,
+            current_gpa=request.gpa,
+            interests=request.interests,
+            career_goals=request.career_goals,
+            learning_style=request.learning_style,
+            time_commitment=request.time_commitment,
+            preferred_difficulty=request.preferred_difficulty
+        )
+        
+        plan = optimizer.generate_plan(profile)
+        return plan
+    
+    @app.get("/health")
+    async def health():
+        return {"status": "healthy", "device": str(optimizer.device)}
+    
+    print("Starting API server on http://localhost:8000")
+    print("API docs at http://localhost:8000/docs")
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+def test_hardware():
+    """Test what hardware is available"""
+    import torch
+    
+    print("=" * 60)
+    print("HARDWARE TEST")
+    print("=" * 60)
+    
+    if torch.cuda.is_available():
+        print(f"✓ CUDA available")
+        print(f"  Device: {torch.cuda.get_device_name(0)}")
+        print(f"  Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f}GB")
+        print(f"  Compute: {torch.cuda.get_device_properties(0).major}.{torch.cuda.get_device_properties(0).minor}")
+    else:
+        print("✗ No CUDA (CPU only)")
+    
+    print(f"\nSelected Config: {get_config().__name__}")
+    config = get_config()
+    print(f"  LLM: {config.LLM_MODEL or 'None (embeddings only)'}")
+    print(f"  Embedder: {config.EMBEDDING_MODEL}")
+    print(f"  Quantization: {config.QUANTIZATION or 'None'}")
+    
+    print("\nRecommended mode based on hardware:")
+    if torch.cuda.is_available() and torch.cuda.get_device_properties(0).total_memory > 10e9:
+        print("  → Use 'streamlit' or 'agent' mode (full features)")
+    else:
+        print("  → Use 'api' mode (lightweight)")
+
+def main():
+    parser = argparse.ArgumentParser(description="Curriculum Optimizer Runner")
+    parser.add_argument(
+        "mode",
+        choices=["streamlit", "agent", "api", "test"],
+        help="Run mode: streamlit (UI), agent (autonomous), api (REST server), test (hardware test)"
+    )
+    parser.add_argument(
+        "--config",
+        choices=["h200", "colab", "local", "cpu", "minimal"],
+        help="Force specific configuration"
+    )
+    
+    args = parser.parse_args()
+    
+    # Set config if specified
+    if args.config:
+        import os
+        os.environ["CURRICULUM_CONFIG"] = args.config
+    
+    # Run selected mode
+    if args.mode == "streamlit":
+        run_streamlit_app()
+    elif args.mode == "agent":
+        run_agent_mode()
+    elif args.mode == "api":
+        run_api_server()
+    elif args.mode == "test":
+        test_hardware()
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        # No arguments - run hardware test
+        test_hardware()
+        print("\nUsage: python run.py [streamlit|agent|api|test]")
+    else:
+        main()