Changes before Firebase Studio auto-run

.idx/dev.nix

@@ -22,11 +22,16 @@
       enable = true;
       previews = {
         web = {
-          command = [ "./devserver.sh" ];
-          env = { PORT = "$PORT"; };
+          command = [ "sh" "-c" "source .venv/bin/activate && python -u 'app copy.py'" ];
+          env = { 
+            PORT = "$PORT";
+            GOOGLE_API_KEY = "AIzaSyCc8ggBCJY0XimSrE1NU8z9Ax4qAPMXO_w";
+           };
           manager = "web";
         };
       };
     };
   };
+  
 }
+

agg.py

@@ -1,25 +1,36 @@
-# data_aggregator.py (Final Version)
+# data_aggregator.py (Complete Version with Resume Parsing)
 
 import json
 import os
 import re
 import time
 from datetime import datetime
+import logging
 
-# Import the scraper functions and classes from your existing files
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('data_aggregator')
+
+# Import the scraper functions and classes
 from github_scraper import get_github_profile
 from codeforces_scraper import get_codeforces_profile
 from leetcode_scraper import get_leetcode_profile
 from ipu_scraper import StudentScraper
+# Import our resume parser
+from resume_parser import parse_resume
 
 # --- Configuration ---
-# Define the list of students you want to fetch data for.
+# Define the list of students with resume paths
 STUDENTS_TO_FETCH = [
     {
         "enrollment_no": "35214811922",
         "leetcode_user": "akshitsharma7093",
         "github_user": "akshit7093",
-        "codeforces_user": "akshit7093"
+        "codeforces_user": "akshit7093",
+        "resume_path": "resume.pdf"  # REQUIRED FIELD
     }
     # Add more student dictionaries here
 ]
@@ -31,6 +42,7 @@ OUTPUT_FILE = 'final_cleaned_student_data.json'
 def clean_ipu_data(raw_data):
     """Transforms raw IPU academic data into a final, clean format."""
     if not raw_data or raw_data.get("status") != "success":
+        logger.warning("IPU data is empty or failed")
         return None
 
     overall = raw_data["academic_summary"]["overall_performance"]
@@ -67,6 +79,7 @@ def clean_ipu_data(raw_data):
 def clean_leetcode_data(raw_data):
     """Cleans and filters LeetCode data, summarizing top skills."""
     if not raw_data:
+        logger.warning("LeetCode data is empty")
         return None
         
     # Flatten all skills into a single list to find the absolute top skills
@@ -103,6 +116,7 @@ def clean_leetcode_data(raw_data):
 def clean_github_data(raw_data):
     """Summarizes GitHub data, cleans README, and fixes pinned repo logic."""
     if not raw_data:
+        logger.warning("GitHub data is empty")
         return None
         
     def summarize_repo(repo):
@@ -156,6 +170,7 @@ def clean_github_data(raw_data):
 def clean_codeforces_data(raw_data):
     """Cleans Codeforces data, focusing on performance and simplifying contest history."""
     if not raw_data:
+        logger.warning("Codeforces data is empty")
         return None
         
     profile = raw_data.get("profile", {})
@@ -190,6 +205,57 @@ def clean_codeforces_data(raw_data):
         ]
     }
 
+def clean_resume_data(raw_resume_data):
+    """Processes raw resume data into final structured format"""
+    if not raw_resume_data:
+        logger.warning("Resume data is empty")
+        return None
+    
+    # Extract only professional hyperlinks (filter out common non-professional links)
+    professional_links = [
+        url for url in raw_resume_data["hyperlinks"]
+        if not re.search(r'(facebook|instagram|twitter|linkedin\.com\/in\/[^\/]+\/(detail|overlay)|youtube)', url, re.I)
+    ]
+    
+    # Extract skills from resume text (simplified approach)
+    skills = []
+    skill_keywords = ['python', 'java', 'javascript', 'react', 'node', 'angular', 'vue', 'sql', 
+                     'mongodb', 'aws', 'docker', 'kubernetes', 'git', 'c++', 'c#', 'typescript',
+                     'html', 'css', 'spring', 'django', 'flask', 'tensorflow', 'pytorch', 'dsa',
+                     'data structures', 'algorithms', 'problem solving', 'full stack', 'backend',
+                     'frontend', 'mobile', 'android', 'ios', 'flutter', 'react native']
+    
+    resume_text = raw_resume_data["full_text"].lower()
+    for keyword in skill_keywords:
+        if keyword in resume_text and keyword not in skills:
+            skills.append(keyword.capitalize())
+    
+    # Identify missing elements (simplified approach)
+    missing_elements = []
+    if 'projects' not in resume_text and 'project' not in resume_text:
+        missing_elements.append("Projects section")
+    if 'internship' not in resume_text and 'experience' not in resume_text and 'work' not in resume_text:
+        missing_elements.append("Work experience")
+    if 'education' not in resume_text and 'degree' not in resume_text:
+        missing_elements.append("Education details")
+    if len(skills) < 3:
+        missing_elements.append("Technical skills listing")
+    
+    # Clean summary text (remove excessive whitespace and special characters)
+    cleaned_summary = re.sub(r'\s{2,}', ' ', raw_resume_data["summary"])
+    cleaned_summary = re.sub(r'[^\w\s.,;:!?()\-]', '', cleaned_summary)
+    
+    return {
+        "full_text": raw_resume_data["full_text"],
+        "full_text_preview": raw_resume_data["full_text"][:500] + "..." if len(raw_resume_data["full_text"]) > 500 else raw_resume_data["full_text"],
+        "professional_links": professional_links,
+        "skills_summary": cleaned_summary,
+        "key_skills": skills,
+        "total_hyperlinks": len(raw_resume_data["hyperlinks"]),
+        "professional_link_count": len(professional_links),
+        "missing_elements": missing_elements
+    }
+
 # --- Main Execution Logic ---
 
 def main():
@@ -197,15 +263,15 @@ def main():
     ipu_scraper = StudentScraper(encryption_key="Qm9sRG9OYVphcmEK")
     all_student_data = {}
 
-    print(f"Starting data aggregation for {len(STUDENTS_TO_FETCH)} student(s)...")
+    logger.info(f"Starting data aggregation for {len(STUDENTS_TO_FETCH)} student(s)...")
 
     for student in STUDENTS_TO_FETCH:
         enrollment_no = student.get("enrollment_no")
         if not enrollment_no:
-            print("Skipping entry due to missing enrollment number.")
+            logger.warning("Skipping entry due to missing enrollment number.")
             continue
 
-        print(f"\nFetching & Cleaning data for Enrollment No: {enrollment_no}")
+        logger.info(f"\nProcessing data for Enrollment No: {enrollment_no}")
         
         student_record = {
             "name": None,
@@ -216,72 +282,89 @@ def main():
                 "github": None,
                 "codeforces": None,
             },
+            "resume": None,  # NEW FIELD
             "errors": {}
         }
 
         # Fetch, Clean, and Assign Data
         try:
-            print("  - Processing IPU data...")
+            logger.info("  - Processing IPU data...")
             raw_ipu_data = ipu_scraper.get_student_data(enrollment_no)
             student_record["academic_profile"] = clean_ipu_data(raw_ipu_data)
             if student_record["academic_profile"]:
                 student_record["name"] = raw_ipu_data.get("student_info", {}).get("name")
-                print("    > Success.")
+                logger.info("    > IPU data processed successfully.")
             else:
-                 raise Exception("Failed to process IPU data.")
+                raise Exception("Failed to process IPU data.")
         except Exception as e:
             student_record["errors"]["ipu"] = str(e)
-            print(f"    > FAILED: {e}")
+            logger.error(f"    > IPU processing FAILED: {e}")
 
         if student.get("leetcode_user"):
             try:
-                print(f"  - Processing LeetCode data for '{student['leetcode_user']}'...")
+                logger.info(f"  - Processing LeetCode data for '{student['leetcode_user']}'...")
                 raw_leetcode_result = get_leetcode_profile(student["leetcode_user"])
                 if raw_leetcode_result.get("success"):
                     student_record["coding_profiles"]["leetcode"] = clean_leetcode_data(raw_leetcode_result["data"])
-                    print("    > Success.")
+                    logger.info("    > LeetCode data processed successfully.")
                 else:
                     raise Exception(raw_leetcode_result.get("error", "Unknown error"))
             except Exception as e:
                 student_record["errors"]["leetcode"] = str(e)
-                print(f"    > FAILED: {e}")
+                logger.error(f"    > LeetCode processing FAILED: {e}")
         
         if student.get("github_user"):
             try:
-                print(f"  - Processing GitHub data for '{student['github_user']}'...")
+                logger.info(f"  - Processing GitHub data for '{student['github_user']}'...")
                 raw_github_result = get_github_profile(student["github_user"])
                 if raw_github_result.get("success"):
                     student_record["coding_profiles"]["github"] = clean_github_data(raw_github_result["data"])
-                    print("    > Success.")
+                    logger.info("    > GitHub data processed successfully.")
                 else:
                     raise Exception(raw_github_result.get("error", "Unknown error"))
             except Exception as e:
                 student_record["errors"]["github"] = str(e)
-                print(f"    > FAILED: {e}")
+                logger.error(f"    > GitHub processing FAILED: {e}")
 
         if student.get("codeforces_user"):
             try:
-                print(f"  - Processing Codeforces data for '{student['codeforces_user']}'...")
+                logger.info(f"  - Processing Codeforces data for '{student['codeforces_user']}'...")
                 raw_codeforces_result = get_codeforces_profile(student["codeforces_user"])
                 if raw_codeforces_result.get("success"):
                     student_record["coding_profiles"]["codeforces"] = clean_codeforces_data(raw_codeforces_result["data"])
-                    print("    > Success.")
+                    logger.info("    > Codeforces data processed successfully.")
                 else:
                     raise Exception(raw_codeforces_result.get("error", "Unknown error"))
             except Exception as e:
                 student_record["errors"]["codeforces"] = str(e)
-                print(f"    > FAILED: {e}")
+                logger.error(f"    > Codeforces processing FAILED: {e}")
+        
+        # Process resume data
+        if student.get("resume_path"):
+            try:
+                logger.info(f"  - Processing resume from '{student['resume_path']}'...")
+                
+                # Check if file exists
+                if not os.path.exists(student["resume_path"]):
+                    raise FileNotFoundError(f"Resume file not found at {student['resume_path']}")
+                
+                raw_resume_data = parse_resume(student["resume_path"])
+                student_record["resume"] = clean_resume_data(raw_resume_data)
+                logger.info("    > Resume data processed successfully.")
+            except Exception as e:
+                student_record["errors"]["resume"] = str(e)
+                logger.error(f"    > Resume processing FAILED: {e}")
         
         all_student_data[enrollment_no] = student_record
-        time.sleep(1)
+        time.sleep(1)  # Respectful delay between requests
 
     # Save the final cleaned & aggregated data
     try:
         with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
             json.dump(all_student_data, f, indent=4, ensure_ascii=False)
-        print(f"\n✅ Final cleaning complete. Data saved to '{OUTPUT_FILE}'.")
+        logger.info(f"\n✅ Final cleaning complete. Data saved to '{OUTPUT_FILE}'.")
     except Exception as e:
-        print(f"\n❌ Error saving final JSON file: {e}")
+        logger.error(f"\n❌ Error saving final JSON file: {e}")
 
 if __name__ == "__main__":
     main()

app copy.py

@@ -1,58 +0,0 @@
-# app.py
-from flask import Flask, render_template, jsonify, request
-from rag_system import StudentApiRAG
-import json
-
-app = Flask(__name__)
-
-# Initialize the RAG system once when the application starts.
-# This is efficient as the data is loaded into memory only once.
-print("Initializing Student Analysis System...")
-rag_system = StudentApiRAG()
-print("System Initialized Successfully.")
-
-# --- API Endpoints ---
-
-@app.route('/')
-def index():
-    """Serves the main HTML page."""
-    return render_template('final.html')
-
-@app.route('/api/students', methods=['GET'])
-def get_students():
-    """Returns a list of all available students to populate the dropdown."""
-    student_list = [
-        {"enrollment_no": eno, "name": data.get("name", "Unknown")}
-        for eno, data in rag_system.student_data.items()
-    ]
-    return jsonify(student_list)
-
-@app.route('/api/report/<enrollment_no>', methods=['GET'])
-def get_report(enrollment_no):
-    """Generates and returns the full structured report for a student."""
-    if not enrollment_no:
-        return jsonify({"error": "Enrollment number is required."}), 400
-    
-    report = rag_system.generate_structured_report(enrollment_no)
-    
-    if "error" in report:
-        return jsonify(report), 500
-        
-    return jsonify(report)
-
-@app.route('/api/ask', methods=['POST'])
-def ask_question():
-    """Handles a chatbot question and returns the AI's answer."""
-    data = request.json
-    enrollment_no = data.get('enrollment_no')
-    question = data.get('question')
-
-    if not all([enrollment_no, question]):
-        return jsonify({"error": "Enrollment number and question are required."}), 400
-
-    answer = rag_system.answer_question(question, enrollment_no)
-    return jsonify({"answer": answer})
-
-if __name__ == '__main__':
-    # Use host='0.0.0.0' to make it accessible from your local network
-    app.run(host='0.0.0.0', port=5000, debug=True)

app_copy.py

@@ -0,0 +1,203 @@
+# app_copy.py (or whatever your main Flask app file is named)
+
+from flask import Flask, jsonify, request, render_template, redirect, url_for
+import os
+# Import the RAG system class
+from rag_system import StudentApiRAG
+import logging # Import logging module
+
+# --- Configure logging ---
+# It's generally good practice to configure logging early
+logging.basicConfig(level=logging.INFO) # Adjust level as needed (DEBUG, INFO, WARNING, ERROR)
+logger = logging.getLogger(__name__) # Create a logger for this module
+
+# --- Initialize Flask App ---
+app = Flask(__name__,
+            static_folder='static',  # Directory for CSS/JS files
+            template_folder='templates')  # Directory for HTML files
+
+# Ensure static and templates directories exist
+os.makedirs('static', exist_ok=True)
+os.makedirs('templates', exist_ok=True)
+
+# --- Initialize the RAG System ---
+# This is the crucial part: create the instance and attach it to the app object
+# Make sure the GOOGLE_API_KEY environment variable is set
+try:
+    app.rag_system = StudentApiRAG() # <-- This line is key
+    logger.info("RAG System initialized successfully.")
+except Exception as e:
+    logger.error(f"Failed to initialize RAG System: {e}")
+    # Depending on your needs, you might want to exit here or disable related features
+    app.rag_system = None # Or handle the error appropriately
+
+
+# --- Define Routes ---
+
+@app.route('/')
+def home():
+    return redirect(url_for('test_frontend'))
+
+@app.route('/test') # Assuming this is your frontend route
+def test_frontend():
+    return render_template('final.html') # Make sure index.html exists in templates/
+
+# --- Example route for students (adjust as needed) ---
+@app.route('/api/students', methods=['GET'])
+def get_students_list():
+    # Dummy implementation or integrate with your student data
+    # This is just an example, replace with actual logic
+    return jsonify([{"enrollment_no": "35214811922", "name": "Akshit Sharma"}])
+
+# --- Job Analysis Route (Corrected) ---
+@app.route('/api/job-analysis', methods=['POST'])
+def analyze_job_application_route():
+    """Endpoint for job application analysis"""
+    # Check if RAG system was initialized successfully
+    if not app.rag_system:
+        logger.error("RAG System not initialized. Cannot perform job analysis.")
+        return jsonify({
+            'success': False,
+            'error': 'Internal server error: Analysis system not available.'
+        }), 500
+
+    try:
+        data = request.get_json()
+        if not data:
+             logger.warning("No JSON data received in job analysis request.")
+             return jsonify({
+                'success': False,
+                'error': 'Invalid request: No JSON data provided.'
+            }), 400
+
+        job_application_link = data.get('job_application_link')
+        # Get the enrollment number from the request data
+        enrollment_no = data.get('enrollment_no')
+
+        if not job_application_link or not enrollment_no:
+            logger.warning("Missing 'job_application_link' or 'enrollment_no' in job analysis request data.")
+            return jsonify({
+                'success': False,
+                'error': 'Job application link and enrollment number are required.'
+            }), 400
+
+        logger.info(f"Initiating job application analysis for link: {job_application_link} and student: {enrollment_no}")
+        # Call the analyze_job_application method on the RAG system instance with both arguments
+        result = app.rag_system.analyze_job_application(job_application_link, enrollment_no)
+
+        if result.get("error"):
+            logger.warning(f"Job analysis reported an error: {result['error']}")
+            return jsonify({
+                'success': False,
+                'error': result["error"]
+            }), 400 # Or maybe 500 if it's an internal processing error?
+
+        logger.info("Job application analysis completed successfully.")
+        return jsonify({
+            'success': True,
+            'data': result
+        })
+
+    except Exception as e:
+        # Now 'logger' is defined and can be used
+        logger.error(f"Error in job analysis route: {e}", exc_info=True) # exc_info=True adds traceback
+        return jsonify({
+            'success': False,
+            'error': 'Failed to analyze job application due to an internal server error.'
+        }), 500
+
+
+# Add this route to your app_copy.py
+@app.route('/api/ask', methods=['POST'])
+def answer_question_route():
+    """Endpoint for answering questions about a student"""
+    # Check if RAG system was initialized successfully
+    if not app.rag_system:
+        logger.error("RAG System not initialized. Cannot answer question.")
+        return jsonify({
+            'success': False,
+            'error': 'Internal server error: Question answering system not available.'
+        }), 500
+
+    try:
+        data = request.get_json()
+        if not data:
+            logger.warning("No JSON data received in question request.")
+            return jsonify({
+                'success': False,
+                'error': 'Invalid request: No JSON data provided.'
+            }), 400
+
+        enrollment_no = data.get('enrollment_no')
+        question = data.get('question')
+
+        if not enrollment_no or not question:
+            logger.warning("Missing 'enrollment_no' or 'question' in request data.")
+            return jsonify({
+                'success': False,
+                'error': 'Enrollment number and question are required.'
+            }), 400
+
+        logger.info(f"Answering question for enrollment {enrollment_no}: {question}")
+        # Call the answer_question method on the RAG system instance
+        answer = app.rag_system.answer_question(question, enrollment_no)
+
+        logger.info("Question answered successfully.")
+        return jsonify({
+            'success': True,
+            'answer': answer
+        })
+
+    except Exception as e:
+        logger.error(f"Error in question answering route: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': 'Failed to answer question due to an internal server error.'
+        }), 500
+
+# --- Route for getting student-specific dashboard metrics ---
+@app.route('/api/dashboard/metrics/<enrollment_no>', methods=['GET'])
+def get_student_dashboard_metrics(enrollment_no: str):
+    """Endpoint for getting detailed dashboard metrics for a specific student."""
+    if not app.rag_system:
+        logger.error("RAG System not initialized. Cannot get dashboard metrics.")
+        return jsonify({'error': 'Internal server error: Dashboard system not available.'}), 500
+
+    try:
+        logger.info(f"Fetching dashboard metrics for enrollment: {enrollment_no}")
+        # Call the new get_student_dashboard_metrics method on the RAG system instance
+        metrics_data = app.rag_system.get_student_dashboard_metrics(enrollment_no)
+
+        if metrics_data.get("error"):
+             logger.warning(f"Dashboard metrics error for {enrollment_no}: {metrics_data['error']}")
+             return jsonify(metrics_data), 404 # Or appropriate error code
+        return jsonify(metrics_data)
+    except Exception as e:
+        logger.error(f"Error fetching dashboard metrics for {enrollment_no}: {e}", exc_info=True)
+        return jsonify({'error': 'Failed to fetch dashboard metrics.'}), 500
+
+# --- Other routes (e.g., /api/report/<enrollment_no>, /api/ask, etc.) ---
+# Make sure to use app.rag_system.<method_name>() for calling RAG methods
+# Example placeholder for report generation:
+@app.route('/api/report/<enrollment_no>', methods=['GET'])
+def get_student_report(enrollment_no: str):
+    if not app.rag_system:
+        logger.error("RAG System not initialized. Cannot generate report.")
+        return jsonify({'error': 'Internal server error: Report system not available.'}), 500
+
+    try:
+        logger.info(f"Generating report for enrollment: {enrollment_no}")
+        report_data = app.rag_system.generate_structured_report(enrollment_no)
+        if report_data.get("error"):
+             logger.warning(f"Report generation error for {enrollment_no}: {report_data['error']}")
+             return jsonify(report_data), 404 # Or appropriate error code
+        return jsonify(report_data)
+    except Exception as e:
+        logger.error(f"Error generating report for {enrollment_no}: {e}", exc_info=True)
+        return jsonify({'error': 'Failed to generate report.'}), 500
+
+
+if __name__ == '__main__':
+    # Run the app
+    
+    app.run(host='0.0.0.0', port=5000, debug=True) # Adjust host/port/debug as needed

dashboard_analyzer.py

@@ -0,0 +1,222 @@
+# dashboard_analyzer.py
+import logging
+import json
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+# --- Constants for Scoring and Analysis ---
+# These can be tweaked to adjust the analysis logic. They are data-agnostic.
+THRESHOLDS = {
+    'CGPA_EXCELLENT': 8.5,
+    'CGPA_GOOD': 7.5,
+    'LEETCODE_TOTAL_HIGH': 200,
+    'LEETCODE_TOTAL_MEDIUM': 100,
+    'GITHUB_STARS_HIGH': 10,
+    'GITHUB_REPOS_HIGH': 20,
+}
+
+WEIGHTS = {
+    'LEETCODE_EASY': 0.2,
+    'LEETCODE_MEDIUM': 1.0,
+    'LEETCODE_HARD': 2.5,
+    'GITHUB_STARS': 2.0,
+    'GITHUB_FORKS': 3.0,
+    'GITHUB_REPOS': 0.5,
+}
+
+def get_dashboard_metrics(student_data: dict) -> dict:
+    """
+    Performs a fully data-driven, advanced analysis of a student's raw JSON data
+    to extract a rich set of metrics for the dashboard without any hardcoded assumptions.
+
+    Args:
+        student_data (dict): The dictionary containing all data for one student.
+
+    Returns:
+        dict: A deeply nested dictionary with structured dashboard metrics and insights.
+    """
+    if not student_data:
+        return {"error": "No student data provided."}
+
+    # --- Perform analysis on different sections of the profile ---
+    academics = _analyze_academics(student_data.get("academic_profile", {}))
+    leetcode = _analyze_leetcode(student_data.get("coding_profiles", {}).get("leetcode", {}))
+    github = _analyze_github(student_data.get("coding_profiles", {}).get("github", {}))
+    skills = _extract_skills(student_data)
+    completeness = _calculate_profile_completeness(student_data)
+    
+    # --- Synthesize overall insights from the analyses ---
+    archetype = _determine_student_archetype(skills, leetcode, github)
+
+    # --- Assemble the final, comprehensive metrics object ---
+    return {
+        "overall_summary": {
+            "student_archetype": archetype,
+            "profile_completeness": completeness
+        },
+        "academics": academics,
+        "coding_profiles": {
+            "leetcode": leetcode,
+            "github": github
+        },
+        "skills_distribution": skills,
+    }
+
+def _analyze_academics(academic_data: dict) -> dict:
+    """
+    Analyzes academic performance dynamically from the data provided.
+    Includes trajectory, overall subject performance, and detailed semester overviews.
+    """
+    cgpa = academic_data.get("overall_cgpa", 0)
+    
+    # Qualitative Rating based on CGPA
+    if cgpa >= THRESHOLDS['CGPA_EXCELLENT']: rating = "Excellent"
+    elif cgpa >= THRESHOLDS['CGPA_GOOD']: rating = "Good"
+    else: rating = "Needs Improvement"
+
+    # Academic Trajectory based on SGPA trend
+    sgpa_list = [sem.get("sgpa", 0) for sem in academic_data.get("semester_performance", [])]
+    trajectory = "Stable"
+    if len(sgpa_list) > 2:
+        first_half_avg = sum(sgpa_list[:len(sgpa_list)//2]) / (len(sgpa_list)//2)
+        second_half_avg = sum(sgpa_list[len(sgpa_list)//2:]) / (len(sgpa_list) - len(sgpa_list)//2)
+        if second_half_avg > first_half_avg + 0.2: trajectory = "Improving"
+        elif second_half_avg < first_half_avg - 0.2: trajectory = "Declining"
+
+    # --- Detailed Semester Overviews and Overall Subject Analysis ---
+    all_subjects_overall = []
+    semester_overviews = []
+
+    for semester_info in academic_data.get("semester_performance", []):
+        semester_subjects = []
+        high_grades_count = 0
+        
+        for subject_info in semester_info.get("subjects", []):
+            subject_record = {
+                "name": subject_info.get("subject"),
+                "marks": subject_info.get("marks", 0)
+            }
+            semester_subjects.append(subject_record)
+            all_subjects_overall.append(subject_record)
+            
+            if subject_info.get("grade") in ['O', 'A+']:
+                high_grades_count += 1
+        
+        if semester_subjects:
+            semester_subjects.sort(key=lambda x: x['marks']) # Sort by marks ascending
+            
+            semester_overviews.append({
+                "semester_number": semester_info.get("semester"),
+                "sgpa": semester_info.get("sgpa"),
+                "percentage": semester_info.get("percentage"),
+                "top_subject": semester_subjects[-1], # Last item is highest
+                "bottom_subject": semester_subjects[0], # First item is lowest
+                "high_grades_count": high_grades_count
+            })
+
+    # Determine overall subject strengths and weaknesses from all semesters
+    overall_strengths = []
+    overall_weaknesses = []
+    if all_subjects_overall:
+        all_subjects_overall.sort(key=lambda x: x['marks'], reverse=True) # Sort descending
+        overall_strengths = all_subjects_overall[:3] # Top 3 overall
+        overall_weaknesses = all_subjects_overall[-3:] # Bottom 3 overall
+
+    return {
+        "cgpa": cgpa,
+        "rating": rating,
+        "trajectory": trajectory,
+        "overall_subject_strengths": overall_strengths,
+        "overall_subject_weaknesses": overall_weaknesses,
+        "semester_overviews": semester_overviews
+    }
+
+# --- The following functions are already fully data-driven and remain unchanged ---
+
+def _analyze_leetcode(leetcode_data: dict) -> dict:
+    """Performs a nuanced analysis of LeetCode performance."""
+    if not leetcode_data: return {"rating": "Not Available", "score": 0, "total_solved": 0}
+    total_solved = leetcode_data.get("totalSolved", 0)
+    try:
+        easy = int(leetcode_data.get("problemsByDifficulty", {}).get("Easy", "0/0").split('/')[0])
+        medium = int(leetcode_data.get("problemsByDifficulty", {}).get("Medium", "0/0").split('/')[0])
+        hard = int(leetcode_data.get("problemsByDifficulty", {}).get("Hard", "0/0").split('/')[0])
+    except (ValueError, IndexError): easy, medium, hard = 0, 0, 0
+    raw_score = (easy * WEIGHTS['LEETCODE_EASY'] + medium * WEIGHTS['LEETCODE_MEDIUM'] + hard * WEIGHTS['LEETCODE_HARD'])
+    target_score = (150 * WEIGHTS['LEETCODE_EASY'] + 100 * WEIGHTS['LEETCODE_MEDIUM'] + 30 * WEIGHTS['LEETCODE_HARD'])
+    normalized_score = round((raw_score / target_score) * 10, 1) if target_score > 0 else 0
+    final_score = min(normalized_score, 10.0)
+    rating = "Beginner"
+    if hard > 10 or medium > 50: rating = "Advanced Problem Solver"
+    elif medium > 25 or total_solved > THRESHOLDS['LEETCODE_TOTAL_HIGH']: rating = "Active Competitor"
+    elif total_solved > THRESHOLDS['LEETCODE_TOTAL_MEDIUM']: rating = "Consistent Learner"
+    return {"rating": rating, "score": final_score, "total_solved": total_solved, "difficulty_breakdown": {"easy": easy, "medium": medium, "hard": hard}}
+
+def _analyze_github(github_data: dict) -> dict:
+    """Analyzes GitHub profile for activity, impact, and tech stack."""
+    if not github_data: return {"rating": "Not Available", "activity_level": "Unknown"}
+    stats, repos = github_data.get("stats", {}), github_data.get("top_repositories", [])
+    activity_level = "Low"
+    if repos:
+        try:
+            latest_push = max(datetime.strptime(repo['last_pushed'], "%Y-%m-%d") for repo in repos if repo.get('last_pushed'))
+            if (datetime.now() - latest_push).days < 7: activity_level = "Very Active"
+            elif (datetime.now() - latest_push).days < 30: activity_level = "Active"
+            elif (datetime.now() - latest_push).days < 90: activity_level = "Inactive"
+        except (ValueError, TypeError): pass
+    impact_score = sum(repo.get('stars', 0) * WEIGHTS['GITHUB_STARS'] + repo.get('forks', 0) * WEIGHTS['GITHUB_FORKS'] for repo in repos)
+    top_languages = list(dict.fromkeys([repo.get("language") for repo in repos if repo.get("language")]))[:3]
+    rating = "Needs Development"
+    if impact_score > 50 or stats.get('public_repos', 0) > THRESHOLDS['GITHUB_REPOS_HIGH']: rating = "Strong Profile"
+    elif activity_level in ["Very Active", "Active"] or stats.get('public_repos', 0) > 10: rating = "Good Profile"
+    return {"rating": rating, "activity_level": activity_level, "top_languages": top_languages, "stats": stats}
+
+def _extract_skills(student_data: dict) -> list:
+    """Extracts, combines, and cleans a list of key skills."""
+    resume_skills = student_data.get("resume", {}).get("key_skills", [])
+    leetcode_skills = [item.get("skill") for item in student_data.get("coding_profiles", {}).get("leetcode", {}).get("topSkillsSummary", [])]
+    normalized_resume = [s.strip().title() for s in resume_skills]
+    normalized_leetcode = [s.strip().title() for s in leetcode_skills]
+    return list(dict.fromkeys(normalized_resume + normalized_leetcode))
+
+def _calculate_profile_completeness(student_data: dict) -> dict:
+    """Scores the profile based on the presence of key data points."""
+    checks = {
+        "Academics": bool(student_data.get("academic_profile", {}).get("semester_performance")),
+        "Resume": bool(student_data.get("resume", {}).get("key_skills")),
+        "LeetCode": bool(student_data.get("coding_profiles", {}).get("leetcode")),
+        "GitHub": bool(student_data.get("coding_profiles", {}).get("github")),
+        "Codeforces": bool(student_data.get("coding_profiles", {}).get("codeforces"))
+    }
+    score = int((sum(checks.values()) / len(checks)) * 100)
+    return {"score_percentage": score, "missing_sections": [key for key, value in checks.items() if not value]}
+
+def _determine_student_archetype(skills: list, leetcode_metrics: dict, github_metrics: dict) -> list:
+    """Generates dynamic tags based on analyzed metrics."""
+    archetypes = []
+    skills_lower = {s.lower() for s in skills}
+    if any(kw in skills_lower for kw in ["tensorflow", "pytorch", "ai", "machine learning", "nlp", "computer vision"]): archetypes.append("AI/ML Enthusiast")
+    if any(kw in skills_lower for kw in ["react", "node", "flask", "django", "backend", "frontend"]): archetypes.append("Web Developer")
+    if leetcode_metrics.get("rating") in ["Advanced Problem Solver", "Active Competitor"]: archetypes.append("Competitive Programmer")
+    if any(kw in skills_lower for kw in ["aws", "google cloud", "docker", "kubernetes"]): archetypes.append("Cloud & DevOps Oriented")
+    return archetypes if archetypes else ["Generalist"]
+
+# --- Testing Block ---
+if __name__ == '__main__':
+    print("Testing advanced, fully data-driven dashboard_analyzer.py...")
+    try:
+        with open('final_cleaned_student_data.json', 'r', encoding='utf-8') as f:
+            full_data = json.load(f)
+        sample_enrollment = "35214811922"
+        student_sample = full_data.get(sample_enrollment)
+        if student_sample:
+            metrics = get_dashboard_metrics(student_sample)
+            print("\n--- Generated Advanced Metrics ---")
+            print(json.dumps(metrics, indent=4))
+        else:
+            print(f"Error: Student with enrollment '{sample_enrollment}' not found.")
+    except FileNotFoundError:
+        print("Error: `final_cleaned_student_data.json` not found.")
+    except Exception as e:
+        logger.error(f"An unexpected error occurred during testing: {e}", exc_info=True)

final_cleaned_student_data.json

@@ -833,6 +833,50 @@
                 ]
             }
         },
+        "resume": {
+            "full_text": "Akshit Sharma \nFinal‑Year B.Tech (AI & Data Science) | Backend & AI/ML Engineer | Cloud‑Native Systems \nakshitsharma7096@gmail.com/ +91 8810248097/Github / Linkedin / LeetCode / CodeForces \nSKILLS\n \n●​\nProgramming Languages: Python, Java, C/C++, JavaScript, SQL, React, Node.js, TypeScript, Flask, FastAPI \n●​\nDatabases & Tools: Pandas, NumPy, Matplotlib, MongoDB, Postgre \n●​\nML/AI & Frameworks: TensorFlow, PyTorch, NLP, Computer Vision, Transformers, RAG, LangChain \n●​\nCloud & DevOps: AWS, Google Cloud Platform, OpenStack SDK, Docker, Kubernetes \n●​\nSystems & Fundamentals: Unix/Linux, TCP/IP Networking, Git, Data Structures & Algorithms, Computer Networks \nEXPERIENCE\n \nResearch Intern | Directorate of Research, Government of Arunachal Pradesh​\n​\n                    \n(August  2025 – Present) \n●​\nDeveloped a low-resource speech-to-speech translation pipeline using Wav2Vec 2.0 for ASR, MarianMT for NMT, and Tacotron 2 \nfor TTS, focusing on endangered languages with context-dependent meanings. \n●​\nOptimised system architecture to reduce translation latency to under 2 seconds, enabling real time deployment for field use. \nDeep Learning Intern | Akanila Technologies ​ ​\n                        https://github.com/akshit7093/Chatbot-for-websites \n(July 2024 – December 2024) \n●​\nDeveloped a universal chatbot platform by fine‑tuning Llama3.1 LLM using LoRA and integrating RAG with FAISS for \ndomain‑specific retrieval, boosting query accuracy to 90 % and improving response relevance by 25 %. \n●​\nDesigned a flexible Python backend with modular components in FastAPI increasing code reusability to 65% . \n●​\nImplemented automated deployments on AWS EC2, leveraging Docker for containerization and Kubernetes for container \norchestration. \nMachine Learning Intern | CodSoft                            ​\n        https://github.com/akshit7093/CODSOFT \n(August 2024 – September 2024) \n●​\nDeveloped a credit card fraud detection system using XGBoost, analyzing 1 million transaction records. \n●​\nEngineered 20+ features from behavioral and time-series data then trained an XGBoost model on SageMaker to drop false \npositives from 20% to 5% while keeping recall over 90%. \n●​\nBuilt an NLP model for SMS spam detection using Python and scikit-learn, achieving 95% accuracy on test data. \nPROJECT\n \nOpenStack Cloud Management System with Natural Language Interface          https://github.com/akshit7093/VM_manager_AgenticAi \n●​\nBuilt a cloud management system interfacing with OpenStack infrastructure APIs. \n●​\nEnabled users to issue natural language prompts (e.g., \"create a server\" or \"delete a volume\"), which an AI agent created using \nLangChain and Google's Gemini-2.5 pro model translated into precise OpenStack API calls. \n●​\nBuilt an interactive CLI and a web app for remote management, featuring resource analytics and container monitoring per VM. \n●​\nDesigned RESTful backend with Fastapi and containerized the application using Docker. \n●​\nTechnologies: Python, OpenStack SDK, Gemini, Fastapi, Docker, LangChain \nSignEase -Video calling platform for individuals with disabilities​                        https://github.com/akshit7093/Sign-language-translator.git \n●​\nCreated a video chat application using React and Node.js to enable video communication with ASL translation. \n●​\nImplemented American Sign Language (ASL) detection using MediaPipe for landmarks and an LSTM network in TensorFlow, \nreaching 89% accuracy on a small dataset of 20 videos. \n●​\nReduced latency from 500ms to 180ms using model quantization (TensorFlow Lite) and frame-rate optimization. \n●​\nTechnologies: Python, TensorFlow, WebRTC, React, Node.js, MediaPipe. \nEDUCATION \n \nMaharaja Agrasen Institute of Technology​\n​\n​\n​\n​\n​\n​\n(June 2022 - June 2026) \n●​\nB.Tech. in Computer Science with a specialization in Artificial Intelligence and Data Science \n●​\nCGPA:8.96/10 ​\n​\n​\n​\n​\n​\n​\n​\n  \n●​\nRelevant Coursework: Machine Learning, Data Mining, Image Processing, Data Structures and Algorithms, Computer Networks \nCERTIFICATIONS \n \n●​\nData Science (Pwskills) \n●​\nMachine Learning and Deep Learning Specialization (Coursera) \n●​\nAWS Solutions Architect Virtual Experience Program (Forage)  \n●​\nIntroduction to Generative AI (Google) \n●​\nDevelop GenAI Apps with Gemini and Streamlit (Google) \n●​\nPrompt Design in Vertex AI (Google) \nACHIEVEMENTS \n \n●​\nWinner – AceCloud X RTDS Hackathon ‘25",
+            "full_text_preview": "Akshit Sharma \nFinal‑Year B.Tech (AI & Data Science) | Backend & AI/ML Engineer | Cloud‑Native Systems \nakshitsharma7096@gmail.com/ +91 8810248097/Github / Linkedin / LeetCode / CodeForces \nSKILLS\n \n●​\nProgramming Languages: Python, Java, C/C++, JavaScript, SQL, React, Node.js, TypeScript, Flask, FastAPI \n●​\nDatabases & Tools: Pandas, NumPy, Matplotlib, MongoDB, Postgre \n●​\nML/AI & Frameworks: TensorFlow, PyTorch, NLP, Computer Vision, Transformers, RAG, LangChain \n●​\nCloud & DevOps: AWS, Google...",
+            "professional_links": [
+                "mailto:akshitsharma7096@gmail.com",
+                "https://github.com/akshit7093",
+                "https://www.linkedin.com/in/akshit-sharma-475a94271/",
+                "https://leetcode.com/u/akshitsharma7093/",
+                "https://codeforces.com/profile/akshit7093",
+                "https://github.com/akshit7093/Chatbot-for-websites",
+                "https://github.com/akshit7093/CODSOFT",
+                "https://github.com/akshit7093/VM_manager_AgenticAi",
+                "https://github.com/akshit7093/Sign-language-translator.git",
+                "https://www.cloudskillsboost.google/public_profiles/1b626606-8403-4450-9b1a-dbba876587d7/badges/9194948",
+                "https://www.cloudskillsboost.google/public_profiles/1b626606-8403-4450-9b1a-dbba876587d7/badges/9194066",
+                "https://www.cloudskillsboost.google/public_profiles/1b626606-8403-4450-9b1a-dbba876587d7/badges/9140322",
+                "https://drive.google.com/file/d/1OeO7jFd7le1gg_6I0oBGjmsBIfA50p73/view?usp=sharing"
+            ],
+            "skills_summary": "Akshit Sharma FinalYear B.Tech (AI  Data Science)  Backend  AIML Engineer  CloudNative Systems akshitsharma7096gmail.com 91 8810248097Github  Linkedin  LeetCode  CodeForces SKILLS  Programming Languages: Python, Java, CC, JavaScript, SQL, React, Node.js, TypeScript, Flask, FastAPI  Databases  Tools: Pandas, NumPy, Matplotlib, MongoDB, Postgre  MLAI  Frameworks: TensorFlow, PyTorch, NLP, Computer Vision, Transformers, RAG, LangChain  Cloud  DevOps: AWS, Google Cloud Platform, OpenStack SDK, Docker, Kubernetes  Systems  Fundamentals: UnixLinux, TCPIP Networking, Git, Data Structures  Algorithms, Computer Networks EXPERIENCE Research Intern  Directorate of Research, Government of Arunachal Pradesh  (August 2025  Present)  Developed a low-resource speech-to-speech translation pipeline using Wav2Vec 2.0 for ASR, MarianMT for NMT, and Tacotron 2 for TTS, focusing on endangered languages with context-dependent meanings.  Optimised system architecture to reduce translation latency to under 2 seconds, enabling real time deployment for field use. Deep Learning Intern  Akanila Technologies   https:github.comakshit7093Chatbot-for-websites (July 2024  December 2024)  Developed a universal chatbot platform by finetuning Llama3.1 LLM using LoRA and integrating RAG with FAISS for domainspecific retrieval, boosting query accuracy to 90  and improving response relevance by 25 .  Designed a flexible Python...",
+            "key_skills": [
+                "Python",
+                "Java",
+                "Javascript",
+                "React",
+                "Node",
+                "Sql",
+                "Mongodb",
+                "Aws",
+                "Docker",
+                "Kubernetes",
+                "Git",
+                "C++",
+                "Typescript",
+                "Flask",
+                "Tensorflow",
+                "Pytorch",
+                "Data structures",
+                "Algorithms",
+                "Backend"
+            ],
+            "total_hyperlinks": 13,
+            "professional_link_count": 13,
+            "missing_elements": []
+        },
         "errors": {}
     }
 }

job_scraper.py

@@ -0,0 +1,203 @@
+# job_analyzer.py
+
+import os
+import json
+import logging
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import PromptTemplate
+from youtube_search_tool import YouTubeSearchTool
+
+logger = logging.getLogger('job_analyzer')
+
+class JobApplicationAnalyzer:
+    def __init__(self):
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            raise ValueError("GOOGLE_API_KEY environment variable not set!")
+            
+        self.llm = ChatGoogleGenerativeAI(
+            model="models/gemini-flash-latest",  # Using a more powerful model for better comparative analysis
+            google_api_key=api_key,
+            temperature=0.3  # Allowing for slightly more creative and encouraging coaching language
+        )
+        
+        self.youtube_tool = YouTubeSearchTool()
+        print("Job Application Analyzer initialized successfully.")
+
+    def analyze(self, job_application_link: str, student_profile: dict) -> dict:
+        """
+        Analyzes a student's profile against a job description and provides a
+        personalized action plan. This is the new, primary method.
+        """
+        print("  > Starting personalized job analysis...")
+        
+        # Convert the student's profile dictionary to a formatted JSON string for the prompt
+        student_context = json.dumps(student_profile, indent=2)
+
+        # Use the new, highly detailed prompt template
+        prompt = PromptTemplate(
+            template=self.get_analysis_prompt_template(),
+            input_variables=["job_application_link", "student_context"]
+        )
+        
+        chain = prompt | self.llm
+        
+        try:
+            response = chain.invoke({
+                "job_application_link": job_application_link,
+                "student_context": student_context
+            })
+            response_text = response.content
+            
+            # Clean and parse the JSON response from the LLM
+            json_text = self._extract_json(response_text)
+            if not json_text:
+                logger.error("No JSON object found in the LLM response for job analysis.")
+                return self._get_default_analysis("Failed to extract JSON from LLM response.")
+
+            analysis_data = json.loads(json_text)
+            
+            # Enhance the analysis with YouTube recommendations based on the AI's suggestions
+            if "strategic_areas_for_growth" in analysis_data:
+                print("  > Generating YouTube recommendations for growth areas...")
+                # Create a new key for recommendations to match the desired output format
+                analysis_data["video_recommendations"] = []
+                for area in analysis_data.get("strategic_areas_for_growth", []):
+                    # Use the concise search query provided by the LLM to avoid errors
+                    search_query = area.get("youtube_search_query")
+                    if not search_query:
+                        logger.warning(f"No youtube_search_query found for growth area: {area.get('area_to_develop')}")
+                        continue
+
+                    category = self._determine_skill_category(search_query)
+                    
+                    try:
+                        videos = self.youtube_tool.run({
+                            "query": search_query,
+                            "max_results": 3,
+                            "topic_category": category
+                        })
+                        
+                        formatted_videos = [{
+                            "title": v.get("title", "N/A"),
+                            "url": v.get("url"),
+                            "embed_url": v.get("embed_url"),
+                            "reason": v.get("description", "A recommended video to help you learn this topic.")
+                        } for v in videos]
+                        
+                        # Add to the new recommendations list
+                        analysis_data["video_recommendations"].append({
+                            "topic": area.get("area_to_develop"),
+                            "reason": f"This is a key area for you to focus on to better match the job requirements.",
+                            "category": category,
+                            "videos": formatted_videos
+                        })
+                    except Exception as e:
+                        logger.error(f"Error getting videos for topic '{search_query}': {e}")
+            
+            return analysis_data
+
+        except Exception as e:
+            logger.error(f"An error occurred during job application analysis: {e}", exc_info=True)
+            return self._get_default_analysis(str(e))
+
+    def _extract_json(self, text: str) -> str:
+        """Safely extracts a JSON object from a string that might contain other text."""
+        try:
+            # Find the first '{' and the last '}' to isolate the JSON object
+            start_index = text.find('{')
+            end_index = text.rfind('}') + 1
+            if start_index != -1 and end_index != 0:
+                return text[start_index:end_index]
+        except Exception:
+            return None
+        return None
+        
+    def get_analysis_prompt_template(self) -> str:
+        """
+        Returns the new, detailed prompt that forces a personalized, comparative analysis.
+        """
+        return """
+        **Your Persona:** You are a world-class Senior Career Strategist from Google. You are a mentor speaking directly and encouragingly to a student, using "you" and "your". Your advice is insightful, strategic, and hyper-personalized.
+
+        **Your Mission:** Analyze the provided student's profile against the requirements of the job description. Your output MUST BE a direct, comparative analysis, creating a personalized action plan to help the student land this specific job. You will not speak about a generic candidate; you will speak directly about the student's provided data.
+
+        **1. Student's Profile (Context):**
+        ```json
+        {student_context}
+        ```
+
+        **2. Job Description Link:**
+        {job_application_link}
+
+        **Your Step-by-Step Thinking Process (Internal Monologue):**
+        1.  **Deconstruct the Job:** I will identify the top 5 'must-have' technical and soft skills from the job description (e.g., BigQuery, Dataflow, customer-facing skills).
+        2.  **Analyze the Student:** I will thoroughly review the student's resume, projects, and coding stats. I will note the specific technologies they've used (e.g., Python, SQL, React) and the outcomes of their projects.
+        3.  **Perform a Comparative Gap Analysis:** This is the most critical step. I will compare the student's specific skills and projects to the job's requirements. 
+            - I will find direct evidence in their profile that matches the job (e.g., "Your project 'EcoSort' uses Python and computer vision, which directly aligns with the job's need for ML skills.").
+            - I will identify the most critical gaps (e.g., "The job requires Google Cloud experience, but your resume and projects only list AWS. This is your main gap to address.").
+        4.  **Craft the Action Plan:** I will translate this direct comparison into the structured JSON output below, ensuring every point refers back to the student's profile and the job description.
+
+        **The Output: Your Personalized Action Plan (JSON Format)**
+        Provide your response ONLY in the valid JSON format below. Do not include any text before or after the JSON block.
+
+        {{
+            "strategic_overview": {{
+                "summary": "Start with an encouraging summary directly referencing the student's background. e.g., 'With your background in [Student's Major/Key Skill], this role is a great potential fit. We need to focus on showcasing how your projects align with their needs and strategically build up your Google Cloud expertise.'",
+                "your_key_opportunity": "Identify the single most important thing for you to do. e.g., 'Your biggest opportunity is to frame your AWS project experience as cloud-agnostic engineering excellence, while rapidly learning the GCP specifics.'"
+            }},
+            "your_core_strengths_for_this_role": [
+                {{
+                    "strength_area": "Reference a specific skill or project from the student's profile. e.g., 'Python and Data Manipulation Skills'",
+                    "evidence_from_your_profile": "Quote or describe the evidence from the student's JSON data. e.g., 'Your 'Data-Driven-Dialogue' project on GitHub shows strong proficiency in Python with Pandas and Scikit-learn.'",
+                    "how_it_matches_the_job": "Explain precisely how this evidence meets a key requirement from the job description. e.g., 'This is crucial for the role, which requires scripting and building data prototypes to solve customer problems.'"
+                }}
+            ],
+            "strategic_areas_for_growth": [
+                {{
+                    "area_to_develop": "Identify a specific missing skill or experience. e.g., 'Hands-On Google Cloud Data Stack Expertise'",
+                    "severity": "Categorize as 'Critical Gap', 'High-Impact Area', or 'Nice-to-Have'.",
+                    "insight": "Explain why this is a gap by comparing their profile to the job description. e.g., 'The role is laser-focused on the GCP ecosystem. While your foundational data skills are strong, your resume does not mention hands-on experience with BigQuery or Dataflow, which are core requirements.'",
+                    "path_to_improvement": [
+                        "1. **Certify:** Rapidly study for and pass the Google Cloud Professional Data Engineer certification. This is the strongest signal you can send.",
+                        "2. **Build & Showcase:** Create a small, end-to-end project using Pub/Sub, Dataflow, and BigQuery and feature it prominently on your GitHub and resume."
+                    ],
+                    "youtube_search_query": "Provide a short, effective search query (3-5 words) for this topic. e.g., 'Google Cloud Dataflow tutorial' or 'Technical presentation skills for engineers'"
+                }}
+            ]
+        }}
+        """
+
+    def _determine_skill_category(self, skill: str) -> str:
+        """Determines the category for a skill, optimized for short search queries."""
+        skill_lower = skill.lower()
+        if any(kw in skill_lower for kw in ["cloud", "aws", "azure", "gcp", "docker", "bigquery", "dataflow"]):
+            return "Cloud Computing"
+        if any(kw in skill_lower for kw in ["python", "java", "sql", "javascript", "c++"]):
+            return "Programming Languages"
+        if any(kw in skill_lower for kw in ["ml", "ai", "machine learning", "vertex"]):
+            return "Machine Learning"
+        if any(kw in skill_lower for kw in ["presentation", "communication", "soft skills", "customer"]):
+            return "Soft Skills"
+        return "Computer Science Fundamentals"
+
+    def _get_default_analysis(self, error_message: str) -> dict:
+        """Returns a default, structured analysis in case of a processing error."""
+        logger.warning(f"Using default job analysis due to processing error: {error_message}")
+        return {
+            "strategic_overview": {
+                "summary": "There was an error while generating your personalized analysis. Please try again.",
+                "your_key_opportunity": "Please ensure the job link is active and publicly accessible."
+            },
+            "your_core_strengths_for_this_role": [],
+            "strategic_areas_for_growth": [
+                {
+                    "area_to_develop": "System Processing Error",
+                    "severity": "Critical Gap",
+                    "insight": f"The analysis could not be completed due to a system error: {error_message}",
+                    "path_to_improvement": ["Please try your request again in a few moments."],
+                    "youtube_search_query": "Fixing application errors"
+                }
+            ],
+            "video_recommendations": []
+        }

prompts.py

@@ -1,10 +1,10 @@
-# prompts.py (Updated with stronger instructions)
+# prompts.py (Updated with resume analysis and YouTube recommendations)
 
 from langchain.prompts import PromptTemplate
-from langchain_core.pydantic_v1 import BaseModel, Field
-from typing import List
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
 
-# --- Pydantic Models for Structured Report Output (No changes here) ---
+# --- Pydantic Models for Structured Report Output ---
 
 class ScoreMetric(BaseModel):
     parameter: str = Field(description="The name of the parameter being scored, e.g., 'Problem Volume'.")
@@ -18,28 +18,45 @@ class StrengthWeakness(BaseModel):
 class Recommendation(BaseModel):
     recommendations: List[str] = Field(description="A list of 2-3 actionable, personalized recommendations for the student.")
 
+class ResumeAnalysis(BaseModel):
+    summary: str = Field(description="Concise summary of the resume content")
+    key_skills: List[str] = Field(description="Key technical and soft skills identified from the resume")
+    professional_links: List[str] = Field(description="Professional links found in the resume (GitHub, LinkedIn, portfolio)")
+    missing_elements: List[str] = Field(description="Important elements missing from the resume")
+
+class YouTubeRecommendation(BaseModel):
+    title: str = Field(description="Title of the YouTube video")
+    url: str = Field(description="URL of the YouTube video")
+    reason: str = Field(description="Why this video is recommended for the student")
+    embed_url: str = Field(description="Embed URL for the video (convert standard URL to embed format)")
+
 class StudentReport(BaseModel):
     """The complete structured report for a student."""
     overall_summary: str = Field(description="A one-paragraph 'HR Summary' of the student's overall profile.")
     detailed_scores: List[ScoreMetric] = Field(description="A list of scores for each parameter.")
     analysis: StrengthWeakness = Field(description="An analysis of strengths and weaknesses.")
     actionable_advice: Recommendation = Field(description="Personalized advice for improvement.")
+    resume_analysis: ResumeAnalysis = Field(description="Analysis of the student's resume")
+    youtube_recommendations: List[YouTubeRecommendation] = Field(description="Recommended YouTube videos for improvement")
 
 
 # --- Prompt Templates ---
 
-# --- UPDATED REPORT PROMPT TEMPLATE ---
 REPORT_PROMPT_TEMPLATE = """
-You are an expert AI career coach. Your task is to generate a performance report for a student based on the provided JSON data.
+You are an expert AI career coach. Your task is to generate a comprehensive performance report for a student based on the provided JSON data, including their resume analysis.
 
 **Student Profile Data:**
 {context}
 
 **Your Instructions:**
-1.  Analyze the provided data thoroughly.
-2.  Adhere strictly to the scoring rubric below to evaluate the student.
-3.  You MUST output a single, valid JSON object that conforms to the schema provided. 
-4.  DO NOT output any text, explanation, or markdown before or after the JSON object. Your entire response must be only the JSON.
+1. Analyze all provided data thoroughly, including the resume analysis section.
+2. Adhere strictly to the scoring rubric below to evaluate the student.
+3. For YouTube recommendations, provide 3-5 highly relevant videos that address the student's specific weaknesses or enhance their strengths.
+   - Convert standard YouTube URLs to embed format (replace 'watch?v=' with 'embed/')
+   - Focus on high-quality, educational content from reputable channels
+   - Prioritize recent videos (within last 2 years) for technical topics
+4. You MUST output a single, valid JSON object that conforms to the schema provided. 
+5. DO NOT output any text, explanation, or markdown before or after the JSON object. Your entire response must be only the JSON.
 
 **Scoring Rubric:**
 - **Problem Volume (20%):** Score based on total problems solved (LeetCode, Codeforces).
@@ -50,6 +67,18 @@ You are an expert AI career coach. Your task is to generate a performance report
 - **Programming Language Skill (5%):** Score based on primary language and versatility.
 - **Recent Activity (5%):** Score based on recent submissions and commits.
 
+**Resume Analysis Guidelines:**
+- Extract key skills mentioned in the resume
+- Identify professional links (GitHub, LinkedIn, portfolio)
+- Note any important elements missing (projects, education details, etc.)
+- Compare resume content with coding profiles for consistency
+
+**YouTube Recommendation Guidelines:**
+- Match videos to specific weaknesses identified in the analysis
+- Include videos that build on existing strengths
+- Provide clear reasoning for each recommendation
+- Format URLs correctly for embedding (https://www.youtube.com/embed/VIDEO_ID)
+
 **Output Format Instructions:**
 {format_instructions}
 """

rag_system.py

@@ -1,11 +1,19 @@
-# api_rag_system.py (Updated with Robust Parsing)
-
+# rag.py
 from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_core.output_parsers import JsonOutputParser # <-- CHANGED IMPORT
+from langchain_core.output_parsers import JsonOutputParser
 from prompts import REPORT_PROMPT, QA_PROMPT, StudentReport
 import json
+from langchain_core.prompts import PromptTemplate
 import os
+import re
+import logging
+from youtube_search_tool import YouTubeSearchTool
+# Import the new JobApplicationAnalyzer
+from job_scraper import JobApplicationAnalyzer # Corrected import name
+# Import the new dashboard analyzer logic
+from dashboard_analyzer import get_dashboard_metrics # Import the main function
 
+logger = logging.getLogger('rag_system')
 DATA_PATH = "final_cleaned_student_data.json"
 
 class StudentApiRAG:
@@ -14,66 +22,365 @@ class StudentApiRAG:
         api_key = os.getenv("GOOGLE_API_KEY")
         if not api_key:
             raise ValueError("GOOGLE_API_KEY environment variable not set!")
-            
         self.llm = ChatGoogleGenerativeAI(
-            model="models/gemini-2.5-pro",
+            model="models/gemini-flash-latest", # Updated model name if needed
             google_api_key=api_key,
             temperature=0.2
         )
-        
+        # Initialize the YouTube search tool
+        self.youtube_tool = YouTubeSearchTool()
         print("Loading student data into memory...")
         with open(DATA_PATH, 'r', encoding='utf-8') as f:
             self.student_data = json.load(f)
         print(f"✅ Loaded data for {len(self.student_data)} students. System ready.")
+        
+        # Initialize the new JobApplicationAnalyzer
+        self.job_analyzer = JobApplicationAnalyzer()
+        
+        # Define topic categories for better search organization (kept for potential other uses)
+        self.topic_categories = {
+            "DSA": [
+                "Arrays", "Strings", "Linked Lists", "Stacks", "Queues", 
+                "Trees", "Graphs", "Heaps", "Hashing", "Binary Search",
+                "Dynamic Programming", "Greedy Algorithms", "Backtracking",
+                "Bit Manipulation", "Math", "Sorting", "Searching", "AIDS303", "AIDS353"
+            ],
+            "Web Development": [
+                "HTML", "CSS", "JavaScript", "React", "Angular", "Vue",
+                "Node.js", "Express", "Django", "Flask", "REST APIs",
+                "TypeScript", "Webpack", "Babel", "CSS Frameworks"
+            ],
+            "Programming Languages": [
+                "Python", "Java", "C++", "C#", "JavaScript", "TypeScript",
+                "Go", "Rust", "Ruby", "PHP", "Swift", "Kotlin"
+            ],
+            "Computer Science Fundamentals": [
+                "Operating Systems", "Computer Networks", "Database Systems",
+                "Compilers", "Computer Architecture", "Distributed Systems",
+                "Artificial Intelligence", "Machine Learning", "Data Science",
+                "Cloud Computing", "Cybersecurity"
+            ]
+        }
 
     def _determine_sources_from_query(self, query: str) -> list:
-        # This function remains the same
         query = query.lower()
         sources = []
-        if any(keyword in query for keyword in ["dsa", "problem solving", "coding", "leetcode", "codeforces"]):
-            sources.extend(["leetcode", "codeforces"])
+        if any(keyword in query for keyword in ["dsa", "problem solving", "coding", "leetcode", "codeforces", "resume", "cv", "skills", "video", "youtube", "tutorial"]):
+            sources.extend(["leetcode", "codeforces", "resume"])
         if any(keyword in query for keyword in ["project", "experience", "github", "code", "repository"]):
             sources.append("github")
         if any(keyword in query for keyword in ["academic", "grade", "gpa", "cgpa", "subject", "marks", "semester"]):
             sources.append("academic_profile")
-        
-        return list(set(sources)) if sources else ["academic_profile", "coding_profiles"]
+        return list(set(sources)) if sources else ["academic_profile", "coding_profiles", "resume"]
+
+    def _identify_learning_topics(self, student_report: dict) -> list:
+        """Have the AI identify specific topic areas where the student needs improvement."""
+        print("  > Identifying specific learning topics for YouTube recommendations...")
+        # Extract relevant information from the report
+        weaknesses = student_report.get("analysis", {}).get("weaknesses", [])
+        strengths = student_report.get("analysis", {}).get("strengths", [])
+        # Get scores from the report
+        dev_orientation_score = 5
+        dsa_orientation_score = 5
+        # Try to extract scores from detailed_scores if available
+        for score in student_report.get("detailed_scores", []):
+            if "Development" in score["parameter"] or "Project" in score["parameter"]:
+                dev_orientation_score = score["score"]
+            if "DSA" in score["parameter"] or "Problem" in score["parameter"]:
+                dsa_orientation_score = score["score"]
+        # Create a more robust prompt template
+        prompt_template = """
+        Analyze this student's academic and coding profile to identify 3-5 specific topic areas 
+        where they need improvement. Focus on concrete, actionable topics that have dedicated 
+        learning resources on YouTube.
+        Student Profile:
+        - DSA Score: {dsa_orientation_score}/10
+        - Development/Project Score: {dev_orientation_score}/10
+        - Strengths: {strengths}
+        - Weaknesses: {weaknesses}
+        Identify specific topic areas where the student needs improvement. For each topic:
+        1. Provide a concise, specific topic name (e.g., "Binary Search", "React Hooks", "SQL Joins")
+        2. Explain why this topic is important for the student
+        3. Ensure the topic is narrow enough to have dedicated YouTube tutorials
+        Return ONLY a valid JSON array in this exact format:
+        [
+            {{
+                "topic": "Binary Search",
+                "reason": "The student struggles with searching algorithms and needs to understand binary search for efficient problem solving."
+            }},
+            {{
+                "topic": "React State Management",
+                "reason": "The student's projects show difficulty managing component state in complex UIs."
+            }}
+        ]
+        Make sure your JSON is properly formatted with double quotes around all keys and string values.
+        """
+        try:
+            # Create a chain to get the topic recommendations
+            chain = PromptTemplate(
+                template=prompt_template, 
+                input_variables=["dsa_orientation_score", "dev_orientation_score", "strengths", "weaknesses"]
+            ) | self.llm
+            # Invoke the chain with the actual values
+            response = chain.invoke({
+                "dsa_orientation_score": dsa_orientation_score,
+                "dev_orientation_score": dev_orientation_score,
+                "strengths": ', '.join(strengths) if strengths else 'None specifically identified',
+                "weaknesses": ', '.join(weaknesses) if weaknesses else 'None specifically identified'
+            })
+            response_text = response.content
+            # Try to extract JSON from the response
+            json_start = response_text.find('[')
+            json_end = response_text.rfind(']') + 1
+            if json_start == -1 or json_end == 0:
+                logger.error("No JSON array found in topic identification response")
+                logger.debug(f"Response text: {response_text}")
+                return self._get_default_topics()
+            json_text = response_text[json_start:json_end]
+            # Clean up common JSON issues
+            json_text = json_text.replace('\n', ' ').replace('\r', '')
+            try:
+                # Parse JSON
+                topics_data = json.loads(json_text)
+            except json.JSONDecodeError as e:
+                logger.error(f"Failed to parse topic identification as JSON: {e}")
+                logger.debug(f"JSON text: {json_text}")
+                # Try to fix common JSON issues
+                try:
+                    # Replace single quotes with double quotes
+                    fixed_json = json_text.replace("'", '"')
+                    topics_data = json.loads(fixed_json)
+                except:
+                    # If still fails, return default topics
+                    return self._get_default_topics()
+            if not isinstance(topics_data, list):
+                logger.error("Topic identification response is not a list")
+                return self._get_default_topics()
+            # Validate and clean the topics
+            valid_topics = []
+            for item in topics_data[:5]:  # Limit to 5 topics
+                topic = item.get("topic", "").strip()
+                reason = item.get("reason", "").strip()
+                if topic and reason:
+                    valid_topics.append({
+                        "topic": topic,
+                        "reason": reason,
+                        "category": self._determine_topic_category(topic)
+                    })
+            if not valid_topics:
+                logger.warning("No valid topics identified, using defaults")
+                return self._get_default_topics()
+            print(f"    > Identified {len(valid_topics)} specific learning topics.")
+            return valid_topics
+        except Exception as e:
+            logger.error(f"Error identifying learning topics: {e}")
+            return self._get_default_topics()
+
+    def _determine_topic_category(self, topic: str) -> str:
+        """Determine the most appropriate category for a topic."""
+        topic_lower = topic.lower()
+        # Check against our predefined categories
+        for category, topics in self.topic_categories.items():
+            for predefined_topic in topics:
+                if predefined_topic.lower() in topic_lower or topic_lower in predefined_topic.lower():
+                    return category
+        # Fallback categories based on keywords
+        if any(kw in topic_lower for kw in ["algorithm", "data structure", "dsa", "binary", "dynamic", "greedy", "tree", "graph", "array", "string"]):
+            return "DSA"
+        elif any(kw in topic_lower for kw in ["web", "react", "angular", "vue", "node", "express", "api", "html", "css", "javascript"]):
+            return "Web Development"
+        elif any(kw in topic_lower for kw in ["python", "java", "c++", "c#", "javascript", "go", "rust"]):
+            return "Programming Languages"
+        return "Computer Science Fundamentals"
+
+    def _get_default_topics(self) -> list:
+        """Return default topics in case of errors."""
+        return [
+            {
+                "topic": "Binary Search",
+                "reason": "Essential searching algorithm that forms the basis for many problem-solving techniques",
+                "category": "DSA"
+            },
+            {
+                "topic": "Dynamic Programming",
+                "reason": "Fundamental technique for solving optimization problems with overlapping subproblems",
+                "category": "DSA"
+            },
+            {
+                "topic": "React Fundamentals",
+                "reason": "Core concepts for building modern web applications with component-based architecture",
+                "category": "Web Development"
+            }
+        ]
+
+    def _get_youtube_recommendations(self, student_report: dict) -> list:
+        """Generate real YouTube video recommendations based on specific learning topics."""
+        print("  > Generating topic-based YouTube recommendations...")
+        # First, identify specific learning topics
+        learning_topics = self._identify_learning_topics(student_report)
+        # Now search for videos for each topic
+        topic_recommendations = []
+        for topic_info in learning_topics:
+            topic = topic_info["topic"]
+            category = topic_info["category"]
+            print(f"    > Searching for videos on topic: '{topic}' (category: {category})")
+            try:
+                # Search YouTube for this specific topic
+                youtube_videos = self.youtube_tool.run({
+                    "query": topic,
+                    "max_results": 5,
+                    "topic_category": category
+                })
+                # Format the videos for this topic
+                topic_videos = [{
+                    "title": video["title"],
+                    "url": video["url"],
+                    "embed_url": video["embed_url"],
+                    "reason": video["description"]
+                } for video in youtube_videos]
+                # Add to recommendations
+                topic_recommendations.append({
+                    "topic": topic,
+                    "reason": topic_info["reason"],
+                    "category": category,
+                    "videos": topic_videos
+                })
+                print(f"      > Found {len(topic_videos)} videos for topic '{topic}'")
+            except Exception as e:
+                print(f"    > Warning: Failed to get videos for topic '{topic}': {e}")
+                # Add fallback videos for this topic
+                fallback_videos = self.youtube_tool._get_fallback_videos(topic, 5, category)
+                topic_videos = [{
+                    "title": video["title"],
+                    "url": video["url"],
+                    "embed_url": video["embed_url"],
+                    "reason": video["description"]
+                } for video in fallback_videos]
+                topic_recommendations.append({
+                    "topic": topic,
+                    "reason": topic_info["reason"],
+                    "category": category,
+                    "videos": topic_videos
+                })
+        print(f"    > Generated {len(topic_recommendations)} topic sections with video recommendations.")
+        return topic_recommendations
 
     def generate_structured_report(self, enrollment_no: str) -> dict:
-        """Generates the full, structured student report via API call."""
+        """Generates the full, structured student report via API call including video suggestions."""
         print(f"Generating full report for {enrollment_no}...")
-        
         student_profile = self.student_data.get(enrollment_no)
         if not student_profile:
             return {"error": "No data found for this student."}
-            
         context = json.dumps(student_profile, indent=2)
-        
-        # --- PARSING FIX ---
-        # Use JsonOutputParser, which is more robust for this task.
-        # We pass the Pydantic model to it so it knows what to expect.
+        # Use JsonOutputParser with the Pydantic model
         parser = JsonOutputParser(pydantic_object=StudentReport)
-        
-        # Update the prompt to include the parser's format instructions
         prompt_with_format = REPORT_PROMPT.partial(
             format_instructions=parser.get_format_instructions()
         )
-        
-        # Use the new LangChain Expression Language (LCEL) syntax
         chain = prompt_with_format | self.llm | parser
-        
         try:
-            # The output from this chain will be a dictionary that matches the Pydantic model
+            # Get the base report
             report_dict = chain.invoke({"context": context})
+            # Now generate topic-based video recommendations
+            try:
+                youtube_recommendations = self._get_youtube_recommendations(report_dict)
+                # Add video suggestions to the report
+                report_dict["youtube_recommendations"] = youtube_recommendations
+                print(f"    > Added {len(youtube_recommendations)} topic sections with video recommendations.")
+            except Exception as e:
+                print(f"    > Warning: Failed to generate video suggestions: {e}")
+                report_dict["youtube_recommendations"] = self._get_default_topic_recommendations()
             return report_dict
         except Exception as e:
             print(f"Error invoking LLM or parsing output: {e}")
-            return {"error": "Failed to generate a valid report from the LLM."}
+            return {
+                "error": "Failed to generate a valid report from the LLM.",
+                "overall_summary": "Error generating report. Please try again later.",
+                "detailed_scores": [],
+                "analysis": {
+                    "strengths": ["Report generation error"],
+                    "weaknesses": ["Unable to analyze profile due to system error"]
+                },
+                "actionable_advice": {
+                    "recommendations": ["Please try generating the report again or contact support"]
+                },
+                "resume_analysis": {
+                    "summary": "Resume analysis unavailable",
+                    "key_skills": [],
+                    "professional_links": [],
+                    "missing_elements": ["Analysis failed"]
+                },
+                "youtube_recommendations": self._get_default_topic_recommendations()
+            }
+
+    def _get_default_topic_recommendations(self) -> list:
+        """Return default topic-based recommendations in case of errors."""
+        default_topics = self._get_default_topics()
+        topic_recommendations = []
+        for topic_info in default_topics:
+            topic = topic_info["topic"]
+            category = topic_info["category"]
+            # Get fallback videos for this topic
+            fallback_videos = self.youtube_tool._get_fallback_videos(topic, 5, category)
+            # Format the videos
+            topic_videos = [{
+                "title": video["title"],
+                "url": video["url"],
+                "embed_url": video["embed_url"],
+                "reason": video["description"]
+            } for video in fallback_videos]
+            topic_recommendations.append({
+                "topic": topic,
+                "reason": topic_info["reason"],
+                "category": category,
+                "videos": topic_videos
+            })
+        return topic_recommendations
+
+    def analyze_job_application(self, job_application_link: str, enrollment_no: str) -> dict:
+        """
+        Analyzes a student's profile against a job description link using the new JobApplicationAnalyzer.
+        This method now performs a comparative analysis and integrates YouTube recommendations based on specific AI-generated queries.
+        It fetches the student profile internally using the enrollment_no.
+        """
+        print(f"  > Starting job analysis using the new analyzer for link: {job_application_link} and student: {enrollment_no}")
+        
+        # Fetch the student profile internally
+        student_profile = self.student_data.get(enrollment_no)
+        if not student_profile:
+            logger.error(f"No data found for enrollment number: {enrollment_no}")
+            return {
+                "error": "No data found for the provided student enrollment number.",
+                "strategic_overview": {"summary": "Error: Student data not found.", "your_key_opportunity": "Please check the enrollment number."},
+                "your_core_strengths_for_this_role": [],
+                "strategic_areas_for_growth": [],
+                "video_recommendations": []
+            }
+        
+        # Use the imported JobApplicationAnalyzer's analyze method
+        analysis_result = self.job_analyzer.analyze(job_application_link, student_profile)
+        
+        return analysis_result
+
+    def get_student_dashboard_metrics(self, enrollment_no: str) -> dict:
+        """
+        Retrieves and analyzes a specific student's profile data using the dashboard_analyzer logic.
+        """
+        print(f"  > Calculating dashboard metrics for student: {enrollment_no}")
+        student_profile = self.student_data.get(enrollment_no)
+        if not student_profile:
+            logger.error(f"No data found for enrollment number: {enrollment_no}")
+            return {"error": "No data found for the provided student enrollment number."}
+        
+        # Use the imported get_dashboard_metrics function from dashboard_analyzer.py
+        metrics = get_dashboard_metrics(student_profile)
+        
+        return metrics
+
 
     def answer_question(self, query: str, enrollment_no: str) -> str:
         """Answers a specific question using a targeted context from the JSON."""
         print(f"Answering question for {enrollment_no}: '{query}'")
-        
         student_profile = self.student_data.get(enrollment_no)
         if not student_profile:
             return "Could not find data for the selected student."
@@ -84,7 +391,6 @@ class StudentApiRAG:
         targeted_context = {}
         if "academic_profile" in sources_to_use:
             targeted_context["academic_profile"] = student_profile.get("academic_profile")
-        
         coding_profiles = {}
         if "leetcode" in sources_to_use:
             coding_profiles["leetcode"] = student_profile.get("coding_profiles", {}).get("leetcode")
@@ -92,19 +398,17 @@ class StudentApiRAG:
             coding_profiles["github"] = student_profile.get("coding_profiles", {}).get("github")
         if "codeforces" in sources_to_use:
             coding_profiles["codeforces"] = student_profile.get("coding_profiles", {}).get("codeforces")
-        
         if coding_profiles:
             targeted_context["coding_profiles"] = coding_profiles
-        
         if "coding_profiles" in sources_to_use and not coding_profiles:
-             targeted_context["coding_profiles"] = student_profile.get("coding_profiles")
+            targeted_context["coding_profiles"] = student_profile.get("coding_profiles")
+        if "resume" in sources_to_use:
+            targeted_context["resume"] = student_profile.get("resume")
 
         if not targeted_context:
             return "I could not find any relevant information in this student's profile to answer that question."
 
         context_str = json.dumps(targeted_context, indent=2)
-        
         chain = QA_PROMPT | self.llm
         result = chain.invoke({"context": context_str, "question": query})
-        
-        return result.content
+        return result.content

requirements.txt

@@ -1,13 +1,102 @@
-pip
-autopep8
+acres==0.5.0
+annotated-types==0.7.0
+anyio==4.11.0
+autopep8==2.3.2
+beautifulsoup4==4.14.2
+blinker==1.9.0
+breadability==0.1.20
+bs4==0.0.2
+cachetools==6.2.0
+certifi==2025.10.5
+chardet==5.2.0
+charset-normalizer==3.4.3
+ci-info==0.3.0
+click==8.3.0
+configobj==5.0.9
+configparser==7.2.0
+docopt==0.6.2
+etelemetry==0.3.1
+filelock==3.19.1
+filetype==1.2.0
+fitz==0.0.1.dev2
 Flask==3.0.3
+google-ai-generativelanguage==0.6.15
+google-api-core==2.25.2
+google-api-python-client==2.184.0
+google-auth==2.41.1
+google-auth-httplib2==0.2.0
+google-generativeai==0.8.5
+googleapis-common-protos==1.70.0
+greenlet==3.2.4
+grpcio==1.75.1
+grpcio-status==1.71.2
 gunicorn==22.0.0
+h11==0.16.0
+httpcore==1.0.9
+httplib2==0.31.0
+httpx==0.28.1
+idna==3.10
+importlib_resources==6.5.2
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.5.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.3.27
+langchain-core==0.3.78
+langchain-google-genai==2.0.10
+langchain-text-splitters==0.3.11
+langsmith==0.4.32
+looseversion==1.3.0
+lxml==6.0.2
+MarkupSafe==3.0.3
+networkx==3.5
+nibabel==5.3.2
+nipype==1.10.0
+nltk==3.9.2
+numpy==2.3.3
+orjson==3.11.3
+packaging==25.0
+pandas==2.3.3
+pathlib==1.0.1
+proto-plus==1.26.1
+protobuf==5.29.5
+prov==2.1.1
+puremagic==1.30
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pycodestyle==2.14.0
+pycountry==24.6.1
+pycryptodome==3.23.0
+pydantic==2.11.10
+pydantic_core==2.33.2
+pydot==4.0.1
+PyMuPDF==1.26.4
+pyngrok==7.4.0
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+pytz==2025.2
+pyxnat==1.6.3
+PyYAML==6.0.3
+rdflib==7.2.1
+regex==2025.9.18
+requests==2.32.5
+requests-toolbelt==1.0.0
+rsa==4.9.1
+scipy==1.16.2
+simplejson==3.20.2
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.8
+SQLAlchemy==2.0.43
+sumy==0.11.0
+tenacity==9.1.2
+tqdm==4.67.1
+traits==7.0.2
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+uritemplate==4.2.0
+urllib3==2.5.0
 Werkzeug==3.0.6
-requests
-pyngrok
-pycryptodome
-bs4
-google-generativeai
-langchain-google-genai
-langchain
-pydantic
+zstandard==0.25.0

resume.pdf

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

resume_parser.py

@@ -0,0 +1,53 @@
+# resume_parser.py
+import fitz  # PyMuPDF
+import re
+from sumy.parsers.plaintext import PlaintextParser
+from sumy.nlp.tokenizers import Tokenizer
+from sumy.summarizers.lex_rank import LexRankSummarizer
+
+def parse_resume(pdf_path):
+    """
+    Parse PDF resume to extract text, hyperlinks, and generate summary
+    Returns: {
+        "full_text": str,
+        "hyperlinks": list,
+        "summary": str
+    }
+    """
+    doc = fitz.open(pdf_path)
+    full_text = ""
+    hyperlinks = []
+    
+    # Extract text and hyperlinks
+    for page_num in range(len(doc)):
+        page = doc[page_num]
+        full_text += page.get_text() + "\n"
+        
+        # Extract hyperlinks
+        links = page.get_links()
+        for link in links:
+            if link.get('uri'):
+                # Clean up common PDF hyperlink artifacts
+                url = re.sub(r'\s+', '', link['uri'])
+                if url.startswith(('http://', 'https://', 'mailto:')):
+                    hyperlinks.append(url)
+    
+    # Remove duplicates while preserving order
+    hyperlinks = list(dict.fromkeys(hyperlinks))
+    
+    # Generate summary (fallback to first 200 words if summarization fails)
+    try:
+        parser = PlaintextParser.from_string(full_text, Tokenizer("english"))
+        summarizer = LexRankSummarizer()
+        # Summarize to 5 sentences
+        summary_sentences = summarizer(parser.document, 5)
+        summary = " ".join(str(sentence) for sentence in summary_sentences)
+    except Exception as e:
+        print(f"Warning: Summarization failed ({e}). Using fallback summary.")
+        summary = " ".join(full_text.split()[:200]) + "..."
+    
+    return {
+        "full_text": full_text.strip(),
+        "hyperlinks": hyperlinks,
+        "summary": summary.strip()
+    }

static/final.css

@@ -0,0 +1,449 @@
+/* --- CSS Variables for Theming --- */
+:root {
+    --bg-color: #0D0D0D; /* Near black background */
+    --panel-color: #1A1A1A; /* Darkest gray for panels/cards */
+    --input-bg: #2C2C2C; /* Lighter gray for inputs */
+    --border-color: #333333; /* Subtle border color */
+    --text-color: #E0E0E0; /* Light gray for text */
+    --text-color-muted: #8A8A8A; /* Dimmer text for labels/placeholders */
+    --accent-color: #00E5FF; /* Vibrant cyan/teal for highlights */
+    --accent-color-hover: #00B8CC;
+    --font-family: 'Inter', sans-serif;
+}
+
+/* --- Global & Reset Styles --- */
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: var(--font-family);
+    background-color: var(--bg-color);
+    color: var(--text-color);
+    font-size: 16px;
+    overflow-x: hidden;
+}
+
+h1, h2, h3, h4 {
+    font-weight: 600;
+}
+
+h2 {
+    font-size: 1.75rem;
+    margin-bottom: 24px;
+}
+
+h3 {
+    font-size: 1.1rem;
+    margin-bottom: 12px;
+    color: var(--text-color);
+}
+
+a {
+    color: var(--accent-color);
+    text-decoration: none;
+}
+
+ul {
+    list-style-position: inside;
+}
+
+/* --- Main Layout --- */
+.app-container {
+    display: grid;
+    grid-template-columns: 240px 1fr;
+    height: 100vh;
+}
+
+.sidebar {
+    background-color: var(--bg-color);
+    border-right: 1px solid var(--border-color);
+    padding: 24px;
+    display: flex;
+    flex-direction: column;
+}
+
+.main-content {
+    padding: 24px 48px;
+    overflow-y: auto;
+}
+
+/* --- Sidebar --- */
+.app-header {
+    margin-bottom: 40px;
+}
+
+.app-header h1 {
+    font-size: 2rem;
+    color: var(--accent-color);
+    font-weight: 700;
+}
+
+.app-header p {
+    font-size: 0.9rem;
+    color: var(--text-color-muted);
+}
+
+.main-nav ul {
+    list-style: none;
+}
+
+.main-nav .nav-link {
+    display: block;
+    color: var(--text-color-muted);
+    padding: 12px 16px;
+    margin-bottom: 8px;
+    border-radius: 8px;
+    font-weight: 500;
+    transition: background-color 0.2s, color 0.2s;
+    position: relative;
+}
+
+.main-nav .nav-link:hover {
+    background-color: var(--panel-color);
+    color: var(--text-color);
+}
+
+.main-nav .nav-link.active {
+    background-color: var(--panel-color);
+    color: var(--text-color);
+    font-weight: 600;
+}
+
+.main-nav .nav-link.active::before {
+    content: '';
+    position: absolute;
+    left: 0;
+    top: 50%;
+    transform: translateY(-50%);
+    width: 4px;
+    height: 24px;
+    background-color: var(--accent-color);
+    border-radius: 0 4px 4px 0;
+}
+
+/* --- Top Control Bar --- */
+.top-bar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 20px;
+    background-color: var(--panel-color);
+    padding: 16px 24px;
+    border-radius: 12px;
+    margin-bottom: 32px;
+    border: 1px solid var(--border-color);
+}
+
+.input-group {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.input-group label {
+    font-size: 0.9rem;
+    color: var(--text-color-muted);
+    font-weight: 500;
+}
+
+/* --- Buttons & Inputs --- */
+.btn {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    font-size: 0.9rem;
+    cursor: pointer;
+    transition: background-color 0.2s, transform 0.1s;
+}
+
+.btn:disabled {
+    cursor: not-allowed;
+    opacity: 0.5;
+}
+
+.btn:active:not(:disabled) {
+    transform: scale(0.98);
+}
+
+.btn-primary {
+    background-color: var(--accent-color);
+    color: #000;
+}
+
+.btn-primary:hover:not(:disabled) {
+    background-color: var(--accent-color-hover);
+}
+
+.btn-secondary {
+    background-color: var(--input-bg);
+    color: var(--text-color);
+    border: 1px solid var(--border-color);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background-color: #383838;
+}
+
+input[type="text"],
+select {
+    background-color: var(--input-bg);
+    border: 1px solid var(--border-color);
+    color: var(--text-color);
+    padding: 10px 14px;
+    border-radius: 8px;
+    min-width: 250px;
+    font-family: var(--font-family);
+    font-size: 0.9rem;
+}
+
+input[type="text"]::placeholder {
+    color: var(--text-color-muted);
+}
+
+
+/* --- Content Sections & Cards --- */
+.content-section.hidden {
+    display: none;
+}
+
+.card {
+    background: rgba(26, 26, 26, 0.7); /* The semi-transparent panel color for the gloss effect */
+    backdrop-filter: blur(10px); /* The "frosted glass" effect */
+    border: 1px solid var(--border-color);
+    border-radius: 16px;
+    padding: 24px;
+}
+
+.chart-placeholder {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--text-color-muted);
+    font-size: 1.2rem;
+}
+
+/* --- Dashboard --- */
+.dashboard-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    grid-gap: 24px;
+}
+
+.large-card {
+    grid-column: 1 / 3;
+    grid-row: 1 / 3;
+    min-height: 400px;
+}
+
+.metric-cards-grid {
+    grid-column: 3 / 4;
+    display: grid;
+    grid-template-rows: repeat(3, 1fr);
+    gap: 24px;
+}
+
+.metric {
+    font-size: 2.5rem;
+    font-weight: 700;
+    color: var(--accent-color);
+}
+
+
+/* --- Report & Job Analysis Grids --- */
+.report-grid, .job-analysis-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
+    gap: 24px;
+}
+
+.skills-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+.skill-tag {
+    background-color: var(--input-bg);
+    padding: 6px 12px;
+    border-radius: 6px;
+    font-size: 0.85rem;
+}
+
+/* --- Chat Interface --- */
+.chat-container {
+    display: flex;
+    flex-direction: column;
+    height: 70vh; /* Adjust height as needed */
+    padding: 0;
+}
+
+#chat-history {
+    flex-grow: 1;
+    overflow-y: auto;
+    padding: 24px;
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+#chat-form {
+    display: flex;
+    gap: 10px;
+    padding: 24px;
+    border-top: 1px solid var(--border-color);
+}
+
+#chat-input {
+    flex-grow: 1;
+    min-width: 0;
+}
+
+.chat-message {
+    padding: 12px 16px;
+    border-radius: 12px;
+    max-width: 80%;
+}
+
+.user-message {
+    background-color: var(--accent-color);
+    color: #000;
+    align-self: flex-end;
+    border-bottom-right-radius: 0;
+}
+
+.ai-message {
+    background-color: var(--input-bg);
+    color: var(--text-color);
+    align-self: flex-start;
+    border-bottom-left-radius: 0;
+}
+.ai-message strong {
+    color: var(--accent-color);
+}
+.ai-message p {
+    white-space: pre-wrap;
+}
+
+
+/* --- Loading Spinner --- */
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.7);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+
+.spinner {
+    border: 4px solid rgba(255, 255, 255, 0.3);
+    border-radius: 50%;
+    border-top: 4px solid var(--accent-color);
+    width: 50px;
+    height: 50px;
+    animation: spin 1s linear infinite;
+    margin-bottom: 20px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.loading-overlay p {
+    color: var(--text-color);
+}
+
+.hidden {
+    display: none !important;
+}
+/* Add these rules to your existing final.css */
+
+/* Ensure the chart containers have a defined size */
+.chart-container {
+    /* You can adjust these values as needed */
+    min-height: 300px; /* Set a minimum height */
+    /* Optional: Set a max-height if needed */
+    /* max-height: 400px; */
+    /* Ensure the canvas fills the container */
+    display: flex;
+    flex-direction: column; /* Stack chart title and canvas vertically */
+    justify-content: center; /* Center the chart vertically if needed */
+    align-items: center;   /* Center the chart horizontally */
+    position: relative; /* Needed for Chart.js responsiveness */
+}
+
+/* Ensure the canvas elements themselves have a defined size */
+.chart-container canvas {
+    width: 100% !important; /* Override any inline styles Chart.js might add */
+    height: 100% !important; /* Override any inline styles Chart.js might add */
+    max-width: 100%; /* Prevent overflow */
+    max-height: 100%; /* Prevent overflow */
+}
+
+/* Optional: Style the placeholder text if no data is shown */
+.chart-placeholder {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: 100%;
+    color: var(--gray); /* Use your defined CSS variable */
+    font-style: italic;
+}
+
+/* Adjust the grid layout if necessary */
+.dashboard-grid {
+    display: grid;
+    grid-template-columns: 1fr; /* Default to single column */
+    gap: 20px;
+    margin-top: 20px;
+}
+
+.metric-cards-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); /* Adjust minmax width as needed */
+    gap: 20px;
+    margin-bottom: 20px; /* Space below the metric row */
+}
+
+/* Responsive grid for dashboard sections */
+@media (min-width: 992px) {
+    .dashboard-grid {
+        grid-template-columns: 1fr 1fr; /* Two columns for most dashboard items */
+    }
+    .metric-cards-grid {
+        grid-column: span 2; /* Metrics span full width */
+    }
+    .large-card {
+        grid-column: span 2; /* Large card spans 2 columns */
+    }
+    .chart-row {
+        grid-column: span 2; /* Chart row spans 2 columns */
+        display: grid;
+        grid-template-columns: 1fr 1fr; /* Two charts side-by-side within the row */
+        gap: 20px;
+    }
+    .chart-container {
+        /* Remove min-height from individual containers if using chart-row */
+        min-height: auto;
+    }
+}
+
+/* Fallback for smaller screens */
+@media (max-width: 991px) {
+    .chart-row {
+        display: grid;
+        grid-template-columns: 1fr; /* Charts stack vertically on smaller screens */
+        gap: 20px;
+    }
+}

static/final.js

@@ -0,0 +1,817 @@
+// Helper function to convert basic markdown to HTML
+// This handles **bold**, *italic*, and \n (newlines)
+function convertMarkdownToHTML(text) {
+    if (typeof text !== 'string') {
+        return text; // Return as-is if not a string
+    }
+    let htmlText = text;
+    // Handle **bold**
+    htmlText = htmlText.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+    // Handle *italic* (single underscores might interfere with URLs, so using single asterisks here)
+    htmlText = htmlText.replace(/\*(.*?)\*/g, '<em>$1</em>');
+    // Handle line breaks (\n)
+    htmlText = htmlText.replace(/\n/g, '<br>');
+    return htmlText;
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    const studentSelector = document.getElementById('student-selector');
+    const generateReportBtn = document.getElementById('generate-report-btn');
+    const jobApplicationInput = document.getElementById('job-application-input');
+    const analyzeJobBtn = document.getElementById('analyze-job-btn');
+    const loadingSpinner = document.getElementById('loading-spinner');
+    const reportContainer = document.getElementById('reports'); // Updated to match new HTML ID
+    const jobAnalysisContainer = document.getElementById('job-analysis'); // Updated to match new HTML ID
+    const chatbotContainer = document.getElementById('chat'); // Updated to match new HTML ID
+    const chatForm = document.getElementById('chat-form');
+    const chatInput = document.getElementById('chat-input');
+    const chatHistory = document.getElementById('chat-history');
+
+    // --- Chart Instances (To destroy/recreate when data changes) ---
+    let skillsChart = null;
+    let dsaChart = null;
+    let jobMatchChart = null; // This one might be tricky without specific data
+
+    // --- Navigation Elements ---
+    const navLinks = document.querySelectorAll('.nav-link');
+    const contentSections = document.querySelectorAll('.content-section');
+
+    // --- Sidebar Navigation ---
+    navLinks.forEach(link => {
+        link.addEventListener('click', (e) => {
+            e.preventDefault();
+
+            const targetId = link.getAttribute('href').substring(1); // Get ID without '#'
+
+            // Update active link
+            navLinks.forEach(l => l.classList.remove('active'));
+            link.classList.add('active');
+
+            // Show target section, hide others
+            contentSections.forEach(section => {
+                section.classList.add('hidden');
+                if (section.id === targetId) {
+                    section.classList.remove('hidden');
+                    section.classList.add('active');
+                    // Load dashboard data when the dashboard section becomes active
+                    if (targetId === 'dashboard') {
+                        console.log("Dashboard section activated, attempting to load data.");
+                        loadDashboardData(); // Call loadDashboardData here
+                    }
+                } else {
+                    section.classList.remove('active');
+                }
+            });
+        });
+    });
+
+    // --- Initial Navigation Setup (Show Dashboard by default) ---
+    const dashboardLink = document.querySelector('.nav-link[href="#dashboard"]');
+    if (dashboardLink) {
+        dashboardLink.click(); // Programmatically click the dashboard link to show it initially
+    }
+
+
+    // 1. Populate student dropdown on page load
+    fetch('/api/students')
+        .then(response => response.json())
+        .then(students => {
+            students.forEach(student => {
+                const option = document.createElement('option');
+                option.value = student.enrollment_no;
+                option.textContent = `${student.name} (${student.enrollment_no})`;
+                studentSelector.appendChild(option);
+            });
+        })
+        .catch(error => console.error('Error fetching students:', error));
+
+    // 2. Enable buttons when inputs are filled
+    studentSelector.addEventListener('change', () => {
+        const hasSelection = !!studentSelector.value;
+        generateReportBtn.disabled = !hasSelection;
+        // Note: chatbotContainer is now a section, not tied directly to student selection visibility here
+        // reportContainer.classList.add('hidden'); // Hide old report on new selection - Handled by nav now
+        // chatHistory.innerHTML = ''; // Clear chat history - Handled by nav or separately if needed
+        console.log("Student selection changed to:", studentSelector.value);
+        // Reload dashboard data if currently on the dashboard page
+        if (document.querySelector('#dashboard')?.classList.contains('active')) { // Added optional chaining
+             console.log("Currently on dashboard, reloading data for new selection.");
+             loadDashboardData();
+        }
+    });
+
+    jobApplicationInput.addEventListener('input', () => {
+        analyzeJobBtn.disabled = !jobApplicationInput.value.trim();
+    });
+
+    // 3. Handle "Generate Report" button click
+    generateReportBtn.addEventListener('click', () => {
+        const enrollmentNo = studentSelector.value;
+        if (!enrollmentNo) return;
+
+        loadingSpinner.classList.remove('hidden');
+        // Hide other sections while loading
+        reportContainer.classList.add('hidden');
+        jobAnalysisContainer.classList.add('hidden');
+        // chatbotContainer.classList.add('hidden'); // Don't hide chat, just report
+
+        // Navigate to the reports section
+        document.querySelector('.nav-link[href="#reports"]').click();
+
+        fetch(`/api/report/${enrollmentNo}`)
+            .then(response => {
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                return response.json();
+            })
+            .then(report => {
+                loadingSpinner.classList.add('hidden');
+                if (report.error) {
+                    alert(`Error generating report: ${report.error}`);
+                } else {
+                    displayReport(report);
+                    // The section is shown by the navigation click above
+                }
+            })
+            .catch(error => {
+                loadingSpinner.classList.add('hidden');
+                console.error('Report generation error:', error);
+                alert(`An unexpected error occurred: ${error.message}`);
+            });
+    });
+
+    // 4. Handle "Analyze Job Application" button click
+    analyzeJobBtn.addEventListener('click', () => {
+        const jobApplicationLink = jobApplicationInput.value.trim();
+        // Get the enrollment number from the currently selected student in the dropdown
+        const enrollmentNo = studentSelector.value;
+
+        if (!jobApplicationLink || !enrollmentNo) { // Check if both values exist
+             alert('Please select a student and provide a job application link.');
+             return; // Stop execution if either value is missing
+        }
+
+        loadingSpinner.classList.remove('hidden');
+        // Hide other sections while loading
+        reportContainer.classList.add('hidden');
+        jobAnalysisContainer.classList.add('hidden');
+        // chatbotContainer.classList.add('hidden'); // Don't hide chat, just job analysis
+
+        // Navigate to the job analysis section
+        document.querySelector('.nav-link[href="#job-analysis"]').click();
+
+        fetch('/api/job-analysis', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            // Include both the job link and the enrollment number in the request body
+            body: JSON.stringify({
+                job_application_link: jobApplicationLink,
+                enrollment_no: enrollmentNo // <-- Add this line
+            })
+        })
+        .then(response => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        })
+        .then(data => {
+            loadingSpinner.classList.add('hidden');
+            if (data.error) {
+                alert(`Error analyzing job application: ${data.error}`);
+            } else {
+                displayJobAnalysis(data.data); // Access data.data as per API response structure
+                // The section is shown by the navigation click above
+            }
+        })
+        .catch(error => {
+            loadingSpinner.classList.add('hidden');
+            console.error('Job analysis error:', error);
+            alert(`An unexpected error occurred: ${error.message}`);
+        });
+    });
+
+    // 5. Handle chat form submission
+    chatForm.addEventListener('submit', (e) => {
+        e.preventDefault();
+        const enrollmentNo = studentSelector.value;
+        const question = chatInput.value.trim();
+
+        if (!question || !enrollmentNo) return;
+
+        // Navigate to the chat section if not already there
+        document.querySelector('.nav-link[href="#chat"]').click();
+
+        appendMessage(question, 'user');
+        chatInput.value = '';
+        appendMessage('Thinking...', 'ai', true); // Show loading indicator
+
+        fetch('/api/ask', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ enrollment_no: enrollmentNo, question: question })
+        })
+        .then(response => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        })
+        .then(data => {
+            const loadingElement = chatHistory.querySelector('.loading');
+            if (loadingElement) {
+                loadingElement.parentElement.remove();
+            }
+            // Apply markdown formatting to the AI's answer before displaying
+            appendMessage(data.answer, 'ai', false, true); // Pass true for markdown formatting
+            chatHistory.scrollTop = chatHistory.scrollHeight; // Scroll to bottom after adding message
+        })
+        .catch(error => {
+            console.error('Chat error:', error);
+            const loadingElement = chatHistory.querySelector('.loading');
+            if (loadingElement) {
+                loadingElement.parentElement.remove();
+            }
+            appendMessage('Sorry, an error occurred while fetching the answer.', 'ai', false, true); // Apply markdown to error message too
+        });
+    });
+
+    // --- Helper Functions ---
+
+    function displayReport(report) {
+        const reportTitleElement = document.getElementById('report-title');
+        if (reportTitleElement) {
+            reportTitleElement.textContent = `Performance Report for ${studentSelector.options[studentSelector.selectedIndex].text}`;
+        }
+        // Apply markdown formatting to the summary
+        const summaryTextElement = document.getElementById('summary-text');
+        if (summaryTextElement) {
+             summaryTextElement.innerHTML = convertMarkdownToHTML(report.overall_summary);
+        }
+
+        // Display resume analysis
+        displayResumeAnalysis(report.resume_analysis);
+
+        const scoresGrid = document.getElementById('scores-grid');
+        if (scoresGrid) {
+            scoresGrid.innerHTML = '';
+            report.detailed_scores.forEach(item => {
+                // Apply markdown to justification
+                scoresGrid.innerHTML += `
+                    <div class="score-card">
+                        <div class="parameter">
+                            <span>${item.parameter}</span>
+                            <span class="score">${item.score}/10</span>
+                        </div>
+                        <div class="justification">${convertMarkdownToHTML(item.justification)}</div>
+                    </div>
+                `;
+            });
+        }
+
+        const createListItems = (items) => items.map(item => `<li>${convertMarkdownToHTML(item)}</li>`).join(''); // Apply to list items
+
+        const strengthsListElement = document.getElementById('strengths-list');
+        if (strengthsListElement) {
+            strengthsListElement.innerHTML = createListItems(report.analysis.strengths);
+        }
+        const weaknessesListElement = document.getElementById('weaknesses-list');
+        if (weaknessesListElement) {
+            weaknessesListElement.innerHTML = createListItems(report.analysis.weaknesses);
+        }
+        const adviceListElement = document.getElementById('advice-list');
+        if (adviceListElement) {
+            adviceListElement.innerHTML = createListItems(report.actionable_advice.recommendations);
+        }
+
+        // Display YouTube recommendations
+        displayYouTubeRecommendations(report.youtube_recommendations);
+    }
+
+    function displayResumeAnalysis(resumeAnalysis) {
+        // Display skills as tags
+        const skillsContainer = document.getElementById('resume-skills');
+        if (skillsContainer) {
+            skillsContainer.innerHTML = '';
+            resumeAnalysis.key_skills.forEach(skill => {
+                const tag = document.createElement('span');
+                tag.className = 'skill-tag';
+                tag.textContent = skill;
+                skillsContainer.appendChild(tag);
+            });
+        }
+
+
+        // Display professional links
+        const linksContainer = document.getElementById('resume-links');
+        if (linksContainer) {
+            linksContainer.innerHTML = '';
+            resumeAnalysis.professional_links.forEach(link => {
+                const li = document.createElement('li');
+                const a = document.createElement('a');
+                a.href = link;
+                a.target = '_blank';
+
+                // Extract domain for display
+                try {
+                    const url = new URL(link);
+                    a.textContent = url.hostname.replace('www.', '');
+                } catch (e) {
+                    a.textContent = link;
+                }
+
+                li.appendChild(a);
+                linksContainer.appendChild(li);
+            });
+        }
+
+
+        // Display missing elements
+        const missingContainer = document.getElementById('resume-missing');
+        if (missingContainer) {
+            missingContainer.innerHTML = '';
+            resumeAnalysis.missing_elements.forEach(item => {
+                const li = document.createElement('li');
+                li.className = 'missing-items';
+                // Apply markdown to missing elements (though unlikely to have formatting)
+                li.innerHTML = convertMarkdownToHTML(item);
+                missingContainer.appendChild(li);
+            });
+        }
+    }
+
+    function displayYouTubeRecommendations(recommendations) {
+        const container = document.getElementById('youtube-recommendations');
+        if (!container) {
+            console.error("Container #youtube-recommendations not found.");
+            return;
+        }
+        container.innerHTML = '';
+
+        if (!recommendations || recommendations.length === 0) {
+            container.innerHTML = '<p>No YouTube recommendations available for this student.</p>';
+            return;
+        }
+
+        recommendations.forEach(topic => {
+            // Check if this is a topic with videos or a single video
+            if (topic.videos && Array.isArray(topic.videos)) {
+                // This is a topic with multiple videos
+                const topicSection = document.createElement('div');
+                topicSection.className = 'topic-section';
+
+                const topicHeader = document.createElement('h3');
+                topicHeader.textContent = topic.topic;
+                topicSection.appendChild(topicHeader);
+
+                const topicReason = document.createElement('p');
+                topicReason.className = 'topic-reason';
+                // Apply markdown to reason/description
+                topicReason.innerHTML = convertMarkdownToHTML(topic.reason);
+                topicSection.appendChild(topicReason);
+
+                const videosContainer = document.createElement('div');
+                videosContainer.className = 'videos-container';
+
+                topic.videos.forEach(video => {
+                    const card = document.createElement('div');
+                    card.className = 'youtube-card';
+
+                    // Fix URL formatting - remove extra spaces
+                    const embedUrl = (video.embed_url || video.url).replace(/\s+/g, '');
+
+                    card.innerHTML = `
+                        <div class="youtube-embed">
+                            <iframe src="${embedUrl}"
+                                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                                    allowfullscreen></iframe>
+                        </div>
+                        <div class="youtube-info">
+                            <h3 class="youtube-title">${video.title}</h3>
+                            <p class="youtube-reason">${convertMarkdownToHTML(video.reason || video.description)}</p>
+                        </div>
+                    `;
+
+                    videosContainer.appendChild(card);
+                });
+
+                topicSection.appendChild(videosContainer);
+                container.appendChild(topicSection);
+            } else {
+                // This is a single video (fallback case)
+                const card = document.createElement('div');
+                card.className = 'youtube-card';
+
+                // Fix URL formatting - remove extra spaces
+                const embedUrl = (topic.embed_url || topic.url).replace(/\s+/g, '');
+
+                card.innerHTML = `
+                    <div class="youtube-embed">
+                        <iframe src="${embedUrl}"
+                                allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                                allowfullscreen></iframe>
+                    </div>
+                    <div class="youtube-info">
+                        <h3 class="youtube-title">${topic.title || 'Untitled Video'}</h3>
+                        <p class="youtube-reason">${convertMarkdownToHTML(topic.reason || topic.description)}</p>
+                    </div>
+                `;
+
+                container.appendChild(card);
+            }
+        });
+    }
+
+    function displayJobAnalysis(data) {
+        console.log("Job analysis ", data); // Debug log
+
+        // --- Map new structure to expected display structure ---
+
+        // 1. Display Strategic Overview (Summary and Key Opportunity)
+        const reportTitleElement = document.getElementById('report-title'); // Reuse title element or create a new one if needed for job analysis
+        if (reportTitleElement) {
+            reportTitleElement.textContent = `Job Application Analysis`; // Or use data.strategic_overview.summary if it's a full sentence
+        }
+        // Assuming you might want to display summary and key opportunity in a dedicated area if available
+        // const overviewSummaryElement = document.getElementById('overview-summary'); // Add this element in HTML if needed
+        // if (overviewSummaryElement && data.strategic_overview && data.strategic_overview.summary) {
+        //     overviewSummaryElement.innerHTML = convertMarkdownToHTML(data.strategic_overview.summary);
+        // }
+        // const keyOpportunityElement = document.getElementById('key-opportunity'); // Add this element in HTML if needed
+        // if (keyOpportunityElement && data.strategic_overview && data.strategic_overview.your_key_opportunity) {
+        //     keyOpportunityElement.innerHTML = convertMarkdownToHTML(data.strategic_overview.your_key_opportunity);
+        // }
+
+        // 2. Display Strengths (from 'your_core_strengths_for_this_role')
+        const strengthsContainer = document.getElementById('job-strengths-list');
+        if (strengthsContainer) {
+            strengthsContainer.innerHTML = '';
+
+            const strengths = data['your_core_strengths_for_this_role'] || [];
+
+            if (Array.isArray(strengths) && strengths.length > 0) {
+                strengths.forEach(strength => {
+                    const item = document.createElement('div');
+                    item.className = 'job-strength-item';
+                    // Map the new keys to the expected keys in the HTML structure
+                    // Apply markdown formatting to description and relevance
+                    item.innerHTML = `
+                        <div class="job-item-aspect">${convertMarkdownToHTML(strength.strength_area || 'N/A')}</div>
+                        <div class="job-item-description">${convertMarkdownToHTML(strength.evidence_from_your_profile || 'N/A')}</div>
+                        <div class="job-item-relevance">${convertMarkdownToHTML(strength.how_it_matches_the_job || 'N/A')}</div>
+                    `;
+                    strengthsContainer.appendChild(item);
+                });
+            } else {
+                strengthsContainer.innerHTML = '<p class="no-data">No strengths data available.</p>';
+            }
+        }
+
+        // 3. Display Weaknesses (from 'strategic_areas_for_growth')
+        const weaknessesContainer = document.getElementById('job-weaknesses-list');
+        if (weaknessesContainer) {
+            weaknessesContainer.innerHTML = '';
+
+            const weaknesses = data['strategic_areas_for_growth'] || [];
+
+            if (Array.isArray(weaknesses) && weaknesses.length > 0) {
+                weaknesses.forEach(weakness => {
+                    const item = document.createElement('div');
+                    item.className = 'job-weakness-item';
+                    // Map the new keys to the expected keys in the HTML structure
+                    // Apply markdown formatting to description, importance, and suggestion
+                    item.innerHTML = `
+                        <div class="job-item-aspect">${convertMarkdownToHTML(weakness.area_to_develop || 'N/A')}</div>
+                        <div class="job-item-description">${convertMarkdownToHTML(weakness.insight || 'N/A')}</div>
+                        <div class="job-item-importance">${convertMarkdownToHTML("Importance: " + (weakness.severity || 'N/A'))}</div>
+                        <div class="job-item-suggestion">${convertMarkdownToHTML(weakness.path_to_improvement ? weakness.path_to_improvement.join('<br>') : 'N/A')}</div>
+                    `;
+                    weaknessesContainer.appendChild(item);
+                });
+            } else {
+                weaknessesContainer.innerHTML = '<p class="no-data">No weaknesses data available.</p>';
+            }
+        }
+
+        // 4. Display Enhancement Recommendations (from 'strategic_areas_for_growth' as well)
+        const enhancementsContainer = document.getElementById('job-enhancements-list');
+        if (enhancementsContainer) {
+            enhancementsContainer.innerHTML = '';
+
+            // We can reuse the 'strategic_areas_for_growth' for enhancement recommendations
+            const weaknessesForRecs = data['strategic_areas_for_growth'] || []; // Use the same array
+            if (Array.isArray(weaknessesForRecs) && weaknessesForRecs.length > 0) {
+                weaknessesForRecs.forEach(rec => {
+                    const item = document.createElement('div');
+                    item.className = 'job-enhancement-item';
+                    // Map the new keys to the expected keys in the HTML structure
+                    // Apply markdown formatting to description and priority
+                    item.innerHTML = `
+                        <div class="job-item-aspect">${convertMarkdownToHTML(rec.area_to_develop || 'N/A')}</div>
+                        <div class="job-item-description">${convertMarkdownToHTML(rec.path_to_improvement ? rec.path_to_improvement.join('<br>') : 'N/A')}</div>
+                        <div class="job-item-importance">${convertMarkdownToHTML("Priority: " + (rec.severity || 'N/A'))}</div>
+                    `;
+                    enhancementsContainer.appendChild(item);
+                });
+            } else {
+                enhancementsContainer.innerHTML = '<p class="no-data">No enhancement recommendations available.</p>';
+            }
+        }
+
+
+        // 5. Display YouTube recommendations (should already be in the correct format)
+        displayJobYouTubeRecommendations(data.video_recommendations);
+    }
+
+    function displayJobYouTubeRecommendations(recommendations) {
+        const container = document.getElementById('job-youtube-recommendations');
+        if (!container) {
+            console.error("Container #job-youtube-recommendations not found.");
+            return;
+        }
+        container.innerHTML = '';
+
+        if (!recommendations || !Array.isArray(recommendations) || recommendations.length === 0) {
+            container.innerHTML = '<p class="no-data">No YouTube recommendations available for this job application.</p>';
+            return;
+        }
+
+        recommendations.forEach(topic => {
+            // Check if this is a topic with videos or a single video
+            if (topic.videos && Array.isArray(topic.videos)) {
+                // This is a topic with multiple videos
+                const topicSection = document.createElement('div');
+                topicSection.className = 'topic-section';
+
+                const topicHeader = document.createElement('h3');
+                topicHeader.textContent = topic.topic || 'Recommended Topic';
+                topicSection.appendChild(topicHeader);
+
+                const topicReason = document.createElement('p');
+                topicReason.className = 'topic-reason';
+                // Apply markdown to reason
+                topicReason.innerHTML = convertMarkdownToHTML(topic.reason || 'Recommended to improve your skills');
+                topicSection.appendChild(topicReason);
+
+                const videosContainer = document.createElement('div');
+                videosContainer.className = 'videos-container';
+
+                topic.videos.forEach(video => {
+                    const card = document.createElement('div');
+                    card.className = 'youtube-card';
+
+                    // Fix URL formatting - remove extra spaces
+                    const embedUrl = (video.embed_url || video.url).replace(/\s+/g, '');
+
+                    card.innerHTML = `
+                        <div class="youtube-embed">
+                            <iframe src="${embedUrl}"
+                                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                                    allowfullscreen></iframe>
+                        </div>
+                        <div class="youtube-info">
+                            <h3 class="youtube-title">${video.title || 'Untitled Video'}</h3>
+                            <p class="youtube-reason">${convertMarkdownToHTML(video.reason || video.description || 'Recommended for skill development')}</p>
+                        </div>
+                    `;
+
+                    videosContainer.appendChild(card);
+                });
+
+                topicSection.appendChild(videosContainer);
+                container.appendChild(topicSection);
+            } else {
+                // This is a single video (fallback case)
+                const card = document.createElement('div');
+                card.className = 'youtube-card';
+
+                // Fix URL formatting - remove extra spaces
+                const embedUrl = (topic.embed_url || topic.url).replace(/\s+/g, '');
+
+                card.innerHTML = `
+                    <div class="youtube-embed">
+                        <iframe src="${embedUrl}"
+                                allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                                allowfullscreen></iframe>
+                    </div>
+                    <div class="youtube-info">
+                        <h3 class="youtube-title">${topic.title || 'Untitled Video'}</h3>
+                        <p class="youtube-reason">${convertMarkdownToHTML(topic.reason || topic.description || 'Recommended for skill development')}</p>
+                    </div>
+                `;
+
+                container.appendChild(card);
+            }
+        });
+    }
+
+    // --- Updated Dashboard Data Loading Function with Chart.js ---
+    async function loadDashboardData() {
+        console.log("Loading dashboard data for selected student...");
+        const selectedEnrollment = studentSelector.value;
+
+        // Clear previous charts *first* to prevent infinite stretching if new data fails
+        if (skillsChart) { skillsChart.destroy(); skillsChart = null; }
+        if (dsaChart) { dsaChart.destroy(); dsaChart = null; }
+        if (jobMatchChart) { jobMatchChart.destroy(); jobMatchChart = null; }
+
+        // Get canvas elements and their contexts
+        const skillsCanvas = document.getElementById('skills-chart-canvas');
+        const dsaCanvas = document.getElementById('dsa-chart-canvas');
+        const jobMatchCanvas = document.getElementById('job-match-chart-canvas');
+
+        // Check if canvases exist before proceeding
+        if (!skillsCanvas || !dsaCanvas || !jobMatchCanvas) {
+            console.error("One or more dashboard chart canvases not found in the DOM.");
+            return;
+        }
+
+        const skillsCtx = skillsCanvas.getContext('2d');
+        const dsaCtx = dsaCanvas.getContext('2d');
+        const jobMatchCtx = jobMatchCanvas.getContext('2d');
+
+        // Clear canvases
+        if (skillsCtx) skillsCtx.clearRect(0, 0, skillsCtx.canvas.width, skillsCtx.canvas.height);
+        if (dsaCtx) dsaCtx.clearRect(0, 0, dsaCtx.canvas.width, dsaCtx.canvas.height);
+        if (jobMatchCtx) jobMatchCtx.clearRect(0, 0, jobMatchCtx.canvas.width, jobMatchCtx.canvas.height);
+
+        if (!selectedEnrollment) {
+            console.log("No student selected, showing placeholder.");
+            // Show placeholder text on canvases if contexts are available
+            [skillsCtx, dsaCtx, jobMatchCtx].forEach(ctx => {
+                if (ctx) { // Check if context exists
+                    ctx.font = "16px Arial";
+                    ctx.fillStyle = "gray";
+                    ctx.textAlign = "center";
+                    ctx.fillText("Select a student to see details", ctx.canvas.width / 2, ctx.canvas.height / 2);
+                }
+            });
+            // Reset metric counters if needed (e.g., to 0 or N/A)
+            const totalStudentsEl = document.querySelector('#total-students-count');
+            const reportsGeneratedEl = document.querySelector('#reports-generated-count');
+            const jobAnalysesEl = document.querySelector('#job-analyses-count');
+            if (totalStudentsEl) totalStudentsEl.textContent = 'N/A';
+            if (reportsGeneratedEl) reportsGeneratedEl.textContent = 'N/A';
+            if (jobAnalysesEl) jobAnalysesEl.textContent = 'N/A';
+            return; // Exit if no student is selected
+        }
+
+        try {
+            console.log(`Fetching dashboard metrics for enrollment: ${selectedEnrollment}`);
+            const response = await fetch(`/api/dashboard/metrics/${selectedEnrollment}`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const dashboardData = await response.json();
+            console.log("Dashboard data for selected student:", dashboardData);
+
+            // --- Update Dashboard Elements ---
+            // 1. Metrics Cards (Example: Using data from student's profile if available)
+            // document.querySelector('#total-students-count').textContent = dashboardData.academics.cgpa || 0; // Example for CGPA
+            // This section requires more specific data points from your dashboard analyzer output.
+
+            // 2. Skills Distribution Chart
+            if (dashboardData.skills_distribution && skillsCtx) { // Check if data and context exist
+                const topSkills = Object.entries(dashboardData.skills_distribution)
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 5); // Get top 5
+                const labels = topSkills.map(item => item[0]);
+                const data = topSkills.map(item => item[1]);
+
+                skillsChart = new Chart(skillsCtx, {
+                    type: 'bar', // or 'doughnut', 'pie', etc.
+                     {
+                        labels: labels,
+                        datasets: [{
+                            label: 'Skill Count',
+                            data: data,
+                            backgroundColor: [
+                                'rgba(255, 99, 132, 0.2)',
+                                'rgba(54, 162, 235, 0.2)',
+                                'rgba(255, 205, 86, 0.2)',
+                                'rgba(75, 192, 192, 0.2)',
+                                'rgba(153, 102, 255, 0.2)'
+                            ],
+                            borderColor: [
+                                'rgb(255, 99, 132)',
+                                'rgb(54, 162, 235)',
+                                'rgb(255, 205, 86)',
+                                'rgb(75, 192, 192)',
+                                'rgb(153, 102, 255)'
+                            ],
+                            borderWidth: 1
+                        }]
+                    },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: false, // Allows the chart to fill its container
+                        scales: {
+                            y: {
+                                beginAtZero: true
+                            }
+                        }
+                    }
+                });
+            } else if (skillsCtx) { // Check context exists before drawing
+                // If no data, show a message
+                skillsCtx.font = "16px Arial";
+                skillsCtx.fillStyle = "gray";
+                skillsCtx.textAlign = "center";
+                skillsCtx.fillText("No Skills Data Available", skillsCtx.canvas.width / 2, skillsCtx.canvas.height / 2);
+            }
+
+
+            // 3. DSA Performance Chart
+            if (dashboardData.coding_profiles?.leetcode?.score !== undefined && dsaCtx) { // Check if data and context exist
+                // Example: Using a radial gauge or a simple bar chart for score
+                // For simplicity, let's use a bar chart here showing score out of 10
+                dsaChart = new Chart(dsaCtx, {
+                    type: 'bar', // Could be 'radar', 'doughnut' for score
+                     {
+                        labels: ['DSA Score'],
+                        datasets: [{
+                            label: 'DSA Performance (0-10)',
+                            data: [dashboardData.coding_profiles.leetcode.score],
+                            backgroundColor: 'rgba(75, 192, 192, 0.2)',
+                            borderColor: 'rgb(75, 192, 192)',
+                            borderWidth: 1
+                        }]
+                    },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: false,
+                        scales: {
+                            y: {
+                                beginAtZero: true,
+                                max: 10 // Set max scale to 10
+                            }
+                        }
+                    }
+                });
+            } else if (dsaCtx) { // Check context exists before drawing
+                 // If no data, show a message
+                dsaCtx.font = "16px Arial";
+                dsaCtx.fillStyle = "gray";
+                dsaCtx.textAlign = "center";
+                dsaCtx.fillText("No DSA Data Available", dsaCtx.canvas.width / 2, dsaCtx.canvas.height / 2);
+            }
+
+            // 4. Job Match Score Chart (Placeholder - requires specific data from job analysis)
+            // This would need data from a job analysis call, which is tied to a specific job link.
+            // For now, show a placeholder or message.
+            if (jobMatchCtx) { // Check context exists before drawing
+                jobMatchCtx.font = "16px Arial";
+                jobMatchCtx.fillStyle = "gray";
+                jobMatchCtx.textAlign = "center";
+                jobMatchCtx.fillText("Job Match Score (requires Job Analysis)", jobMatchCtx.canvas.width / 2, jobMatchCtx.canvas.height / 2);
+            }
+
+        } catch (error) {
+            console.error('Error loading dashboard data for selected student:', error);
+            // Show error message on canvases if contexts are available
+            [skillsCtx, dsaCtx, jobMatchCtx].forEach(ctx => {
+                if (ctx) { // Check if context exists
+                    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height); // Clear again just in case
+                    ctx.font = "16px Arial";
+                    ctx.fillStyle = "red";
+                    ctx.textAlign = "center";
+                    ctx.fillText("Error Loading Data", ctx.canvas.width / 2, ctx.canvas.height / 2);
+                }
+            });
+        }
+
+        // Example: Static metrics for Total Students, Reports Generated, Job Analyses
+        // These would ideally come from a server-side counter or an aggregate API call
+        // For now, keep them static or update based on global counts if available separately
+        // const totalStudentsEl = document.querySelector('#total-students-count');
+        // const reportsGeneratedEl = document.querySelector('#reports-generated-count');
+        // const jobAnalysesEl = document.querySelector('#job-analyses-count');
+        // if (totalStudentsEl) totalStudentsEl.textContent = '1'; // Total Students
+        // if (reportsGeneratedEl) reportsGeneratedEl.textContent = '0'; // Reports Generated
+        // if (jobAnalysesEl) jobAnalysesEl.textContent = '0'; // Job Analyses
+    }
+
+
+    // Modified appendMessage function to accept a markdown flag
+    function appendMessage(text, sender, isLoading = false, useMarkdown = false) {
+        const messageWrapper = document.createElement('div');
+        messageWrapper.classList.add('chat-message', `${sender}-message`);
+
+        const messageP = document.createElement('p');
+        // Apply markdown formatting if the flag is true (e.g., for AI responses)
+        if (useMarkdown) {
+            messageP.innerHTML = text; // Use innerHTML to render the formatted HTML
+        } else {
+            messageP.textContent = text; // Use textContent for plain text (e.g., user messages, loading)
+        }
+
+        if (isLoading) {
+            messageP.classList.add('loading');
+        }
+
+        messageWrapper.appendChild(messageP);
+        chatHistory.appendChild(messageWrapper);
+        chatHistory.scrollTop = chatHistory.scrollHeight; // Auto-scroll to bottom
+    }
+});

templates/final.html

@@ -4,403 +4,190 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>AI Student Analyzer</title>
-    
-    <!-- CSS is now embedded directly in the HTML -->
-    <style>
-        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap');
-
-        :root {
-            --bg-color: #f0f2f5;
-            --card-bg: #ffffff;
-            --text-color: #333;
-            --text-light: #666;
-            --primary-color: #007bff;
-            --border-color: #e0e0e0;
-            --shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
-        }
-
-        body {
-            font-family: 'Inter', sans-serif;
-            background-color: var(--bg-color);
-            color: var(--text-color);
-            margin: 0;
-            padding: 20px;
-            line-height: 1.6;
-        }
-
-        .container {
-            max-width: 900px;
-            margin: 0 auto;
-            background: var(--card-bg);
-            border-radius: 12px;
-            box-shadow: var(--shadow);
-            padding: 30px;
-        }
-
-        header {
-            text-align: center;
-            margin-bottom: 30px;
-            border-bottom: 1px solid var(--border-color);
-            padding-bottom: 20px;
-        }
-
-        header h1 {
-            margin: 0;
-            font-size: 2rem;
-        }
-
-        header p {
-            color: var(--text-light);
-            font-size: 1.1rem;
-        }
-
-        .controls {
-            display: flex;
-            gap: 15px;
-            margin-bottom: 20px;
-        }
-
-        #student-selector, button {
-            padding: 12px 18px;
-            border: 1px solid var(--border-color);
-            border-radius: 8px;
-            font-size: 1rem;
-            font-family: 'Inter', sans-serif;
-        }
-
-        #student-selector {
-            flex-grow: 1;
-        }
-
-        button {
-            background-color: var(--primary-color);
-            color: white;
-            font-weight: 600;
-            cursor: pointer;
-            transition: background-color 0.2s;
-        }
-
-        button:disabled {
-            background-color: #ccc;
-            cursor: not-allowed;
-        }
-
-        button:hover:not(:disabled) {
-            background-color: #0056b3;
-        }
-
-        .hidden { display: none !important; }
-
-        /* Spinner */
-        .spinner {
-            border: 4px solid rgba(0,0,0,0.1);
-            width: 36px;
-            height: 36px;
-            border-radius: 50%;
-            border-left-color: var(--primary-color);
-            animation: spin 1s ease infinite;
-            margin: 20px auto;
-        }
-
-        @keyframes spin {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
-        }
-
-        /* Report Styling */
-        #report-title {
-            text-align: center;
-            margin-top: 30px;
-        }
-        .report-section {
-            background-color: var(--bg-color);
-            padding: 20px;
-            border-radius: 8px;
-            margin-bottom: 20px;
-        }
-        .report-section h3, .report-section h4 {
-            margin-top: 0;
-            color: var(--primary-color);
-            border-bottom: 2px solid var(--border-color);
-            padding-bottom: 8px;
-            margin-bottom: 15px;
-        }
-        .report-section ul {
-            padding-left: 20px;
-            line-height: 1.7;
-        }
-        #scores-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-            gap: 15px;
-        }
-        .score-card {
-            background: var(--card-bg);
-            padding: 15px;
-            border-radius: 8px;
-            border-left: 4px solid var(--primary-color);
-            box-shadow: 0 2px 4px rgba(0,0,0,0.03);
-        }
-        .score-card .parameter {
-            font-weight: 600;
-            font-size: 1.1rem;
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-        }
-        .score-card .score {
-            font-size: 1.5rem;
-            font-weight: 700;
-        }
-        .score-card .justification {
-            color: var(--text-light);
-            font-size: 0.9rem;
-            margin-top: 8px;
-        }
-
-        /* Chatbot Styling */
-        #chatbot-container {
-            margin-top: 30px;
-            border-top: 1px solid var(--border-color);
-            padding-top: 20px;
-        }
-        #chat-history {
-            height: 300px;
-            overflow-y: auto;
-            border: 1px solid var(--border-color);
-            border-radius: 8px;
-            padding: 15px;
-            margin-bottom: 15px;
-            background-color: #fafafa;
-        }
-        .chat-message {
-            margin-bottom: 15px;
-            line-height: 1.5;
-            display: flex;
-            flex-direction: column;
-        }
-        .user-message {
-            align-items: flex-end;
-        }
-        .user-message p {
-            background-color: var(--primary-color);
-            color: white;
-            border-radius: 15px 15px 0 15px;
-        }
-        .ai-message {
-            align-items: flex-start;
-        }
-        .ai-message p {
-            background-color: #e9ecef;
-            border-radius: 15px 15px 15px 0;
-        }
-        .chat-message p {
-            display: inline-block;
-            padding: 10px 15px;
-            max-width: 80%;
-            margin: 0;
-        }
-        #chat-form {
-            display: flex;
-            gap: 10px;
-        }
-        #chat-input {
-            flex-grow: 1;
-        }
-    </style>
+    <link rel="stylesheet" href="../static/final.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <!-- Include Chart.js from CDN -->
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
 </head>
 <body>
-    <div class="container">
-        <header>
-            <h1>AI Student Profile Analyzer</h1>
-            <p>Select a student to generate a detailed performance report or ask questions.</p>
-        </header>
+    <div class="app-container">
+        <!-- Sidebar -->
+        <aside class="sidebar">
+            <header class="app-header">
+                <h1>Ai</h1>
+                <p>AI Student Analyzer</p>
+            </header>
+            <nav class="main-nav">
+                <ul>
+                    <li><a href="#dashboard" class="nav-link active">Dashboard</a></li>
+                    <li><a href="#students" class="nav-link">Students</a></li>
+                    <li><a href="#reports" class="nav-link">Reports</a></li>
+                    <li><a href="#job-analysis" class="nav-link">Job Analysis</a></li>
+                    <li><a href="#chat" class="nav-link">Chat</a></li>
+                </ul>
+            </nav>
+        </aside>
+
+        <!-- Main Content Area -->
+        <main class="main-content">
+            <!-- Top Control Bar -->
+            <header class="top-bar">
+                <div class="input-group">
+                    <label for="student-selector">Select Student</label>
+                    <select id="student-selector">
+                        <option value="">-- Select a Student --</option>
+                        <!-- Options will be populated by JS -->
+                    </select>
+                    <button id="generate-report-btn" class="btn btn-secondary" disabled>Generate Report</button>
+                </div>
+                <div class="input-group">
+                    <label for="job-application-input">Job Application Link</label>
+                    <input type="text" id="job-application-input" placeholder="Paste job application link here...">
+                     <button id="analyze-job-btn" class="btn btn-primary" disabled>Analyze</button>
+                </div>
+            </header>
 
-        <div class="controls">
-            <select id="student-selector">
-                <option value="">-- Select a Student --</option>
-            </select>
-            <button id="generate-report-btn" disabled>Generate Full Report</button>
-        </div>
+            <!-- Loading Spinner -->
+            <div id="loading-spinner" class="loading-overlay hidden">
+                <div class="spinner"></div>
+                <p>Processing...</p>
+            </div>
 
-        <div id="loading-spinner" class="spinner hidden"></div>
+            <!-- Dashboard / Overview -->
+            <section id="dashboard" class="content-section active">
+                <h2>Dashboard Overview</h2>
+                <div class="dashboard-grid">
+                    <!-- Metric Cards Row -->
+                    <div class="metric-cards-grid">
+                        <div class="card">
+                            <h3>Total Students</h3>
+                            <p class="metric" id="total-students-count">1</p> <!-- ID added for JS -->
+                        </div>
+                        <div class="card">
+                            <h3>Reports Generated</h3>
+                            <p class="metric" id="reports-generated-count">0</p> <!-- ID added for JS -->
+                        </div>
+                        <div class="card">
+                            <h3>Job Analyses</h3>
+                            <p class="metric" id="job-analyses-count">0</p> <!-- ID added for JS -->
+                        </div>
+                    </div>
 
-        <!-- Report Display Area -->
-        <div id="report-container" class="hidden">
-            <h2 id="report-title"></h2>
-            <div id="report-content">
-                <div class="report-section summary">
-                    <h3>HR Summary</h3>
-                    <p id="summary-text"></p>
+                    <!-- Large Card for Skills Distribution -->
+                    <div class="card large-card chart-container">
+                        <h3>Skills Distribution (for selected student)</h3>
+                        <!-- Replace placeholder with canvas for Chart.js -->
+                        <canvas id="skills-chart-canvas"></canvas>
+                    </div>
+
+                    <!-- Row for DSA and Job Match -->
+                    <div class="chart-row">
+                        <div class="card chart-container">
+                            <h3>DSA Performance (for selected student)</h3>
+                             <!-- Replace placeholder with canvas for Chart.js -->
+                            <canvas id="dsa-chart-canvas"></canvas>
+                        </div>
+                        <div class="card chart-container">
+                            <h3>Job Match Score (for selected student)</h3>
+                             <!-- Replace placeholder with canvas for Chart.js -->
+                            <canvas id="job-match-chart-canvas"></canvas>
+                        </div>
+                    </div>
                 </div>
-                <div class="report-section scores">
-                    <h3>Detailed Scores</h3>
-                    <div id="scores-grid"></div>
+            </section>
+
+            <!-- Student Report Display Area -->
+            <section id="reports" class="content-section hidden">
+                <h2 id="report-title">Student Performance Report</h2>
+                <div class="report-grid">
+                    <div class="report-section summary card">
+                        <h3>HR Summary</h3>
+                        <p id="summary-text">Summary will appear here...</p>
+                    </div>
+                    <div class="report-section resume card">
+                         <h3>Resume Analysis</h3>
+                        <div class="resume-section">
+                            <div class="resume-column">
+                                <h4>Key Skills</h4>
+                                <div class="skills-list" id="resume-skills"></div>
+                                <h4 style="margin-top: 20px;">Professional Links</h4>
+                                <ul class="links-list" id="resume-links"></ul>
+                            </div>
+                            <div class="resume-column">
+                                <h4>Missing Elements</h4>
+                                <ul id="resume-missing"></ul>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="report-section scores card">
+                        <h3>Detailed Scores</h3>
+                        <div id="scores-grid"></div>
+                    </div>
+                    <div class="report-section analysis card">
+                        <h3>Analysis</h3>
+                        <div id="analysis-content">
+                            <div class="analysis-grid">
+                                <div class="analysis-column">
+                                    <h4>Strengths</h4>
+                                    <ul id="strengths-list"></ul>
+                                </div>
+                                <div class="analysis-column">
+                                    <h4>Weaknesses</h4>
+                                    <ul id="weaknesses-list"></ul>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="report-section advice card">
+                        <h3>Actionable Advice</h3>
+                        <ul id="advice-list"></ul>
+                    </div>
+                    <div class="report-section youtube card">
+                        <h3>Recommended Learning Resources</h3>
+                        <div class="youtube-recommendations" id="youtube-recommendations"></div>
+                    </div>
                 </div>
-                <div class="report-section analysis">
-                    <h3>Analysis</h3>
-                    <div id="analysis-content">
-                        <h4>Strengths</h4>
-                        <ul id="strengths-list"></ul>
-                        <h4>Weaknesses</h4>
-                        <ul id="weaknesses-list"></ul>
+            </section>
+
+            <!-- Job Application Analysis Display Area -->
+            <section id="job-analysis" class="content-section hidden">
+                <h2>Job Application Analysis</h2>
+                <div class="job-analysis-grid">
+                    <div class="job-section job-strengths card">
+                        <h3>Strengths</h3>
+                        <div id="job-strengths-list"></div>
+                    </div>
+                    <div class="job-section job-weaknesses card">
+                        <h3>Weaknesses</h3>
+                        <div id="job-weaknesses-list"></div>
+                    </div>
+                    <div class="job-section job-enhancements card">
+                        <h3>Enhancement Recommendations</h3>
+                        <div id="job-enhancements-list"></div>
+                    </div>
+                    <div class="job-section youtube card">
+                        <h3>Recommended Learning Resources</h3>
+                        <div class="youtube-recommendations" id="job-youtube-recommendations"></div>
                     </div>
                 </div>
-                <div class="report-section advice">
-                    <h3>Actionable Advice</h3>
-                    <ul id="advice-list"></ul>
+            </section>
+
+            <!-- Chatbot Interface -->
+            <section id="chat" class="content-section hidden">
+                <h2>Student Q&A</h2>
+                <div class="chat-container card">
+                    <div id="chat-history"></div>
+                    <form id="chat-form">
+                        <input type="text" id="chat-input" placeholder="e.g., What are their strongest DSA topics?" autocomplete="off" required>
+                        <button type="submit" class="btn btn-primary">Send</button>
+                    </form>
                 </div>
-            </div>
-        </div>
-
-        <!-- Chatbot Interface -->
-        <div id="chatbot-container" class="hidden">
-            <h2>Ask a Question</h2>
-            <div id="chat-history"></div>
-            <form id="chat-form">
-                <input type="text" id="chat-input" placeholder="e.g., What are their strongest DSA topics?" autocomplete="off" required>
-                <button type="submit">Send</button>
-            </form>
-        </div>
+            </section>
+        </main>
     </div>
 
-    <!-- JavaScript is now embedded directly in the HTML -->
-    <script>
-        document.addEventListener('DOMContentLoaded', () => {
-            const studentSelector = document.getElementById('student-selector');
-            const generateReportBtn = document.getElementById('generate-report-btn');
-            const loadingSpinner = document.getElementById('loading-spinner');
-            const reportContainer = document.getElementById('report-container');
-            const chatbotContainer = document.getElementById('chatbot-container');
-            const chatForm = document.getElementById('chat-form');
-            const chatInput = document.getElementById('chat-input');
-            const chatHistory = document.getElementById('chat-history');
-
-            // 1. Populate student dropdown on page load
-            fetch('/api/students')
-                .then(response => response.json())
-                .then(students => {
-                    students.forEach(student => {
-                        const option = document.createElement('option');
-                        option.value = student.enrollment_no;
-                        option.textContent = `${student.name} (${student.enrollment_no})`;
-                        studentSelector.appendChild(option);
-                    });
-                })
-                .catch(error => console.error('Error fetching students:', error));
-
-            // 2. Enable button when a student is selected
-            studentSelector.addEventListener('change', () => {
-                const hasSelection = !!studentSelector.value;
-                generateReportBtn.disabled = !hasSelection;
-                chatbotContainer.classList.toggle('hidden', !hasSelection);
-                reportContainer.classList.add('hidden'); // Hide old report on new selection
-                chatHistory.innerHTML = ''; // Clear chat history
-            });
-
-            // 3. Handle "Generate Report" button click
-            generateReportBtn.addEventListener('click', () => {
-                const enrollmentNo = studentSelector.value;
-                if (!enrollmentNo) return;
-
-                loadingSpinner.classList.remove('hidden');
-                reportContainer.classList.add('hidden');
-                chatbotContainer.classList.add('hidden');
-
-                fetch(`/api/report/${enrollmentNo}`)
-                    .then(response => response.json())
-                    .then(report => {
-                        loadingSpinner.classList.add('hidden');
-                        if (report.error) {
-                            alert(`Error generating report: ${report.error}`);
-                        } else {
-                            displayReport(report);
-                            reportContainer.classList.remove('hidden');
-                            chatbotContainer.classList.remove('hidden');
-                        }
-                    })
-                    .catch(error => {
-                        loadingSpinner.classList.add('hidden');
-                        alert(`An unexpected error occurred: ${error}`);
-                    });
-            });
-
-            // 4. Handle chat form submission
-            chatForm.addEventListener('submit', (e) => {
-                e.preventDefault();
-                const enrollmentNo = studentSelector.value;
-                const question = chatInput.value.trim();
-
-                if (!question || !enrollmentNo) return;
-                
-                appendMessage(question, 'user');
-                chatInput.value = '';
-                appendMessage('Thinking...', 'ai', true); // Show loading indicator
-
-                fetch('/api/ask', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ enrollment_no: enrollmentNo, question: question })
-                })
-                .then(response => response.json())
-                .then(data => {
-                    const loadingElement = chatHistory.querySelector('.loading');
-                    if (loadingElement) {
-                        loadingElement.parentElement.remove();
-                    }
-                    appendMessage(data.answer, 'ai');
-                })
-                .catch(error => {
-                    const loadingElement = chatHistory.querySelector('.loading');
-                    if (loadingElement) {
-                        loadingElement.parentElement.remove();
-                    }
-                    appendMessage('Sorry, an error occurred while fetching the answer.', 'ai');
-                });
-            });
-
-            // --- Helper Functions ---
-
-            function displayReport(report) {
-                document.getElementById('report-title').textContent = `Performance Report for ${studentSelector.options[studentSelector.selectedIndex].text}`;
-                document.getElementById('summary-text').textContent = report.overall_summary;
-
-                const scoresGrid = document.getElementById('scores-grid');
-                scoresGrid.innerHTML = '';
-                report.detailed_scores.forEach(item => {
-                    scoresGrid.innerHTML += `
-                        <div class="score-card">
-                            <div class="parameter">
-                                <span>${item.parameter}</span>
-                                <span class="score">${item.score}/10</span>
-                            </div>
-                            <div class="justification">${item.justification}</div>
-                        </div>
-                    `;
-                });
-
-                const createListItems = (items) => items.map(item => `<li>${item}</li>`).join('');
-
-                document.getElementById('strengths-list').innerHTML = createListItems(report.analysis.strengths);
-                document.getElementById('weaknesses-list').innerHTML = createListItems(report.analysis.weaknesses);
-                document.getElementById('advice-list').innerHTML = createListItems(report.actionable_advice.recommendations);
-            }
-
-            function appendMessage(text, sender, isLoading = false) {
-                const messageWrapper = document.createElement('div');
-                messageWrapper.classList.add('chat-message', `${sender}-message`);
-                
-                const messageP = document.createElement('p');
-                messageP.textContent = text;
-                if (isLoading) {
-                    messageP.classList.add('loading');
-                }
-                
-                messageWrapper.appendChild(messageP);
-                chatHistory.appendChild(messageWrapper);
-                chatHistory.scrollTop = chatHistory.scrollHeight; // Auto-scroll to bottom
-            }
-        });
-    </script>
+    <script src="../static/final.js"></script>
 </body>
 </html>

templates/script.js

@@ -0,0 +1,463 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const studentSelector = document.getElementById('student-selector');
+    const generateReportBtn = document.getElementById('generate-report-btn');
+    const jobApplicationInput = document.getElementById('job-application-input');
+    const analyzeJobBtn = document.getElementById('analyze-job-btn');
+    const loadingSpinner = document.getElementById('loading-spinner');
+    const reportContainer = document.getElementById('report-container');
+    const jobAnalysisContainer = document.getElementById('job-analysis-container');
+    const chatbotContainer = document.getElementById('chatbot-container');
+    const chatForm = document.getElementById('chat-form');
+    const chatInput = document.getElementById('chat-input');
+    const chatHistory = document.getElementById('chat-history');
+
+    // 1. Populate student dropdown on page load
+    fetch('/api/students')
+        .then(response => response.json())
+        .then(students => {
+            students.forEach(student => {
+                const option = document.createElement('option');
+                option.value = student.enrollment_no;
+                option.textContent = `${student.name} (${student.enrollment_no})`;
+                studentSelector.appendChild(option);
+            });
+        })
+        .catch(error => console.error('Error fetching students:', error));
+
+    // 2. Enable buttons when inputs are filled
+    studentSelector.addEventListener('change', () => {
+        const hasSelection = !!studentSelector.value;
+        generateReportBtn.disabled = !hasSelection;
+        chatbotContainer.classList.toggle('hidden', !hasSelection);
+        reportContainer.classList.add('hidden'); // Hide old report on new selection
+        chatHistory.innerHTML = ''; // Clear chat history
+    });
+
+    jobApplicationInput.addEventListener('input', () => {
+        analyzeJobBtn.disabled = !jobApplicationInput.value.trim();
+    });
+
+    // 3. Handle "Generate Report" button click
+    generateReportBtn.addEventListener('click', () => {
+        const enrollmentNo = studentSelector.value;
+        if (!enrollmentNo) return;
+
+        loadingSpinner.classList.remove('hidden');
+        reportContainer.classList.add('hidden');
+        jobAnalysisContainer.classList.add('hidden');
+        chatbotContainer.classList.add('hidden');
+
+        fetch(`/api/report/${enrollmentNo}`)
+            .then(response => {
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                return response.json();
+            })
+            .then(report => {
+                loadingSpinner.classList.add('hidden');
+                if (report.error) {
+                    alert(`Error generating report: ${report.error}`);
+                } else {
+                    displayReport(report);
+                    reportContainer.classList.remove('hidden');
+                    chatbotContainer.classList.remove('hidden');
+                }
+            })
+            .catch(error => {
+                loadingSpinner.classList.add('hidden');
+                console.error('Report generation error:', error);
+                alert(`An unexpected error occurred: ${error.message}`);
+            });
+    });
+
+    // 4. Handle "Analyze Job Application" button click
+    analyzeJobBtn.addEventListener('click', () => {
+        const jobApplicationLink = jobApplicationInput.value.trim();
+        if (!jobApplicationLink) return;
+
+        loadingSpinner.classList.remove('hidden');
+        reportContainer.classList.add('hidden');
+        jobAnalysisContainer.classList.add('hidden');
+        chatbotContainer.classList.add('hidden');
+
+        fetch('/api/job-analysis', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ job_application_link: jobApplicationLink })
+        })
+        .then(response => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        })
+        .then(data => {
+            loadingSpinner.classList.add('hidden');
+            if (data.error) {
+                alert(`Error analyzing job application: ${data.error}`);
+            } else {
+                displayJobAnalysis(data.data); // Access data.data as per API response structure
+                jobAnalysisContainer.classList.remove('hidden');
+            }
+        })
+        .catch(error => {
+            loadingSpinner.classList.add('hidden');
+            console.error('Job analysis error:', error);
+            alert(`An unexpected error occurred: ${error.message}`);
+        });
+    });
+
+    // 5. Handle chat form submission
+    chatForm.addEventListener('submit', (e) => {
+        e.preventDefault();
+        const enrollmentNo = studentSelector.value;
+        const question = chatInput.value.trim();
+
+        if (!question || !enrollmentNo) return;
+        
+        appendMessage(question, 'user');
+        chatInput.value = '';
+        appendMessage('Thinking...', 'ai', true); // Show loading indicator
+
+        fetch('/api/ask', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ enrollment_no: enrollmentNo, question: question })
+        })
+        .then(response => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        })
+        .then(data => {
+            const loadingElement = chatHistory.querySelector('.loading');
+            if (loadingElement) {
+                loadingElement.parentElement.remove();
+            }
+            appendMessage(data.answer, 'ai');
+        })
+        .catch(error => {
+            console.error('Chat error:', error);
+            const loadingElement = chatHistory.querySelector('.loading');
+            if (loadingElement) {
+                loadingElement.parentElement.remove();
+            }
+            appendMessage('Sorry, an error occurred while fetching the answer.', 'ai');
+        });
+    });
+
+    // --- Helper Functions ---
+
+    function displayReport(report) {
+        document.getElementById('report-title').textContent = `Performance Report for ${studentSelector.options[studentSelector.selectedIndex].text}`;
+        document.getElementById('summary-text').textContent = report.overall_summary;
+
+        // Display resume analysis
+        displayResumeAnalysis(report.resume_analysis);
+        
+        const scoresGrid = document.getElementById('scores-grid');
+        scoresGrid.innerHTML = '';
+        report.detailed_scores.forEach(item => {
+            scoresGrid.innerHTML += `
+                <div class="score-card">
+                    <div class="parameter">
+                        <span>${item.parameter}</span>
+                        <span class="score">${item.score}/10</span>
+                    </div>
+                    <div class="justification">${item.justification}</div>
+                </div>
+            `;
+        });
+
+        const createListItems = (items) => items.map(item => `<li>${item}</li>`).join('');
+
+        document.getElementById('strengths-list').innerHTML = createListItems(report.analysis.strengths);
+        document.getElementById('weaknesses-list').innerHTML = createListItems(report.analysis.weaknesses);
+        document.getElementById('advice-list').innerHTML = createListItems(report.actionable_advice.recommendations);
+        
+        // Display YouTube recommendations
+        displayYouTubeRecommendations(report.youtube_recommendations);
+    }
+    
+    function displayResumeAnalysis(resumeAnalysis) {
+        // Display skills as tags
+        const skillsContainer = document.getElementById('resume-skills');
+        skillsContainer.innerHTML = '';
+        resumeAnalysis.key_skills.forEach(skill => {
+            const tag = document.createElement('span');
+            tag.className = 'skill-tag';
+            tag.textContent = skill;
+            skillsContainer.appendChild(tag);
+        });
+        
+        // Display professional links
+        const linksContainer = document.getElementById('resume-links');
+        linksContainer.innerHTML = '';
+        resumeAnalysis.professional_links.forEach(link => {
+            const li = document.createElement('li');
+            const a = document.createElement('a');
+            a.href = link;
+            a.target = '_blank';
+            
+            // Extract domain for display
+            try {
+                const url = new URL(link);
+                a.textContent = url.hostname.replace('www.', '');
+            } catch (e) {
+                a.textContent = link;
+            }
+            
+            li.appendChild(a);
+            linksContainer.appendChild(li);
+        });
+        
+        // Display missing elements
+        const missingContainer = document.getElementById('resume-missing');
+        missingContainer.innerHTML = '';
+        resumeAnalysis.missing_elements.forEach(item => {
+            const li = document.createElement('li');
+            li.className = 'missing-items';
+            li.textContent = item;
+            missingContainer.appendChild(li);
+        });
+    }
+    
+    function displayYouTubeRecommendations(recommendations) {
+        const container = document.getElementById('youtube-recommendations');
+        container.innerHTML = '';
+        
+        if (!recommendations || recommendations.length === 0) {
+            container.innerHTML = '<p>No YouTube recommendations available for this student.</p>';
+            return;
+        }
+        
+        recommendations.forEach(topic => {
+            // Check if this is a topic with videos or a single video
+            if (topic.videos && Array.isArray(topic.videos)) {
+                // This is a topic with multiple videos
+                const topicSection = document.createElement('div');
+                topicSection.className = 'topic-section';
+                
+                const topicHeader = document.createElement('h3');
+                topicHeader.textContent = topic.topic;
+                topicSection.appendChild(topicHeader);
+                
+                const topicReason = document.createElement('p');
+                topicReason.className = 'topic-reason';
+                topicReason.textContent = topic.reason;
+                topicSection.appendChild(topicReason);
+                
+                const videosContainer = document.createElement('div');
+                videosContainer.className = 'videos-container';
+                
+                topic.videos.forEach(video => {
+                    const card = document.createElement('div');
+                    card.className = 'youtube-card';
+                    
+                    // Fix URL formatting - remove extra spaces
+                    const embedUrl = (video.embed_url || video.url).replace(/\s+/g, '');
+                    
+                    card.innerHTML = `
+                        <div class="youtube-embed">
+                            <iframe src="${embedUrl}" 
+                                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
+                                    allowfullscreen></iframe>
+                        </div>
+                        <div class="youtube-info">
+                            <h3 class="youtube-title">${video.title}</h3>
+                            <p class="youtube-reason">${video.reason || video.description}</p>
+                        </div>
+                    `;
+                    
+                    videosContainer.appendChild(card);
+                });
+                
+                topicSection.appendChild(videosContainer);
+                container.appendChild(topicSection);
+            } else {
+                // This is a single video (fallback case)
+                const card = document.createElement('div');
+                card.className = 'youtube-card';
+                
+                // Fix URL formatting - remove extra spaces
+                const embedUrl = (topic.embed_url || topic.url).replace(/\s+/g, '');
+                
+                card.innerHTML = `
+                    <div class="youtube-embed">
+                        <iframe src="${embedUrl}" 
+                                allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
+                                allowfullscreen></iframe>
+                    </div>
+                    <div class="youtube-info">
+                        <h3 class="youtube-title">${topic.title}</h3>
+                        <p class="youtube-reason">${topic.reason || topic.description}</p>
+                    </div>
+                `;
+                
+                container.appendChild(card);
+            }
+        });
+    }
+    
+    function displayJobAnalysis(data) {
+        console.log("Job analysis data:", data); // Debug log
+        
+        // Display strengths
+        const strengthsContainer = document.getElementById('job-strengths-list');
+        strengthsContainer.innerHTML = '';
+        
+        // Check if strengths exist and is an array
+        if (data.strengths && Array.isArray(data.strengths)) {
+            data.strengths.forEach(strength => {
+                const item = document.createElement('div');
+                item.className = 'job-strength-item';
+                item.innerHTML = `
+                    <div class="job-item-aspect">${strength.aspect || 'N/A'}</div>
+                    <div class="job-item-description">${strength.description || 'N/A'}</div>
+                    <div class="job-item-relevance">${strength.relevance || 'N/A'}</div>
+                `;
+                strengthsContainer.appendChild(item);
+            });
+        } else {
+            strengthsContainer.innerHTML = '<p>No strengths data available.</p>';
+        }
+        
+        // Display weaknesses
+        const weaknessesContainer = document.getElementById('job-weaknesses-list');
+        weaknessesContainer.innerHTML = '';
+        
+        // Check if weaknesses exist and is an array
+        if (data.weaknesses && Array.isArray(data.weaknesses)) {
+            data.weaknesses.forEach(weakness => {
+                const item = document.createElement('div');
+                item.className = 'job-weakness-item';
+                item.innerHTML = `
+                    <div class="job-item-aspect">${weakness.aspect || 'N/A'}</div>
+                    <div class="job-item-description">${weakness.description || 'N/A'}</div>
+                    <div class="job-item-importance">Importance: ${weakness.importance || 'N/A'}</div>
+                    <div class="job-item-suggestion">${weakness.improvement_suggestion || 'N/A'}</div>
+                `;
+                weaknessesContainer.appendChild(item);
+            });
+        } else {
+            weaknessesContainer.innerHTML = '<p>No weaknesses data available.</p>';
+        }
+        
+        // Display enhancement recommendations
+        const enhancementsContainer = document.getElementById('job-enhancements-list');
+        enhancementsContainer.innerHTML = '';
+        
+        // Check if enhancement_recommendations exist and is an array
+        if (data.enhancement_recommendations && Array.isArray(data.enhancement_recommendations)) {
+            data.enhancement_recommendations.forEach(rec => {
+                const item = document.createElement('div');
+                item.className = 'job-enhancement-item';
+                item.innerHTML = `
+                    <div class="job-item-aspect">${rec.area || 'N/A'}</div>
+                    <div class="job-item-description">${rec.suggestion || 'N/A'}</div>
+                    <div class="job-item-importance">Priority: ${rec.priority || 'N/A'}</div>
+                `;
+                enhancementsContainer.appendChild(item);
+            });
+        } else {
+            enhancementsContainer.innerHTML = '<p>No enhancement recommendations available.</p>';
+        }
+        
+        // Display YouTube recommendations
+        displayJobYouTubeRecommendations(data.video_recommendations);
+    }
+    
+    function displayJobYouTubeRecommendations(recommendations) {
+        const container = document.getElementById('job-youtube-recommendations');
+        container.innerHTML = '';
+        
+        if (!recommendations || !Array.isArray(recommendations) || recommendations.length === 0) {
+            container.innerHTML = '<p>No YouTube recommendations available for this job application.</p>';
+            return;
+        }
+        
+        recommendations.forEach(topic => {
+            // Check if this is a topic with videos or a single video
+            if (topic.videos && Array.isArray(topic.videos)) {
+                // This is a topic with multiple videos
+                const topicSection = document.createElement('div');
+                topicSection.className = 'topic-section';
+                
+                const topicHeader = document.createElement('h3');
+                topicHeader.textContent = topic.topic || 'Recommended Topic';
+                topicSection.appendChild(topicHeader);
+                
+                const topicReason = document.createElement('p');
+                topicReason.className = 'topic-reason';
+                topicReason.textContent = topic.reason || 'Recommended to improve your skills';
+                topicSection.appendChild(topicReason);
+                
+                const videosContainer = document.createElement('div');
+                videosContainer.className = 'videos-container';
+                
+                topic.videos.forEach(video => {
+                    const card = document.createElement('div');
+                    card.className = 'youtube-card';
+                    
+                    // Fix URL formatting - remove extra spaces
+                    const embedUrl = (video.embed_url || video.url).replace(/\s+/g, '');
+                    
+                    card.innerHTML = `
+                        <div class="youtube-embed">
+                            <iframe src="${embedUrl}" 
+                                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
+                                    allowfullscreen></iframe>
+                        </div>
+                        <div class="youtube-info">
+                            <h3 class="youtube-title">${video.title || 'Untitled Video'}</h3>
+                            <p class="youtube-reason">${video.reason || video.description || 'Recommended for skill development'}</p>
+                        </div>
+                    `;
+                    
+                    videosContainer.appendChild(card);
+                });
+                
+                topicSection.appendChild(videosContainer);
+                container.appendChild(topicSection);
+            } else {
+                // This is a single video (fallback case)
+                const card = document.createElement('div');
+                card.className = 'youtube-card';
+                
+                // Fix URL formatting - remove extra spaces
+                const embedUrl = (topic.embed_url || topic.url).replace(/\s+/g, '');
+                
+                card.innerHTML = `
+                    <div class="youtube-embed">
+                        <iframe src="${embedUrl}" 
+                                allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
+                                allowfullscreen></iframe>
+                    </div>
+                    <div class="youtube-info">
+                        <h3 class="youtube-title">${topic.title || 'Untitled Video'}</h3>
+                        <p class="youtube-reason">${topic.reason || topic.description || 'Recommended for skill development'}</p>
+                    </div>
+                `;
+                
+                container.appendChild(card);
+            }
+        });
+    }
+
+    function appendMessage(text, sender, isLoading = false) {
+        const messageWrapper = document.createElement('div');
+        messageWrapper.classList.add('chat-message', `${sender}-message`);
+        
+        const messageP = document.createElement('p');
+        messageP.textContent = text;
+        if (isLoading) {
+            messageP.classList.add('loading');
+        }
+        
+        messageWrapper.appendChild(messageP);
+        chatHistory.appendChild(messageWrapper);
+        chatHistory.scrollTop = chatHistory.scrollHeight; // Auto-scroll to bottom
+    }
+});

templates/style.css

@@ -0,0 +1,378 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap');
+
+:root {
+    --bg-color: #f0f2f5;
+    --card-bg: #ffffff;
+    --text-color: #333;
+    --text-light: #666;
+    --primary-color: #007bff;
+    --border-color: #e0e0e0;
+    --shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+    --job-bg: #f8f9fa;
+}
+
+body {
+    font-family: 'Inter', sans-serif;
+    background-color: var(--bg-color);
+    color: var(--text-color);
+    margin: 0;
+    padding: 20px;
+    line-height: 1.6;
+}
+
+.container {
+    max-width: 900px;
+    margin: 0 auto;
+    background: var(--card-bg);
+    border-radius: 12px;
+    box-shadow: var(--shadow);
+    padding: 30px;
+}
+
+header {
+    text-align: center;
+    margin-bottom: 30px;
+    border-bottom: 1px solid var(--border-color);
+    padding-bottom: 20px;
+}
+
+header h1 {
+    margin: 0;
+    font-size: 2rem;
+}
+
+header p {
+    color: var(--text-light);
+    font-size: 1.1rem;
+}
+
+.controls {
+    display: flex;
+    gap: 15px;
+    margin-bottom: 20px;
+    flex-wrap: wrap;
+}
+
+#student-selector, #job-application-input, button {
+    padding: 12px 18px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    font-size: 1rem;
+    font-family: 'Inter', sans-serif;
+}
+
+#student-selector, #job-application-input {
+    flex-grow: 1;
+}
+
+#job-application-input {
+    flex-grow: 2;
+}
+
+button {
+    background-color: var(--primary-color);
+    color: white;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+
+button:disabled {
+    background-color: #ccc;
+    cursor: not-allowed;
+}
+
+button:hover:not(:disabled) {
+    background-color: #0056b3;
+}
+
+.hidden { display: none !important; }
+
+/* Spinner */
+.spinner {
+    border: 4px solid rgba(0,0,0,0.1);
+    width: 36px;
+    height: 36px;
+    border-radius: 50%;
+    border-left-color: var(--primary-color);
+    animation: spin 1s ease infinite;
+    margin: 20px auto;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Report Styling */
+#report-title {
+    text-align: center;
+    margin-top: 30px;
+}
+
+.report-section {
+    background-color: var(--bg-color);
+    padding: 20px;
+    border-radius: 8px;
+    margin-bottom: 20px;
+}
+
+.job-section {
+    background-color: var(--job-bg);
+    border-left: 4px solid #28a745;
+}
+
+.report-section h3, .report-section h4 {
+    margin-top: 0;
+    color: var(--primary-color);
+    border-bottom: 2px solid var(--border-color);
+    padding-bottom: 8px;
+    margin-bottom: 15px;
+}
+
+.job-section h3, .job-section h4 {
+    color: #28a745;
+}
+
+.report-section ul {
+    padding-left: 20px;
+    line-height: 1.7;
+}
+
+#scores-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 15px;
+}
+
+.score-card {
+    background: var(--card-bg);
+    padding: 15px;
+    border-radius: 8px;
+    border-left: 4px solid var(--primary-color);
+    box-shadow: 0 2px 4px rgba(0,0,0,0.03);
+}
+
+.score-card .parameter {
+    font-weight: 600;
+    font-size: 1.1rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.score-card .score {
+    font-size: 1.5rem;
+    font-weight: 700;
+}
+
+.score-card .justification {
+    color: var(--text-light);
+    font-size: 0.9rem;
+    margin-top: 8px;
+}
+
+/* Resume Section Styling */
+.resume-section {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 15px;
+}
+
+.resume-column {
+    background: white;
+    padding: 15px;
+    border-radius: 8px;
+}
+
+.resume-column h4 {
+    margin-top: 0;
+    color: var(--primary-color);
+}
+
+.skills-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-top: 10px;
+}
+
+.skill-tag {
+    background-color: #e9ecef;
+    padding: 5px 10px;
+    border-radius: 20px;
+    font-size: 0.9rem;
+}
+
+.links-list {
+    list-style: none;
+    padding-left: 0;
+}
+
+.links-list li {
+    margin-bottom: 8px;
+}
+
+.links-list a {
+    color: var(--primary-color);
+    text-decoration: none;
+}
+
+.links-list a:hover {
+    text-decoration: underline;
+}
+
+.missing-items {
+    color: #dc3545;
+}
+
+/* YouTube Recommendations Styling */
+.youtube-recommendations {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 20px;
+}
+
+.youtube-card {
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    overflow: hidden;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.youtube-embed {
+    position: relative;
+    padding-bottom: 56.25%; /* 16:9 aspect ratio */
+    height: 0;
+    overflow: hidden;
+    max-width: 100%;
+}
+
+.youtube-embed iframe {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    border: 0;
+}
+
+.youtube-info {
+    padding: 15px;
+}
+
+.youtube-title {
+    font-weight: 600;
+    margin: 0 0 8px 0;
+    color: var(--text-color);
+}
+
+.youtube-reason {
+    color: var(--text-light);
+    font-size: 0.9rem;
+}
+
+/* Chatbot Styling */
+#chatbot-container {
+    margin-top: 30px;
+    border-top: 1px solid var(--border-color);
+    padding-top: 20px;
+}
+
+#chat-history {
+    height: 300px;
+    overflow-y: auto;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    padding: 15px;
+    margin-bottom: 15px;
+    background-color: #fafafa;
+}
+
+.chat-message {
+    margin-bottom: 15px;
+    line-height: 1.5;
+    display: flex;
+    flex-direction: column;
+}
+
+.user-message {
+    align-items: flex-end;
+}
+
+.user-message p {
+    background-color: var(--primary-color);
+    color: white;
+    border-radius: 15px 15px 0 15px;
+}
+
+.ai-message {
+    align-items: flex-start;
+}
+
+.ai-message p {
+    background-color: #e9ecef;
+    border-radius: 15px 15px 15px 0;
+}
+
+.chat-message p {
+    display: inline-block;
+    padding: 10px 15px;
+    max-width: 80%;
+    margin: 0;
+}
+
+#chat-form {
+    display: flex;
+    gap: 10px;
+}
+
+#chat-input {
+    flex-grow: 1;
+}
+
+/* Job Application Analysis */
+.job-analysis-container {
+    margin-top: 30px;
+    padding-top: 20px;
+    border-top: 1px solid var(--border-color);
+}
+
+.job-analysis-container h2 {
+    margin-top: 0;
+    color: #28a745;
+}
+
+.job-section-content {
+    margin-top: 20px;
+}
+
+.job-strengths, .job-weaknesses, .job-enhancements {
+    margin-bottom: 25px;
+}
+
+.job-strengths h4, .job-weaknesses h4, .job-enhancements h4 {
+    color: #28a745;
+    border-bottom: 1px solid #c3e6cb;
+}
+
+.job-strengths ul, .job-weaknesses ul, .job-enhancements ul {
+    padding-left: 20px;
+}
+
+.job-strength-item, .job-weakness-item, .job-enhancement-item {
+    margin-bottom: 10px;
+}
+
+.job-item-aspect {
+    font-weight: bold;
+}
+
+.job-item-description {
+    margin-top: 5px;
+}
+
+.job-item-relevance, .job-item-importance, .job-item-suggestion {
+    font-size: 0.9rem;
+    color: var(--text-light);
+}

youtube_search_tool.py

@@ -0,0 +1,478 @@
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field
+from typing import Type, List, Dict, Any, Optional
+import os
+import requests
+import logging
+import re
+from bs4 import BeautifulSoup
+import json
+import time
+import random
+import urllib.parse
+
+
+
+logger = logging.getLogger('youtube_search_tool')
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+
+
+class YouTubeSearchInput(BaseModel):
+    """Input schema for YouTube search tool"""
+    query: str = Field(..., description="The search query for educational videos")
+    max_results: int = Field(default=5, ge=1, le=10, description="Number of results to return (1-10)")
+    topic_category: Optional[str] = Field(
+        default=None, 
+        description="Specific topic category to filter results (dsa, web, python, etc.)"
+    )
+
+
+
+class YouTubeSearchTool(BaseTool):
+    """Tool for searching YouTube for educational videos related to academic topics"""
+    
+    name: str = "YouTube Academic Search"
+    description: str = (
+        "Searches YouTube for high-quality educational videos related to computer science, "
+        "DSA, programming, and academic topics. Returns real video data with working URLs."
+    )
+    args_schema: Type[BaseModel] = YouTubeSearchInput
+    
+    YOUTUBE_SEARCH_URL: str = "https://www.youtube.com/results"  # Fixed: removed extra spaces
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # No API key needed
+    
+    def _run(self, query: str, max_results: int = 5, topic_category: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Execute the YouTube search with the given parameters"""
+        logger.info(f"Searching YouTube for: '{query}' (max_results={max_results}, category={topic_category})")
+        
+        try:
+            # Prepare search query
+            search_query = self._enhance_query(query, topic_category)
+            
+            # Prepare request parameters
+            params = {
+                "search_query": search_query,
+                "sp": "EgIQAQ%3D%3D"  # This parameter filters for videos only
+            }
+            
+            # Execute request with headers to mimic a browser
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+                "Accept-Language": "en-US,en;q=0.9",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+                "Connection": "keep-alive",
+                "Upgrade-Insecure-Requests": "1",
+                "Sec-Fetch-Dest": "document",
+                "Sec-Fetch-Mode": "navigate",
+                "Sec-Fetch-Site": "none",
+                "Sec-Fetch-User": "?1"
+            }
+            
+            # Add a small delay to avoid being blocked
+            time.sleep(random.uniform(0.5, 1.5))
+            
+            response = requests.get(
+                self.YOUTUBE_SEARCH_URL, 
+                params=params, 
+                headers=headers, 
+                timeout=15,
+                cookies={"CONSENT": "YES+cb.20210328-17-p0.en+FX+100"}
+            )
+            response.raise_for_status()
+            
+            # Parse the HTML response
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Extract initial data from the page
+            scripts = soup.find_all('script')
+            initial_data = None
+            
+            for script in scripts:
+                if script.string and 'var ytInitialData' in script.string:
+                    # Extract the JSON data from the script
+                    start_index = script.string.find('var ytInitialData = ') + len('var ytInitialData = ')
+                    end_index = script.string.find(';</script>', start_index)
+                    if end_index == -1:
+                        end_index = script.string.find(';', start_index)
+                    
+                    try:
+                        # Handle possible JSONP responses
+                        json_text = script.string[start_index:end_index].strip()
+                        if json_text.endswith(')'):
+                            json_text = json_text[:-1]
+                        initial_data = json.loads(json_text)
+                        break
+                    except json.JSONDecodeError as e:
+                        logger.debug(f"JSON decode error: {str(e)}")
+                        continue
+            
+            if not initial_data:
+                logger.warning("Could not extract initial data from YouTube page")
+                return self._get_fallback_videos(query, max_results, topic_category)
+            
+            # Process results
+            videos = []
+            try:
+                # Navigate through the JSON structure to find video data
+                contents = initial_data['contents']['twoColumnSearchResultsRenderer']['primaryContents']['sectionListRenderer']['contents']
+                
+                for section in contents:
+                    if 'itemSectionRenderer' in section:
+                        items = section['itemSectionRenderer']['contents']
+                        
+                        for item in items:
+                            if 'videoRenderer' in item:
+                                video_data = item['videoRenderer']
+                                
+                                # Extract video information
+                                video_id = video_data.get('videoId', '')
+                                if not video_id:
+                                    continue
+                                    
+                                # Get title - handle different possible structures
+                                title = ""
+                                if 'title' in video_data and 'runs' in video_data['title']:
+                                    title = video_data['title']['runs'][0].get('text', '')
+                                elif 'title' in video_data and 'simpleText' in video_data['title']:
+                                    title = video_data['title'].get('simpleText', '')
+                                
+                                # Get channel name
+                                channel = ""
+                                if 'ownerText' in video_data and 'runs' in video_data['ownerText']:
+                                    channel = video_data['ownerText']['runs'][0].get('text', '')
+                                
+                                # Get description
+                                description = ""
+                                if 'descriptionSnippet' in video_data and 'runs' in video_data['descriptionSnippet']:
+                                    description = video_data['descriptionSnippet']['runs'][0].get('text', '')
+                                
+                                # Get thumbnail URL
+                                thumbnail_url = ""
+                                if 'thumbnail' in video_data and 'thumbnails' in video_data['thumbnail']:
+                                    thumbnails = video_data['thumbnail']['thumbnails']
+                                    if thumbnails:
+                                        # Get the highest quality thumbnail
+                                        thumbnail_url = thumbnails[-1].get('url', '')
+                                
+                                # Filter for relevance
+                                if self._is_relevant_video(title, description, query, topic_category):
+                                    # FIXED: Removed extra spaces from URLs
+                                    videos.append({
+                                        "title": title,
+                                        "url": f"https://www.youtube.com/watch?v={video_id}",
+                                        "embed_url": f"https://www.youtube.com/embed/{video_id}",
+                                        "channel": channel,
+                                        "description": self._clean_description(description),
+                                        "thumbnail": thumbnail_url,
+                                        "category": self._determine_video_category(
+                                            title, 
+                                            description,
+                                            query,
+                                            topic_category
+                                        )
+                                    })
+                                    
+                                    if len(videos) >= max_results:
+                                        break
+                        
+                        if len(videos) >= max_results:
+                            break
+            except (KeyError, IndexError, TypeError) as e:
+                logger.error(f"Error parsing YouTube data: {str(e)}")
+                return self._get_fallback_videos(query, max_results, topic_category)
+            
+            if not videos:
+                logger.warning(f"No relevant videos found for query: '{query}'")
+                return self._get_fallback_videos(query, max_results, topic_category)
+                
+            logger.info(f"Found {len(videos)} relevant YouTube videos for query: '{query}'")
+            return videos
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error during YouTube search: {str(e)}")
+            return self._get_fallback_videos(query, max_results, topic_category)
+        except Exception as e:
+            logger.exception(f"Unexpected error during YouTube search: {str(e)}")
+            return self._get_fallback_videos(query, max_results, topic_category)
+    
+    async def _arun(self, query: str, max_results: int = 5, topic_category: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Async version of the tool"""
+        return self._run(query, max_results, topic_category)
+    
+    def _enhance_query(self, query: str, topic_category: Optional[str] = None) -> str:
+        """Enhance the search query for better educational results"""
+        base_query = query
+        
+        # Add educational terms based on topic
+        if topic_category:
+            topic_lower = topic_category.lower()
+            if "dsa" in topic_lower or "algorithm" in topic_lower or "data structure" in topic_lower:
+                base_query += " algorithm tutorial"
+            elif "web" in topic_lower or "development" in topic_lower:
+                base_query += " tutorial"
+            elif "python" in topic_lower or "programming" in topic_lower:
+                base_query += " programming tutorial"
+            elif "operating" in topic_lower or "os" in topic_lower:
+                base_query += " tutorial"
+            elif "machine learning" in topic_lower or "ml" in topic_lower:
+                base_query += " tutorial"
+        
+        # Always add terms for high-quality educational content
+        enhanced_query = f"{base_query}"
+        
+        logger.debug(f"Enhanced YouTube query: '{enhanced_query}'")
+        return enhanced_query
+    
+    def _is_relevant_video(self, title: str, description: str, query: str, topic_category: Optional[str]) -> bool:
+        """Determine if a video is relevant to the academic search"""
+        # Handle empty inputs
+        if not title:
+            return False
+            
+        title_lower = title.lower()
+        description_lower = description.lower() if description else ""
+        query_lower = query.lower()
+        
+        # Filter out irrelevant content
+        irrelevant_terms = [
+            "song", "music", "gaming", "funny", "meme", "challenge", 
+            "vlog", "unboxing", "review", "top 10", "best of",
+            "live", "stream", "reaction", "cover", "remix"
+        ]
+        
+        for term in irrelevant_terms:
+            if term in title_lower or (description and term in description_lower):
+                return False
+        
+        # Check for educational indicators - make this less strict
+        educational_indicators = [
+            "tutorial", "course", "lesson", "guide", "explained", 
+            "how to", "learn", "beginner", "advanced", "lecture",
+            "class", "notes", "concepts", "explained", "fundamentals",
+            "introduction", "overview", "basics", "complete", "full"
+        ]
+        
+        has_educational_indicator = any(term in title_lower or (description and term in description_lower) 
+                                    for term in educational_indicators)
+        
+        # If we have a topic category, check for specific relevance
+        if topic_category:
+            topic_lower = topic_category.lower()
+            if "dsa" in topic_lower:
+                return has_educational_indicator or (
+                    "algorithm" in title_lower or "data structure" in title_lower or 
+                    "dsa" in title_lower or "problem solving" in title_lower
+                )
+            elif "web" in topic_lower:
+                return has_educational_indicator or (
+                    "web development" in title_lower or "frontend" in title_lower or 
+                    "backend" in title_lower or "full stack" in title_lower
+                )
+        
+        # If no educational indicators, check if the title contains the query
+        if not has_educational_indicator and query_lower in title_lower:
+            return True
+            
+        return has_educational_indicator
+    
+    def _clean_description(self, description: str) -> str:
+        """Clean up the video description for display"""
+        if not description:
+            return ""
+            
+        # Remove URLs
+        description = re.sub(r'http\S+', '', description)
+        # Remove excessive whitespace
+        description = re.sub(r'\s+', ' ', description).strip()
+        # Truncate if too long
+        if len(description) > 200:
+            description = description[:197] + "..."
+        return description
+    
+    def _determine_video_category(self, title: str, description: str, query: str, topic_category: Optional[str]) -> str:
+        """Determine the most appropriate category for the video"""
+        title_lower = title.lower()
+        description_lower = description.lower() if description else ""
+        
+        # Use topic_category if provided and valid
+        if topic_category:
+            topic_lower = topic_category.lower()
+            if "dsa" in topic_lower or "algorithm" in topic_lower or "data structure" in topic_lower:
+                return "DSA"
+            elif "web" in topic_lower or "development" in topic_lower:
+                return "Web Development"
+            elif "python" in topic_lower or "programming" in topic_lower:
+                return "Programming"
+            elif "operating" in topic_lower or "os" in topic_lower:
+                return "Operating Systems"
+            elif "machine learning" in topic_lower or "ml" in topic_lower:
+                return "Machine Learning"
+        
+        # Determine category from content
+        if "dsa" in title_lower or "algorithm" in title_lower or "data structure" in title_lower:
+            return "DSA"
+        elif "web development" in title_lower or "frontend" in title_lower or "backend" in title_lower:
+            return "Web Development"
+        elif "python" in title_lower or "programming" in title_lower or "coding" in title_lower:
+            return "Programming"
+        elif "operating system" in title_lower or "os" in title_lower:
+            return "Operating Systems"
+        elif "machine learning" in title_lower or "deep learning" in title_lower or "ai" in title_lower:
+            return "Machine Learning"
+        elif "database" in title_lower or "dbms" in title_lower:
+            return "Databases"
+        elif "network" in title_lower or "computer network" in title_lower:
+            return "Networking"
+            
+        return "Computer Science"
+    
+    def _get_fallback_videos(self, query: str, max_results: int, topic_category: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Return high-quality fallback videos when scraping fails"""
+        logger.warning("Using fallback YouTube videos due to scraping issues")
+        
+        # Check if we have specific videos for this query
+        query_lower = query.lower()
+        
+        # Specific videos for common topics
+        if "binary search" in query_lower:
+            return [
+                {
+                    "title": "Binary Search Algorithm Explained",
+                    "url": "https://www.youtube.com/watch?v=j5uXyPJ0Pew",
+                    "embed_url": "https://www.youtube.com/embed/j5uXyPJ0Pew",
+                    "channel": "CS Dojo",
+                    "description": "Clear explanation of binary search algorithm with examples",
+                    "thumbnail": "https://i.ytimg.com/vi/j5uXyPJ0Pew/hqdefault.jpg",
+                    "duration": "10 min",
+                    "views": "500K+",
+                    "category": "DSA"
+                },
+                {
+                    "title": "Binary Search Implementation in Python",
+                    "url": "https://www.youtube.com/watch?v=zeEaz5J0w1c",
+                    "embed_url": "https://www.youtube.com/embed/zeEaz5J0w1c",
+                    "channel": "Programming with Mosh",
+                    "description": "Step-by-step implementation of binary search in Python",
+                    "thumbnail": "https://i.ytimg.com/vi/zeEaz5J0w1c/hqdefault.jpg",
+                    "duration": "12 min",
+                    "views": "300K+",
+                    "category": "DSA"
+                }
+            ]
+        elif "dynamic programming" in query_lower:
+            return [
+                {
+                    "title": "Dynamic Programming - Learn to Solve Algorithmic Problems",
+                    "url": "https://www.youtube.com/watch?v=oBt53YbR9Kk",
+                    "embed_url": "https://www.youtube.com/embed/oBt53YbR9Kk",
+                    "channel": "freeCodeCamp",
+                    "description": "Complete guide to dynamic programming with examples",
+                    "thumbnail": "https://i.ytimg.com/vi/oBt53YbR9Kk/hqdefault.jpg",
+                    "duration": "45 min",
+                    "views": "1M+",
+                    "category": "DSA"
+                },
+                {
+                    "title": "Dynamic Programming Tutorial",
+                    "url": "https://www.youtube.com/watch?v=CB_N7A_a1qY",
+                    "embed_url": "https://www.youtube.com/embed/CB_N7A_a1qY",
+                    "channel": "Abdul Bari",
+                    "description": "Comprehensive tutorial on dynamic programming concepts",
+                    "thumbnail": "https://i.ytimg.com/vi/CB_N7A_a1qY/hqdefault.jpg",
+                    "duration": "30 min",
+                    "views": "800K+",
+                    "category": "DSA"
+                }
+            ]
+        elif "react" in query_lower:
+            return [
+                {
+                    "title": "React JS Tutorial for Beginners",
+                    "url": "https://www.youtube.com/watch?v=w7ejDZ8o_s8",
+                    "embed_url": "https://www.youtube.com/embed/w7ejDZ8o_s8",
+                    "channel": "Programming with Mosh",
+                    "description": "Complete React tutorial for beginners",
+                    "thumbnail": "https://i.ytimg.com/vi/w7ejDZ8o_s8/hqdefault.jpg",
+                    "duration": "1 hour",
+                    "views": "5M+",
+                    "category": "Web Development"
+                },
+                {
+                    "title": "React Fundamentals",
+                    "url": "https://www.youtube.com/watch?v=Ke90Tje7VS0",
+                    "embed_url": "https://www.youtube.com/embed/Ke90Tje7VS0",
+                    "channel": "freeCodeCamp",
+                    "description": "Learn React fundamentals with hands-on examples",
+                    "thumbnail": "https://i.ytimg.com/vi/Ke90Tje7VS0/hqdefault.jpg",
+                    "duration": "2 hours",
+                    "views": "2M+",
+                    "category": "Web Development"
+                }
+            ]
+        
+        # Default educational videos by category
+        category_videos = {
+            "dsa": [
+                {
+                    "title": "Data Structures and Algorithms - Full Course for Beginners",
+                    "url": "https://www.youtube.com/watch?v=8hly31xKli0",
+                    "embed_url": "https://www.youtube.com/embed/8hly31xKli0",
+                    "channel": "freeCodeCamp",
+                    "description": "Comprehensive DSA course covering all fundamental data structures and algorithms with practical examples",
+                    "thumbnail": "https://i.ytimg.com/vi/8hly31xKli0/hqdefault.jpg",
+                    "duration": "4+ hours",
+                    "views": "2.5M+",
+                    "category": "DSA"
+                }
+            ],
+            "web": [
+                {
+                    "title": "Web Development Tutorial for Beginners",
+                    "url": "https://www.youtube.com/watch?v=ysyzdFV45ek",
+                    "embed_url": "https://www.youtube.com/embed/ysyzdFV45ek",
+                    "channel": "Traversy Media",
+                    "description": "Complete guide to modern web development practices including HTML, CSS, and JavaScript",
+                    "thumbnail": "https://i.ytimg.com/vi/ysyzdFV45ek/hqdefault.jpg",
+                    "duration": "1+ hour",
+                    "views": "3.5M+",
+                    "category": "Web Development"
+                }
+            ],
+            "programming": [
+                {
+                    "title": "Python Programming Tutorial - Full Course",
+                    "url": "https://www.youtube.com/watch?v=_uQrJ0TkZlc",
+                    "embed_url": "https://www.youtube.com/embed/_uQrJ0TkZlc",
+                    "channel": "Programming with Mosh",
+                    "description": "Learn Python programming from scratch with hands-on examples and projects",
+                    "thumbnail": "https://i.ytimg.com/vi/_uQrJ0TkZlc/hqdefault.jpg",
+                    "duration": "6+ hours",
+                    "views": "5.2M+",
+                    "category": "Programming"
+                }
+            ]
+        }
+        
+        # Determine which category to use
+        category_key = "programming"  # Default category
+        
+        if topic_category:
+            topic_lower = topic_category.lower()
+            if "dsa" in topic_lower or "algorithm" in topic_lower or "data structure" in topic_lower:
+                category_key = "dsa"
+            elif "web" in topic_lower or "development" in topic_lower:
+                category_key = "web"
+            elif "python" in topic_lower or "programming" in topic_lower or "coding" in topic_lower:
+                category_key = "programming"
+        
+        # Return videos from the appropriate category, or default to programming
+        return category_videos.get(category_key, category_videos["programming"])[:max_results]