Deployment: High-Fidelity Dashboard & Native Storage Integration

.dockerignore

@@ -0,0 +1,21 @@
+node_modules
+build
+dist
+venv
+env
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+.git
+.gitignore
+.dockerignore
+Dockerfile
+README.md
+backend/polyline_generation.log
+backend/db.json
+backend/db_backup.json
+.env
+*.pem
+*.local

.gitignore

@@ -0,0 +1,46 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+.env
+
+# Temporary and local files
+__pycache__/
+hf_https_clone/
+temp_zip_check/
+backend/backend_logs.txt
+backend/data/*.db
+backend/data/*.sql
+nl_main_deployment.zip
+
+# Large files and models
+**/*.xlsx
+**/*.pth
+**/*.zip
+backend/models/
+backend/nlp/*.xlsx
+backend/data/*.json
+!backend/data/youtube_links.json
+!backend/data/youtube_transcripts.json
+!backend/nlp/nlp_resources.json
+!backend/data/db.json
+!extracted_data.json

Dockerfile

@@ -0,0 +1,45 @@
+# Stage 1: Build the React Frontend
+FROM node:18-alpine as build-frontend
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+# Stage 2: Setup the Python Backend
+FROM python:3.9-slim
+
+# Create a non-root user for Hugging Face (UID 1000)
+RUN useradd -m -u 1000 user
+
+# Install system dependencies first (cached layer)
+USER root
+RUN apt-get update && apt-get install -y --no-install-recommends gcc python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /home/user/app
+
+# Install PyTorch CPU-only FIRST (largest package, separate cache layer)
+# This avoids downloading the ~800MB CUDA version
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
+
+# Install remaining Python dependencies
+COPY --chown=user backend/requirements.txt backend/
+# Remove torch from requirements since we installed it above
+RUN grep -v '^torch' backend/requirements.txt > /tmp/req_notorch.txt && pip install --no-cache-dir --upgrade -r /tmp/req_notorch.txt && pip install --no-cache-dir gunicorn
+
+# Copy Backend Code
+COPY --chown=user backend/ backend/
+COPY --chown=user Navigators/ Navigators/
+
+# Copy Frontend Build from Stage 1
+COPY --chown=user --from=build-frontend /app/dist ./dist
+
+# Environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Run the application
+CMD gunicorn -b 0.0.0.0:$PORT backend.nlp_api:app

README.md

@@ -0,0 +1,34 @@
+
+---
+title: NL Main
+emoji: 🧠
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+---
+
+# NLP Learning Grid
+
+Advanced agentic NLP learning platform with a 3D grid interface, DQN-based pathfinding, and interactive AI learning assistant.
+
+## Deployment Options
+
+### Hugging Face Spaces
+This repository is configured for direct deployment to Hugging Face Spaces using Docker.
+- Port: 7860 (Auto-configured in Dockerfile)
+
+### Fly.io
+Deploy using the included `fly.toml`:
+```bash
+fly launch
+```
+
+### Render.com
+Use the `render.yaml` for one-click deployment.
+
+### Manual
+```bash
+docker build -t nlp-learning-grid .
+docker run -p 5000:7860 nlp-learning-grid
+```

backend/Inspiration/app.py

@@ -0,0 +1,600 @@
+# This Flask backend manages user authentication (signup/login), course enrollment, teacher/TA assignment, 
+# and provides course/learner data. It handles requests for course details, module/topic information, learner positions,
+# and quiz interactions (submission, fetching questions/logs, recording attempts, creation).
+# Data is often fetched from or updated in the database based on user actions and IDs.
+import datetime
+from utils import is_valid_id
+from dbModels import User, db, Course, Question, UserQuiz
+from init import app, DBcreated
+import pandas as pd
+from flask import make_response,jsonify, request
+from repository import add_learner_from_user, add_teacher_from_user, create_Course, update_position, login,signup,teacher_course,teacher_course_unassigned,assign_teacher_course,unassign_teacher_course, learner_course_enrolled,generate_data,learner_course_unenrolled,enrolled_learner_data,enrolled_learners_by_course,calculate_all_module_centroids,add_enroll,update_by_quiz,learner_polyline_enrolled,get_suitable_position,change_resource_position,update_position_resource,update_summary_grade, quiz_adder_from_json,ta_course,ta_course_teached,ta_course_unteached, user_enrolled_courses, user_recom_courses
+from datetime import datetime, timedelta,timezone
+from flask import Flask
+import modelsRoutes # to expose routes
+
+# Read data from Excel file
+excel_file = 'DM_Resource_Plot.xlsx'
+df = pd.read_excel(excel_file)
+excel_file = 'DM_learner_plot.xlsx'
+df_learner = pd.read_excel(excel_file)
+
+# Assuming your Excel file has columns 'x', 'y', and 'video_url'
+scatterplot_data = df[['index', 'name', 'x', 'y', 'video_url', 'module','module_id','submodule_id']].to_dict(orient='records')
+
+# Convert the scatterplot_data into a DataFrame
+df_scatter = pd.DataFrame(scatterplot_data)
+
+# Group by 'module_id' and calculate the mean of 'x' and 'y'
+module_data_df = df_scatter.groupby('module_id').agg({'x': 'mean', 'y': 'mean','module': 'first' }).reset_index()
+
+# Convert the result to a list of dictionaries with 'module_id', 'x', and 'y'
+module_data = module_data_df.to_dict(orient='records')
+topic_data_df=pd.read_excel('DM/DM_topics.xlsx')
+topic_data=topic_data_df[['name','description']].to_dict(orient='records')
+
+
+learner_data = df_learner[['index', 'resource_name', 'x', 'y', 'description']].to_dict(orient='records')
+
+if DBcreated:
+    # print("creating the course")
+    # create_Course("Discreate Mathematics",
+    #               "this is the description of DM", None, None)
+    print("Generating Data")
+    generate_data()
+
+
+@app.route('/ids/<int:user_id>')
+def get_ids(user_id):
+    """
+    Fetches learner, teacher, and TA IDs for a given user.
+
+    Args:
+        user_id (int): ID of the user.
+
+    Returns:
+        JSON: Dictionary containing 'learner_id', 'teacher_id', and 'ta_id'.
+    """
+    with app.app_context():
+        user = User.query.get(user_id)
+        return ({
+            'learner_id': user.learner_id,
+            'teacher_id': user.teacher_id,
+            'ta_id': user.ta_id,
+        })
+
+@app.route('/data')
+def get_data():
+    """
+    Returns resource scatterplot data (x, y, video URLs, module info).
+
+    Returns:
+        JSON: List of resource data dictionaries.
+    """
+    return jsonify(scatterplot_data)
+
+@app.route('/moduleData/<int:id>')
+def get_module_data(id):
+    """
+    Calculates and returns module centroid data for a given course.
+
+    Args:
+        id (int): Course ID.
+
+    Returns:
+        JSON: List of module data with centroid positions.
+    """
+    moudle = calculate_all_module_centroids(id)
+    return jsonify(moudle)
+
+@app.route('/topicData')
+def get_topic_data():
+    """
+    Fetches topic names and descriptions.
+
+    Returns:
+        JSON: List of topic dictionaries with 'name' and 'description'.
+    """
+    return jsonify(topic_data)
+
+@app.route('/new_positions')
+def get_new_data():
+    """
+    Returns learner plot data including positions and descriptions.
+
+    Returns:
+        JSON: List of learner data dictionaries.
+    """
+    return jsonify(learner_data)
+
+@app.route("/signup", methods=['POST'])
+def signup_user():
+    """
+    Registers a new user.
+
+    Request JSON:
+        - name (str): Full name of the user.
+        - username (str): Username for login.
+        - password (str): Password for the account.
+
+    Returns:
+        JSON: Created user details if successful, else error message.
+    """
+    data = request.get_json()
+    name = data["name"]
+    username = data["username"]
+    password = data["password"]
+    print("user signup: ", name, password, username)
+
+    user = signup(name, username, password)
+    if user:
+        return jsonify(user), 201
+    else:
+        return jsonify({"msg":"Error Creating user"}), 400
+
+@app.route("/login", methods=['POST'])
+def login_user():
+    """
+    Logs in an existing user.
+
+    Request JSON:
+        - username (str): Username of the user.
+        - password (str): Password of the user.
+
+    Returns:
+        JSON: User details if login is successful, else 401 status.
+    """
+    data = request.get_json()
+    username = data["username"]
+    password = data["password"]
+    print("user login request:", username, password)
+
+    user = login(username, password)
+    response = make_response(jsonify(user)) 
+    if user:
+        response.status_code = 200
+    else:
+        response.status_code = 401
+    
+    return response
+
+@app.route("/teacher/courses/<int:id>", methods=['GET'])
+def get_teacher_course(id):
+    """
+    Fetches all courses assigned to a teacher.
+
+    Args:
+        id (int): Teacher ID.
+
+    Returns:
+        JSON: List of courses assigned to the teacher.
+    """
+    return teacher_course(id)
+
+@app.route("/teacher/courses/unassigned/<int:id>", methods=['GET'])
+def get_teacher_course_unassigned(id):
+    """
+    Fetches all unassigned courses for a teacher.
+
+    Args:
+        id (int): Teacher ID.
+
+    Returns:
+        JSON: List of unassigned courses available for assignment.
+    """
+    return teacher_course_unassigned(id)
+
+@app.route("/teacher/courses/assign", methods=['POST'])
+def assign_teacher():
+    """
+    Assigns a teacher to a course. If teacher doesn't exist, creates one.
+
+    Request JSON:
+        - user_id (int): User ID.
+        - teacher_id (int): Teacher ID (may be invalid if new teacher).
+        - course_id (int): Course ID.
+
+    Returns:
+        JSON: Assignment result (success or failure).
+    """
+    data = request.get_json()
+    user_id = data["user_id"]
+    teacher_id = data["teacher_id"]
+    course_id = data["course_id"]
+    print(f"user_id: {user_id}, teacher_id: {teacher_id}, course_id: {course_id}")
+    if not is_valid_id(teacher_id):
+        print("adding new teacher...")
+        teacher_id = add_teacher_from_user(user_id)["id"]
+    if teacher_id and course_id:
+        result = assign_teacher_course(teacher_id, course_id)
+        response = make_response(jsonify(result))
+        if result:
+            response.status_code = 200
+        else :
+            response.status_code = 500
+    else:
+        response = make_response(None)
+        response.status_code = 400
+    return response
+
+@app.route("/teacher/courses/unassign", methods=['POST'])
+def unassign_teacher():
+    """
+    Unassigns a teacher from a course.
+
+    Request JSON:
+        - teacher_id (int): Teacher ID.
+        - course_id (int): Course ID.
+
+    Returns:
+        JSON: Result of unassignment (success/failure).
+    """
+    data = request.get_json()
+    teacher_id = data["teacher_id"]
+    course_id = data["course_id"]
+    print(teacher_id,course_id)
+    if teacher_id and course_id :
+        result = unassign_teacher_course(teacher_id, course_id)
+    return jsonify(result), 200 if result else jsonify(result), 400
+
+@app.route("/enrolledCourses/<int:id>", methods=['GET'])
+def get_enrolled_course(id):
+    """
+    Fetches list of courses a user is enrolled in, including role.
+
+    Args:
+        id (int): User ID.
+
+    Returns:
+        JSON: List of enrolled courses with role info.
+    """
+    return user_enrolled_courses(id)
+
+@app.route("/taTeachedCourses/<int:id>",methods=['GET'])
+def get_teached_course(id):
+    """
+    Fetches courses taught by a TA.
+
+    Args:
+        id (int): TA ID.
+
+    Returns:
+        JSON: List of courses taught by the TA.
+    """
+    return ta_course_teached(id)
+
+@app.route("/enrolledLearner/<int:id>/<int:id2>", methods=['GET'])
+def get_enrolled_learner(id,id2):
+    """
+    Fetches enrollment data for a learner in a specific course.
+
+    Args:
+        id (int): Learner ID.
+        id2 (int): Course ID.
+
+    Returns:
+        JSON: Learner enrollment details.
+    """
+    return enrolled_learner_data(id,id2)
+
+@app.route("/enrolledLearnersByCourse/<int:id>", methods=['GET'])
+def get_enrolled_learners(id):
+    """
+    Fetches all learners enrolled in a given course.
+
+    Args:
+        id (int): Course ID.
+
+    Returns:
+        JSON: List of enrolled learners.
+    """
+    return enrolled_learners_by_course(id)
+
+@app.route("/recomCourses/<int:id>", methods=['GET'])
+def get_recom_course(id):
+    """
+    Fetches list of courses recommended for a user.
+
+    Args:
+        id (int): User ID.
+
+    Returns:
+        JSON: List of recommended courses for enrollment.
+    """
+    return user_recom_courses(id)
+
+@app.route("/ta/recomCourses/<int:id>",methods=['GET'])
+def get_ta_recom_course(id):
+    """
+    Fetches list of courses recommended for a TA to teach.
+
+    Args:
+        id (int): TA ID.
+
+    Returns:
+        JSON: List of teachable recommended courses.
+    """
+    return ta_course_unteached(id)
+
+@app.route("/enrolledPolylines/<int:id>", methods=['GET'])
+def get_enrolled_polyline(id):
+    """
+    Fetches polyline data for resources a learner is enrolled in.
+
+    Args:
+        id (int): Learner ID.
+
+    Returns:
+        JSON: Polyline positions of enrolled resources.
+    """
+    return learner_polyline_enrolled(id)
+
+@app.route("/submitsummary", methods=['POST'])
+def get_new_postion():
+    """
+    Updates learner's position after submitting a summary.
+
+    Request JSON:
+        - summary (str): Learner's summary.
+        - enroll_id (int): Enrollment ID.
+
+    Returns:
+        JSON: Updated position and contribution ID.
+    """
+    data = request.get_json()
+    summary = data["summary"]
+    enrollId = data["enroll_id"]
+    pos,contribution_id = update_position(summary, enrollId)
+    return jsonify({"position": pos, "contribution_id": contribution_id}), 200
+
+@app.route("/changeSummaryGrade", methods=['POST'])
+def get_new_learner_postion():
+    """
+    Updates the grade of a learner's summary.
+
+    Request JSON:
+        - contribution_id (int): Contribution ID.
+        - grade (float): Grade to assign.
+
+    Returns:
+        JSON: Updated learner position.
+    """
+    data = request.get_json()
+    contributionId = data["contribution_id"]
+    grade = data["grade"]
+    pos = update_summary_grade(contributionId,grade)
+    return jsonify(pos), 200
+
+@app.route("/watchResource", methods=['POST'])
+def get_updated_postion():
+    """
+    Updates learner's position after watching a resource.
+
+    Request JSON:
+        - enroll_id (int): Enrollment ID.
+        - resource_id (int): Resource ID.
+
+    Returns:
+        JSON: Updated learner position.
+    """
+    data = request.get_json()
+    enrollId = data["enroll_id"]
+    resourceId = data["resource_id"]
+    pos = update_position_resource(enrollId,resourceId)
+    return jsonify(pos), 200
+
+@app.route("/suitableResourcePosition", methods=['POST'])
+def suitable_postion():
+    """
+    Suggests a suitable position for a learner based on resource.
+
+    Request JSON:
+        - pos (float): Initial position.
+        - resource_id (int): Resource ID.
+
+    Returns:
+        JSON: Adjusted suitable position.
+    """
+    data = request.get_json()
+    initial_pos = data["pos"]
+    resourceId = data["resource_id"]
+    pos = get_suitable_position(initial_pos,resourceId)
+    return jsonify(pos), 200
+
+@app.route("/changeResourcePosition", methods=['POST'])
+def change_postion():
+    """
+    Changes position of a resource.
+
+    Request JSON:
+        - pos (float): New position.
+        - resource_id (int): Resource ID.
+
+    Returns:
+        JSON: Empty success response.
+    """
+    data = request.get_json()
+    pos = data["pos"]
+    resourceId = data["resource_id"]
+    change_resource_position(pos,resourceId)
+    return jsonify({}), 200
+
+@app.route("/submitquiz", methods=['POST'])
+def update_by_quiz_route():
+    """
+    Updates learner's position based on quiz performance.
+
+    Request JSON:
+        - enroll_id (int): Enrollment ID.
+        - course_id (int): Course ID.
+        - to_consider (list): Boolean array of questions to consider.
+        - question_polyline (list): Polyline array for each question.
+
+    Returns:
+        JSON: Updated learner position.
+    """
+    data = request.get_json()
+    enrollId = data["enroll_id"]
+    courseId = data["course_id"]
+    to_consider = data["to_consider"]
+    question_polyline = data["question_polyline"]
+
+    pos = update_by_quiz(enrollId, courseId, to_consider, question_polyline, position_scaler = 1)
+
+    return jsonify(pos), 200
+
+@app.route('/quiz_questions/<int:quiz_id>', methods=['GET'])
+def get_quiz_questions(quiz_id):
+    """
+    Fetches all questions for a given quiz.
+
+    Args:
+        quiz_id (int): Quiz ID.
+
+    Returns:
+        JSON: List of question dictionaries with options and correct answer.
+    """
+    questions = Question.query.filter_by(quiz_id=quiz_id).all()
+    questions_data = []
+    for question in questions:
+        questions_data.append({
+            'id': question.id,
+            'quiz_id': question.quiz_id,
+            'question_text': question.question_text,
+            'option_a': question.option_a,
+            'option_b': question.option_b,
+            'option_c': question.option_c,
+            'option_d': question.option_d,
+            'correct_answer': question.correct_answer,
+            'polyline': question.polyline
+        })
+
+    return jsonify(questions_data), 200
+
+@app.route('/fetch_quiz_log/<int:user_id>', methods=['GET'])
+def fetch_quiz_log(user_id):
+    """
+    Fetches all quiz attempts made by a user.
+
+    Args:
+        user_id (int): User ID.
+
+    Returns:
+        JSON: List of quiz attempt logs with score and attempt date.
+    """
+    user_quizzes = UserQuiz.query.filter_by(user_id=user_id).all()
+    user_quiz_data = []
+
+    for user_quiz in user_quizzes:
+        user_quiz_data.append({
+            'id': user_quiz.id,
+            'quiz_id': user_quiz.quiz_id,
+            'user_id': user_quiz.user_id,
+            'score': user_quiz.score,
+            'completion_date': user_quiz.attempt_date,
+        })
+
+    return jsonify(user_quiz_data), 200
+
+@app.route('/record_quiz_attempt', methods=['POST'])
+def record_quiz_attempt():
+    """
+    Records a quiz attempt for a user.
+
+    Request JSON:
+        - user_id (int): User ID.
+        - quiz_id (int): Quiz ID.
+        - score (float): Score obtained.
+        - status (str): Status (e.g., completed, pending).
+        - attempt_date (str, optional): ISO timestamp of attempt.
+
+    Returns:
+        JSON: Created quiz attempt record if successful.
+    """
+    try:
+        data = request.get_json()
+        attempt_date = None
+        if 'attempt_date' in data:
+            attempt_date_utc = datetime.fromisoformat(data['attempt_date'].replace("Z", "+00:00"))
+            ist_timezone = timezone(timedelta(hours=5, minutes=30))
+            attempt_date = attempt_date_utc.astimezone(ist_timezone)
+
+        new_user_quiz = UserQuiz(
+            user_id=data['user_id'],
+            quiz_id=data['quiz_id'],
+            score=data.get('score'),
+            status=data['status'],
+            attempt_date=attempt_date
+        )
+
+        db.session.add(new_user_quiz)
+        db.session.commit()
+        return jsonify(new_user_quiz.to_dict()), 201
+    except Exception as e:
+        print("Error in record_quiz_attempt:", e)
+        return jsonify({"error": "Failed to record quiz attempt"}), 500
+
+@app.route('/createquiz', methods=['POST'])
+def create_quiz():
+    """
+    Creates a new quiz and its associated questions.
+
+    Request JSON:
+        - quiz details and questions in structured format.
+
+    Returns:
+        JSON: Success message with x, y coordinates from quiz creation.
+    """
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+
+        x, y = quiz_adder_from_json(data)
+        return jsonify({"message": "Quiz and questions added successfully!", "x": x, "y": y}), 201
+
+    except Exception as e:
+        print("Unexpected error in create_quiz:", e)
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/enrolls', methods=['POST'])
+def create_enroll():
+    """
+    Enrolls a learner into a course. Creates learner profile if missing.
+
+    Request JSON:
+        - user_id (int): User ID.
+        - learner_id (int): Learner ID (optional if new).
+        - course_id (int): Course ID.
+
+    Returns:
+        JSON: Enrollment confirmation.
+    """
+    data = request.get_json()
+    user_id=data['user_id']
+    learner_id=data['learner_id']
+    course_id=data['course_id']
+    if not is_valid_id(learner_id):
+        learner_id = add_learner_from_user(user_id)['id']
+    return add_enroll(learner_id, course_id)
+
+@app.route('/coursename/<int:course_id>', methods=['GET'])
+def get_course_name(course_id):
+    """
+    Fetches the name of a course by its ID.
+
+    Args:
+        course_id (int): ID of the course.
+
+    Returns:
+        JSON: A dictionary containing the course name or an error message.
+    """
+    course = Course.query.get(course_id)
+    if course:
+        return jsonify({'course_id': course.id, 'name': course.name})
+    else:
+        return jsonify({'error': 'Course not found'}), 404
+
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", debug=True)

backend/Inspiration/model_library.py

@@ -0,0 +1,597 @@
+import pandas as pd
+from bs4 import BeautifulSoup
+import re
+import nltk
+from nltk.stem import WordNetLemmatizer, PorterStemmer
+from nltk.corpus import stopwords
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from transformers import BertModel, BertTokenizer, BertForMaskedLM
+import torch
+from dbModels import db, Resource, Course, Topic, app, Enroll, Learner
+import math
+from keybert import KeyBERT
+from utils import get_cos_sim
+from statistics import mean
+# from memory_profiler import profile
+import gc
+
+nltk.download('stopwords')
+nltk.download('wordnet')
+stop_words = set(stopwords.words('english'))
+
+
+def utils_preprocess_text(text: str, flg_stemm: bool = False, flg_lemm: bool = True, lst_stopwords: list = None) -> str:
+    """
+    Preprocess text by removing HTML tags, punctuations, numbers, stopwords, and applying stemming/lemmatization.
+
+    Parameters:
+        text (str): The text to preprocess.
+        flg_stemm (bool): Flag to apply stemming. Default is False.
+        flg_lemm (bool): Flag to apply lemmatization. Default is True.
+        lst_stopwords (list): List of stopwords to remove. Default is None.
+
+    Returns:
+        str: The preprocessed text.
+    """
+
+    # Remove HTML
+    soup = BeautifulSoup(text, 'lxml')
+    text = soup.get_text()
+
+    # Remove punctuations and numbers
+    text = re.sub('[^a-zA-Z]', ' ', text)
+
+    # Single character removal
+    text = re.sub(r"\s+[a-zA-Z]\s+", ' ', text)
+
+    # Remove multiple spaces
+    text = re.sub(r'\s+', ' ', text)
+
+    # Tokenize text
+    lst_text = text.split()
+
+    # Remove stopwords
+    if lst_stopwords is not None:
+        lst_text = [word for word in lst_text if word not in lst_stopwords]
+
+    # Apply stemming
+    if flg_stemm:
+        ps = PorterStemmer()
+        lst_text = [ps.stem(word) for word in lst_text]
+
+    # Apply lemmatization
+    if flg_lemm:
+        lem = WordNetLemmatizer()
+        lst_text = [lem.lemmatize(word) for word in lst_text]
+
+    text = " ".join(lst_text)
+    return text
+
+
+def apply_preprocessing(df: pd.DataFrame):
+    """
+    Apply text preprocessing to the 'description' column of the DataFrame.
+
+    Parameters:
+        df (pd.DataFrame): DataFrame containing topics.
+    """
+    stop_words = set(stopwords.words('english'))  # Define stopwords
+    df['clean_text'] = df['description'].apply(lambda x: x.lower())
+    df['clean_text'] = df['clean_text'].apply(lambda x: utils_preprocess_text(
+        x, flg_stemm=False, flg_lemm=True, lst_stopwords=stop_words))
+    df['tokens'] = df['clean_text'].apply(lambda x: x.split())
+
+# @profile
+def create_topic_embeddings(topics: pd.DataFrame) -> list:
+    """
+    Create embeddings for each topic using a pre-trained BERT model.
+
+    Parameters:
+        topics (pd.DataFrame): DataFrame containing topics.
+
+    Returns:
+        list: List of topic embeddings.
+    """
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    topic_embeddings = []
+
+    for i in range(len(topics)):
+        embedding = model.encode(
+            topics.loc[i, "description"], convert_to_tensor=True)
+        # Store embeddings as numpy arrays
+        topic_embeddings.append(embedding.cpu().numpy())
+        # Clear the embedding tensor and force garbage collection after each iteration
+        del embedding
+        gc.collect()
+
+    return topic_embeddings
+
+# @profile
+def create_topic_polylines(topics: pd.DataFrame, topic_embeddings: list) -> pd.DataFrame:
+    """
+    Create a DataFrame containing topic names, module numbers, and cosine similarity polylines.
+
+    Parameters:
+        topics (pd.DataFrame): DataFrame containing topics.
+        topic_embeddings (list): List of topic embeddings.
+
+    Returns:
+        pd.DataFrame: DataFrame with topic polylines.
+    """
+    topic_names = topics["name"].tolist()  # Topic keyphrases
+    length = len(topics)
+    topic_modules = []  # Topic module number
+    for i in range(12):
+        topic_modules.append(1)
+    for i in range(8):
+        topic_modules.append(2)
+    nowl = len(topic_modules)
+    for i in range(length-nowl):
+        topic_modules.append(3)
+    # Topic embedding - mean of topic embeddings of individual words of a keyphrase
+
+    top_poly = []
+    top_module = []
+    topic = []
+
+    # Going through each topic and computing the cosine similarity between it's embedding and all other topic's embeddings
+    for i in range(len(topic_names)):
+        polyline = [0]*len(topic_names)
+        for j in range(len(topic_names)):
+            cos_sim = 0
+            if topic_names[i] == topic_names[j]:
+                cos_sim = 1
+            else:
+                topic1_vector = topic_embeddings[i]
+                topic2_vector = topic_embeddings[j]
+
+                # scaling cosine similarity value from [-1,1] to [0,1]
+                cos_sim = (get_cos_sim(
+                    (topic1_vector), (topic2_vector)) + 1) / 2
+
+            polyline[j] = cos_sim  # format 1
+            # polyline.append((j, cos_sim)) #format 2
+
+        topic.append(topic_names[i])
+        top_module.append(topic_modules[i])
+        top_poly.append(polyline)
+
+    polyline_dict = {"topic": topic,
+                     "module": top_module, "polyline": top_poly}
+    # converting the topic polyline to a dataframe
+    topic_polylines = pd.DataFrame(polyline_dict)
+    return topic_polylines
+
+
+#
+#
+# Resources functions start
+#
+#
+# @profile
+
+def create_summary_embeddings(summary) -> list:
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    summary_embeddings_list = []
+
+    # Encode the summary and convert to numpy array, then wrap in an additional list to match the format
+    embedding = model.encode(summary, convert_to_tensor=True).cpu().numpy()
+    summary_embeddings_list.append([embedding.tolist()])  # Add extra list wrapping to match format
+
+    # Clear the embedding tensor and force garbage collection after each iteration
+    del embedding
+    gc.collect()
+    
+    return summary_embeddings_list
+
+def create_resource_embeddings(keywords):
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    keybert_embeddings_list = []
+    for i in keywords:
+        # Encode the keyword
+        embedding = model.encode(i)
+        
+        # Convert to list and wrap to match expected structure [[float, ...]]
+        embeddings = [embedding.tolist()]
+        keybert_embeddings_list.append(embeddings)
+        
+    return keybert_embeddings_list
+
+# @profile
+def create_resource_polylines(topicembedding, keybert_embeddings_list, beta):
+    all_polylines = []
+    topic_embeddings = topicembedding
+    for embeddings in keybert_embeddings_list:
+        single_file_polyline = []
+        for i in range(len(embeddings)):
+            docVector = embeddings[i]
+            polyline = []
+            for j in range(len(topic_embeddings)):
+                wordVector = topic_embeddings[j]
+                # find the cosine similarity between resource embeddings and the topic embeddings
+                cos_sim = (get_cos_sim(wordVector, docVector) + 1) / 2
+                polyline.append({'x': j, 'y': cos_sim})
+            single_file_polyline.append(polyline)
+        all_polylines.append(single_file_polyline)
+    new_polylines = []
+
+    for single_file_polyline in all_polylines:
+        templ = [0]*len(topicembedding)
+        for i in range(len(topicembedding)):
+            temp = 0
+            # between the multiple polylines for each doc find the average and set that as the final polyline
+            for j in range(len(single_file_polyline)):
+                temp += single_file_polyline[j][i]['y']
+            templ[i] = temp / len(single_file_polyline)
+        new_polylines.append(templ)
+
+    polylines = []
+    temporary_list = []
+    learning_objects = []
+    for i in range(len(new_polylines)):
+        polyline = new_polylines[i]
+        pol = {}
+        temporary_dict = {}
+        for j in range(len(polyline)):
+            pol[j] = polyline[j]
+        hd1 = np.array([v for v in pol.values()])
+        hd1.tolist()
+        temporary_dict["polyline"] = hd1
+        temporary_dict["ID"] = "r"
+        learning_objects.append(temporary_dict)
+        temporary_list.append(hd1)
+    polylines.extend(temporary_list)
+
+    beta = beta  # beta funtion to get more variance when plotting the polyline
+    polyline2 = polylines.copy()
+    beta_polylines = []
+    for line in polyline2:
+        v2 = []
+        mean_val = np.average(line)
+        len_arr = len(line)
+        for j in line:
+            j = j + beta*(j - mean_val)
+            if j > 1:
+                j = 1
+            if j < 0:
+                j = 0
+            v2.append(j)
+        beta_polylines.append(v2)
+
+    return beta_polylines
+
+def create_beta_polylines(resource_polylines,beta):
+    beta = beta  # beta funtion to get more variance when plotting the polyline
+    polyline2 = resource_polylines.copy()
+    beta_polylines = []
+    for line in polyline2:
+        v2 = []
+        mean_val = np.average(line)
+        len_arr = len(line)
+        for j in line:
+            j = j + beta*(j - mean_val)
+            if j > 1:
+                j = 1
+            if j < 0:
+                j = 0
+            v2.append(j)
+        beta_polylines.append(v2)
+
+    return beta_polylines
+
+def create_beta_polyline(polyline, beta):
+    # Apply beta transformation to a single polyline
+    beta_polyline = []
+    mean_val = np.average(polyline)
+    
+    for j in polyline:
+        j = j + beta * (j - mean_val)
+        # Clamping the values between 0 and 1
+        if j > 1:
+            j = 1
+        if j < 0:
+            j = 0
+        beta_polyline.append(j)
+    
+    return beta_polyline
+
+#
+#
+#
+# learners functions
+#
+#
+#
+
+
+def create_embeddings_centroid_list(l):
+    new_keybert_embeddings_list = []
+    for i in l:
+        # find the centroid of the embeddings for a doc
+        index_averages = [sum(x) / len(x) for x in zip(*i)]
+        new_keybert_embeddings_list.append(index_averages)
+    return new_keybert_embeddings_list
+
+
+def rad_plot_axes(num: int, x_max: float, y_max: float):
+    """
+    Generate radial plot axes.
+
+    Parameters:
+        num (int): Number of axes.
+        x_max (float): Maximum x-coordinate.
+        y_max (float): Maximum y-coordinate.
+
+    Returns:
+        tuple: A tuple containing the lengths of the axes and the angle theta.
+    """
+    empt_arr = []  # Temporary container for y-coordinate calculations
+    xstop = []  # List to store x-coordinate of the axes endpoints
+    ystop = []  # List to store y-coordinate of the axes endpoints
+    tlen = []  # List to store the length of axes
+    ttempl = []  # Temporary container for reversed lengths
+    theta = ((np.pi) / (num - 1)) / 2  # Calculate theta
+    b = 0
+
+    while (b * theta) <= (np.arctan(y_max / x_max)):
+        y_val = x_max * math.tan(b * theta)
+        empt_arr.append(y_val)
+        ystop.append(y_val)
+        ttemp = math.sqrt((x_max ** 2) + (y_val ** 2))
+        tlen.append(ttemp)
+        if (b * theta) != np.arctan(y_max / x_max):
+            ttempl.append(ttemp)
+        b += 1
+
+    while b < num:
+        ystop.append(y_max)
+        b += 1
+
+    tlen.extend(list(reversed(ttempl)))
+    xstop = list(reversed(ystop))
+
+    # Plotting is commented out for modularity; can be enabled as needed
+    # for d in range(num):
+    #     x_values = [0, xstop[d]]
+    #     y_values = [0, ystop[d]]
+    #     plt.plot(x_values, y_values, label=f'Axis {d+1}', alpha=1, linewidth=0.2)
+
+    return tlen, theta
+
+# @profile
+def rad_plot_poly(num: int, hd_point: list, tlen: list, theta: float) -> list:
+    """
+    Plot the polyline and calculate their centroids.
+
+    Parameters:
+        num (int): Number of points.
+        hd_point (list): List of polyline points.
+        tlen (list): Length of the axes.
+        theta (float): Angle theta.
+
+    Returns:
+        list: List of centroid coordinates.
+    """
+    coordinates = []
+
+    for pnt in hd_point:
+        x_values = []
+        y_values = []
+        for p in range(num):
+            rlen = pnt[p] * tlen[p]
+            x_values.append(rlen * math.cos(p * theta))
+            y_values.append(rlen * math.sin(p * theta))
+
+        # Plotting is commented out for modularity; can be enabled as needed
+        # plt.plot(x_values, y_values, label='Polyline', alpha=0.6, linewidth=0.5)
+
+        average_x = sum(x_values) / num
+        average_y = sum(y_values) / num
+        coordinates.append([average_x, average_y])
+
+    # Print statement for debugging
+    print("Red    - Resources ")
+
+    return coordinates
+
+
+def push_topics_to_db(topics: pd.DataFrame, topic_embeddings: list, topic_polylines: pd.DataFrame, course_id: str):
+    """
+    Push topics, their embeddings, and polylines to the database.
+
+    Parameters:
+        topics (pd.DataFrame): DataFrame containing topics.
+        topic_embeddings (list): List of topic embeddings.
+        topic_polylines (pd.DataFrame): DataFrame with topic polylines.
+        course_id (str): Unique identifier for the course.
+    """
+    # Print the lengths of topics, polylines, and embeddings for debugging
+    print(len(topics), len(topic_polylines), len(topic_embeddings))
+
+    # Determine the feature length from the polyline data
+    feature_length = len(topic_polylines["polyline"][0])
+
+    # Generate radial plot axes and plot polylines to get centroid coordinates
+    tlen, theta = rad_plot_axes(feature_length, 1, 1)
+    centroid_list = rad_plot_poly(
+        feature_length, topic_polylines["polyline"], tlen, theta)
+
+    # List to hold all topic objects
+    all_topics = []
+
+    with app.app_context():
+        for i in range(len(topics)):
+            topic = Topic(
+                name=topics["name"][i],
+                description=topics["description"][i],
+                keywords=topics["tokens"][i],
+                polyline=topic_polylines["polyline"][i],
+                x_coordinate=centroid_list[i][0],
+                y_coordinate=centroid_list[i][1],
+                course_id=course_id,
+                embedding=topic_embeddings[i].tolist()
+            )
+            all_topics.append(topic)
+
+        # Add all topics to the session and commit to the database
+        db.session.add_all(all_topics)
+        db.session.commit()
+
+    print("Added topics to DB")
+
+
+def get_cord_from_polyline(polylines):
+    x_max = y_max = 1
+    tlen, ttempl = [], []
+    b = 0
+    theta = ((np.pi) / (len(polylines[0]) - 1)) / 2
+    while (b * theta) <= (np.arctan(y_max / x_max)):
+        y_val = x_max * math.tan(b * theta)
+        ttemp = math.sqrt((x_max ** 2) + (y_val ** 2))
+        tlen.append(ttemp)
+        if (b * theta) != np.arctan(y_max / x_max):
+            ttempl.append(ttemp)
+        b += 1
+
+    while b < len(polylines[0]):
+        b += 1
+
+    tlen.extend(list(reversed(ttempl)))
+    print(tlen)
+    coordinates = []
+
+    for polyline in polylines:
+        x_values = []
+        y_values = []
+        for p in range(len(polyline)):
+            rlen = polyline[p] * tlen[p]
+            x_values.append(rlen * math.cos(p * theta))
+            y_values.append(rlen * math.sin(p * theta))
+        coordinates.append([mean(x_values), mean(y_values)])
+    return coordinates
+
+
+def pushResourcesToDB(resources, resourceembedding, resource_polylines, course_id):
+    print(len(resources), len(resource_polylines), len(resourceembedding))
+    beta_polylines=create_beta_polylines(resource_polylines,8)
+    feature_length = len(resource_polylines[0])
+    (tlen, theta) = rad_plot_axes(feature_length, 1, 1)
+    centroid_list = rad_plot_poly(
+        feature_length, beta_polylines, tlen, theta)
+    allresources = []
+    with app.app_context():
+        for i in range(len(resources)):
+            new_resource = Resource(
+                name=resources["name"][i],
+                description=resources["description"][i],
+                keywords=resources['tokens'][i],
+                polyline=resource_polylines[i],
+                x_coordinate=centroid_list[i][0],
+                y_coordinate=centroid_list[i][1],
+                course_id=course_id,
+                type=1,
+                module_id=resources["module_id"][i],
+                submodule_id=resources["submodule_id"][i],
+                module=resources["module"][i],
+                index=resources["index"][i],
+                # embedding=resourceembedding[i],
+                link=resources['links'][i],
+                beta=8
+            )
+            # print(new_resource.to_dict())
+            allresources.append(new_resource)
+            # db.session.add(new_resource)
+            # db.session.commit()
+        db.session.add_all(allresources)
+        db.session.commit()
+    print("added resources to the DB")
+    # breakpoint()
+
+
+# find the keywords for all the documents and store it in a list
+def create_keywords_list(content_list,num_keywords=10):
+    kw_model = KeyBERT(model='all-mpnet-base-v2')
+    all_keywords_list = []
+    all_weight_list = []
+    for i in range(len(content_list)):
+        keywords = kw_model.extract_keywords(content_list[i], keyphrase_ngram_range=(
+            1, 2), stop_words='english', highlight=False, top_n=num_keywords)
+        keywords_list = list(dict(keywords).keys())
+        cs_list = list(dict(keywords).values())
+        weight = sum(cs_list)/len(cs_list)
+        all_keywords_list.append(keywords_list)
+        all_weight_list.append(weight)
+    return all_keywords_list, all_weight_list
+
+
+# Load pre-trained BERT model and tokenizer
+def create_embeddings_list(l):
+    model_name = 'bert-base-uncased'
+    tokenizer = BertTokenizer.from_pretrained(model_name)
+    new_model = BertModel.from_pretrained(model_name)
+
+    keybert_embeddings_list = []
+    for i in l:
+
+        # Tokenize the keywords and convert them into token IDs
+        tokenized_inputs = tokenizer(
+            i, padding=True, truncation=True, return_tensors="pt")
+
+        # Obtain the embeddings from the BERT model
+        with torch.no_grad():
+            outputs = new_model(**tokenized_inputs)
+
+        # Extract the embeddings corresponding to the [CLS] token
+        embeddings = outputs.last_hidden_state[:, 0, :].numpy()
+        embeddings = embeddings.tolist()
+        keybert_embeddings_list.append(embeddings)
+    return keybert_embeddings_list
+
+
+def create_polyline(l, course_id):
+    all_polylines = []
+    embeddings = db.session.query(
+        Topic.embedding).filter_by(course_id=course_id).all()
+    topic_embeddings = embeddings
+    for keybert_embeddings in l:
+        docVector = keybert_embeddings
+        polyline = []
+        for j in range(len(topic_embeddings)):
+            wordVector = topic_embeddings[j]
+            # find cosine similarity between the learner embeddings and the topic embeddings
+            cos_sim = (get_cos_sim(wordVector, docVector) + 1) / 2
+            polyline.append(cos_sim)
+        all_polylines.append(polyline)
+    return all_polylines
+
+
+
+def pushQuizToResourceInDB(
+    name, description, keywords, polyline, 
+    x_coordinate, y_coordinate, course_id, 
+    module_id, submodule_id, module, index, 
+    link,beta, type=1):
+    
+    new_resource = Resource(
+        name=name,
+        description=description,
+        keywords=keywords,
+        polyline=polyline,
+        x_coordinate=x_coordinate,
+        y_coordinate=y_coordinate,
+        course_id=course_id,
+        type=type,
+        module_id=module_id,
+        submodule_id=submodule_id,
+        module=module,
+        index=index,
+        link=link,
+        beta=beta
+    )
+
+    with app.app_context():
+        db.session.add(new_resource)
+        db.session.commit()
+    
+    print("Quiz resource added to the DB")

backend/Inspiration/modelsRoutes.py

@@ -0,0 +1,1457 @@
+import gc
+import json
+import math
+import os
+import re
+from datetime import datetime
+import numpy as np
+import pandas as pd
+import pdfplumber
+import torch
+from flask import jsonify, request, send_from_directory
+from utils import is_valid_id
+from repository import add_ta_from_user
+from dbModels import TAT, Activity, Contribution, Course, Enroll, Learner, Module, Question, Quiz, Resource, Topic, UserQuiz, db, Description,ExitPoint
+from init import app
+from keybert import KeyBERT
+from sentence_transformers import SentenceTransformer
+from sqlalchemy import text
+from sqlalchemy.sql import func
+from transformers import BertModel, BertTokenizer
+from werkzeug.utils import secure_filename
+from youtube_transcript_api import YouTubeTranscriptApi
+
+
+UPLOAD_FOLDER_NAME = "uploads"
+UPLOAD_FOLDER = os.path.join(os.getcwd(), UPLOAD_FOLDER_NAME)  # Save files in a 'uploads' folder in the project directory
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)  # Create the folder if it doesn't exist
+
+app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
+
+def get_cos_sim(a: np.ndarray, b: np.ndarray) -> float:
+    """
+    Calculate the cosine similarity between two vectors.
+
+    Parameters:
+        a (np.ndarray): First vector.
+        b (np.ndarray): Second vector.
+
+    Returns:
+        float: Cosine similarity between the two vectors.
+    """
+    dot_product = np.dot(a, b)
+    norm_a = np.linalg.norm(a)
+    norm_b = np.linalg.norm(b)
+    return dot_product / (norm_a * norm_b)
+
+
+# Routes
+
+# Learners
+
+
+@app.route('/learners', methods=['GET'])
+def get_learners():
+    learners = Learner.query.all()
+    return jsonify([learner.to_dict() for learner in learners])
+
+
+@app.route('/learners', methods=['POST'])
+def create_learner():
+    data = request.get_json()
+    new_learner = Learner(
+        name=data['name'],
+        cgpa=data['cgpa'],
+        username=data['username'],
+        password=data['password']
+    )
+    db.session.add(new_learner)
+    db.session.commit()
+    return jsonify(new_learner.to_dict()), 201
+
+# Courses
+
+
+@app.route('/course/<int:id>', methods=['GET'])
+def get_courses(id):
+    course = Course.query.filter_by(id=id).first()
+    return (course.to_dict())
+
+
+@app.route('/courses', methods=['POST'])
+def create_course():
+    data = request.get_json()
+    new_course = Course(
+        name=data['name'],
+        description=data['description'],
+        initial_position=[0]*data['topic_count']
+    )
+    db.session.add(new_course)
+    db.session.commit()
+    return jsonify(new_course.to_dict()), 201
+
+# Resources
+
+@app.route("/resource-types", methods=['GET'])
+def get_resource_types():
+    return jsonify([
+        { "type" : "0", "name" : "PDF"},
+        { "type" : "1", "name" : "Youtube Video"},
+        # { "type" : "2", "name" : "Quiz"}, :)
+    ])
+
+@app.route('/resources/<int:id>', methods=['GET'])
+def get_resources(id):
+    resources = Resource.query.filter_by(course_id=id)
+    # print("resources are ")
+    # print([resource.to_dict() for resource in resources])
+    return jsonify([resource.to_dict() for resource in resources])
+
+@app.route('/specific_resource/<int:id>', methods=['GET'])
+def get_specifc_resource(id):
+    resource = Resource.query.filter_by(id=id).first()
+    return jsonify(resource.to_dict())
+
+@app.route('/resources', methods=['POST'])
+def create_resource():
+    data = request.get_json()
+    new_resource = Resource(
+        name=data['name'],
+        description=data['description'],
+        keywords=data['keywords'],
+        polyline=data['polyline'],
+        x_coordinate=data['x_coordinate'],
+        y_coordinate=data['y_coordinate'],
+        course_id=data['course_id'],
+        type=data['type']
+        # ,
+        # embedding=data['embedding']
+    )
+    db.session.add(new_resource)
+    db.session.commit()
+    return jsonify(new_resource.to_dict()), 201
+
+# Topics
+
+
+@app.route('/topics/<int:id>', methods=['GET'])
+def get_topics(id):
+    topics = Topic.query.filter_by(course_id=id)
+    return jsonify([topic.to_dict() for topic in topics])
+
+
+@app.route('/topics', methods=['POST'])
+def create_topic():
+    data = request.get_json()
+    new_topic = Topic(
+        name=data['name'],
+        description=data['description'],
+        keywords=data['keywords'],
+        polyline=data['polyline'],
+        x_coordinate=data['x_coordinate'],
+        y_coordinate=data['y_coordinate'],
+        course_id=data['course_id'],
+        embedding=data['embedding']
+    )
+    db.session.add(new_topic)
+    db.session.commit()
+    return jsonify(new_topic.to_dict()), 201
+
+# Enrolls
+
+
+@app.route('/enrolls/<int:id>', methods=['GET'])
+def get_enroll(id):
+    enroll = Enroll.query.get(id)
+    return jsonify(enroll.to_dict())
+
+@app.route('/teach/<int:id>',methods=['GET'])
+def get_teach(id):
+    teach = TAT.query.get(id)
+    return jsonify(teach.to_dict())
+
+
+# Activities
+
+
+@app.route('/activities/<int:id>', methods=['GET'])
+def get_activities(id):
+    activities = Activity.query.filter_by(enroll_id=id)
+    return jsonify([activity.to_dict() for activity in activities])
+
+
+@app.route('/activities', methods=['POST'])
+def create_activity():
+    data = request.get_json()
+    if data.get('resource_id') is not None:
+        new_activity = Activity(
+        time=datetime.strptime(data['time'], '%Y-%m-%d %H:%M:%S'),
+        # type_id=data['type_id'],
+        type=data['type'],
+        name=data['name'],
+        link=data['link'],
+        enroll_id=data['enroll_id'],
+        resource_id=data['resource_id'],
+        x_coordinate=data['x_coordinate'],
+        y_coordinate=data['y_coordinate'],
+    )
+    else:
+        new_activity = Activity(
+            time=datetime.strptime(data['time'], '%Y-%m-%d %H:%M:%S'),
+            # type_id=data['type_id'],
+            type=data['type'],
+            name=data['name'],
+            link=data['link'],
+            enroll_id=data['enroll_id'],
+            contribution_id=data['contribution_id'],
+            x_coordinate=data['x_coordinate'],
+            y_coordinate=data['y_coordinate'],
+        )
+    db.session.add(new_activity)
+    db.session.commit()
+    return jsonify(new_activity.to_dict()), 201
+
+# Contributions
+
+
+@app.route('/contributions/<int:id>', methods=['GET'])
+def get_contributions(id):
+    contributions = Contribution.query.filter_by(enroll_id=id)
+
+    return jsonify([contribution.to_dict() for contribution in contributions])
+
+@app.route('/contributions/view/<int:id>', methods=['GET'])
+def get_contribution_view(id):
+    contribution = Contribution.query.filter_by(id=id).first()
+
+    return jsonify(contribution.to_dict())
+
+
+@app.route('/contributions', methods=['POST'])
+def create_contribution():
+    data = request.get_json()
+    new_contribution = Contribution(
+        enroll_id=data['enroll_id'],
+        submitted_on=datetime.strptime(
+            data['submitted_on'], '%Y-%m-%d %H:%M:%S'),
+        file_path=data['file_path'],
+        description=data['description'],
+        prev_polyline=data['prev_polyline'],
+        polyline=data['polyline'],
+        x_coordinate=data['x_coordinate'],
+        y_coordinate=data['y_coordinate'],
+        embedding=data['embedding']
+    )
+    db.session.add(new_contribution)
+    db.session.commit()
+    return jsonify(new_contribution.to_dict()), 201
+
+# Quizzes
+
+
+@app.route('/quizzes', methods=['GET'])
+def get_quizzes():
+    quizzes = Quiz.query.all()
+    return jsonify([quiz.to_dict() for quiz in quizzes])
+
+
+# Questions
+
+
+@app.route('/questions', methods=['GET'])
+def get_questions():
+    quiz_id = request.args.get('quiz_id')
+    questions = Question.query.filter_by(quiz_id=quiz_id).all()
+    return jsonify([question.to_dict() for question in questions])
+
+
+@app.route('/questions', methods=['POST'])
+def create_question():
+    data = request.get_json()
+    new_question = Question(
+        quiz_id=data['quiz_id'],
+        question_text=data['question_text'],
+        option_a=data.get('option_a'),
+        option_b=data.get('option_b'),
+        option_c=data.get('option_c'),
+        option_d=data.get('option_d'),
+        correct_answer=data['correct_answer']
+    )
+    db.session.add(new_question)
+    db.session.commit()
+    return jsonify(new_question.to_dict()), 201
+
+# UserQuiz : log of quizzes attempted by various users
+
+
+@app.route('/user_quizzes', methods=['GET'])
+def get_user_quizzes():
+    user_id = request.args.get('user_id')
+    user_quizzes = UserQuiz.query.filter_by(user_id=user_id).all()
+    return jsonify([user_quiz.to_dict() for user_quiz in user_quizzes])
+
+
+@app.route('/user_quizzes', methods=['POST'])
+def create_user_quiz():
+    data = request.get_json()
+    new_user_quiz = UserQuiz(
+        user_id=data['user_id'],
+        quiz_id=data['quiz_id'],
+        score=data.get('score'),
+        status=data['status'],
+        attempt_date=datetime.strptime(
+            data['attempt_date'], '%Y-%m-%d %H:%M:%S') if 'attempt_date' in data else None
+    )
+    db.session.add(new_user_quiz)
+    db.session.commit()
+    return jsonify(new_user_quiz.to_dict()), 201
+
+# ------------------------------------------------------Teacher APIs
+
+@app.route('/course_module_mappings/<int:course_id>', methods=['GET'])
+def course_module_mappings(course_id):
+    try:
+        # Query for ModName_ModID mapping
+        mod_name_mod_id_query = (
+            db.session.query(Resource.module, Resource.module_id)
+            .filter(Resource.course_id == course_id)
+            .distinct()
+            .all()
+        )
+        ModName_ModID = {row.module: row.module_id for row in mod_name_mod_id_query}
+
+        # Query for ModID_SubModCount mapping
+        mod_id_submod_count_query = (
+            db.session.query(Resource.module_id, func.count(Resource.submodule_id))
+            .filter(Resource.course_id == course_id)
+            .group_by(Resource.module_id)
+            .all()
+        )
+        ModID_SubModCount = {row.module_id: row[1] for row in mod_id_submod_count_query}
+
+        # Return the mappings as JSON
+        return jsonify({
+            "ModName_ModID": ModName_ModID,
+            "ModID_SubModCount": ModID_SubModCount
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# Function to create topic embeddings
+def create_topic_embeddings(topics: pd.DataFrame) -> list:
+    model = SentenceTransformer('bert-base-nli-mean-tokens')
+    topic_embeddings = []
+
+    for i in range(len(topics)):
+        embedding = model.encode(topics.loc[i, "description"], convert_to_tensor=True)
+        topic_embeddings.append(embedding.cpu().numpy().tolist())  # Ensure list for JSON compatibility
+        del embedding
+        gc.collect()
+
+    return topic_embeddings
+
+# Function to create polylines from embeddings
+def create_topic_polylines(topics: pd.DataFrame, topic_embeddings: list) -> pd.DataFrame:
+    topic_names = topics["name"].tolist()
+    length = len(topics)
+    topic_modules = [1] * 12 + [2] * 8 + [3] * (length - 20)
+
+    top_poly = []
+    top_module = []
+    topic = []
+
+    for i in range(len(topic_names)):
+        polyline = [0] * len(topic_names)
+        for j in range(len(topic_names)):
+            cos_sim = 0
+            if topic_names[i] == topic_names[j]:
+                cos_sim = 1
+            else:
+                topic1_vector = topic_embeddings[i]
+                topic2_vector = topic_embeddings[j]
+                cos_sim = (get_cos_sim(topic1_vector, topic2_vector) + 1) / 2
+            polyline[j] = cos_sim
+
+        topic.append(topic_names[i])
+        top_module.append(topic_modules[i])
+        top_poly.append(polyline)
+
+    polyline_dict = {"topic": topic, "module": top_module, "polyline": top_poly}
+    topic_polylines = pd.DataFrame(polyline_dict)
+    return topic_polylines
+
+# Function to create a list of keywords from the topic descriptions
+def create_keywords_list(content_list, num_keywords=10):
+    kw_model = KeyBERT(model='all-mpnet-base-v2')
+    all_keywords_list = []
+    all_weight_list = []
+
+    for i in range(len(content_list)):
+        keywords = kw_model.extract_keywords(content_list[i], keyphrase_ngram_range=(1, 2), stop_words='english', highlight=False, top_n=num_keywords)
+        keywords_list = list(dict(keywords).keys())
+        cs_list = list(dict(keywords).values())
+
+
+
+        # Ensure safe handling of cs_list
+        if isinstance(cs_list, (list, np.ndarray)) and len(cs_list) > 0:
+            weight = np.mean(cs_list)  # Use NumPy's mean for safer handling
+        else:
+            weight = 0  # Default weight if cs_list is empty or invalid
+
+        all_keywords_list.append(keywords_list)
+        all_weight_list.append(weight)
+
+    return all_keywords_list, all_weight_list
+
+
+def rad_plot_axes(num: int, x_max: float, y_max: float):
+    """
+    Generate radial plot axes.
+
+    Parameters:
+        num (int): Number of axes.
+        x_max (float): Maximum x-coordinate.
+        y_max (float): Maximum y-coordinate.
+
+    Returns:
+        tuple: A tuple containing the lengths of the axes and the angle theta.
+    """
+    empt_arr = []  # Temporary container for y-coordinate calculations
+    xstop = []  # List to store x-coordinate of the axes endpoints
+    ystop = []  # List to store y-coordinate of the axes endpoints
+    tlen = []  # List to store the length of axes
+    ttempl = []  # Temporary container for reversed lengths
+    theta = ((np.pi) / (num - 1)) / 2  # Calculate theta
+    b = 0
+
+    while (b * theta) <= (np.arctan(y_max / x_max)):
+        y_val = x_max * math.tan(b * theta)
+        empt_arr.append(y_val)
+        ystop.append(y_val)
+        ttemp = math.sqrt((x_max ** 2) + (y_val ** 2))
+        tlen.append(ttemp)
+        if (b * theta) != np.arctan(y_max / x_max):
+            ttempl.append(ttemp)
+        b += 1
+
+    while b < num:
+        ystop.append(y_max)
+        b += 1
+
+    tlen.extend(list(reversed(ttempl)))
+    xstop = list(reversed(ystop))
+
+    # Plotting is commented out for modularity; can be enabled as needed
+    # for d in range(num):
+    #     x_values = [0, xstop[d]]
+    #     y_values = [0, ystop[d]]
+    #     plt.plot(x_values, y_values, label=f'Axis {d+1}', alpha=1, linewidth=0.2)
+
+    return tlen, theta
+
+
+def rad_plot_poly(num: int, hd_point: list, tlen: list, theta: float) -> list:
+    """
+    Plot the polyline and calculate their centroids.
+
+    Parameters:
+        num (int): Number of points.
+        hd_point (list): List of polyline points.
+        tlen (list): Length of the axes.
+        theta (float): Angle theta.
+
+    Returns:
+        list: List of centroid coordinates.
+    """
+    coordinates = []
+
+    for pnt in hd_point:
+        x_values = []
+        y_values = []
+        for p in range(num):
+            rlen = pnt[p] * tlen[p]
+            x_values.append(rlen * math.cos(p * theta))
+            y_values.append(rlen * math.sin(p * theta))
+
+        # Plotting is commented out for modularity; can be enabled as needed
+        # plt.plot(x_values, y_values, label='Polyline', alpha=0.6, linewidth=0.5)
+
+        average_x = sum(x_values) / num
+        average_y = sum(y_values) / num
+        coordinates.append([average_x, average_y])
+
+    # Print statement for debugging
+    print("Red    - Resources ")
+
+    return coordinates
+
+
+
+@app.route('/add-module', methods=['POST'])
+def add_modules():
+    try:
+        data = request.get_json()
+        course_id = data.get('course_id')
+        name = data.get('name')
+
+        if not course_id or not name:
+            return jsonify({"error": "course_id and name are required"}), 400
+
+        new_module = Module(
+            name=name,
+            course_id=course_id,
+        )
+        
+        db.session.add(new_module)
+        db.session.commit()
+        return jsonify(new_module.to_dict()), 201
+
+    except Exception as e:
+        app.logger.error(f"Error in add_modules: {str(e)}", exc_info=True)
+        return jsonify({"error": "Server error", "details": str(e)}), 500
+
+
+# Route for creating topics related to a newly created course
+@app.route('/new-course-topics', methods=['POST'])
+def create_new_topics_for_new_course():
+    try:
+        data = request.get_json()
+
+        # Validate input
+        course_id = data.get('course_id')
+        topics_data = data.get('topics')
+
+        if not course_id or not topics_data or not isinstance(topics_data, list):
+            return jsonify({"error": "Invalid or missing 'course_id' or 'topics'"}), 400
+
+        topics = pd.DataFrame(topics_data)
+
+        # Generate embeddings, polylines, and keywords
+        topic_embeddings = create_topic_embeddings(topics)
+        topic_polylines = create_topic_polylines(topics, topic_embeddings)
+        keywords, weights = create_keywords_list(topics["description"].tolist())
+
+        # Ensure polylines exist before calculating centroids
+        if not topic_polylines.empty and "polyline" in topic_polylines:
+            feature_length = len(topic_polylines["polyline"][0])
+            tlen, theta = rad_plot_axes(feature_length, 1, 1)
+            centroid_list = rad_plot_poly(feature_length, topic_polylines["polyline"], tlen, theta)
+        else:
+            return jsonify({"error": "Failed to generate topic polylines"}), 500
+
+        # Check if generated lists match topic count
+        if len(topic_embeddings) != len(topics) or len(topic_polylines) != len(topics) or len(centroid_list) != len(topics):
+            return jsonify({"error": "Mismatch in topic processing results"}), 500
+
+        # Insert topics into the database
+        for i in range(len(topics)):
+            new_topic = Topic(
+                name=topics.loc[i, 'name'],
+                description=topics.loc[i, 'description'],
+                module_id=topics.loc[i, 'module_id'],
+                keywords=keywords[i] if i < len(keywords) else None,
+                polyline=topic_polylines.loc[i, 'polyline'] if i < len(topic_polylines) else None,
+                course_id=course_id,
+                x_coordinate=centroid_list[i][0] if i < len(centroid_list) else None,
+                y_coordinate=centroid_list[i][1] if i < len(centroid_list) else None,
+                embedding=topic_embeddings[i] if i < len(topic_embeddings) else None
+            )
+            db.session.add(new_topic)
+
+        db.session.commit()
+
+        return jsonify({"message": "Topics created successfully"}), 201
+
+    except Exception as e:
+        app.logger.error(f"Error in create_new_topics_for_new_course: {str(e)}", exc_info=True)
+        return jsonify({"error": "Server error", "details": str(e)}), 500
+
+def extract_transcript(video_id):
+    try:
+        transcript = YouTubeTranscriptApi.get_transcript(video_id)
+        transcript_text = ""
+        for i in transcript:
+            transcript_text += i['text'] + " "
+        return transcript_text.strip()
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def get_youtube_video_id(url):
+    # Regular expression pattern to match video ID
+    pattern = r"(?:v=|\/)([0-9A-Za-z_-]{11}).*"
+    match = re.search(pattern, url)
+    if match:
+        return match.group(1)
+    else:
+        return "Invalid YouTube URL"
+
+
+def create_resource_embeddings(keywords):
+
+    if not keywords:
+        print("ERROR: Received empty keywords list!")
+        return []
+
+    model_name = 'bert-base-uncased'
+    try:
+        tokenizer = BertTokenizer.from_pretrained(model_name)
+        model = BertModel.from_pretrained(model_name)
+    except Exception as e:
+        print(f"ERROR: Failed to load BERT model -> {e}")
+        return []
+
+    model.eval()
+    keybert_embeddings_list = []
+
+    for keyword in keywords:
+        if not isinstance(keyword, str) or not keyword.strip():
+            print(f"WARNING: Skipping invalid keyword -> {keyword}")
+            continue
+
+        try:
+            tokenized_inputs = tokenizer(keyword, padding=True, truncation=True, return_tensors="pt")
+            with torch.no_grad():
+                outputs = model(**tokenized_inputs)
+
+            embeddings = outputs.last_hidden_state[:, 0, :].detach().cpu().numpy()
+
+            # Ensure embeddings are always lists of lists
+            if isinstance(embeddings, np.ndarray):
+                embeddings = embeddings.tolist()
+
+            if isinstance(embeddings, list) and isinstance(embeddings[0], list):
+                keybert_embeddings_list.append(embeddings[0])
+            else:
+                print(f"ERROR: Unexpected embedding format for '{keyword}', skipping.")
+                continue
+
+        except Exception as e:
+            print(f"ERROR: Failed to generate embedding for '{keyword}' -> {e}")
+            continue
+
+    return keybert_embeddings_list
+
+def get_topic_embedding(topic_id):
+    topic = Topic.query.filter_by(id=topic_id).first()
+
+    if topic and topic.embedding is not None:
+
+        if isinstance(topic.embedding, np.ndarray):
+            topic_embeddings = topic.embedding.tolist()  # Convert NumPy array to list
+        elif isinstance(topic.embedding, list):
+            topic_embeddings = topic.embedding  # Already a list
+        else:
+            print("ERROR: Unexpected topic embedding format!")
+            return None  # Handle unexpected data formats
+
+        # 🔹 Ensure `topic_embeddings` is a list of vectors
+        if isinstance(topic_embeddings, list):
+            if all(isinstance(vec, (list, np.ndarray)) for vec in topic_embeddings):
+                return topic_embeddings  # ✅ Correct format
+            elif isinstance(topic_embeddings[0], (float, int)):
+                # 🔹 If it's a single vector (not wrapped in a list), wrap it
+                print("WARNING: Detected single topic embedding, wrapping it in a list.")
+                return [topic_embeddings]
+
+
+        return None
+
+
+    return None  # If topic is not found or embedding is None
+
+
+
+def create_resource_polylines(topic_embeddings, keybert_embeddings_list, beta):
+    if not keybert_embeddings_list or not topic_embeddings:
+        print("ERROR: Empty embeddings provided")
+        return []
+
+    all_polylines = []
+
+    for i, docVector in enumerate(keybert_embeddings_list):
+        if not isinstance(docVector, list):
+            print(f"ERROR: Skipping invalid embedding at index {i} -> Expected list, got {type(docVector)}")
+            continue
+
+        polyline = []
+        for idx, wordVector in enumerate(topic_embeddings):
+            if not isinstance(wordVector, list):
+                print(f"ERROR: Invalid topic embedding at [{idx}] -> Expected list, got {type(wordVector)}")
+                continue
+
+            cos_sim = get_cos_sim(wordVector, docVector)
+            cos_sim = (cos_sim + 1) / 2 if cos_sim is not None else 0  # Normalize and handle None
+            polyline.append({'x': idx, 'y': cos_sim})
+
+        all_polylines.append(polyline)
+
+    if not all_polylines:
+        print("WARNING: No polylines were generated")
+        return []
+
+    # Averaging polylines across multiple keywords
+    new_polylines = []
+    for polyline in all_polylines:
+        averaged_polyline = [sum(p['y'] for p in polyline) / len(polyline) for _ in range(len(topic_embeddings))]
+        new_polylines.append(averaged_polyline)
+
+    beta = float(beta)
+    beta_polylines = [[max(0, min(val + beta * (val - np.mean(polyline)), 1)) for val in polyline] for polyline in new_polylines]
+
+
+    return beta_polylines
+
+
+@app.route('/new-resources-topics', methods=['POST'])
+def create_new_resources_for_new_course():
+    try:
+        data = request.get_json()
+
+        name = data.get('name')
+        course_id = data.get('course_id')
+        module_id = data.get('module_id')
+        res_type = data.get('type')
+        link = data.get('link')
+        module = data.get('module')
+
+        if not all([course_id, module_id, res_type, link]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        video_id = get_youtube_video_id(link)
+        if video_id == "Invalid YouTube URL":
+            return jsonify({"error": "Invalid YouTube URL"}), 400
+
+        transcript = extract_transcript(video_id)
+        if transcript.startswith("Error:"):
+            return jsonify({"error": f"Failed to fetch transcript: {transcript}"}), 400
+
+        try:
+            keywords, weights = create_keywords_list([transcript])
+            if keywords and isinstance(keywords[0], list):
+                keywords = [word for sublist in keywords for word in sublist]
+
+        except Exception as e:
+            return jsonify({"error": f"Failed to extract keywords: {str(e)}"}), 400
+
+        if not keywords:
+            return jsonify({"error": "No keywords extracted"}), 400
+
+        resource_embeddings = create_resource_embeddings(keywords)
+        if not resource_embeddings:
+            return jsonify({"error": "Failed to generate resource embeddings"}), 400
+
+        topic_embeddings = get_topic_embedding(module_id)
+
+        # Debugging
+        if topic_embeddings is None:
+            return jsonify({"error": "Topic embeddings not found"}), 400
+
+        if isinstance(topic_embeddings, np.ndarray) and topic_embeddings.ndim == 1:
+            topic_embeddings = [topic_embeddings]
+
+        # If only one topic embedding is available, duplicate it
+        if len(topic_embeddings) == 1:
+            print("WARNING: Only one topic embedding found, duplicating it.")
+            topic_embeddings.append(topic_embeddings[0])
+
+        if len(topic_embeddings) < 2:
+            return jsonify({"error": "Insufficient topic embeddings"}), 400
+
+        resource_polylines = create_resource_polylines(topic_embeddings, resource_embeddings, 8)
+        if not resource_polylines:
+            return jsonify({"error": "Generated polylines are empty"}), 400
+
+        # Ensure num_axes is valid
+        num_axes = len(topic_embeddings)
+        x_max, y_max = 1.0, 1.0
+
+        # Compute axes lengths and angle safely
+        tlen, theta = rad_plot_axes(num_axes, x_max, y_max)
+
+        # Compute x, y coordinates
+        centroids = rad_plot_poly(num_axes, resource_polylines, tlen, theta)
+
+        max_id = db.session.query(db.func.max(Resource.id)).scalar() or 0
+        new_resources = []
+
+        if centroids:
+            x_coordinate, y_coordinate = centroids[0]  # Use only the first centroid
+            new_resource = Resource(
+                id=max_id + 1,
+                name=name,
+                description=None,
+                keywords=keywords,
+                polyline=resource_polylines,
+                x_coordinate=x_coordinate,
+                y_coordinate=y_coordinate,
+                course_id=course_id,
+                module_id=module_id,
+                submodule_id=None,
+                type=res_type,
+                link=link,
+                index=max_id + 1,
+                module=module,
+                beta=8
+            )
+
+            db.session.add(new_resource)
+            db.session.commit()
+
+            return jsonify({"message": "Resource created successfully"}), 201
+        else:
+            return jsonify({"error": "No valid centroid found"}), 400
+
+    except Exception as e:
+        db.session.rollback()
+        app.logger.error(f"Error occurred: {e}")
+        return jsonify({"error": "Server error", "details": str(e)}), 500
+
+
+def allowed_file(filename):
+    ALLOWED_EXTENSIONS = {"pdf"}
+    return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@app.route('/uploads/<string:filename>')
+def send_file(filename: str):
+    filename = secure_filename(filename)
+    filepath = os.path.join(app.config["UPLOAD_FOLDER"], filename)
+    if allowed_file(filename):
+        if os.path.exists(filepath):
+            return send_from_directory(UPLOAD_FOLDER_NAME, filename)
+        else:
+            return jsonify({'error': 'file not found'}), 404
+    return jsonify({'error': 'invalid filename'}), 400
+
+@app.route("/upload-pdf-resource", methods=["POST"])
+def upload_pdf_resource():
+    try:
+        if "pdf_file" not in request.files:
+            return jsonify({"error": "No PDF file provided"}), 400
+
+        pdf_file = request.files["pdf_file"]
+        if pdf_file.filename == "":
+            return jsonify({"error": "No selected file"}), 400
+
+        if not allowed_file(pdf_file.filename):
+            return jsonify({"error": "Invalid file type"}), 400
+
+        # Secure filename and save file
+        filename = secure_filename(pdf_file.filename)
+        filepath = os.path.join(app.config["UPLOAD_FOLDER"], filename)
+        pdf_file.save(filepath)
+
+        # Extract metadata
+        name = request.form.get("name")
+        course_id = request.form.get("course_id")
+        module_id = request.form.get("module_id")
+        res_type = request.form.get("type")
+        module = request.form.get("module")
+
+        if not all([name, course_id, module_id, res_type]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Extract text from PDF
+        extracted_text = ""
+        with pdfplumber.open(filepath) as pdf:
+            for page in pdf.pages:
+                extracted_text += page.extract_text() or ""
+
+        if not extracted_text.strip():
+            return jsonify({"error": "Failed to extract text from PDF"}), 400
+
+        # Generate keywords
+        try:
+            keywords, _ = create_keywords_list([extracted_text])
+            if keywords and isinstance(keywords[0], list):
+                keywords = [word for sublist in keywords for word in sublist]
+        except Exception as e:
+            return jsonify({"error": f"Failed to extract keywords: {str(e)}"}), 400
+
+        if not keywords:
+            return jsonify({"error": "No keywords extracted"}), 400
+
+        # Generate embeddings
+        resource_embeddings = create_resource_embeddings(keywords)
+        if not resource_embeddings:
+            return jsonify({"error": "Failed to generate resource embeddings"}), 400
+
+        topic_embeddings = get_topic_embedding(module_id)
+        if topic_embeddings is None:
+            return jsonify({"error": "Topic embeddings not found"}), 400
+
+        if isinstance(topic_embeddings, np.ndarray) and topic_embeddings.ndim == 1:
+            topic_embeddings = [topic_embeddings]
+
+        if len(topic_embeddings) == 1:
+            topic_embeddings.append(topic_embeddings[0])
+
+        if len(topic_embeddings) < 2:
+            return jsonify({"error": "Insufficient topic embeddings"}), 400
+
+        # Generate resource polylines
+        resource_polylines = create_resource_polylines(topic_embeddings, resource_embeddings, 8)
+        if not resource_polylines:
+            return jsonify({"error": "Generated polylines are empty"}), 400
+
+        num_axes = len(topic_embeddings)
+        x_max, y_max = 1.0, 1.0
+        tlen, theta = rad_plot_axes(num_axes, x_max, y_max)
+        centroids = rad_plot_poly(num_axes, resource_polylines, tlen, theta)
+
+        max_id = db.session.query(db.func.max(Resource.id)).scalar() or 0
+        if centroids:
+            x_coordinate, y_coordinate = centroids[0]
+
+            new_resource = Resource(
+                id=max_id + 1,
+                name=name,
+                description=None,
+                keywords=keywords,
+                polyline=resource_polylines,
+                x_coordinate=x_coordinate,
+                y_coordinate=y_coordinate,
+                course_id=course_id,
+                module_id=module_id,
+                submodule_id=None,
+                type=res_type,
+                link='/' + UPLOAD_FOLDER_NAME + '/' + filename,
+                index=max_id + 1,
+                module=module,
+                beta=8
+            )
+
+            db.session.add(new_resource)
+            db.session.commit()
+
+            return jsonify({"message": "PDF Resource uploaded successfully"}), 201
+        else:
+            return jsonify({"error": "No valid centroid found"}), 400
+
+    except Exception as e:
+        db.session.rollback()
+        app.logger.error(f"Error occurred: {e}")
+        return jsonify({"error": "Server error", "details": str(e)}), 500
+
+
+def convert_to_lists(data):
+    if isinstance(data, np.ndarray):
+        return data.tolist()
+    elif isinstance(data, list):
+        return [convert_to_lists(item) for item in data]
+    elif isinstance(data, dict):
+        return {key: convert_to_lists(value) for key, value in data.items()}
+    else:
+        return data
+
+@app.route('/ta-gi-summary',methods=['POST'])
+def changed_by_summary():
+    try:
+        print("[REQUEST RECEIVED] Processing new TA description request...")
+
+        # Parse request data
+        data = request.get_json()
+        #user_id = data.get('user_id')
+        ta_id = data.get('ta_id')
+        course_id = data.get('course_id')
+        description = data.get('description')
+
+        # if not isinstance(ta_id, int):
+        #     print("adding new ta...")
+        #     ta_id = add_ta_from_user(user_id)["id"]
+
+        # Validate inputs
+        if not all([ta_id, course_id, description]):
+            print("p1")
+            print(ta_id)
+            print(description)
+            print(course_id)
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Generate keywords
+        all_keywords_list, _ = create_keywords_list([description])
+        if not all_keywords_list:
+            print("p2")
+            return jsonify({"error": "Keyword extraction failed"}), 400
+        if isinstance(all_keywords_list[0], list):
+            all_keywords_list = [word for sublist in all_keywords_list for word in sublist]
+
+        # Generate embeddings
+        learner_embeddings = create_resource_embeddings(all_keywords_list)
+        if not learner_embeddings:
+            print("p3")
+            return jsonify({"error": "Embedding generation failed"}), 400
+
+        # Fetch topic embeddings for the given course_id
+        raw_embeddings = db.session.query(Topic.embedding).filter_by(course_id=course_id).all()
+
+        # Convert embeddings safely
+        topic_embeddings = []
+        for embed in raw_embeddings:
+            try:
+                emb_value = json.loads(embed[0]) if isinstance(embed[0], str) else embed[0]
+                if isinstance(emb_value, list):
+                    topic_embeddings.append(emb_value)
+                else:
+                    print(f"ERROR: Invalid topic embedding -> Expected list, got {type(emb_value)}")
+            except json.JSONDecodeError:
+                print("ERROR: Failed to parse embedding JSON")
+
+        # Validate topic embeddings
+        if not topic_embeddings:
+            print("p4")
+            return jsonify({"error": "No valid topic embeddings found for this course"}), 400
+
+        # Generate polylines
+        learner_polylines = create_resource_polylines(topic_embeddings, learner_embeddings, 8)
+        if not learner_polylines:
+            print("p5")
+            return jsonify({"error": "Polyline generation failed"}), 400
+
+        # Convert to description polyline
+        description_polyline_list = [item for sublist in convert_to_lists(learner_polylines[0]) for item in (
+            sublist if isinstance(sublist, list) else [sublist])]
+
+        # Compute axes and centroid
+        feature_length = len(learner_polylines[0])
+        tlen, theta = rad_plot_axes(feature_length, 1, 1)
+        centroid_list = rad_plot_poly(feature_length, [description_polyline_list], tlen, theta)
+
+        # Extract centroid coordinates
+        x_coordinate, y_coordinate = centroid_list[0]
+
+        #  Insert description into description table
+        insert_description_query = text("""
+            INSERT INTO description (ta_id, description,course_id)
+            VALUES (:ta_id, :description, :course_id)
+        """)
+
+        db.session.execute(insert_description_query, {
+            "ta_id": ta_id,
+            "description": json.dumps(description),
+            "course_id": course_id
+        })
+
+        print(f"Saving to tat: x={x_coordinate}, y={y_coordinate}")
+
+        # 🔹 Save TA position in tat table
+        # update_query = text("""
+        #     INSERT INTO tat (ta_id, course_id, x_coordinate, y_coordinate, polyline)
+        #     VALUES (:ta_id, :course_id, :x_coordinate, :y_coordinate, :polyline)
+        # """)
+
+        # db.session.execute(update_query, {
+        #     "ta_id": ta_id,
+        #     "course_id": course_id,
+        #     "x_coordinate": float(x_coordinate),
+        #     "y_coordinate": float(y_coordinate),
+        #     "polyline": json.dumps(learner_polylines)
+        # })
+        
+        max_learner_id = db.session.query(db.func.max(Learner.id)).scalar()
+        new_learner_id = (max_learner_id ) if max_learner_id else 1  # Start from 1 if table is empty
+
+        # 🔹 Fetch all resource indexes for this course_id
+        resource_indexes = db.session.query(Resource.index).filter_by(course_id=course_id).all()
+        resource_index_list = [idx[0] for idx in resource_indexes if idx[0] is not None]  # Extract values from tuples
+
+        # 🔹 Insert into enroll table with learner_id as max+1 and ta_id as given
+        enroll_insert_query = text("""
+            INSERT INTO enroll (learner_id, course_id, x_coordinate, y_coordinate, polyline, ta_id, accessible_resources)
+            VALUES (:learner_id, :course_id, :x_coordinate, :y_coordinate, :polyline, :ta_id, :accessible_resources)
+        """)
+
+        db.session.execute(enroll_insert_query, {
+            "learner_id": new_learner_id,
+            "course_id": course_id,
+            "x_coordinate": float(x_coordinate),
+            "y_coordinate": float(y_coordinate),
+            "polyline": json.dumps(learner_polylines),
+            "ta_id": ta_id,
+            "accessible_resources": json.dumps(resource_index_list)  # Store indexes as JSON array
+        })
+
+        db.session.commit()
+        print("[SUCCESS] TA position stored successfully!")
+        return jsonify({"message": "TA position stored successfully"}), 201
+
+    except ValueError as ve:
+        print(f"[ERROR] Validation error: {str(ve)}")
+        return jsonify({"error": "Validation Error", "details": str(ve)}), 400
+
+    except Exception as e:
+        db.session.rollback()
+        print(f"[ERROR] Server error: {str(e)}")
+        return jsonify({"error": "Internal Server Error", "details": str(e)}), 500
+
+@app.route('/ta-ch-description', methods=['POST'])
+def changed_ta_position():
+    try:
+        print("[REQUEST RECEIVED] Processing new TA description request...")
+
+        # Parse request data
+        data = request.get_json()
+        user_id = data.get('user_id')
+        ta_id = data.get('ta_id')
+        course_id = data.get('course_id')
+        description = data.get('description')
+
+        if not is_valid_id(ta_id):
+            print("adding new ta...")
+            ta_id = add_ta_from_user(user_id)["id"]
+
+        # Validate inputs
+        if not all([ta_id, course_id, description]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Generate keywords
+        all_keywords_list, _ = create_keywords_list([description])
+        if not all_keywords_list:
+            return jsonify({"error": "Keyword extraction failed"}), 400
+        if isinstance(all_keywords_list[0], list):
+            all_keywords_list = [word for sublist in all_keywords_list for word in sublist]
+
+        # Generate embeddings
+        learner_embeddings = create_resource_embeddings(all_keywords_list)
+        if not learner_embeddings:
+            return jsonify({"error": "Embedding generation failed"}), 400
+
+        # Fetch topic embeddings for the given course_id
+        raw_embeddings = db.session.query(Topic.embedding).filter_by(course_id=course_id).all()
+
+        # Convert embeddings safely
+        topic_embeddings = []
+        for embed in raw_embeddings:
+            try:
+                emb_value = json.loads(embed[0]) if isinstance(embed[0], str) else embed[0]
+                if isinstance(emb_value, list):
+                    topic_embeddings.append(emb_value)
+                else:
+                    print(f"ERROR: Invalid topic embedding -> Expected list, got {type(emb_value)}")
+            except json.JSONDecodeError:
+                print("ERROR: Failed to parse embedding JSON")
+
+        if not topic_embeddings:
+            return jsonify({"error": "No valid topic embeddings found for this course"}), 400
+
+        # Generate polylines
+        learner_polylines = create_resource_polylines(topic_embeddings, learner_embeddings, 8)
+        if not learner_polylines:
+            return jsonify({"error": "Polyline generation failed"}), 400
+
+        description_polyline_list = [item for sublist in convert_to_lists(learner_polylines[0]) for item in (
+            sublist if isinstance(sublist, list) else [sublist])]
+
+        feature_length = len(learner_polylines[0])
+        tlen, theta = rad_plot_axes(feature_length, 1, 1)
+        centroid_list = rad_plot_poly(feature_length, [description_polyline_list], tlen, theta)
+
+        x_coordinate, y_coordinate = centroid_list[0]
+
+        # 🔹 Insert into description table
+        insert_description_query = text("""
+            INSERT INTO description (ta_id, description)
+            VALUES (:ta_id, :description)
+        """)
+        db.session.execute(insert_description_query, {
+            "ta_id": ta_id,
+            "description": json.dumps(description)
+        })
+
+        print(f"Saving to tat: x={x_coordinate}, y={y_coordinate}")
+
+        # 🔹 Insert into tat table
+        update_query = text("""
+            INSERT INTO tat (ta_id, course_id, x_coordinate, y_coordinate, polyline)
+            VALUES (:ta_id, :course_id, :x_coordinate, :y_coordinate, :polyline)
+        """)
+        db.session.execute(update_query, {
+            "ta_id": ta_id,
+            "course_id": course_id,
+            "x_coordinate": float(x_coordinate),
+            "y_coordinate": float(y_coordinate),
+            "polyline": json.dumps(learner_polylines)
+        })
+
+        # 🔹 Fetch user info to add to learner table
+        user_data_query = text("""
+            SELECT registered_date, name, username, password FROM user WHERE id = :user_id
+        """)
+        user_data_result = db.session.execute(user_data_query, {"user_id": user_id}).fetchone()
+        if not user_data_result:
+            return jsonify({"error": "User not found"}), 404
+
+        registered_date, name, username, password = user_data_result
+
+        # 🔹 Insert into learner table
+        insert_learner_query = text("""
+            INSERT INTO learner (registered_date, name, cgpa, username, password, ta_id)
+            VALUES (:registered_date, :name, 4, :username, :password, :ta_id)
+        """)
+        db.session.execute(insert_learner_query, {
+            "registered_date": registered_date,
+            "name": name,
+            "cgpa": 4,
+            "username": username,
+            "password": password,
+            "ta_id": ta_id
+        })
+
+        # 🔹 Get newly inserted learner_id
+        new_learner_id = db.session.query(db.func.max(Learner.id)).scalar()
+
+        # 🔹 Fetch accessible resources for course
+        resource_indexes = db.session.query(Resource.index).filter_by(course_id=course_id).all()
+        resource_index_list = [idx[0] for idx in resource_indexes if idx[0] is not None]
+
+        # 🔹 Insert into enroll table
+        enroll_insert_query = text("""
+            INSERT INTO enroll (learner_id, course_id, x_coordinate, y_coordinate, polyline, ta_id, accessible_resources)
+            VALUES (:learner_id, :course_id, :x_coordinate, :y_coordinate, :polyline, :ta_id, :accessible_resources)
+        """)
+        db.session.execute(enroll_insert_query, {
+            "learner_id": new_learner_id,
+            "course_id": course_id,
+            "x_coordinate": float(x_coordinate),
+            "y_coordinate": float(y_coordinate),
+            "polyline": json.dumps(learner_polylines),
+            "ta_id": ta_id,
+            "accessible_resources": json.dumps(resource_index_list)
+        })
+
+        db.session.commit()
+        print("[SUCCESS] TA and Learner information stored successfully!")
+        return jsonify({"message": "TA and Learner data stored successfully"}), 201
+
+    except ValueError as ve:
+        print(f"[ERROR] Validation error: {str(ve)}")
+        return jsonify({"error": "Validation Error", "details": str(ve)}), 400
+
+    except Exception as e:
+        db.session.rollback()
+        print(f"[ERROR] Server error: {str(e)}")
+        return jsonify({"error": "Internal Server Error", "details": str(e)}), 500
+
+
+@app.route('/teacher-exit-points', methods=['POST'])
+def teacher_exit_points():
+    try:
+        print("[REQUEST RECEIVED] Processing teacher exit point...")
+
+        # Parse request data
+        data = request.get_json()
+        course_id = data.get('course_id')
+        description = data.get('description')
+
+        if not all([course_id, description]):
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # 🔹 Step 1: Generate keywords
+        all_keywords_list, _ = create_keywords_list([description])
+        if not all_keywords_list:
+            return jsonify({"error": "Keyword extraction failed"}), 400
+        if isinstance(all_keywords_list[0], list):
+            all_keywords_list = [word for sublist in all_keywords_list for word in sublist]
+
+        # 🔹 Step 2: Generate learner embeddings
+        learner_embeddings = create_resource_embeddings(all_keywords_list)
+        if not learner_embeddings:
+            return jsonify({"error": "Embedding generation failed"}), 400
+
+        # 🔹 Step 3: Fetch topic embeddings for the given course_id
+        raw_embeddings = db.session.query(Topic.embedding).filter_by(course_id=course_id).all()
+
+        topic_embeddings = []
+        for embed in raw_embeddings:
+            try:
+                emb_value = json.loads(embed[0]) if isinstance(embed[0], str) else embed[0]
+                if isinstance(emb_value, list):
+                    topic_embeddings.append(emb_value)
+                else:
+                    print(f"ERROR: Invalid topic embedding -> Expected list, got {type(emb_value)}")
+            except json.JSONDecodeError:
+                print("ERROR: Failed to parse embedding JSON")
+
+        if not topic_embeddings:
+            return jsonify({"error": "No valid topic embeddings found for this course"}), 400
+
+        # 🔹 Step 4: Generate polylines
+        learner_polylines = create_resource_polylines(topic_embeddings, learner_embeddings, 8)
+        if not learner_polylines:
+            return jsonify({"error": "Polyline generation failed"}), 400
+
+        description_polyline_list = [item for sublist in convert_to_lists(learner_polylines[0]) for item in (
+            sublist if isinstance(sublist, list) else [sublist])]
+
+        # 🔹 Step 5: Get (x, y) coordinates
+        feature_length = len(learner_polylines[0])
+        tlen, theta = rad_plot_axes(feature_length, 1, 1)
+        centroid_list = rad_plot_poly(feature_length, [description_polyline_list], tlen, theta)
+        x_coordinate, y_coordinate = centroid_list[0]
+
+        print(f"[EXIT POINT] x: {x_coordinate}, y: {y_coordinate}")
+
+        # 🔹 Step 6: Insert into exit_point table
+        insert_exit_point_query = text("""
+            INSERT INTO exit_point (id, course_id, description, polyline, x, y)
+            VALUES (:id, :course_id, :description, :polyline, :x, :y)
+        """)
+
+        # You may want to dynamically generate `id`, e.g., as max(id)+1
+        new_id_query = text("SELECT COALESCE(MAX(id), 0) + 1 FROM exit_point")
+        new_id = db.session.execute(new_id_query).scalar()
+
+
+        db.session.execute(insert_exit_point_query, {
+            "id": new_id,
+            "course_id": course_id,
+            "description": json.dumps(description),
+            "polyline": json.dumps(learner_polylines),
+            "x": float(x_coordinate),
+            "y": float(y_coordinate)
+        })
+
+        db.session.commit()
+        print("[SUCCESS] Exit point saved successfully.")
+        return jsonify({"message": "Exit point stored successfully."}), 201
+
+    except Exception as e:
+        db.session.rollback()
+        print(f"[ERROR] Server error: {str(e)}")
+        return jsonify({"error": "Internal Server Error", "details": str(e)}), 500
+
+
+@app.route('/summaries/<int:ta_id>/<int:course_id>', methods=['GET'])
+def get_summaries(ta_id, course_id):
+    try:
+        # Fetch summaries for the given TA and course
+        summaries = db.session.query(Description).filter_by(ta_id=ta_id, course_id=course_id).all()
+        if not summaries:
+            return jsonify({"message": "No summaries found"}), 404
+
+        # Convert to list of dictionaries
+        summaries_list = [{"description": summary.description} for summary in summaries]
+        return jsonify(summaries_list), 200
+
+    except Exception as e:
+        app.logger.error(f"Error fetching summaries: {str(e)}", exc_info=True)
+        return jsonify({"error": "Server error", "details": str(e)}), 500
+
+@app.route('/contributions/insert-summary-coordinates/<int:enroll_id>/<int:course_id>', methods=['POST'])
+def insert_summary_coordinates_per_contribution(enroll_id, course_id):
+    try:
+        print(f"[REQUEST RECEIVED] Inserting summary coordinates for enroll_id: {enroll_id}, course_id: {course_id}")
+
+        # Fetch summary contributions for enroll_id
+        contributions = Contribution.query.filter(
+            Contribution.enroll_id == enroll_id,
+            Contribution.description['summary'].as_boolean() == True
+        ).order_by(Contribution.submitted_on.asc()).all()
+
+        if not contributions:
+            return jsonify({"error": "No summary contributions found for the given enroll_id"}), 404
+
+        # Fetch topic embeddings for course
+        raw_embeddings = db.session.query(Topic.embedding).filter_by(course_id=course_id).all()
+        topic_embeddings = []
+        for embed in raw_embeddings:
+            try:
+                emb_value = json.loads(embed[0]) if isinstance(embed[0], str) else embed[0]
+                if isinstance(emb_value, list):
+                    topic_embeddings.append(emb_value)
+            except json.JSONDecodeError:
+                print("ERROR: Failed to parse embedding JSON")
+
+        if not topic_embeddings:
+            return jsonify({"error": "No valid topic embeddings found for this course"}), 400
+
+        inserted_count = 0
+
+        for contrib in contributions:
+            content = contrib.contribution_content
+            if not content or content.strip() == "":
+                continue
+
+            # Extract keywords
+            all_keywords_list, _ = create_keywords_list([content])
+            if not all_keywords_list:
+                print(f"Keyword extraction failed for contribution id: {contrib.id}")
+                continue
+
+            if isinstance(all_keywords_list[0], list):
+                all_keywords_list = [word for sublist in all_keywords_list for word in sublist]
+
+            # Generate embeddings
+            learner_embeddings = create_resource_embeddings(all_keywords_list)
+            if not learner_embeddings:
+                print(f"Embedding generation failed for contribution id: {contrib.id}")
+                continue
+
+            # Generate polyline
+            learner_polylines = create_resource_polylines(topic_embeddings, learner_embeddings, 8)
+            if not learner_polylines:
+                print(f"Polyline generation failed for contribution id: {contrib.id}")
+                continue
+
+            # Prepare polyline list for centroid calculation
+            description_polyline_list = [
+                item for sublist in convert_to_lists(learner_polylines[0]) 
+                for item in (sublist if isinstance(sublist, list) else [sublist])
+            ]
+
+            # Compute (x,y)
+            feature_length = len(learner_polylines[0])
+            tlen, theta = rad_plot_axes(feature_length, 1, 1)
+            centroid_list = rad_plot_poly(feature_length, [description_polyline_list], tlen, theta)
+            x_coordinate, y_coordinate = centroid_list[0]
+
+            # Get new id for summary_coordinates
+            new_id_query = text("SELECT COALESCE(MAX(id), 0) + 1 FROM summary_coordinates")
+            new_id = db.session.execute(new_id_query).scalar()
+
+            # Insert into summary_coordinates table
+            insert_query = text("""
+                INSERT INTO summary_coordinates (id, enroll_id, course_id, summary, polyline, x_coordinate, y_coordinate)
+                VALUES (:id, :enroll_id, :course_id, :summary, :polyline, :x, :y)
+            """)
+
+            db.session.execute(insert_query, {
+                "id": new_id,
+                "enroll_id": enroll_id,
+                "course_id": course_id,
+                "summary": json.dumps(content),
+                "polyline": json.dumps(learner_polylines),
+                "x": float(x_coordinate),
+                "y": float(y_coordinate)
+            })
+
+            inserted_count += 1
+
+        db.session.commit()
+        print(f"[SUCCESS] Inserted {inserted_count} summary coordinate entries.")
+        return jsonify({"message": f"Inserted {inserted_count} summary coordinate entries."}), 201
+
+    except Exception as e:
+        db.session.rollback()
+        print(f"[ERROR] Server error: {str(e)}")
+        return jsonify({"error": "Internal Server Error", "details": str(e)}), 500
+
+@app.route('/exit-points/<int:course_id>', methods=['GET'])
+def get_exit_coordinates(course_id):
+    exit_points = ExitPoint.query.filter_by(course_id=course_id).all()
+
+    if not exit_points:
+        return jsonify([]), 200  # Return empty list if no data found
+
+    coordinates = [
+        [float(point.x), float(point.y)]
+        for point in exit_points
+        if point.x is not None and point.y is not None
+    ]
+
+    return jsonify(coordinates), 200
+
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", debug=True)

backend/__init__.py

@@ -0,0 +1,32 @@
+"""
+Flask Application Initialization
+Sets up the Flask app with necessary configurations
+"""
+
+from flask import Flask, send_from_directory
+from flask_cors import CORS
+import os
+
+# Initialize Flask app
+# Serves static files from the build directory (../dist)
+app = Flask(__name__, static_folder='../dist', static_url_path='')
+
+# Enable CORS
+CORS(app)
+
+# Serve React App (Catch-all route)
+@app.route('/', defaults={'path': ''})
+@app.route('/<path:path>')
+def serve(path):
+    # Don't interfere with API routes
+    if path.startswith('api'):
+        return {"error": "Not found"}, 404
+        
+    if path != "" and os.path.exists(os.path.join(app.static_folder, path)):
+        return send_from_directory(app.static_folder, path)
+    
+    # Return index.html for SPA routing
+    return send_from_directory(app.static_folder, 'index.html')
+
+# Flag to indicate if database was just created
+DBcreated = False

backend/app.py

@@ -0,0 +1,18 @@
+# NLP Learning Grid Backend
+# Provides API for grid-based NLP learning system
+from init import app
+
+# Import NLP API routes
+try:
+    import nlp_api
+except Exception as e:
+    print(f"Warning: Could not import nlp_api: {e}")
+
+@app.route('/')
+def index():
+    return "NLP Learning Grid Backend is Running!"
+
+if __name__ == '__main__':
+    # Run on port 5000 by default
+    app.run(debug=True, port=5000, host='0.0.0.0')
+

backend/cert.pem

@@ -0,0 +1,35 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

backend/data/db.json

@@ -0,0 +1,512 @@
+{
+    "users": [],
+    "learning_sessions": {
+        "default": {
+            "position": {
+                "x": 3,
+                "y": 13
+            },
+            "level": 2,
+            "totalReward": 200,
+            "visitedResources": [
+                "4",
+                "3",
+                "2",
+                "1"
+            ],
+            "notifications": [
+                {
+                    "id": "notif_1775177177",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775177177230,
+                    "read": false
+                },
+                {
+                    "id": "notif_1775174735",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775174735824,
+                    "read": true
+                },
+                {
+                    "id": "notif_1775174142",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775174142894,
+                    "read": true
+                },
+                {
+                    "id": "notif_1775173994",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775173994762,
+                    "read": true
+                },
+                {
+                    "id": "notif_1775173639",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775173639779,
+                    "read": true
+                },
+                {
+                    "id": "notif_1775172872",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775172872637,
+                    "read": true
+                },
+                {
+                    "id": "notif_1775172411",
+                    "type": "success",
+                    "message": "Level up! You are now Stage 2",
+                    "timestamp": 1775172411178,
+                    "read": true
+                }
+            ]
+        }
+    },
+    "polylines": {
+        "polyline_20260403_032235": {
+            "id": "polyline_20260403_032235",
+            "name": "hye3dg",
+            "path": [
+                {
+                    "x": 2,
+                    "y": 17
+                },
+                {
+                    "x": 0,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(121, 114, 255, 0.4)",
+            "isActive": true,
+            "summary": "hcioasuhioc",
+            "keywords_found": [],
+            "module_scores": [
+                0.036593932658433914,
+                0.051530614495277405,
+                0.1929866373538971,
+                0.1,
+                0.045435961335897446,
+                0.05906526371836662,
+                0.00729989493265748,
+                0.08250045776367188,
+                0.027184199541807175,
+                0.061868976801633835,
+                0.05629986152052879,
+                0.06286735832691193,
+                0.019927512854337692,
+                0.06329352408647537,
+                0.07700204849243164,
+                0.06306321918964386,
+                0.03309740498661995,
+                0.0
+            ],
+            "strengths": [
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Level 1 achieved with 100 points.",
+            "assimilation_position": {
+                "x": 2,
+                "y": 17
+            },
+            "next_recommendation": {
+                "id": "8",
+                "title": "Incontext Learning",
+                "position": {
+                    "x": 3,
+                    "y": 13
+                },
+                "module": "Incontext Learning",
+                "reason": "dqn"
+            }
+        },
+        "polyline_20260403_032347": {
+            "id": "polyline_20260403_032347",
+            "name": "xas",
+            "path": [
+                {
+                    "x": 2,
+                    "y": 17
+                },
+                {
+                    "x": 0,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(153, 107, 255, 0.4)",
+            "isActive": true,
+            "summary": "xss",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.0,
+                0.15388113260269165,
+                0.1306712031364441,
+                0.0,
+                0.0,
+                0.015578164719045162,
+                0.006550716236233711,
+                0.03091040439903736,
+                0.0,
+                0.017347849905490875,
+                0.06170199066400528,
+                0.009152302518486977,
+                0.024282503873109818,
+                0.022633565589785576,
+                0.05440949276089668,
+                0.047033052891492844,
+                0.0
+            ],
+            "strengths": [
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Level 1 achieved with 100 points.",
+            "assimilation_position": {
+                "x": 3,
+                "y": 13
+            },
+            "next_recommendation": {
+                "id": "8",
+                "title": "Incontext Learning",
+                "position": {
+                    "x": 3,
+                    "y": 13
+                },
+                "module": "Incontext Learning",
+                "reason": "dqn"
+            }
+        },
+        "polyline_20260403_033404": {
+            "id": "polyline_20260403_033404",
+            "name": "heyyy",
+            "path": [
+                {
+                    "x": 3,
+                    "y": 18
+                },
+                {
+                    "x": 3,
+                    "y": 17
+                },
+                {
+                    "x": 2,
+                    "y": 17
+                },
+                {
+                    "x": 0,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(180, 160, 255, 0.4)",
+            "isActive": true,
+            "summary": "heyyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.10115420073270798,
+                0.1,
+                0.18399392068386078,
+                0.19090811908245087,
+                0.040012165904045105,
+                0.03171403333544731,
+                0.004172520712018013,
+                0.0,
+                0.0,
+                0.0,
+                0.013521099463105202,
+                0.0,
+                0.06345637887716293,
+                0.02790343202650547,
+                0.057048387825489044,
+                0.09004955738782883,
+                0.0,
+                0.0
+            ],
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Level 2 achieved with 200 points.",
+            "assimilation_position": {
+                "x": 3,
+                "y": 15
+            },
+            "next_recommendation": {
+                "id": "8",
+                "title": "Incontext Learning",
+                "position": {
+                    "x": 3,
+                    "y": 13
+                },
+                "module": "Incontext Learning",
+                "reason": "dqn"
+            }
+        },
+        "polyline_20260403_042600": {
+            "id": "polyline_20260403_042600",
+            "name": "heyyy",
+            "path": [
+                {
+                    "x": 3,
+                    "y": 18
+                },
+                {
+                    "x": 3,
+                    "y": 17
+                },
+                {
+                    "x": 2,
+                    "y": 17
+                },
+                {
+                    "x": 0,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(154, 164, 255, 0.4)",
+            "isActive": true,
+            "summary": "heyyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.10115420073270798,
+                0.1,
+                0.18399392068386078,
+                0.19090811908245087,
+                0.040012165904045105,
+                0.03171403333544731,
+                0.004172520712018013,
+                0.0,
+                0.0,
+                0.0,
+                0.013521099463105202,
+                0.0,
+                0.06345637887716293,
+                0.02790343202650547,
+                0.057048387825489044,
+                0.09004955738782883,
+                0.0,
+                0.0
+            ],
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Stage 2 achieved with 200 points.",
+            "assimilation_position": {
+                "x": 3,
+                "y": 13
+            },
+            "next_recommendation": {
+                "id": "8",
+                "title": "Incontext Learning",
+                "position": {
+                    "x": 3,
+                    "y": 13
+                },
+                "module": "Incontext Learning",
+                "reason": "dqn"
+            }
+        },
+        "polyline_20260403_051831": {
+            "id": "polyline_20260403_051831",
+            "name": "HBOIDCUHGDOHQWE",
+            "path": [
+                {
+                    "x": 3,
+                    "y": 18
+                },
+                {
+                    "x": 3,
+                    "y": 17
+                },
+                {
+                    "x": 2,
+                    "y": 17
+                },
+                {
+                    "x": 0,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(173, 194, 255, 0.4)",
+            "isActive": true,
+            "summary": "BGOAIUXDASHGXCIOAHXIO",
+            "keywords_found": [],
+            "module_scores": [
+                0.12643486261367798,
+                0.1,
+                0.12446118891239166,
+                0.1,
+                0.0,
+                0.010079984553158283,
+                0.0,
+                0.06248624622821808,
+                0.0,
+                0.02448994107544422,
+                0.0,
+                0.0,
+                0.0,
+                0.038079071789979935,
+                0.05198737978935242,
+                0.06710068136453629,
+                0.05336645245552063,
+                0.0
+            ],
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Stage 2 achieved with 200 points.",
+            "assimilation_position": {
+                "x": 3,
+                "y": 13
+            },
+            "next_recommendation": {
+                "id": "8",
+                "title": "Incontext Learning",
+                "position": {
+                    "x": 3,
+                    "y": 13
+                },
+                "module": "Incontext Learning",
+                "reason": "dqn"
+            }
+        }
+    },
+    "notes": {},
+    "bookmarks": {},
+    "summaries": [
+        {
+            "id": "summary_default_20260403_032235",
+            "title": "hye3dg",
+            "summary": "hcioasuhioc",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "recommendations": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Instruction tuning"
+            ],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Level 1 achieved with 100 points.",
+            "avgDifficulty": 2.0,
+            "totalReward": 100,
+            "xp_earned": 0
+        },
+        {
+            "id": "summary_default_20260403_032347",
+            "title": "xas",
+            "summary": "xss",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "recommendations": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Instruction tuning"
+            ],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Level 1 achieved with 100 points.",
+            "avgDifficulty": 2.0,
+            "totalReward": 100,
+            "xp_earned": 0
+        },
+        {
+            "id": "summary_default_20260403_033404",
+            "title": "heyyy",
+            "summary": "heyyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 4,
+            "currentLevel": 1,
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "recommendations": [
+                "Instruction tuning",
+                "Prompt based learning",
+                "Parameter efficient fine tuning"
+            ],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Level 2 achieved with 200 points.",
+            "avgDifficulty": 2.0,
+            "totalReward": 200,
+            "xp_earned": 0
+        },
+        {
+            "id": "summary_default_20260403_042600",
+            "title": "heyyy",
+            "summary": "heyyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 4,
+            "currentLevel": 2,
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "recommendations": [
+                "Instruction tuning",
+                "Prompt based learning",
+                "Parameter efficient fine tuning"
+            ],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Stage 2 achieved with 200 points.",
+            "avgDifficulty": 2.0,
+            "totalReward": 200,
+            "xp_earned": 0
+        },
+        {
+            "id": "summary_default_20260403_051831",
+            "title": "HBOIDCUHGDOHQWE",
+            "summary": "BGOAIUXDASHGXCIOAHXIO",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 4,
+            "currentLevel": 2,
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models",
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "recommendations": [
+                "Instruction tuning",
+                "Prompt based learning",
+                "Parameter efficient fine tuning"
+            ],
+            "ai_analysis": "Learning profile enriched by modules like Basics. Stage 2 achieved with 200 points.",
+            "avgDifficulty": 2.0,
+            "totalReward": 200,
+            "xp_earned": 0
+        }
+    ]
+}

backend/data/youtube_links.json

@@ -0,0 +1,20 @@
+{
+  "Pre training objectives": "https://www.youtube.com/watch?v=WZOqXkld9mk&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=19",
+  "Pre trained models": "https://www.youtube.com/watch?v=NB_4dkfJf_w&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=20",
+  "Tutorial: Introduction to huggingface": "https://www.youtube.com/watch?v=dHqggovEOwk&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=21",
+  "Fine tuning LLM": "https://www.youtube.com/watch?v=eC6Hd1hFvos",
+  "Instruction tuning": "https://www.youtube.com/watch?v=TPDiqPnJDTs&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=22",
+  "Prompt based learning": "https://www.youtube.com/watch?v=sXPggianwos&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=23",
+  "Parameter efficient fine tuning": "https://www.youtube.com/watch?v=S0l-qUniC54&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=30",
+  "Incontext Learning": "https://www.youtube.com/watch?v=eyNLkiQ89KI&t=378s",
+  "Prompting methods": "https://www.youtube.com/watch?v=6BXqKzOwObo&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=24",
+  "Retrieval Methods": "https://www.youtube.com/watch?v=oJvFO2QwuvI",
+  "Retrieval Augmented Generation": "https://www.youtube.com/watch?v=mE7IDf2SmJg",
+  "Quantization": "https://www.youtube.com/watch?v=Kx5x3HYBDls&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=31",
+  "Mixture of Experts Model": "https://www.youtube.com/watch?v=U8J32Z3qV8s",
+  "Agentic AI": "https://www.youtube.com/watch?v=kJLiOGle3Lw",
+  "Multimodal LLMs": "https://www.youtube.com/watch?v=cYfKQ6YG9Qo",
+  "Vision Language Models": "https://www.youtube.com/watch?v=rUQUv4u7jFs",
+  "Policy learning using DQN": "https://www.youtube.com/watch?v=0BsWItDlpxA&list=PLp6ek2hDcoNDDRINFiWGDlPKUwW-g1Hjk&index=26",
+  "RLHF": "https://www.youtube.com/watch?v=2MBJOuVq380"
+}

backend/data/youtube_transcripts.json

@@ -0,0 +1,20 @@
+{
+  "Pre training objectives": "Hello everyone, welcome to this course! So, in this lecture, we are going to talk about pre-training strategies. Last lecture, we covered transformers and different blocks of a transformer model, right? We also talked about what to wear for glove models that are pre-trained. what embedding methods, right. We will see the overall arena of pre-training with transformers. And then we will also see how the paradigm of pre-training actually changed. From pre-trained word embeddings to pre-trained language models.\n\nLet us look at the pretraining strategy. So, while discussing this, let us start with this famous quote. which we already mentioned earlier in the distributional semantics chapter. In the word embedding chapter, it says that \"you shall know a word by the company it keeps,\" right? So, the same person modified the quote later on, and then he said. That the complete meaning of a word is always contextual. Okay, this is always contextual, and no study of meaning can occur apart from a complete context.\n\nCan be taken seriously, okay? And this is essentially the foundation behind building the pre-training strategies, okay. This is an example; I record the record right. If you look at these two, the two positions of the word \"record\" are right. The meanings are completely different. Now if you use a word-to-way kind of method or a glove-type method which basically produces pre-trained embeddings, right? You will get the same embedding for these two positions of the record, right? But the meanings are different.\n\nOkay. Let's take another example. A bat flew out of the cave. He hit the ball with the bat. Again, here are the two words bat, the two positions of the word bat. The two contexts of the word \"bat\" are different, right? If you use the same embedding to represent this, You will not be able to do the proper processing of it, right? So what will we do here? We will produce embeddings that are going to be contextualized. Meaning, depending on the context, the embedding will change. For example, here let us say that for the word \"bat,\" you will get one embedding.\n\nFor the word \"bat\" here, you get another embedding that is different, okay? How do you do this? The first approach that was proposed is not a transformer-based approach. What was proposed in 2018 is called ELMO. Deeply contextualized word representation. This was done mostly by the LNAI team and some folks from this university as well. One of them is a very good friend of mine. So, the idea behind the ELMO method is as follows. So ELMO is a non-transformer-based approach. There is no concept of a transformer.\n\nTransformers were introduced in 2017, around the same time it was introduced, in 2018. So ELMO stands for embeddings from language models. What does it do? It essentially relies on RNNs, which can be LSTM or GRU. And what it does is that it essentially processes a sequence, right? When you process a sequence using RNN, each of the hidden states Which correspond to basically the to",
+  "Pre trained models": "Hello, everyone. Welcome back. So we were discussing different pre-training strategies, and in the last lecture, we discussed. You know, pre-training and encoder-only models, specifically, we discussed the BERT model, right? So, in today's class, we will focus on two other pre-training strategies. One is encoder-decoder-only models, right? Models like T5 and BART. So B-A-R-T is another model, right? This is not B-E-R-T; this is B-A-R-T, BART. And at the same time, we will also discuss decoder-only models, right?\n\nwhich includes ChatGPT, all GPT series models, LLaMA models, and Decoder-only models are essentially very popular. So, the encoder-only model, as I discussed, was discussed in the last class. We saw that a new pre-training strategy called masked language model was introduced. This was used in BERT, where you essentially mask some of the tokens in the input. And you ask the model to predict those masked tokens, right? This is a self-supervised approach. You don't need any labeled data for training, right?\n\nAnd being an encoder model, it essentially means, The BERT model can essentially look at all the tokens present in the input. It is not an autoregressive model, is it? So the entire input is exposed to the model. And you basically perform self-attention. Through self-attention, you look at all the tokens present in the input. And based on that, you predict the mass of the tokens. On the other hand, the encoder-decoder model that we discussed here, As we discussed in today's class, we have this encoder component and the decoder component.\n\nAnd we will see how you can best use both parts of the encoder. And the decoder part during pre-training. And then we will also discuss the decoder-only model. Now, in the decoder-only model, as the name suggests, the decoder part, If you remember in the transformer class we discussed, it's an autoregressive model. autoregressive component in the sense that when you predict a word at the t-th location, You only have access to tokens until the t minus 1th location, right? You don't have access to tokens after the location, right?\n\nWe will see how you understand this autoregressive style of pre-training essentially. helps the decoder-only model learn things correctly This set of models is very popular these days, as people realize. Over the times that an encoder-only model is not the right solution for. For a generative task, right? Because a generative task requires an autoregressive setup, right? Whereas in an encoder-decoder model, right, as you require. Both the encoder part and the decoder part require a lot of memory.\n\nIt requires a lot of parameters, right? You can do all these generative tasks through the encoder-decoder model together, right? But the decoder model makes more sense both in terms of parameters. As well as the setup, right? The autoregressive model setup itself is suitable for, you know, next token generation. And, parameter-wise, you need half of the parameters. than the encoder d",
+  "Tutorial: Introduction to huggingface": "Hi, everyone. In this tutorial, we'll be discussing a kind of introduction to the HuggingFace library. So Hugging Face is a very useful library when we work with basically transformer-based models. Mostly the transformer-based model. All these models, open-source models, and data sets are available on something called the Hugging Face Hub. So we will see how we can use this Hugging Face library to load the models. To fine-tune them using some toy examples, how do I load the data sets? And how to use it for inference.\n\nSo let's get started. So here... That package in Hugging Face, which deals with transformer-based models, is called Transformers. And there's a package called Datasets that deals with all the open-source datasets. So we need to first install them. Let's first look at the whole pipeline: the whole flow of how we process an input. So, first, we have this raw text. This course is amazing. And then we have a tokenization algorithm that breaks the text into tokens. And map it to some numbers correctly.\n\nSo these numbers represent a token, right? So this code is amazing; suppose we apply some tokenization algorithm, say like byte pair encoding. Or something, or a sentence piece tokenization, something like that. And it maps it to a sequence of tokens, and tokens are represented as numbers, right? So these token numbers are basically a kind of dictionary mapping. Please provide the sentence that needs correction. So 101, say, this tells us this is a token, and its number is 101. Something like that.\n\nSo we then have a list of input IDs. And then these are passed on to the model. So when the model receives the input IDs, which are a list of token numbers, What it does is go to its embedding matrix and do a lookup. So the embedding dimension of the token is already stored. In the embedding matrix of the pre-trained model. If it is not pre-trained and we are looking to train it from scratch, Then initialization is either some random initialization or some informed initialization like Xavier initialization or something like that.\n\nAnd then, when you train the model, these embeddings are also updated. Embeddings of the tokens are also updated. So for now, let us assume that the model has been pre-trained. So once we pass the input IDs, the model maps the token IDs to their token embeddings. And then the token embeddings are passed on to the model's position encoding. is added in the case of transformers, regardless of the model architecture present Whether it's an encoder-decoder model or a decoder-only model. Whether it's an encoder-only model, it is processed accordingly.\n\nWe have already seen in our lecture, I guess, one or two weeks ago. That's how you implement transformers from scratch using PyTorch, right? There we saw how a transformer layer is implemented within the model. We saw every component of it: multi-reduction positional encoding and layer normalization. Encoder block, decoder block; we saw all that. So now we are putting all o",
+  "Fine tuning LLM": "hey everyone I'm Shaw and this is the fifth video in the larger series on how to use large language models in practice in the previous video we talked about prompt engineering which is concerned with using large language models out of the box while prompt engineering is a very powerful approach and can handle a lot of llm use cases in practice for some applications prompt engineering just doesn't cut it and for those cases we can go one step further and fine-tune a existing large language model for a\n\nspecific use case so Navy's question is what is model fine tuning the way I like to Define it is taking a pre-trained model and training at least one internal model parameter and here I mean the internal weights or biases inside the neural network what this typically looks like is taking a pre-trained existing model like gpt3 and fine-tuning it for a particular use case for example chatgypt to use an analogy here gpt3 is like a raw diamond right out of the earth it's a diamond but it's a bit rough around\n\nthe edges fine tuning is taking this raw diamond and transforming it into something a bit more practical something that you can put on a diamond ring for example so the process of taking the raw base model of gpt3 and transforming it into the fine-tuned model of gbt 3.5 turbo for example is what gives us applications like chat GPT or any of the other incredible applications of large language models we're seeing these days to get a more concrete sense of the difference between a base model link\n\ngpt3 and a fine-tuned model let's look at this particular example we have to keep in mind that these Foundation large language models like gpg3 llama 2 or whatever your favorite large language model is these models are strictly trained to do word prediction given a sequence of words predicting the next word so when you train one of these launch language models on huge Corpus of text and documents and web pages what it essentially becomes is a document completer what that translates to in practice is if you plug into a lot of\n\nthese base models like gpt3 the prompt tell me how to find tune a model a typical completion might look something like this where it's just listing out questions like you might see in a Google search or maybe like a homework assignment or something here when I prompted gpt3 to tell me how to fine-tune a model the completion was as follows how can I control the complexity of a model how do I know when my model is done how do I test a model well this might be reasonable for gpt3 to do based on the data that it was trained on this\n\nisn't something that's very practical now let's look at the fine-tuned model completion so now we have text DaVinci zero zero three which is just one of the many fine-tuned models based on gpt3 coming from open AI we give it the same prompt tell me how to fine tune a model and this is the completion fine-tuning a model involves a adjusting the parameters of a pre-trained model in order to make it better suited f",
+  "Instruction tuning": "Hello everyone, today we will discuss instruction fine-tuning or instruction tuning. which is one of the key advancements in recent language modeling research. which enables us to have a conversation with language models easily Or, simply put, we can chat with language models. So, first, a quick review. So in previous weeks, we have learned about decoder-based language models. So such models are trained on vast amounts of text from the internet. Using the next word prediction task. As a result of this, these models learn to encode a great deal of information.\n\nAbout the world. They also have the ability to understand language to some extent. So these models are very powerful. They're pretty amazing, but we'll see in the upcoming slides. That they have some major limitations. One note: these pre-trained language models are also known as base models. So I'll be using the term \"base models\" throughout the lecture. So whenever I mention base models, it simply refers to pre-trained language models. For example, let's say we have been given the following prompt.\n\nWhat is the national flower of India? We have prompted the language model with this question. Now, what can happen is that the language model can generate the following response: What is the national animal of India? What is the national bird of India? So this response is nothing but the continuation of the prompt. And this is the result of the next word prediction that is happening. after the prompt. So here we see that the response contains questions that are quite common. which we can come across such questions on the web, where we see\n\nThere is a web page on general knowledge questions about India. Such questions are very common. However, this is not the desired response. Because when we asked this question of the language model, we were expecting an answer. That is, the national flower of India is the lotus. This was the desired outcome. However, since the language model is just predicting the next word, So the response to a question could be that it may. or may not follow the question. May or may not. Might follow the instructions, might not follow the instructions.\n\nBecause, as I said, it's simply just doing next-word prediction at this point. So the key takeaway from this slide is that next-word prediction, which is what is governing this response generation, That does not necessarily ensure that the model understands or follows instructions. So the reason we need instruction tuning is that. We want to teach the language models how to follow and understand instructions. So multitask learning is another very important paradigm in the natural language processing literature.\n\nSo in classical multitask learning, what we do is combine multiple tasks. We train the model, the language model, on multiple tasks with the intention. that these models will have a positive influence on one another And thereby, the final outcome will be improved across all the tasks. So here, if we take a look at th",
+  "Prompt based learning": "Welcome back. So in today's lecture, we are going to talk about prompts, right? And you know when it comes to chat GPT kind of models, Large language models, the first question that comes to our mind is how to write a prompt, right. What is going to be the optimal prompt for a specific model, right? So in this lecture, we will discuss different types of prompting techniques, right? how prompts affect the accuracy of the models, right? And how, with the scaling and the increasing size of the models,\n\nhow it basically affects the accuracy and how a specific prompt will be responsible for it Producing accuracy across different types of models. We'll also discuss prompt sensitivity, right? We'll see that most of these models are highly sensitive to simple perturbations of prompts. Right? And that would affect the accuracy; that would affect other aspects of the model. And how can we quantify them, right? So far, we have discussed different pretraining strategies. We have seen encoder-only models, haven't we?\n\nWe have seen models like BERT, which is a pure encoder-only model, right? And these models are pre-trained with an objective called masked language modeling, right, MLM. We have seen models like GPT, which is a purely decoder-only model. And these models are trained using an autoregressive setup, right, or causal language modeling. This is called causal language modeling or an autoregressive setup. There are other models like T5 and BART, and they are encoder-decoder models. Okay, which are also trained with a kind of autoregressive setup.\n\nWhere your input will be fed to the encoder. and decoder will predict the next word Our decoder will predict if your input is part of, and if your input has noise. the decoder model will be able to essentially denoise your input, right? And you know the board model came out around 2018. The first GPT paper was written in 2018, GPT-1, and then GPT-2 came in 2019. GPT-2 was released in 2019 and then GPT-3 in 2020. Right, and the GPT-3 paper showed that the model doesn't need any fine-tuning. We just need to write prompts, and the model will be able to.\n\nunderstand your prompt, okay. We will discuss all these topics in this lecture. Okay, so I strongly suggest that you guys read this wonderful survey paper. This is a survey paper written by Graham Neubig and his team from CMU. And this is, you know, this rightly and nicely reflects the, you know, Different prompting strategies and the kind of evolution of the overall. You know, prompt, you know, prompt as a kind of aspect overall, how it evolves, right? How do we quantify different components of a prompt, and so on and so forth?\n\nIt's a very nice survey paper that I strongly recommend you read. Okay, so you know there have been, kind of, we have seen. We have witnessed that there has been a kind of war, right? Among all these giant industries, such as Meta, OpenAI, and Google, They have been building larger and larger models with more and more parameters. and so",
+  "Parameter efficient fine tuning": "# Summary: Parameter-Efficient Fine-Tuning (PEFT) for Large Language Models\n\nThis lecture by Dinesh Raghu from IBM Research covers efficient methods for fine-tuning Large Language Models (LLMs) without updating all parameters.\n\n## Key Concepts\n\n**Why PEFT is Needed:**\n- Full fine-tuning requires 12-20× model size in memory for optimizer states, gradients, and activations\n- Storage overhead: each task requires saving a full model checkpoint (e.g., 350GB)\n- In-context learning (prompting) has limitations: lower accuracy than fine-tuning, sensitivity to prompt wording, and high inference costs\n\n**Main PEFT Techniques:**\n\n1. **Prompt Tuning (Soft Prompting)**\n   - Reserves special trainable tokens in the input while freezing all model weights\n   - Extremely parameter-efficient (~0.1% of model parameters)\n   - Enables multi-task serving: different soft prompts can be swapped for different tasks on the same base model\n   - Performance approaches full fine-tuning for large models (11B+ parameters)\n\n2. **Prefix Tuning**\n   - Adds trainable parameters at every transformer layer, not just the input\n   - Uses a bottleneck MLP architecture to prevent training instability\n   - Achieves comparable performance to full fine-tuning with only 0.1% trainable parameters\n\n3. **Adapters**\n   - Inserts new trainable layers (bottleneck architecture) within each transformer block\n   - Down-projects hidden dimensions, applies nonlinearity, then up-projects\n   - Achieves good performance with ~3.6% of parameters\n   - Drawback: inference latency overhead due to added layers\n\n4. **LoRA (Low-Rank Adaptation)**\n   - Most popular PEFT method based on intrinsic dimensionality theory\n   - Decomposes weight updates into low-rank matrices: ΔW = BA\n   - Only modifies query, key, value, and output projection matrices\n   - Advantages: no inference latency, can be merged back into base weights\n   - Variants: QLoRA (memory-efficient), DyLoRA (dynamic rank selection), LoRA+\n\n**Key Benefits of PEFT:**\n- Reduced memory and compute requirements (can use older GPUs)\n- Faster convergence due to smaller parameter space\n- Less overfitting and catastrophic forgetting\n- Better out-of-domain generalization\n- Minimal storage per task\n\nThe lecture emphasizes that PEFT bridges the gap between inefficient in-context learning and computationally prohibitive full fine-tuning, making LLM adaptation accessible and practical.\n\n[1](https://ppl-ai-file-upload.s3.amazonaws.com/web/direct-files/attachments/52028987/a8512587-2c43-4219-84a6-bc60a1065297/paste.txt)",
+  "Incontext Learning": "welcome everyone this is the first screencast in our series on in context learning this series is a kind of companion to the one that we did on information retrieval the two series come together to help you with homework 2 and bake off two which is focused on few shot open domain question answering with frozen retrievers and Frozen large language models to start this series I thought we would just reflect a bit on the origins of the idea of in context learning which is really a story of how NLP got to this\n\nstrange and exciting and chaotic moment for the field and maybe also for the society more broadly all credit to the Chomsky bot for bringing us to this moment I'm only joking the the Chomsky bot is a very simple pattern-based language model it's been around since the 90s I believe and with very simple mechanisms it produces Pros that is roughly in the style of the political philosopher and sometimes linguist Noam Chomsky it produces prose that Delights and maybe informs us and the underlying mechanisms are very\n\nsimple and I think that's a nice reminder about what all of these large language models might be doing even in the present day but I'm only joking although it's only partly a joke I think when we think about precedence for in context learning it is worth mentioning that in the pre-deep learning era engram based language models very sparse large language models were often truly massive for example brands at all 2007 use a 300 billion parameter language model trained on 2 trillion tokens of text to help\n\nwith machine translation that is a very large and very powerful mechanism with a different character from the large language models of today but it is nonetheless worth noting that they played an important role in a lot of different fields way back when I think for in context learning as we know it now the earliest paper as far as I know is the DECA NLP paper this is McCann adult 2018. they do multitask training with task instructions that are natural language questions and that does seem that like the origin of the idea\n\nthat with freeform natural language instructions we could essentially end up with artifacts that could do multiple things guided solely by text and then it's worth noting also that in the GPT paper Radford at all 2018 you can find buried in there some tentative proposals to do prompt-based uh experiments with that model but the real origins of the ideas again as far as I know are Radford at all 2019 this is the gpt2 paper and let me just show you some Snippets from this paper it's really inspiring\n\nhow much they did they say at the start we demonstrate language models can perform Downstream tasks in a zero shot setting without any parameter or architecture modification so there you see this idea of using Frozen models prompting them and seeing if they will produce interesting behaviors they looked at a bunch of different tasks for summarization they say to induce summarization Behavior we add the text tldr after the art",
+  "Prompting methods": "welcome everyone this is the first screencast in our series on in context learning this series is a kind of companion to the one that we did on information retrieval the two series come together to help you with homework 2 and bake off two which is focused on few shot open domain question answering with frozen retrievers and Frozen large language models to start this series I thought we would just reflect a bit on the origins of the idea of in context learning which is really a story of how NLP got to this\n\nstrange and exciting and chaotic moment for the field and maybe also for the society more broadly all credit to the Chomsky bot for bringing us to this moment I'm only joking the the Chomsky bot is a very simple pattern-based language model it's been around since the 90s I believe and with very simple mechanisms it produces Pros that is roughly in the style of the political philosopher and sometimes linguist Noam Chomsky it produces prose that Delights and maybe informs us and the underlying mechanisms are very\n\nsimple and I think that's a nice reminder about what all of these large language models might be doing even in the present day but I'm only joking although it's only partly a joke I think when we think about precedence for in context learning it is worth mentioning that in the pre-deep learning era engram based language models very sparse large language models were often truly massive for example brands at all 2007 use a 300 billion parameter language model trained on 2 trillion tokens of text to help\n\nwith machine translation that is a very large and very powerful mechanism with a different character from the large language models of today but it is nonetheless worth noting that they played an important role in a lot of different fields way back when I think for in context learning as we know it now the earliest paper as far as I know is the DECA NLP paper this is McCann adult 2018. they do multitask training with task instructions that are natural language questions and that does seem that like the origin of the idea\n\nthat with freeform natural language instructions we could essentially end up with artifacts that could do multiple things guided solely by text and then it's worth noting also that in the GPT paper Radford at all 2018 you can find buried in there some tentative proposals to do prompt-based uh experiments with that model but the real origins of the ideas again as far as I know are Radford at all 2019 this is the gpt2 paper and let me just show you some Snippets from this paper it's really inspiring\n\nhow much they did they say at the start we demonstrate language models can perform Downstream tasks in a zero shot setting without any parameter or architecture modification so there you see this idea of using Frozen models prompting them and seeing if they will produce interesting behaviors they looked at a bunch of different tasks for summarization they say to induce summarization Behavior we add the text tldr after the art",
+  "Retrieval Methods": "All right, welcome everyone to the Comet YouTube channel. We are doing a series of guest speakers where we dive into some very fun technical topics related to building and scaling Genai systems. And today I have with us Lena. She is a absolute expert in building rags. I've had some good conversations with her as we prepared for this session about her approaches. And I'm really excited to just go through really some of the best practices around like optimizing retrieval for LMS. We're going to deep\n\ndive into some rag techniques, some advanced stuff here. Um, before we dive in, I want to pass it over to Lena to introduce herself. Thank you Claire for the introduction and uh, hi everyone who is watching the recording. I'm so happy to be here. Uh, my name is Lennena. I'm a founder of pars labs and chatbot and I've been working in this space of chatbot development conversational AI agents since um I think eight years now. Uh my career started in linguistics. I studied theoretical linguistics then AI. I\n\nworked as an NLP research engineer and full stack developer and uh yeah now running a small agency with a team of five now and doing also a lot of um public speaking and sharing my knowledge online with people um running courses on AI automation and things like that. Uh so hopefully I will have something interesting to share uh with you today. >> All right well let's dig into some deep technical topics. Um, I wanted to dive into the advanced techniques for improving rags. I think there's a few\n\nideas that you had here. Um, and if you want to share screen, uh, feel free. We can, uh, pull up some slides here. But let's dive into some of these more advanced techniques in regards to just improving your RAG systems. >> Uh, yes. Um, what should we start with? >> Let's see. I'm thinking about optimizing the retrieval quality. Um, >> okay. Let me share my screen and then we'll just see where it leads us. So I prepared a lot of different diagrams uh with different techniques\n\n>> um in a random order. So you are welcome. >> Thank you. I love this. This is a gold mine of information. >> Uh yeah. So let's start with um maybe uh this um I classified it as improving a retrieval quality trick. So uh in the past we used intent detection when we were building chatbots. So instead of generating anything for anything we had to make data sets for okay this type of question is about salary this type of question is I want to talk to customer support. We had all\n\nthose categories and um I don't see that often being used yet with newer teams who just joined this whole chatbot development. So I want to bring it back. Uh so instead of just generating the response using LLM, you get the user question. So what's the salary? Then you predict an intent and you get an an answer that your SMMES have written. So the answer that's in your database and it says the salary for this position is salary. And then you paste this information uh to the prompt and then\n\nyou generate an answer o",
+  "Retrieval Augmented Generation": "### Lecture Summary: Retrieval-Augmented Generation (RAG) and Contextualization of Language Models\n\nWelcome everyone. Today we’ll discuss **retrieval augmentation** — one of the most active areas in modern NLP. Our speaker, Adella, is CEO of Contextual AI, an enterprise LLM company, an adjunct professor at Stanford, and former head of research at Hugging Face and Facebook AI. His research focuses on machine learning and NLP, especially on language understanding, generation, and evaluation.\n\n---\n\n### 1. The Age of Language Models\n\nWe live in the era of large language models (LLMs). However, **language models** are not a recent invention—neural language modeling dates back to the 1990s. The idea is simple: given a sequence of tokens, predict the next token. Early versions (e.g., Bengio et al., 2003) already had embeddings and similar formulations to today’s models. What changed is scale.\n\nThe main breakthrough of **ChatGPT** wasn’t the model architecture—it was the **user interface**. Previously, using a language model required strange prompt engineering. ChatGPT solved this through *instruction tuning* and *reinforcement learning from human feedback (RLHF)*, allowing people to simply “ask” the model naturally.\n\n---\n\n### 2. Problems with Pure Language Models\n\nEven with good interfaces, LLMs have serious issues:\n\n* **Hallucination:** Models generate incorrect facts with high confidence.\n* **Attribution:** We don’t know *why* a model produced an answer.\n* **Staleness:** Models become outdated quickly.\n* **Editing:** We can’t easily revise or delete knowledge (e.g., for GDPR compliance).\n* **Customization:** Hard to adapt models to specific domains or private data.\n\nThese limitations make LLMs unreliable for enterprise or high-accuracy applications.\n\n---\n\n### 3. Enter Retrieval-Augmented Generation (RAG)\n\nThe solution many have turned to is **RAG** — connecting a generator (LLM) with an **external retriever** or **memory**. Instead of relying solely on parameters, the model can look up information dynamically.\n\nThink of **closed-book vs open-book exams**:\n\n* Closed-book → memorize everything (parametric LMs).\n* Open-book → look up relevant facts when needed (RAG).\n\nThis architecture has two main parts:\n\n1. **Retriever:** Fetches relevant documents or passages from an external database.\n2. **Generator:** Takes the query and retrieved context to produce an answer.\n\nThis approach gives **updatable, grounded, and customizable** models that hallucinate less and can cite their sources.\n\n---\n\n### 4. Retrieval Foundations\n\nEarly retrieval methods used **sparse retrieval** (e.g., TF-IDF, BM25).\nBM25 scores documents by term frequency and inverse document frequency, emphasizing distinctive words. It’s fast and efficient on CPUs but fails with synonyms or paraphrases.\n\n**Dense retrieval** (e.g., DPR, ORQA) replaces sparse counts with **embedding-based similarity** using models like BERT. Each document and query is encoded into a dense vector; retrieval is done v",
+  "Quantization": "Alright, hello everyone. So, today we will be talking about quantization, pruning, and distillation. So, these all fall under the same umbrella, and maybe once I go into the introduction, It will be clear why we are discussing these three topics together. So, like we discussed last time, the reason why we wanted to do theft was Because of how the model sizes have been increasing over time. And this is, again, a recap of that. Over time, the size of the model is increasing exponentially. It is not just the size but also the performance of these models.\n\nare also increasing over time. So, here we see that these are the test laws for various language modeling tasks. on different datasets and you see that they are decreasing considerably Based on the number of parameters that are in the large language model. So now, what is the flip side of having such large models during inference? So, the first thing, as we discussed last time, is that the bigger the model is, You will have to buy new hardware to support them. In a sort of way, it is not very friendly to keep buying hardware.\n\nAnd when the model keeps growing over time. So, this also puts a cap on how many organizations can actually run these LLM inferences. So, the GPU requirement is going to get larger and One of the biggest problems in deployment is latency. So, the larger the model is, the more time it will take to come back. with a completion for a given prompt. Now, let's say that you have a chatbot that has been deployed. whose backbone is an LLM, then having to wait for 30 or 40 seconds, It seems really difficult at this point in time when we are so used to.\n\nGetting replies very quickly. And the way the LLM field is progressing now, People are not just using a single LLM call per sort of response. For example, there is now a new paradigm called agentic behavior. where once a language model responded, You ask the same language model or a different language model to reflect on the output. or even sometimes execute the output, for example, if the model generates a code, you execute the code, Get the outputs and then make the model reflect on the output.\n\nAnd then decide whether there is an execution error; should it redo things. And finally, you give back the answer. So now, if you have to make multiple LLM inferences, to just get back with one output. Then that's going to increase latency even more. So, latency is one of the biggest concerns. Third is the inference cost. If you have an application deployed that uses LLMs, Of course, you'll be worried about how much money. You're going to spend to serve a single user. And the money that a single user is going to pay you.\n\nshould be more than what you invest for that user. So, if LLM is for slightly more improvement in accuracy, If you have to spend a lot more, then it does not seem commercially viable. So, of course, the inference cost is going to be one of the biggest dimensions. And finally, sustainability and environmental concerns. So, yo",
+  "Mixture of Experts Model": "## **Scaling Transformers Through Sparsity**\n\n### **1. Motivation**\n\nThe driving idea behind this research is **scaling**. In the deep learning community, performance has been shown to improve predictably with model size and compute, as outlined in *OpenAI’s 2020 paper “Scaling Laws for Neural Language Models.”*\nThese scaling laws hold across several orders of magnitude, demonstrating that **larger models are more sample-efficient**: for a fixed compute budget, it is better to train a **larger model for fewer steps** than a smaller one for longer.\n\nSo far, most scaling has relied on **dense models**, where every parameter participates in every forward pass. But this is expensive and inefficient.\nToday’s discussion explores a new axis of scaling: **sparsity** — models where different inputs activate **different subsets of weights**, performing **adaptive computation** depending on the input.\n\n---\n\n### **2. What Is Sparsity?**\n\nSparsity here doesn’t mean pruning or zeroing weights, but **conditional computation**:\neach input token is processed by a subset of the network — “experts” — chosen dynamically.\n\nThis idea dates back to 1991’s *Adaptive Mixtures of Local Experts*, revived in modern NLP by Noam Shazeer and colleagues at Google with **Mixture of Experts (MoE)** for LSTMs.\nThe architecture has:\n\n* Several **experts**, each a small feed-forward network.\n* A **router (gating network)** that predicts which experts to send each token to, using a softmax distribution.\n* The output is a weighted mixture of the selected experts.\n\nMoE proved successful in machine translation but had issues like communication cost and training instability.\nThe **Switch Transformer** simplified this by sending each token to **only its top-1 expert**, reducing both cost and complexity.\n\n---\n\n### **3. The Switch Transformer**\n\nA Switch Transformer modifies the Transformer block by replacing some feed-forward layers with **Switch Layers**:\n\n* A **router** decides which expert each token goes to.\n* Each token goes to one expert (top-1 routing).\n* The same amount of computation is done overall, but different tokens use different weight matrices.\n\nThis makes computation adaptive while keeping the FLOPs (floating-point operations) roughly constant.\n\n---\n\n### **4. Key Improvements for Sparse Training**\n\nSparse models can be unstable to train. The team made several innovations to stabilize and optimize performance:\n\n#### (a) **Selective Precision**\n\n* Training in low precision (bfloat16) improves speed but can cause divergence due to numerical instability, especially in routers (softmax/exponentiation).\n* Casting router computations to **float32** (while keeping others in bfloat16) solved this without meaningful speed loss.\n\n#### (b) **Initialization Scaling**\n\n* Default initializations made training unstable.\n* Simply reducing the initialization scale significantly improved convergence and performance.\n\n#### (c) **Expert Dropout Regularization**\n\n* Sparse models with many param",
+  "Agentic AI": "my name is inso so uh today uh we like to uh go over agent AI aent language model as a progression of language model usage so here is the outline of the today's talk uh we'll go over uh the overview of language model and how we use and then and the common limitations and then um some of the method that improves towards this common limitation and then we'll transition it to uh what is the Agent B language model and its design patterns so uh language model is a machine learning model that predicts the\n\nnext coming word given the input text as in this example if the input is the the students open there then um language model uh can predict what's the most likely word coming uh next as a next word so if the language model is trained with the large corpers it is a predict it is generating the probability of next coming word in this example uh as you could see books and laptops have a high higher probability than other other words in the vocabulary so um the so the completion of this whole sentence\n\ncould be uh the students open their books and then if you want to keep generating um the what's coming next then we can uh uh turn them in as an input and then uh um put it into the language model and then language model continuously generating the next coming word then how uh these uh language models are trained largely uh two two parts pre-training part and then posttraining part and then um first pre-training portion is the one that language models are trained with lot with large copers uh text are collected\n\nfrom internet or books or different type of text publicly available text and then trained with the next token or next word prediction objectives so once the models uh is finished in this pre-training stage models are fairly good at predicting um any words coming uh next as a word um given the inputs um however um this type uh the pre-train model uh itself is um is not easy to use so the hence the posttraining uh steps are coming and then these uh post trining stage um uh would includes uh instruction following training as well\n\nas reinforcement learning with human feedback and what this uh training stage uh means is uh um we could prepare a data set such a way that the specific instruction or question and then the answers or the uh generated output that is what the uh user would expect or uh more uh more uh um uh related to the questions and answers so that's how uh the models are trained so that it's easier to use and then also it'll respond to a specific uh and then uh once this done and then uh additional training uh method uh is uh\n\num uh aligning to Humane preference by using uh reinforcement learning with human feedback which uhu U is using human uh preference to align the model by using uh rewards schemes and um let's take a quick look really quick look on the instruction data set this is the template that uh we uh uh we would use to train the model in instruction following training phase as you can see uh there's a specific uh instructions w",
+  "Multimodal LLMs": "um Hello thank you all for joining CS uh 25 Transformers today uh for today's talk we have Ming ding a research scientist at jeu AI based in Beijing he obtained his bachelor's and doctoral degrees at tingua University and he does research on multimodal generative models and pre-training Technologies um he has LED or participated in the research work Works about multimodal generative models such as Cog View and Cog video and multimodal understanding models such as Cog uh VM and Cog agent uh for today's\n\nattendance the attendance form is up on the course website and if you have any questions ask them through slido s l d o and for the code you just have to input cs25 um thank you Ming for today's talk and I'm going to pass it off to you thank you for the instructors of cs25 to is very happy to gave a talk in Stanford University about multimodality in training and uh uh actually I have checked the uh all the previous talks in cs25 and uh they are really diverse topics someone share the intuition in\n\ntheir research about PR training someone shared recent Works about maybe M Moe and some other technical uh actually I'm working in a uh large language model company in China and our company working on print training and uh maybe there's lots of different area uh from a large langage model and multi modality model and generative model diffusion and uh tatto Speech something like that so uh I Le all the multimodality model research in J AI so I will uh share lots of different topics in in in this talk um some some of them\n\nmay be not very familiar to you so uh yeah it's okay but you can uh get more information of the the area uh yeah I will talk about several aspects of Transformers and I will generally follow the history of large language model and say why are we here it's about large language model introduction and history uh and how did we get here it's about the some practical techniques for training large lar langage models and what are we working on it's about the last one year uh the real language\n\nmodels and other techniques in the uh papers of all the uh V language model community and finally I will talk about the some possible and valuable direction for research in multimodality okay okay well uh I will share three moments uh I think the most important three moments in the development of language model uh the first moment is called Bo moment actually I get I got into the area at this moment it's very uh honored that I'm the first among the first group of people who publish paper on the next year ACL when\n\nB came out and at that time since is is we don't really know what is language modeling so at that time nearly all the people talking about uh how can we get a better self-supervised method for an option uh at that time a common opinion is mask language model is just for is is good at understanding the the TX and GPT the auto regressive model is better for tax generations and T5 maybe can U can do the B but is redundant and that's true but uh uh n",
+  "Vision Language Models": "## **Vision–Language Models (VLMs)**\n\n### **1. Introduction and Motivation**\n\nVision–language models (VLMs) are systems that **learn jointly from images and text**, enabling understanding and reasoning across both modalities. These models can describe images, answer visual questions, classify objects in an open vocabulary, and perform grounding or retrieval tasks — all using a shared understanding between vision and language.\n\nThe talk is divided into three parts:\n\n1. **Foundations and Early Models** – how it started (around 2021)\n2. **Cross-Modal Models** – modern multimodal transformers\n3. **Applications and Outlook** – where VLMs are being used and what’s next\n\nThe goal is to trace how we moved from basic dual-encoder models like **CLIP** to modern multimodal systems such as **Gemini**, and how this shift is transforming research and real-world applications.\n\n---\n\n## **2. What Is a Vision–Language Model?**\n\nA VLM jointly processes both **images and text**.\nInput: image(s) + text(s)\nOutput: typically text (caption, answer, label, etc.)\n\nWhile some models can also *generate* images, this talk focuses on those that produce **text outputs**.\n\nTo design a VLM, we must decide:\n\n* How to **encode** images and text (shared vs separate architectures)\n* When and how to **fuse** the modalities\n* What **losses** to use (contrastive, captioning, etc.)\n* Whether to train from **scratch** or **fine-tune** pretrained models\n* What kind of **data** to use: paired (image–text), interleaved, or unpaired\n\n---\n\n## **3. Dual-Encoder Models: The Beginning**\n\n### **3.1 The Idea**\n\nThe simplest form of VLMs are **dual encoders**:\n\n* An **image encoder** and a **text encoder**, each processing its own modality\n* The two encoders only interact **at the loss level** — their final embeddings are compared to learn alignment.\n\nThis structure laid the foundation for large-scale models like **CLIP (OpenAI)** and **ALIGN (Google)**, both published in early 2021.\n\n### **3.2 CLIP: Connecting Images and Text**\n\n**CLIP (Contrastive Language–Image Pretraining)** became the turning point for multimodal learning.\n\n**Training setup:**\n\n* 400 million **image–text pairs** scraped from the web.\n* Train two encoders (ViT for images, Transformer for text) from scratch.\n* Use a **contrastive loss** to bring matching image–text pairs closer and push others apart.\n\nThis simple recipe led to highly transferable representations and *open-vocabulary* capabilities — allowing classification without retraining on new classes.\n\n---\n\n## **4. Contrastive Learning in CLIP**\n\n### **4.1 Principle**\n\nContrastive learning teaches the model to:\n\n* **Maximize similarity** between two *positive* samples (e.g., an image and its true caption)\n* **Minimize similarity** with *negative* samples (other image–text pairs in the batch)\n\nIn formula form, the **InfoNCE loss** compares one positive pair to all others using a softmax over cosine similarities.\n\n### **4.2 Implementation Details**\n\n* **Normalize** embeddings",
+  "Policy learning using DQN": "Hello everyone, welcome back to the course on LLMs. So we were discussing the alignments of large language models. And in the last class, we discussed how you know. Human-generated feedback can be injected into this model for further refining. So, specifically, we discussed that we have a policy model. The policy model is the LLM that you want to refine. that you want to fine-tune. And then this policy model will generate certain output. This output will be scored by a reward model. This reward model is another LLM.\n\nSo, it will produce a reward and based on this reward, we will further refine this policy model. We also discussed that only reward maximization is not enough. Because what happens if we only maximize the reward? What would end up happening is that the policy model would start hacking the reward model. meaning that it will start producing such responses for which The reward model will produce higher reward values. But the responses may not be realistic. For example, the policy model will start producing a lot of emoticons.\n\nIt will start producing sentences that are verbose, lengthy, and so on. Not to the point, and so on and so forth, which you do not want. Therefore, to address this reward hacking loophole, what you do? you have another component in the objective function. Which do you want to minimize, and what is this component? This component is basically the divergence scale between the old policy. And the updated policy, the old LLM, and the updated LLM. So, you do not want the updated LLM to be too far. from the starting LLM.\n\nSo, we discussed maximizing the reward, which is the expected reward. that you obtain  given a policy. So, the policy model is θ. So, this is parameterized by θ. You essentially sample, given a prompt x. this policy model will generate a y and for this y, You have this reward. So, for example, x is the prompt that it is. Where is the Taj Mahal located, and let us say that y is the response? Let us say the response is, \"The Taj Mahal is located in Uttar Pradesh.\" The Taj Mahal is located in France and so on and so forth.\n\nand based on that you give high reward or low reward. And this second term, this term, is essentially the KL divergence between The updated policy model and the reference policy model. So, pi theta and pi ref. So, the reference LLM policy model is the one. from which you started your reward maximization process. These two components will be combined. So, you want to maximize rewards and minimize scale divergence. And there is this beta scaling factor. Now, this lambda is essentially responsible for scaling these two components.\n\nIf you want to give more weight to scale divergence, You increase the value of lambda, and so on and so forth. So this is what we discussed. So now the question is or given this regularized reward maximization Why is this a regularized reward? Because this component... You can think of this as a regularizer. This is your objective, and this is your regularizer. ",
+  "RLHF": "Incredibly powerful and a ton of people were just able to download this and use this on their own and that was transformative on how people viewed machine learning as a technology that interfaced with people's lives and we at hug and face kind of see this as a theme that's going to continue to accelerate as time goes on and there's kind of a lot of questions on Where is this going and kind of how do these tools actually work and one of the big things that has come up in recent years is that these machine learning models can fall short which is they're not perfect and they have some really interesting failure modes so on the left you could see a snippet from chat GPT which uh if you've used chat gbt there's these filters that are built in and essentially if you ask it to say like how do I make a bomb it's going to say I can't do this because I'm a robot I don't know how to do this and this seems harmful but what people have done is that they have figured out how to jailbreak this this agent in a way which is you kind of tell it I have a certain I'm a playwriter how do I do this and you're a character in my play what happens and there's all sorts of huge issues around this where we're trying to make sure these models are safe but there's a long history of failure and challenges with interfacing in society and a like fair and safe Manner and on the right are two a little bit older examples where there's Tay which is a chatbot from Microsoft that was trying to learn in the real world and by interacting with humans and being trained on a large variety of data without any grounding and what values are it quickly became hateful and was turned off and then a large history of it field studying bias in machine learning algorithms and data sets where the by the data and the algorithm often reflect biases of their designers and where the data was created from so it's kind of a question of like how do we actually use machine learning models where we have the goals of mitigating these issues and something that we're going to come and talk to in this talk is is reinforcement learning a lot so I'm just going to kind of get the lingo out of the way for some people that might not be familiar with deeprl essentially reinforcement learning is a mathematical framework when you hear RL you should think about this is kind of like a set of math problems that we're looking at that are constrained and in this framework we can study a lot of different interactions in the world so some terminology that we'll revisit again and again is that there's an agent interacting with an environment and the agent interacts with the environment by taking an action and then the environment returns two things called the state and the reward the reward is the objective that we want to optimize and the state is just kind of a representation of the world at that current time index and the agent uses something called a policy to map from that state to an action and the beauty of this is that "
+}

backend/database.py

@@ -0,0 +1,150 @@
+import json
+import os
+from datetime import datetime
+
+# HF Native Persistence: Check if /data volume is mounted
+IF_HF_PERSISTENT = os.path.exists('/data')
+if IF_HF_PERSISTENT:
+    DB_FILE = '/data/db.json'
+    print(f"📡 HF Native Persistence: Active. Storing data in {DB_FILE}")
+else:
+    DB_FILE = os.path.join(os.path.dirname(__file__), 'data', 'db.json')
+    print(f"💻 Local Persistence: Active. Storing data in {DB_FILE}")
+
+# Ensure data directory exists
+os.makedirs(os.path.dirname(DB_FILE), exist_ok=True)
+
+def init_db():
+    if not os.path.exists(DB_FILE):
+        data = {
+            "users": [],
+            "learning_sessions": {},
+            "polylines": {},
+            "summaries": [],
+            "bookmarks": {},  # session_id -> list of resource_ids
+            "notes": {},      # session_id -> list of note objects
+            "lectures": []    # list of lecture objects
+        }
+        save_db(data)
+
+def reset_db():
+    if os.path.exists(DB_FILE):
+        os.remove(DB_FILE)
+    init_db()
+
+def load_db():
+    if not os.path.exists(DB_FILE):
+        init_db()
+    
+    try:
+        with open(DB_FILE, 'r') as f:
+            content = f.read().strip()
+            if not content:
+                init_db()
+                with open(DB_FILE, 'r') as f2:
+                    db = json.load(f2)
+            else:
+                db = json.loads(content)
+                
+            if "bookmarks" not in db:
+                db["bookmarks"] = {}
+                save_db(db)
+            return db
+    except (json.JSONDecodeError, FileNotFoundError):
+        init_db()
+        with open(DB_FILE, 'r') as f:
+            return json.load(f)
+
+def save_db(data):
+    # Ensure directory exists (in case /data was just mounted)
+    os.makedirs(os.path.dirname(DB_FILE), exist_ok=True)
+    with open(DB_FILE, 'w') as f:
+        json.dump(data, f, indent=4)
+
+def get_session(session_id):
+    db = load_db()
+    if session_id not in db["learning_sessions"]:
+        db["learning_sessions"][session_id] = {
+            'position': {'x': 10, 'y': 10},
+            'level': 0,
+            'totalReward': 0,
+            'visitedResources': [],
+            'notifications': [
+                { 
+                  'id': 'initial', 
+                  'type': 'info', 
+                  'message': 'Welcome back to the Intelligence Hub. Neural Sync complete.', 
+                  'timestamp': int(datetime.now().timestamp() * 1000), 
+                  'read': False 
+                }
+            ]
+        }
+        save_db(db)
+    return db["learning_sessions"][session_id]
+
+def update_session(session_id, session_data):
+    db = load_db()
+    db["learning_sessions"][session_id] = session_data
+    save_db(db)
+
+def save_summary(summary_data):
+    db = load_db()
+    if "summaries" not in db:
+        db["summaries"] = []
+    db["summaries"].append(summary_data)
+    save_db(db)
+
+def save_polyline(polyline_id, polyline_data):
+    db = load_db()
+    db["polylines"][polyline_id] = polyline_data
+    save_db(db)
+
+def get_polylines():
+    db = load_db()
+    return db["polylines"]
+
+def get_bookmarks(session_id):
+    db = load_db()
+    return db["bookmarks"].get(session_id, [])
+
+def add_bookmark(session_id, resource_id):
+    db = load_db()
+    if session_id not in db["bookmarks"]:
+        db["bookmarks"][session_id] = []
+    if resource_id not in db["bookmarks"][session_id]:
+        db["bookmarks"][session_id].append(resource_id)
+        save_db(db)
+
+def remove_bookmark(session_id, resource_id):
+    db = load_db()
+    if session_id in db["bookmarks"] and resource_id in db["bookmarks"][session_id]:
+        db["bookmarks"][session_id].remove(resource_id)
+        save_db(db)
+
+def get_notes(session_id):
+    db = load_db()
+    if "notes" not in db or isinstance(db["notes"], list):
+        db["notes"] = {}
+        save_db(db)
+    return db["notes"].get(session_id, [])
+
+def add_note(session_id, note_data):
+    db = load_db()
+    if "notes" not in db or isinstance(db["notes"], list):
+        db["notes"] = {}
+    if session_id not in db["notes"]:
+        db["notes"][session_id] = []
+    
+    # Simple ID generation if not provided
+    if "id" not in note_data:
+        note_data["id"] = f"note_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    if "createdAt" not in note_data:
+        note_data["createdAt"] = datetime.now().isoformat()
+        
+    db["notes"][session_id].append(note_data)
+    save_db(db)
+    return note_data
+
+def get_lectures():
+    db = load_db()
+    return db.get("lectures", [])

backend/db.json

@@ -0,0 +1,2137 @@
+{
+    "users": [],
+    "learning_sessions": {
+        "default": {
+            "position": {
+                "x": 13,
+                "y": 7
+            },
+            "level": 5,
+            "totalReward": 900,
+            "visitedResources": [
+                "18",
+                "13",
+                "3",
+                "16",
+                "17",
+                "1",
+                "10",
+                "8",
+                "11",
+                "6",
+                "15",
+                "2",
+                "7",
+                "4",
+                "5",
+                "14",
+                "12",
+                "9"
+            ]
+        }
+    },
+    "polylines": {
+        "polyline_0": {
+            "id": "polyline_0",
+            "name": "hi",
+            "path": [],
+            "color": "rgba(124, 111, 197, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hiiii"
+        },
+        "polyline_1": {
+            "id": "polyline_1",
+            "name": "HI",
+            "path": [],
+            "color": "rgba(233, 165, 150, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "HII"
+        },
+        "polyline_2": {
+            "id": "polyline_2",
+            "name": "Hey",
+            "path": [],
+            "color": "rgba(209, 233, 75, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "Helloo",
+            "keywords_found": [],
+            "module_scores": [
+                0.5484583564915045,
+                0.46220741047368424,
+                0.46279993894614624,
+                0.4622026423083014,
+                0.48167479720554324,
+                0.5185239739531438,
+                0.47663528950961,
+                0.5005995736735275,
+                0.45502656055000007,
+                0.4580010883357644,
+                0.45637659612686454,
+                0.5112952634097881,
+                0.5216384772372223,
+                0.5355484607706302,
+                0.5135652915368838,
+                0.46179487959519183,
+                0.5207722130936243,
+                0.49757484056057777
+            ]
+        },
+        "polyline_3": {
+            "id": "polyline_3",
+            "name": "finetuning",
+            "path": [],
+            "color": "rgba(121, 211, 92, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "I studied fine tuning and RAG",
+            "keywords_found": [
+                "Fine tuning LLM",
+                "Retrieval Augmented Generation"
+            ],
+            "module_scores": [
+                0.49860121134816787,
+                0.4500395442873277,
+                0.471618804424644,
+                0.6583558195456436,
+                0.4580364051366949,
+                0.5067814340383607,
+                0.5267787555517994,
+                0.45159593526792297,
+                0.5354930330453695,
+                0.4633757771977945,
+                0.7440110046152995,
+                0.5165231405422576,
+                0.5131620206629675,
+                0.5382607288711271,
+                0.548322797358488,
+                0.4885586287263669,
+                0.5297033776671244,
+                0.5269894013550447
+            ]
+        },
+        "polyline_4": {
+            "id": "polyline_4",
+            "name": "main",
+            "path": [],
+            "color": "rgba(213, 61, 92, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "I studied fine tuning and RAG",
+            "keywords_found": [
+                "Fine tuning LLM",
+                "Retrieval Augmented Generation"
+            ],
+            "module_scores": [
+                0.15775318443775177,
+                0.20897206664085388,
+                0.20236347615718842,
+                0.6945049047470093,
+                0.4463333487510681,
+                0.12979882955551147,
+                0.4455224275588989,
+                0.1599089652299881,
+                0.10129339247941971,
+                0.19735002517700195,
+                0.412064354121685,
+                0.15838992595672607,
+                0.1395527720451355,
+                0.06164519488811493,
+                0.19151057302951813,
+                0.05123066157102585,
+                0.046856656670570374,
+                0.09634523838758469
+            ]
+        },
+        "polyline_5": {
+            "id": "polyline_5",
+            "name": "Test Summary",
+            "path": [
+                {
+                    "x": 7,
+                    "y": 0
+                },
+                {
+                    "x": 14,
+                    "y": 1
+                }
+            ],
+            "color": "rgba(63, 91, 199, 0.4)",
+            "isActive": true,
+            "confidence": 0.73,
+            "summary": "I learned about BERT and Transformers.",
+            "keywords_found": [],
+            "module_scores": [
+                0.41952282190322876,
+                0.4550943672657013,
+                0.38158124685287476,
+                0.22420939803123474,
+                0.21500593423843384,
+                0.2883783280849457,
+                0.08223940432071686,
+                0.2931893765926361,
+                0.12915080785751343,
+                0.09058266133069992,
+                0.19895221292972565,
+                0.10976134240627289,
+                0.10291370004415512,
+                0.17602239549160004,
+                0.28020530939102173,
+                0.2765440344810486,
+                0.153752401471138,
+                0.1386902928352356
+            ]
+        },
+        "polyline_6": {
+            "id": "polyline_6",
+            "name": "work",
+            "path": [
+                {
+                    "x": 9,
+                    "y": 18
+                },
+                {
+                    "x": 1,
+                    "y": 15
+                },
+                {
+                    "x": 6,
+                    "y": 19
+                },
+                {
+                    "x": 7,
+                    "y": 19
+                }
+            ],
+            "color": "rgba(181, 126, 100, 0.4)",
+            "isActive": true,
+            "confidence": 0.76,
+            "summary": "I have learned a lot about rag and preprocessing it was pretty good understanding.",
+            "keywords_found": [
+                "Retrieval Augmented Generation"
+            ],
+            "module_scores": [
+                0.2574118673801422,
+                0.2806059718132019,
+                0.18621119856834412,
+                0.10942331701517105,
+                0.26856184005737305,
+                0.3550261855125427,
+                0.07388029992580414,
+                0.3707934617996216,
+                0.1708703488111496,
+                0.2050769031047821,
+                0.5013039708137512,
+                0.1576768010854721,
+                0.10632561147212982,
+                0.12748579680919647,
+                0.19742925465106964,
+                0.05362231656908989,
+                0.07185838371515274,
+                0.055319223552942276
+            ]
+        },
+        "polyline_7": {
+            "id": "polyline_7",
+            "name": "Hey",
+            "path": [],
+            "color": "rgba(102, 156, 166, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.10327564924955368,
+                0.09360406547784805,
+                0.03690618276596069,
+                0.04519070312380791,
+                0.038354936987161636,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.07473935186862946,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ]
+        },
+        "polyline_8": {
+            "id": "polyline_8",
+            "name": "DQN Learning",
+            "path": [
+                {
+                    "x": 5,
+                    "y": 2
+                },
+                {
+                    "x": 9,
+                    "y": 10
+                }
+            ],
+            "color": "rgba(228, 246, 240, 0.4)",
+            "isActive": true,
+            "confidence": 0.73,
+            "summary": "I studied Policy learning using DQN and reinforcement learning agents.",
+            "keywords_found": [
+                "Agentic AI",
+                "Policy learning using DQN"
+            ],
+            "module_scores": [
+                0.3080591907103858,
+                0.32459903260072087,
+                0.10327564924955368,
+                0.3576170255740485,
+                0.03690618276596069,
+                0.5689638306697211,
+                0.038354936987161636,
+                0.7058747758467994,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                1.0,
+                0.07473935186862946,
+                0.0972217470407486,
+                1.0,
+                1.0
+            ]
+        },
+        "polyline_9": {
+            "id": "polyline_9",
+            "name": "heyyy",
+            "path": [],
+            "color": "rgba(144, 174, 69, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.3080591907103858,
+                0.32459903260072087,
+                0.6197177293813891,
+                0.5326734754360385,
+                0.03690618276596069,
+                0.5689638306697211,
+                0.038354936987161636,
+                0.7058747758467994,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.15920396625167793,
+                1.0,
+                0.36289105295307106,
+                0.5652326095021434,
+                1.0,
+                1.0
+            ]
+        },
+        "polyline_10": {
+            "id": "polyline_10",
+            "name": "hii",
+            "path": [],
+            "color": "rgba(78, 166, 73, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hiii",
+            "keywords_found": [],
+            "module_scores": [
+                0.5118434429168701,
+                0.7275236248970032,
+                0.5195397734642029,
+                0.2506510019302368,
+                0.5906199216842651,
+                0.460385799407959,
+                0.9057682156562805,
+                0.577440083026886,
+                0.44362306594848633,
+                0.6044198870658875,
+                0.26611554622650146,
+                0.5114411115646362,
+                0.49167001247406006,
+                0.6330015063285828,
+                0.38416922092437744,
+                0.5338788628578186,
+                0.37343931198120117,
+                0.7777066826820374
+            ]
+        },
+        "polyline_11": {
+            "id": "polyline_11",
+            "name": "hii",
+            "path": [],
+            "color": "rgba(199, 83, 212, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "nocajco",
+            "keywords_found": [],
+            "module_scores": [
+                0.035517044365406036,
+                0.07075861096382141,
+                0.021871453151106834,
+                0.00989073608070612,
+                0.019412130117416382,
+                0.0,
+                0.11922578513622284,
+                0.039588794112205505,
+                0.06686414033174515,
+                0.09156952798366547,
+                0.03569290041923523,
+                0.0679011419415474,
+                0.03752126544713974,
+                0.00478791818022728,
+                0.07304392009973526,
+                0.011222838424146175,
+                0.026982085779309273,
+                0.054899897426366806
+            ]
+        },
+        "polyline_12": {
+            "id": "polyline_12",
+            "name": "hii",
+            "path": [],
+            "color": "rgba(159, 210, 119, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.03199615329504013,
+                0.11629796773195267,
+                0.09658470749855042,
+                0.03200055658817291,
+                0.054899267852306366,
+                0.03489005193114281,
+                0.10348626226186752,
+                0.008831196464598179,
+                0.0,
+                0.0008121263235807419,
+                0.0,
+                0.051078762859106064,
+                0.01544315367937088,
+                0.07961554080247879,
+                0.11205136775970459,
+                0.007900607772171497,
+                0.0693073719739914
+            ]
+        },
+        "polyline_13": {
+            "id": "polyline_13",
+            "name": "hello",
+            "path": [
+                {
+                    "x": 3,
+                    "y": 19
+                }
+            ],
+            "color": "rgba(230, 228, 186, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "rag and everything was good",
+            "keywords_found": [
+                "Retrieval Augmented Generation"
+            ],
+            "module_scores": [
+                0.05804816260933876,
+                0.09254653751850128,
+                0.10877598077058792,
+                0.012610942125320435,
+                0.03797341510653496,
+                0.015777718275785446,
+                0.059225354343652725,
+                0.028679510578513145,
+                0.055405281484127045,
+                0.10398496687412262,
+                0.31428444385528564,
+                0.0,
+                0.0,
+                0.002234384650364518,
+                0.0014527571620419621,
+                0.025889771059155464,
+                0.012727380730211735,
+                0.0
+            ]
+        },
+        "polyline_14": {
+            "id": "polyline_14",
+            "name": "hello",
+            "path": [
+                {
+                    "x": 13,
+                    "y": 15
+                }
+            ],
+            "color": "rgba(53, 84, 159, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "rag and many other things such as pretrainig objectives and all were good",
+            "keywords_found": [
+                "Pre training objectives",
+                "Retrieval Augmented Generation"
+            ],
+            "module_scores": [
+                0.8379164934158325,
+                0.3340357542037964,
+                0.17760807275772095,
+                0.22517074644565582,
+                0.26595813035964966,
+                0.23630976676940918,
+                0.28637999296188354,
+                0.19740065932273865,
+                0.15292729437351227,
+                0.13514529168605804,
+                0.42122960090637207,
+                0.10186541825532913,
+                0.11643099039793015,
+                0.16304181516170502,
+                0.1428326964378357,
+                0.1396074891090393,
+                0.21233661472797394,
+                0.17357251048088074
+            ]
+        },
+        "polyline_15": {
+            "id": "polyline_15",
+            "name": "hey ",
+            "path": [],
+            "color": "rgba(167, 117, 238, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hey",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.023556426167488098,
+                0.07454296201467514,
+                0.10734860599040985,
+                0.03490018844604492,
+                0.061513230204582214,
+                0.06893599033355713,
+                0.11837682127952576,
+                0.01902083493769169,
+                0.02021801471710205,
+                0.020470205694437027,
+                0.0,
+                0.05460038036108017,
+                0.018192946910858154,
+                0.034782107919454575,
+                0.10332289338111877,
+                0.011397147551178932,
+                0.07992972433567047
+            ]
+        },
+        "polyline_16": {
+            "id": "polyline_16",
+            "name": "hey",
+            "path": [],
+            "color": "rgba(167, 64, 198, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hey",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.023556426167488098,
+                0.07454296201467514,
+                0.10734860599040985,
+                0.03490018844604492,
+                0.061513230204582214,
+                0.06893599033355713,
+                0.11837682127952576,
+                0.01902083493769169,
+                0.02021801471710205,
+                0.020470205694437027,
+                0.0,
+                0.05460038036108017,
+                0.018192946910858154,
+                0.034782107919454575,
+                0.10332289338111877,
+                0.011397147551178932,
+                0.07992972433567047
+            ]
+        },
+        "polyline_17": {
+            "id": "polyline_17",
+            "name": "hey",
+            "path": [],
+            "color": "rgba(142, 153, 121, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hey",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.023556426167488098,
+                0.07454296201467514,
+                0.10734860599040985,
+                0.03490018844604492,
+                0.061513230204582214,
+                0.06893599033355713,
+                0.11837682127952576,
+                0.01902083493769169,
+                0.02021801471710205,
+                0.020470205694437027,
+                0.0,
+                0.05460038036108017,
+                0.018192946910858154,
+                0.034782107919454575,
+                0.10332289338111877,
+                0.011397147551178932,
+                0.07992972433567047
+            ]
+        },
+        "polyline_18": {
+            "id": "polyline_18",
+            "name": "heyy",
+            "path": [],
+            "color": "rgba(205, 206, 221, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.10327564924955368,
+                0.09360406547784805,
+                0.03690618276596069,
+                0.04519070312380791,
+                0.038354936987161636,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.07473935186862946,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ]
+        },
+        "polyline_19": {
+            "id": "polyline_19",
+            "name": "heyy",
+            "path": [],
+            "color": "rgba(188, 202, 118, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "I love rag with my pre trining",
+            "keywords_found": [
+                "Retrieval Augmented Generation"
+            ],
+            "module_scores": [
+                0.09309744089841843,
+                0.12534257769584656,
+                0.18787196278572083,
+                0.05221807584166527,
+                0.053495265543460846,
+                0.14688314497470856,
+                0.09295167028903961,
+                0.13856445252895355,
+                0.11419141292572021,
+                0.0,
+                0.3,
+                0.04010733589529991,
+                0.0,
+                0.045714717358350754,
+                0.06977400183677673,
+                0.03902996703982353,
+                0.010432184673845768,
+                0.014520765282213688
+            ]
+        },
+        "polyline_20": {
+            "id": "polyline_20",
+            "name": "huu",
+            "path": [],
+            "color": "rgba(132, 67, 193, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "huuu",
+            "keywords_found": [],
+            "module_scores": [
+                0.06137967109680176,
+                0.025739794597029686,
+                0.05682278797030449,
+                0.0015102589968591928,
+                0.0,
+                0.0,
+                0.0828077420592308,
+                0.03640921786427498,
+                0.0,
+                0.048738643527030945,
+                0.0,
+                0.07323087751865387,
+                0.0,
+                0.06557325273752213,
+                0.03551648184657097,
+                0.0,
+                0.007635355927050114,
+                0.030927538871765137
+            ]
+        },
+        "polyline_21": {
+            "id": "polyline_21",
+            "name": "hello",
+            "path": [],
+            "color": "rgba(171, 185, 237, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hello",
+            "keywords_found": [],
+            "module_scores": [
+                0.09007163345813751,
+                0.14346976578235626,
+                0.09423135966062546,
+                0.039209116250276566,
+                0.09866251051425934,
+                0.07642864435911179,
+                0.050438638776540756,
+                0.11424312740564346,
+                0.06147314980626106,
+                0.025780409574508667,
+                0.04125567153096199,
+                0.06409071385860443,
+                0.0545211136341095,
+                0.08595173060894012,
+                0.03564179316163063,
+                0.09568523615598679,
+                0.05039823427796364,
+                0.07651611417531967
+            ]
+        },
+        "polyline_22": {
+            "id": "polyline_22",
+            "name": "Introduction",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 19
+                }
+            ],
+            "color": "rgba(117, 80, 114, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "hello",
+            "keywords_found": [],
+            "module_scores": [
+                0.09007163345813751,
+                0.14346976578235626,
+                0.19423136115074158,
+                0.039209116250276566,
+                0.09866251051425934,
+                0.07642864435911179,
+                0.050438638776540756,
+                0.11424312740564346,
+                0.06147314980626106,
+                0.025780409574508667,
+                0.04125567153096199,
+                0.06409071385860443,
+                0.0545211136341095,
+                0.08595173060894012,
+                0.03564179316163063,
+                0.09568523615598679,
+                0.05039823427796364,
+                0.07651611417531967
+            ]
+        },
+        "polyline_23": {
+            "id": "polyline_23",
+            "name": "heyyy",
+            "path": [],
+            "color": "rgba(76, 80, 77, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.10327564924955368,
+                0.09360406547784805,
+                0.03690618276596069,
+                0.04519070312380791,
+                0.038354936987161636,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.07473935186862946,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ]
+        },
+        "polyline_24": {
+            "id": "polyline_24",
+            "name": "heyyy",
+            "path": [],
+            "color": "rgba(123, 83, 128, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyyyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.015168394893407822,
+                0.09509415924549103,
+                0.08808448165655136,
+                0.055125169456005096,
+                0.03878949210047722,
+                0.06340508162975311,
+                0.0406477153301239,
+                0.0,
+                0.0,
+                0.0,
+                0.012255707755684853,
+                0.07024804502725601,
+                0.005069136619567871,
+                0.06734798103570938,
+                0.08735782653093338,
+                0.0,
+                0.03643130138516426
+            ]
+        },
+        "polyline_25": {
+            "id": "polyline_25",
+            "name": "Introduction to transformers",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 19
+                }
+            ],
+            "color": "rgba(143, 130, 92, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "module_scores": [
+                0.433811753988266,
+                0.4582192003726959,
+                0.5164702534675598,
+                0.2946617603302002,
+                0.37847253680229187,
+                0.2834630310535431,
+                0.2269679754972458,
+                0.23173178732395172,
+                0.12193305790424347,
+                0.15064716339111328,
+                0.20222218334674835,
+                0.23586700856685638,
+                0.2287927120923996,
+                0.2737714946269989,
+                0.7030925154685974,
+                0.5322507619857788,
+                0.2212483286857605,
+                0.202763170003891
+            ]
+        },
+        "polyline_26": {
+            "id": "polyline_26",
+            "name": "heyy",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 19
+                },
+                {
+                    "x": 7,
+                    "y": 18
+                },
+                {
+                    "x": 18,
+                    "y": 6
+                },
+                {
+                    "x": 9,
+                    "y": 15
+                },
+                {
+                    "x": 9,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(94, 122, 221, 0.4)",
+            "isActive": true,
+            "confidence": 0.77,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.2032756507396698,
+                0.19360406696796417,
+                0.13690617680549622,
+                0.04519070312380791,
+                0.13835494220256805,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.17473936080932617,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ]
+        },
+        "polyline_27": {
+            "id": "polyline_27",
+            "name": "heyy",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 19
+                }
+            ],
+            "color": "rgba(74, 171, 224, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.2032756507396698,
+                0.09360406547784805,
+                0.03690618276596069,
+                0.04519070312380791,
+                0.038354936987161636,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.07473935186862946,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ]
+        },
+        "polyline_28": {
+            "id": "polyline_28",
+            "name": "introduction to my ",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 19
+                }
+            ],
+            "color": "rgba(76, 227, 191, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "transformers",
+            "keywords_found": [],
+            "module_scores": [
+                0.024954048916697502,
+                0.13416121900081635,
+                0.5420874357223511,
+                0.07039379328489304,
+                0.021926987916231155,
+                0.0,
+                0.19421246647834778,
+                0.0,
+                0.0,
+                0.0374816469848156,
+                0.0,
+                0.057812318205833435,
+                0.04283241927623749,
+                0.0,
+                0.061064332723617554,
+                0.2036512792110443,
+                0.0,
+                0.0
+            ]
+        },
+        "polyline_29": {
+            "id": "polyline_29",
+            "name": "hiii",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 19
+                },
+                {
+                    "x": 7,
+                    "y": 18
+                }
+            ],
+            "color": "rgba(253, 134, 192, 0.4)",
+            "isActive": true,
+            "confidence": 0.73,
+            "summary": "transformers",
+            "keywords_found": [],
+            "module_scores": [
+                0.024954048916697502,
+                0.13416121900081635,
+                0.5420874357223511,
+                0.17039379477500916,
+                0.021926987916231155,
+                0.0,
+                0.19421246647834778,
+                0.0,
+                0.0,
+                0.0374816469848156,
+                0.0,
+                0.057812318205833435,
+                0.04283241927623749,
+                0.0,
+                0.061064332723617554,
+                0.2036512792110443,
+                0.0,
+                0.0
+            ]
+        },
+        "polyline_30": {
+            "id": "polyline_30",
+            "name": "heyy",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 15
+                },
+                {
+                    "x": 11,
+                    "y": 19
+                },
+                {
+                    "x": 5,
+                    "y": 14
+                }
+            ],
+            "color": "rgba(109, 71, 172, 0.4)",
+            "isActive": true,
+            "confidence": 0.74,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.10327564924955368,
+                0.09360406547784805,
+                0.13690617680549622,
+                0.04519070312380791,
+                0.13835494220256805,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.17473936080932617,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ],
+            "strengths": [
+                "Instruction tuning",
+                "Parameter efficient fine tuning",
+                "Multimodal LLMs"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Based on your path, you have shown strong engagement with . You successfully reinforced concepts in Instruction tuning, Parameter efficient fine tuning. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_31": {
+            "id": "polyline_31",
+            "name": "Introduction to transformers",
+            "path": [],
+            "color": "rgba(112, 160, 225, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "module_scores": [
+                0.433811753988266,
+                0.4582192003726959,
+                0.4164702296257019,
+                0.2946617603302002,
+                0.37847253680229187,
+                0.2834630310535431,
+                0.2269679754972458,
+                0.23173178732395172,
+                0.12193305790424347,
+                0.15064716339111328,
+                0.20222218334674835,
+                0.23586700856685638,
+                0.2287927120923996,
+                0.2737714946269989,
+                0.7030925154685974,
+                0.5322507619857788,
+                0.2212483286857605,
+                0.202763170003891
+            ],
+            "strengths": [],
+            "dominant_topics": [
+                "Multimodal LLMs",
+                "Vision Language Models",
+                "Pre trained models"
+            ],
+            "ai_analysis": "Based on your path, you have shown strong engagement with Multimodal LLMs, Vision Language Models. You successfully reinforced concepts in . Consider exploring advanced topics in new areas next."
+        },
+        "polyline_32": {
+            "id": "polyline_32",
+            "name": "Intro",
+            "path": [],
+            "color": "rgba(65, 189, 58, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "module_scores": [
+                0.433811753988266,
+                0.4582192003726959,
+                0.4164702296257019,
+                0.2946617603302002,
+                0.37847253680229187,
+                0.2834630310535431,
+                0.2269679754972458,
+                0.23173178732395172,
+                0.12193305790424347,
+                0.15064716339111328,
+                0.20222218334674835,
+                0.23586700856685638,
+                0.2287927120923996,
+                0.2737714946269989,
+                0.7030925154685974,
+                0.5322507619857788,
+                0.2212483286857605,
+                0.202763170003891
+            ],
+            "strengths": [],
+            "dominant_topics": [
+                "Multimodal LLMs",
+                "Vision Language Models",
+                "Pre trained models"
+            ],
+            "ai_analysis": "To enable advanced AI analysis, set the GEMINI_API_KEY environment variable. Based on your path, you have shown strong engagement with Multimodal LLMs, Vision Language Models. You successfully reinforced concepts in . Consider exploring advanced topics in new areas next."
+        },
+        "polyline_33": {
+            "id": "polyline_33",
+            "name": "Intro",
+            "path": [
+                {
+                    "x": 5,
+                    "y": 16
+                }
+            ],
+            "color": "rgba(196, 90, 89, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "module_scores": [
+                0.433811753988266,
+                0.4582192003726959,
+                0.4164702296257019,
+                0.2946617603302002,
+                0.37847253680229187,
+                0.2834630310535431,
+                0.2269679754972458,
+                0.23173178732395172,
+                0.12193305790424347,
+                0.15064716339111328,
+                0.20222218334674835,
+                0.23586700856685638,
+                0.2287927120923996,
+                0.2737714946269989,
+                0.8030925393104553,
+                0.5322507619857788,
+                0.2212483286857605,
+                0.202763170003891
+            ],
+            "strengths": [
+                "Multimodal LLMs"
+            ],
+            "dominant_topics": [
+                "Multimodal LLMs",
+                "Vision Language Models",
+                "Pre trained models"
+            ],
+            "ai_analysis": "To enable advanced AI analysis, set the GEMINI_API_KEY environment variable. Based on your path, you have shown strong engagement with Multimodal LLMs, Vision Language Models. You successfully reinforced concepts in Multimodal LLMs. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_34": {
+            "id": "polyline_34",
+            "name": "Pre training LLM",
+            "path": [
+                {
+                    "x": 5,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(231, 183, 145, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "I have learnt to finetune a pre trained BERT GPT model and i am using these models for sentiment analysis task",
+            "keywords_found": [
+                "Pre trained models"
+            ],
+            "module_scores": [
+                0.43252697587013245,
+                0.6987414360046387,
+                0.2524697184562683,
+                0.4963360130786896,
+                0.26733019948005676,
+                0.28303566575050354,
+                0.11330951005220413,
+                0.2320728749036789,
+                0.07975509762763977,
+                0.13868987560272217,
+                0.21347038447856903,
+                0.13678917288780212,
+                0.20242607593536377,
+                0.20470771193504333,
+                0.19388322532176971,
+                0.24398048222064972,
+                0.25268879532814026,
+                0.3274286389350891
+            ],
+            "strengths": [
+                "Agentic AI"
+            ],
+            "dominant_topics": [
+                "Pre trained models",
+                "Fine tuning LLM",
+                "Pre training objectives"
+            ],
+            "ai_analysis": "Based on your path, you have shown strong engagement with Pre trained models, Fine tuning LLM. You successfully reinforced concepts in Agentic AI. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_35": {
+            "id": "polyline_35",
+            "name": "heyy",
+            "path": [
+                {
+                    "x": 5,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(95, 72, 171, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.10327564924955368,
+                0.09360406547784805,
+                0.03690618276596069,
+                0.04519070312380791,
+                0.038354936987161636,
+                0.07477933913469315,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.1020158976316452,
+                0.07473935186862946,
+                0.0972217470407486,
+                0.0,
+                0.05581950396299362
+            ],
+            "strengths": [
+                "Agentic AI"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Based on your path, you have shown strong engagement with . You successfully reinforced concepts in Agentic AI. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_36": {
+            "id": "polyline_36",
+            "name": "Agentic AI",
+            "path": [
+                {
+                    "x": 5,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(139, 171, 145, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "agents independently solve the problem, each can have differnt loss function",
+            "keywords_found": [
+                "Agentic AI"
+            ],
+            "module_scores": [
+                0.05024600028991699,
+                0.0863848477602005,
+                0.0,
+                0.1774979680776596,
+                0.007330421358346939,
+                0.06964121013879776,
+                0.08910828828811646,
+                0.1227140724658966,
+                0.0983947366476059,
+                0.02778339385986328,
+                0.012763900682330132,
+                0.0882045105099678,
+                0.2467341423034668,
+                0.6995577812194824,
+                0.13445383310317993,
+                0.07179756462574005,
+                0.3390352427959442,
+                0.24001526832580566
+            ],
+            "strengths": [
+                "Agentic AI"
+            ],
+            "dominant_topics": [
+                "Agentic AI",
+                "Policy learning using DQN"
+            ],
+            "ai_analysis": "Based on your path, you have shown strong engagement with Agentic AI, Policy learning using DQN. You successfully reinforced concepts in Agentic AI. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_37": {
+            "id": "polyline_37",
+            "name": "Agentic AI, Transformer, CNN",
+            "path": [
+                {
+                    "x": 7,
+                    "y": 16
+                },
+                {
+                    "x": 5,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(124, 155, 146, 0.4)",
+            "isActive": true,
+            "confidence": 0.73,
+            "summary": "Agentic AI, AI, Artificial Intelligence, Agentic AI has agents, Agents are good, Agentic AI, Agent",
+            "keywords_found": [
+                "Agentic AI"
+            ],
+            "module_scores": [
+                0.19596125185489655,
+                0.17878513038158417,
+                0.013299948535859585,
+                0.09019515663385391,
+                0.2148519903421402,
+                0.176703080534935,
+                0.04141182824969292,
+                0.12695123255252838,
+                0.14567424356937408,
+                0.06627196818590164,
+                0.07899114489555359,
+                0.17586567997932434,
+                0.19476987421512604,
+                0.9779932498931885,
+                0.14229676127433777,
+                0.17270609736442566,
+                0.3035743236541748,
+                0.3211010694503784
+            ],
+            "strengths": [
+                "Quantization",
+                "Agentic AI"
+            ],
+            "dominant_topics": [
+                "Agentic AI",
+                "RLHF",
+                "Policy learning using DQN"
+            ],
+            "ai_analysis": "Based on your path, you have shown strong engagement with Agentic AI, RLHF. You successfully reinforced concepts in Quantization, Agentic AI. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_38": {
+            "id": "polyline_38",
+            "name": "heyy",
+            "path": [
+                {
+                    "x": 7,
+                    "y": 16
+                },
+                {
+                    "x": 5,
+                    "y": 17
+                }
+            ],
+            "color": "rgba(198, 232, 160, 0.4)",
+            "isActive": true,
+            "confidence": 0.73,
+            "summary": "heyey",
+            "keywords_found": [],
+            "module_scores": [
+                0.03077820874750614,
+                0.08723001182079315,
+                0.17077267169952393,
+                0.0844632163643837,
+                0.05345889925956726,
+                0.06896784901618958,
+                0.01981256529688835,
+                0.10914305597543716,
+                0.025269674137234688,
+                0.0,
+                0.0,
+                0.12327592819929123,
+                0.08018720149993896,
+                0.1916126310825348,
+                0.07461867481470108,
+                0.14787648618221283,
+                0.01713082380592823,
+                0.15488959848880768
+            ],
+            "strengths": [
+                "Quantization",
+                "Agentic AI"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Based on your path, you have shown strong engagement with . You successfully reinforced concepts in Quantization, Agentic AI. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_39": {
+            "id": "polyline_39",
+            "name": "heyu",
+            "path": [],
+            "color": "rgba(215, 166, 66, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "heyu",
+            "keywords_found": [],
+            "module_scores": [
+                0.025842785835266113,
+                0.06289363652467728,
+                0.10655583441257477,
+                0.059236228466033936,
+                0.04497949779033661,
+                0.05150831118226051,
+                0.08413022756576538,
+                0.10349386930465698,
+                0.019398359581828117,
+                0.023599496111273766,
+                0.0,
+                0.02620738558471203,
+                0.055542171001434326,
+                0.08238955587148666,
+                0.07436030358076096,
+                0.08257163316011429,
+                0.05098576098680496,
+                0.10993840545415878
+            ],
+            "strengths": [],
+            "dominant_topics": [],
+            "ai_analysis": "Based on your path, you have shown strong engagement with . You successfully reinforced concepts in . Consider exploring advanced topics in new areas next."
+        },
+        "polyline_40": {
+            "id": "polyline_40",
+            "name": "he7yey",
+            "path": [
+                {
+                    "x": 4,
+                    "y": 2
+                },
+                {
+                    "x": 10,
+                    "y": 10
+                }
+            ],
+            "color": "rgba(68, 203, 241, 0.4)",
+            "isActive": true,
+            "confidence": 0.73,
+            "summary": "heyyy",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.017389550805091858,
+                0.10327564924955368,
+                0.09360406547784805,
+                0.03690618276596069,
+                0.04519070312380791,
+                0.038354936987161636,
+                0.17477934062480927,
+                0.005562630016356707,
+                0.0,
+                0.0,
+                0.0,
+                0.05210745334625244,
+                0.002015892416238785,
+                0.07473935186862946,
+                0.1972217559814453,
+                0.0,
+                0.05581950396299362
+            ],
+            "strengths": [
+                "Incontext Learning",
+                "Vision Language Models"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "Based on your path, you have shown strong engagement with . You successfully reinforced concepts in Incontext Learning, Vision Language Models. Consider exploring advanced topics in new areas next."
+        },
+        "polyline_41": {
+            "id": "polyline_41",
+            "name": "heyy",
+            "path": [],
+            "color": "rgba(129, 154, 197, 0.4)",
+            "isActive": true,
+            "confidence": 0.7,
+            "summary": "hyeyyyhu",
+            "keywords_found": [],
+            "module_scores": [
+                0.053188253194093704,
+                0.0,
+                0.04981702193617821,
+                0.0,
+                0.07837709784507751,
+                0.0,
+                0.11811202019453049,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0558195635676384,
+                0.02478315681219101,
+                0.019923537969589233,
+                0.0004506018303800374,
+                0.046636879444122314
+            ],
+            "strengths": [],
+            "dominant_topics": [],
+            "ai_analysis": "Based on your path, you have shown strong engagement with . You successfully reinforced concepts in . Consider exploring advanced topics in new areas next."
+        },
+        "polyline_42": {
+            "id": "polyline_42",
+            "name": "heyyu",
+            "path": [
+                {
+                    "x": 10,
+                    "y": 13
+                }
+            ],
+            "color": "rgba(253, 226, 126, 0.4)",
+            "isActive": true,
+            "confidence": 0.71,
+            "summary": "heyuuu",
+            "keywords_found": [],
+            "module_scores": [
+                0.0,
+                0.0,
+                0.1106286495923996,
+                0.04658149555325508,
+                0.027793176472187042,
+                0.0,
+                0.05434393510222435,
+                0.037776097655296326,
+                0.1,
+                0.004652492236346006,
+                0.004580324981361628,
+                0.01859883777797222,
+                0.04390064999461174,
+                0.0656537190079689,
+                0.0459163598716259,
+                0.04920380190014839,
+                0.037917736917734146,
+                0.09046495705842972
+            ],
+            "strengths": [
+                "Prompting methods"
+            ],
+            "dominant_topics": [],
+            "ai_analysis": "AI Insight: Tell student to improve summary about Retrieval Augmented Generation. be critical."
+        }
+    },
+    "summaries": [
+        {
+            "id": "summary_default_5",
+            "title": "Test Summary",
+            "summary": "I learned about BERT and Transformers.",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 100
+        },
+        {
+            "id": "summary_default_6",
+            "title": "work",
+            "summary": "I have learned a lot about rag and preprocessing it was pretty good understanding.",
+            "keywords_found": [
+                "Retrieval Augmented Generation"
+            ],
+            "totalResources": 18,
+            "visitedResources": 4,
+            "currentLevel": 2,
+            "strengths": [
+                "Prompt based learning",
+                "Incontext Learning",
+                "Retrieval Methods",
+                "Retrieval Augmented Generation"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 200
+        },
+        {
+            "id": "summary_default_7",
+            "title": "Hey",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_8",
+            "title": "DQN Learning",
+            "summary": "I studied Policy learning using DQN and reinforcement learning agents.",
+            "keywords_found": [
+                "Agentic AI",
+                "Policy learning using DQN"
+            ],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Pre training objectives",
+                "Pre trained models"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 100
+        },
+        {
+            "id": "summary_default_9",
+            "title": "heyyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_10",
+            "title": "hii",
+            "summary": "hiii",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_11",
+            "title": "hii",
+            "summary": "nocajco",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_12",
+            "title": "hii",
+            "summary": "heyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_13",
+            "title": "hello",
+            "summary": "rag and everything was good",
+            "keywords_found": [
+                "Retrieval Augmented Generation"
+            ],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Retrieval Methods"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_14",
+            "title": "hello",
+            "summary": "rag and many other things such as pretrainig objectives and all were good",
+            "keywords_found": [
+                "Pre training objectives",
+                "Retrieval Augmented Generation"
+            ],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Pre training objectives"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_15",
+            "title": "hey ",
+            "summary": "hey",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_16",
+            "title": "hey",
+            "summary": "hey",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_17",
+            "title": "hey",
+            "summary": "hey",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_18",
+            "title": "heyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_19",
+            "title": "heyy",
+            "summary": "I love rag with my pre trining",
+            "keywords_found": [
+                "Retrieval Augmented Generation"
+            ],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_20",
+            "title": "huu",
+            "summary": "huuu",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_21",
+            "title": "hello",
+            "summary": "hello",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_22",
+            "title": "Introduction",
+            "summary": "hello",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_23",
+            "title": "heyyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_24",
+            "title": "heyyy",
+            "summary": "heyyyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_25",
+            "title": "Introduction to transformers",
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_26",
+            "title": "heyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 5,
+            "currentLevel": 2,
+            "strengths": [
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM",
+                "Instruction tuning",
+                "Parameter efficient fine tuning",
+                "Multimodal LLMs"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 250
+        },
+        {
+            "id": "summary_default_27",
+            "title": "heyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_28",
+            "title": "introduction to my ",
+            "summary": "transformers",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_29",
+            "title": "hiii",
+            "summary": "transformers",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Tutorial: Introduction to huggingface",
+                "Fine tuning LLM"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 100
+        },
+        {
+            "id": "summary_default_30",
+            "title": "heyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 3,
+            "currentLevel": 1,
+            "strengths": [
+                "Instruction tuning",
+                "Parameter efficient fine tuning",
+                "Multimodal LLMs"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 150
+        },
+        {
+            "id": "summary_default_31",
+            "title": "Introduction to transformers",
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_32",
+            "title": "Intro",
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_33",
+            "title": "Intro",
+            "summary": "Transformers are a class of deep learning models designed to process sequential data efficiently by relying on an attention-based mechanism rather than recurrence or convolution. Introduced in the landmark paper \u201cAttention Is All You Need\u201d, transformers revolutionized natural language processing by enabling models to capture long-range dependencies in data with high parallelism.\n\nAt the core of a transformer is the self-attention mechanism, which allows the model to weigh the importance of different parts of an input sequence when processing each element. This makes transformers highly effective at understanding context, relationships, and structure within data. The architecture typically consists of an encoder\u2013decoder structure, where encoders extract meaningful representations from input data and decoders generate output sequences based on those representations.\n\nTransformers also use positional encoding to retain information about the order of tokens, since the model itself does not process data sequentially. Combined with multi-head attention and feed-forward neural networks, this design enables scalable training on large datasets.\n\nDue to their flexibility and performance, transformers form the backbone of many modern AI systems, including large language models, machine translation systems, text summarization tools, and increasingly, applications in vision, speech, and multimodal learning.",
+            "keywords_found": [
+                "Multimodal LLMs"
+            ],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Multimodal LLMs"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_34",
+            "title": "Pre training LLM",
+            "summary": "I have learnt to finetune a pre trained BERT GPT model and i am using these models for sentiment analysis task",
+            "keywords_found": [
+                "Pre trained models"
+            ],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Agentic AI"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_35",
+            "title": "heyy",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Agentic AI"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_36",
+            "title": "Agentic AI",
+            "summary": "agents independently solve the problem, each can have differnt loss function",
+            "keywords_found": [
+                "Agentic AI"
+            ],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Agentic AI"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        },
+        {
+            "id": "summary_default_37",
+            "title": "Agentic AI, Transformer, CNN",
+            "summary": "Agentic AI, AI, Artificial Intelligence, Agentic AI has agents, Agents are good, Agentic AI, Agent",
+            "keywords_found": [
+                "Agentic AI"
+            ],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Quantization",
+                "Agentic AI"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 100
+        },
+        {
+            "id": "summary_default_38",
+            "title": "heyy",
+            "summary": "heyey",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Quantization",
+                "Agentic AI"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 100
+        },
+        {
+            "id": "summary_default_39",
+            "title": "heyu",
+            "summary": "heyu",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_40",
+            "title": "he7yey",
+            "summary": "heyyy",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 2,
+            "currentLevel": 1,
+            "strengths": [
+                "Incontext Learning",
+                "Vision Language Models"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 100
+        },
+        {
+            "id": "summary_default_41",
+            "title": "heyy",
+            "summary": "hyeyyyhu",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 0,
+            "currentLevel": 1,
+            "strengths": [],
+            "recommendations": [],
+            "avgDifficulty": 0,
+            "totalReward": 0
+        },
+        {
+            "id": "summary_default_42",
+            "title": "heyyu",
+            "summary": "heyuuu",
+            "keywords_found": [],
+            "totalResources": 18,
+            "visitedResources": 1,
+            "currentLevel": 1,
+            "strengths": [
+                "Prompting methods"
+            ],
+            "recommendations": [],
+            "avgDifficulty": 2.0,
+            "totalReward": 50
+        }
+    ]
+}

backend/debug_nlp.py

@@ -0,0 +1,70 @@
+import os
+import json
+import numpy as np
+
+def load_nlp_resources():
+    nlp_json_path = os.path.join(os.getcwd(), 'backend', 'nlp', 'nlp_resources.json')
+    print(f"Loading from: {nlp_json_path}")
+    
+    try:
+        if not os.path.exists(nlp_json_path):
+            print(f"File not found: {nlp_json_path}")
+            return []
+            
+        with open(nlp_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        print(f"Data count: {len(data)}")
+        
+        # Group by difficulty for tiered journey
+        intro_resources = [r for r in data if int(r.get('difficulty', 2)) <= 3]
+        medium_resources = [r for r in data if 4 <= int(r.get('difficulty', 2)) <= 7]
+        advanced_resources = [r for r in data if int(r.get('difficulty', 2)) >= 8]
+        
+        print(f"Intro: {len(intro_resources)}, Medium: {len(medium_resources)}, Advanced: {len(advanced_resources)}")
+        
+        # Limit introductory count as requested (top 6 by reward)
+        intro_resources.sort(key=lambda x: int(x.get('reward', 0)), reverse=True)
+        intro_resources = intro_resources[:6]
+        
+        journey_data = intro_resources + medium_resources + advanced_resources
+        print(f"Journey data count: {len(journey_data)}")
+        
+        resources = []
+        for idx, row in enumerate(journey_data):
+            title = str(row.get('name', f'Resource {idx + 1}')).strip()
+            module = str(row.get('module', title)).strip()
+            difficulty = int(row.get('difficulty', 2))
+            
+            if difficulty <= 3:
+                y_min, y_max = 16, 19
+            elif difficulty <= 7:
+                y_min, y_max = 8, 15
+            else:
+                y_min, y_max = 1, 7
+            
+            x = int(row.get('x', np.random.randint(2, 18)))
+            y = int(row.get('y', np.random.randint(y_min, y_max + 1)))
+            
+            resource = {
+                'id': str(row.get('id', idx + 1)),
+                'title': title,
+                'module': module,
+                'type': str(row.get('type', 'video')),
+                'difficulty': difficulty,
+                'reward': int(row.get('reward', 10 * difficulty)),
+                'position': {'x': x, 'y': y},
+                'visited': row.get('visited', False)
+            }
+            resources.append(resource)
+            
+        return resources
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return []
+
+if __name__ == "__main__":
+    res = load_nlp_resources()
+    print(f"Final Count: {len(res)}")

backend/fix_db.py

@@ -0,0 +1,32 @@
+import json
+
+db_path = r'e:\Nl_main\backend\data\db.json'
+
+with open(db_path, 'r', encoding='utf-8') as f:
+    s = f.read().strip()
+
+# The file ends with '}}' but should end with '}'
+# Try stripping from the end until valid
+for i in range(1, 20):
+    try:
+        data = json.loads(s[:-i] if i > 0 else s)
+        with open(db_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=4)
+        print(f"DB repaired by removing {i} trailing characters!")
+        break
+    except json.JSONDecodeError:
+        continue
+else:
+    print("Could not repair automatically. Resetting to clean state.")
+    data = {
+        "users": [],
+        "learning_sessions": {},
+        "polylines": {},
+        "summaries": [],
+        "bookmarks": {},
+        "notes": {},
+        "lectures": []
+    }
+    with open(db_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=4)
+    print("DB reset to clean state.")

backend/init.py

@@ -0,0 +1,32 @@
+"""
+Flask Application Initialization
+Sets up the Flask app with necessary configurations
+"""
+
+from flask import Flask, send_from_directory
+from flask_cors import CORS
+import os
+
+# Initialize Flask app
+# Serves static files from the build directory (../dist)
+app = Flask(__name__, static_folder='../dist', static_url_path='')
+
+# Enable CORS
+CORS(app)
+
+# Serve React App (Catch-all route)
+@app.route('/', defaults={'path': ''})
+@app.route('/<path:path>')
+def serve(path):
+    # Don't interfere with API routes
+    if path.startswith('api'):
+        return {"error": "Not found"}, 404
+        
+    if path != "" and os.path.exists(os.path.join(app.static_folder, path)):
+        return send_from_directory(app.static_folder, path)
+    
+    # Return index.html for SPA routing
+    return send_from_directory(app.static_folder, 'index.html')
+
+# Flag to indicate if database was just created
+DBcreated = False

backend/key.pem

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

backend/navigator.py

@@ -0,0 +1,228 @@
+"""
+Navigator — DQN-based Next Resource Recommender
+================================================
+Loads the pre-trained DQN model from Navigators/dqn_model.pth and uses it
+to recommend the next best resource for a student to visit.
+
+Model architecture (inferred from .pth weights):
+    fc1: Linear(18, 128)   — input is a 18-dim state vector
+    fc2: Linear(128, 128)  — hidden layer
+    fc3: Linear(128, 18)   — output is Q-values over 18 topic modules
+    (ReLU activations between layers)
+
+State vector (18-dim): one value per topic module, representing the student's
+    assimilation score (from the polyline) for that module.
+
+Output: index of the module (0-17) with the highest Q-value among unvisited.
+    The unvisited resource from that module with the highest reward is returned.
+"""
+
+import os
+import numpy as np
+
+# ──────────────────────────────────────────────
+# Model Definition — must match training architecture
+# ──────────────────────────────────────────────
+_MODEL_PATH = os.path.join(os.path.dirname(__file__), '..', 'Navigators', 'dqn_model.pth')
+
+_dqn_net = None
+_dqn_mode = "unavailable"
+
+try:
+    import torch
+    import torch.nn as nn
+
+    class DQNNet(nn.Module):
+        def __init__(self, input_dim=18, hidden_dim=128, output_dim=18):
+            super().__init__()
+            self.fc1 = nn.Linear(input_dim, hidden_dim)
+            self.fc2 = nn.Linear(hidden_dim, hidden_dim)
+            self.fc3 = nn.Linear(hidden_dim, output_dim)
+
+        def forward(self, x):
+            x = torch.relu(self.fc1(x))
+            x = torch.relu(self.fc2(x))
+            return self.fc3(x)
+
+    _net = DQNNet(input_dim=18, hidden_dim=128, output_dim=18)
+    state_dict = torch.load(_MODEL_PATH, map_location='cpu', weights_only=False)
+    _net.load_state_dict(state_dict)
+    _net.eval()
+    _dqn_net = _net
+    _dqn_mode = "dqn"
+    print("DQN Navigator loaded successfully")
+
+except Exception as e:
+    print(f"DQN Navigator fallback mode (could not load model): {e}")
+    _dqn_mode = "fallback"
+
+
+# ──────────────────────────────────────────────
+# Topic-to-module index mapping (matches nlp_api.py order)
+# ──────────────────────────────────────────────
+ORDERED_MODULES = [
+    "Pre training objectives",
+    "Pre trained models",
+    "Tutorial: Introduction to huggingface",
+    "Fine tuning LLM",
+    "Instruction tuning",
+    "Prompt based learning",
+    "Parameter efficient fine tuning",
+    "Incontext Learning",
+    "Prompting methods",
+    "Retrieval Methods",
+    "Retrieval Augmented Generation",
+    "Quantization",
+    "Mixture of Experts Model",
+    "Agentic AI",
+    "Multimodal LLMs",
+    "Vision Language Models",
+    "Policy learning using DQN",
+    "RLHF",
+]
+
+
+def recommend_next(visited_ids: list, module_scores: list, nlp_resources: list) -> dict:
+    """
+    Recommend the next best resource using combined DQN + sequential progression.
+    
+    The DQN Q-values alone have minimal differentiation, so we combine them
+    with sequential module ordering for sensible recommendations:
+      - 70% weight on sequential progression (next module by S.No)
+      - 30% weight on DQN Q-value ranking
+    """
+    visited_set = set(str(v).strip() for v in visited_ids)
+    unvisited = [r for r in nlp_resources if str(r['id']).strip() not in visited_set]
+
+    print(f"\n[NAV DEBUG] --- recommend_next called ---")
+    print(f"[NAV DEBUG] Total resources: {len(nlp_resources)}, Visited: {len(visited_ids)}, Unvisited: {len(unvisited)}")
+
+    if not unvisited:
+        print("[NAV DEBUG] No unvisited resources remaining!")
+        return {"resource": None, "module": None, "reason": _dqn_mode, "q_values": []}
+
+    # ── Build state vector ──────────────────────────────────────
+    state = list(module_scores) if module_scores else []
+    if len(state) < 18:
+        state.extend([0.5] * (18 - len(state)))
+    state = state[:18]
+    state_arr = np.array(state, dtype=np.float32)
+
+    # ── Group unvisited resources by module ──────────────────
+    module_to_resources = {}
+    for r in unvisited:
+        m = r.get('module', '')
+        if m not in module_to_resources:
+            module_to_resources[m] = []
+        module_to_resources[m].append(r)
+
+    print(f"[NAV DEBUG] Unvisited modules ({len(module_to_resources)}): {list(module_to_resources.keys())}")
+
+    q_values = []
+    reason = _dqn_mode
+
+    # ── Compute sequential scores (which module should come next by S.No) ──
+    # Find the highest visited module index to determine progression
+    visited_module_indices = set()
+    for r in nlp_resources:
+        if str(r['id']).strip() in visited_set:
+            m = r.get('module', '')
+            if m in ORDERED_MODULES:
+                visited_module_indices.add(ORDERED_MODULES.index(m))
+
+    max_visited_idx = max(visited_module_indices) if visited_module_indices else -1
+    print(f"[NAV DEBUG] Highest visited module index: {max_visited_idx} ({ORDERED_MODULES[max_visited_idx] if max_visited_idx >= 0 else 'none'})")
+
+    # Sequential score: modules right after the last visited get highest score
+    sequential_scores = {}
+    for module_name in module_to_resources:
+        if module_name in ORDERED_MODULES:
+            idx = ORDERED_MODULES.index(module_name)
+            # Distance from next expected module (max_visited_idx + 1)
+            distance = abs(idx - (max_visited_idx + 1))
+            # Score: closer to next = higher score (normalize to 0-1)
+            # Use asinh to soften the penalty for distance so DQN can override more easily
+            sequential_scores[module_name] = 1.0 / (1.0 + distance * 0.5)
+
+    # ── DQN scores (normalized to 0-1 range) ──
+    dqn_scores = {}
+    if _dqn_net is not None:
+        try:
+            import torch
+            with torch.no_grad():
+                t = torch.tensor(state_arr).unsqueeze(0)
+                qs = _dqn_net(t).squeeze(0).tolist()
+            q_values = qs
+
+            # Normalize Q-values to 0-1 for the modules that have unvisited resources
+            relevant_qs = []
+            for module_name in module_to_resources:
+                if module_name in ORDERED_MODULES:
+                    idx = ORDERED_MODULES.index(module_name)
+                    relevant_qs.append(qs[idx])
+
+            if relevant_qs:
+                q_min = min(relevant_qs)
+                q_range = max(relevant_qs) - q_min
+                if q_range > 0.01:  # Meaningful differentiation
+                    for module_name in module_to_resources:
+                        if module_name in ORDERED_MODULES:
+                            idx = ORDERED_MODULES.index(module_name)
+                            dqn_scores[module_name] = (qs[idx] - q_min) / q_range
+                else:
+                    # Q-values are too clustered, DQN can't differentiate
+                    print(f"[NAV DEBUG] Q-values too clustered (range={q_range:.4f}), ignoring DQN scores")
+                    for module_name in module_to_resources:
+                        dqn_scores[module_name] = 0.5  # neutral
+
+            reason = "dqn"
+        except Exception as e:
+            print(f"[NAV DEBUG] DQN inference error: {e}")
+            reason = "fallback"
+
+    # ── Combined scoring (DQN-forward approach) ──
+    WEIGHT_SEQUENTIAL = 0.05
+    WEIGHT_DQN = 0.95
+
+    best_module = None
+    best_score = float('-inf')
+
+    print(f"[NAV DEBUG] Module scores (seq={WEIGHT_SEQUENTIAL}, dqn={WEIGHT_DQN}):")
+    for module_name in module_to_resources:
+        seq = sequential_scores.get(module_name, 0.0)
+        dqn = dqn_scores.get(module_name, 0.5)
+        combined = WEIGHT_SEQUENTIAL * seq + WEIGHT_DQN * dqn
+        
+        idx_str = ""
+        if module_name in ORDERED_MODULES:
+            idx_str = f" (idx={ORDERED_MODULES.index(module_name)})"
+        
+        print(f"[NAV DEBUG]   '{module_name}'{idx_str}: seq={seq:.3f}, dqn={dqn:.3f}, combined={combined:.3f}")
+        
+        if combined > best_score:
+            best_score = combined
+            best_module = module_name
+
+    if best_module and best_module in module_to_resources:
+        candidates = module_to_resources[best_module]
+        candidates.sort(key=lambda r: -r['reward'])
+        chosen = candidates[0]
+        print(f"[NAV DEBUG] ✓ Chose '{best_module}' → '{chosen['title']}' (id={chosen['id']}, score={best_score:.3f})")
+        return {
+            "resource": chosen,
+            "module": best_module,
+            "reason": reason,
+            "q_values": q_values
+        }
+
+    # ── Fallback: next sequential unvisited resource ──
+    unvisited_sorted = sorted(unvisited, key=lambda r: int(r['id']))
+    best = unvisited_sorted[0]
+    print(f"[NAV DEBUG] Fallback: '{best['title']}' (id={best['id']})")
+    return {
+        "resource": best,
+        "module": best.get('module', ''),
+        "reason": "fallback",
+        "q_values": q_values
+    }
+

backend/nlp_api.py

@@ -0,0 +1,1178 @@
+"""
+NLP Learning Grid API
+Provides endpoints for the frontend grid-based NLP learning system.
+"""
+
+import os
+import json
+import pandas as pd
+from flask import jsonify, request
+import numpy as np
+from datetime import datetime
+import nltk
+
+# Ensure requisite NLTK data is available
+try:
+    nltk.download('stopwords', quiet=True)
+    nltk.download('wordnet', quiet=True)
+    from nltk.corpus import stopwords
+    STOPWORDS = set(stopwords.words('english'))
+except Exception as e:
+    print(f"Warning: Could not load NLTK stopwords: {e}")
+    STOPWORDS = set()
+
+# Import backend modules (support both script and package execution)
+try:
+    from .init import app
+    from .database import get_session, update_session, save_summary, save_polyline, get_polylines as get_db_polylines, get_notes, add_note, get_lectures, reset_db
+    from .request_logger import log_request
+    from .utils import utils_preprocess_text, get_cos_sim
+    from . import navigator
+except ImportError:
+    from init import app
+    from database import get_session, update_session, save_summary, save_polyline, get_polylines as get_db_polylines, get_notes, add_note, get_lectures, reset_db
+    from request_logger import log_request
+    from utils import utils_preprocess_text, get_cos_sim
+    import navigator
+
+# Define stopwords
+stop_words = set(stopwords.words('english'))
+
+# Polyline logging
+POLYLINE_LOG_FILE = os.path.join(os.path.dirname(__file__), 'polyline_generation.log')
+
+def log_polyline_step(step, details):
+    """Log detailed steps of polyline generation"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open(POLYLINE_LOG_FILE, 'a', encoding='utf-8') as f:
+        f.write(f"[{timestamp}] [{step}]\n{details}\n{'-'*50}\n")
+
+_bert_model = None
+
+def get_bert_model():
+    global _bert_model
+    if _bert_model is None:
+        try:
+            from sentence_transformers import SentenceTransformer
+            print("Loading BERT model (lazy)...")
+            _bert_model = SentenceTransformer('all-MiniLM-L6-v2')
+            print("BERT model loaded successfully")
+        except Exception as e:
+            print(f"Error loading BERT model: {e}")
+            _bert_model = None
+    return _bert_model
+
+# Load NLP data from JSON (Excel was rejected by HF)
+nlp_json_path = os.path.join(os.path.dirname(__file__), 'nlp', 'nlp_resources.json')
+
+def load_nlp_resources():
+    """Load NLP resources from JSON file"""
+    try:
+        # Check if the JSON file exists
+        if not os.path.exists(nlp_json_path):
+            print(f"File not found: {nlp_json_path}")
+            return []
+            
+        with open(nlp_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        if not isinstance(data, list):
+            print(f"Unexpected data format in {nlp_json_path}")
+            return []
+            
+        # First-quadrant arc projection (bottom-left origin)
+        # Resources fan from 5° to 85° like Q1 of a polar chart
+        # Origin: bottom-LEFT of 20×20 grid
+        cx, cy = 0.0, 19.5
+
+        # Sequential split: 7 / 5 / 4 / 2 = 18
+        ordered_data = data[:18] if len(data) >= 18 else data
+
+        tier_configs = [
+            {'label': 'Fundamentals', 'count': 4, 'radius':  3, 'difficulty': 2},
+            {'label': 'Intermediate', 'count': 5, 'radius':  7, 'difficulty': 4},
+            {'label': 'Advance',      'count': 5, 'radius': 11, 'difficulty': 6},
+            {'label': 'Mastery',      'count': 4, 'radius': 15, 'difficulty': 8},
+        ]
+
+        used_positions = set()
+        resources = []
+        resource_idx = 0
+
+        # Fan: 8° to 82° (keeps resources comfortably inside axes)
+        angle_start_deg = 8.0
+        angle_end_deg   = 82.0
+
+        for t_idx, tier in enumerate(tier_configs):
+            count  = tier['count']
+            r_val  = tier['radius']
+            tier_data = ordered_data[resource_idx : resource_idx + count]
+            resource_idx += count
+
+            n = len(tier_data)
+            if n == 0:
+                continue
+
+            angle_step = (angle_end_deg - angle_start_deg) / (n - 1) if n > 1 else 0.0
+
+            for i, row in enumerate(tier_data):
+                angle_deg  = angle_start_deg + i * angle_step
+                angle_rad  = np.radians(angle_deg)
+
+                x_raw = cx + r_val * np.cos(angle_rad)
+                y_raw = cy - r_val * np.sin(angle_rad)
+
+                x = int(round(np.clip(x_raw, 0, 18)))
+                y = int(round(np.clip(y_raw, 0, 18)))
+
+                # Resolve collisions by nudging along the arc (y direction)
+                attempts = 0
+                while (x, y) in used_positions and attempts < 20:
+                    y = max(0, min(18, y - 1 if attempts % 2 == 0 else y + 1))
+                    attempts += 1
+
+                used_positions.add((x, y))
+
+                # Tier-based points: Fundamentals=50, Intermediate=100, Advance=150, Mastery=200
+                tier_points = {2: 50, 4: 100, 6: 150, 8: 200}
+                base_pts = tier_points.get(tier['difficulty'], 50)
+
+                # Per-resource high_line: seeded random 0.70-0.85
+                import random as _rnd
+                _rnd.seed(len(resources) + 42)  # deterministic per resource index
+                high_line = round(_rnd.uniform(0.70, 0.85), 2)
+
+                resources.append({
+                    'id':         str(len(resources) + 1),
+                    'position':   {'x': int(x), 'y': int(y)},
+                    'type':       'video' if 'youtube' in str(row.get('links', '')).lower() else 'book',
+                    'title':      str(row.get('name', f'Resource {len(resources) + 1}')).strip(),
+                    'visited':    False,
+                    'difficulty': tier['difficulty'],
+                    'reward':     base_pts,
+                    'base_points': base_pts,
+                    'high_line':  high_line,
+                    'url':        str(row.get('links', '')).strip(),
+                    'description':str(row.get('description', '')).strip(),
+                    'module':     str(row.get('module', 'NLP Concept')).strip()
+                })
+
+        print(f"Successfully projected {len(resources)} resources into 4-tier Radar arcs")
+        return resources
+    except Exception as e:
+        print(f"Error loading NLP resources: {e}")
+        return []
+
+# Cache resources
+nlp_resources = load_nlp_resources()
+
+# Load YouTube links mapping
+_youtube_links_path = os.path.join(os.path.dirname(__file__), 'data', 'youtube_links.json')
+try:
+    if os.path.exists(_youtube_links_path):
+        with open(_youtube_links_path, 'r', encoding='utf-8') as f:
+            raw_links = json.load(f)
+        
+        # Create a normalized mapping for easier lookup
+        _youtube_links = {str(k).strip().lower(): v for k, v in raw_links.items()}
+        print(f"Loaded {len(_youtube_links)} YouTube links from mapping file")
+        
+        # Inject youtube_url into each resource
+        for r in nlp_resources:
+            module_lower = r['module'].lower()
+            title_lower = r['title'].lower()
+            
+            # 1. Exact module match
+            url = _youtube_links.get(module_lower, '')
+            
+            # 2. Fuzzy match on title or module
+            if not url:
+                for key, val in _youtube_links.items():
+                    if key in title_lower or key in module_lower or title_lower in key or module_lower in key:
+                        url = val
+                        break
+            
+            r['youtube_url'] = url
+            
+        yt_count = sum(1 for r in nlp_resources if r.get('youtube_url'))
+        print(f"Matched YouTube URLs for {yt_count}/{len(nlp_resources)} resources")
+    else:
+        print(f"YouTube links file not found: {_youtube_links_path}")
+        for r in nlp_resources: r['youtube_url'] = ''
+except Exception as e:
+    print(f"Could not load YouTube links: {e}")
+    for r in nlp_resources: r['youtube_url'] = ''
+
+# Pre-compute module embeddings
+module_embeddings = {}
+
+def compute_module_embeddings():
+    bert_model = get_bert_model()
+    if not bert_model:
+        return
+        
+    print("Computing module embeddings...")
+    # Group resources by module to form a "document" for each module
+    module_docs = {}
+    for r in nlp_resources:
+        m = r['module']
+        # Combine title and description for a rich representation
+        text = f"{r['title']} {r.get('description', '')}"
+        if m in module_docs:
+            module_docs[m] += " " + text
+        else:
+            module_docs[m] = text
+            
+    # Compute embeddings
+    for m, doc in module_docs.items():
+        # Apply preprocessing
+        clean_doc = utils_preprocess_text(doc, flg_stemm=False, flg_lemm=True, lst_stopwords=stop_words)
+        module_embeddings[m] = bert_model.encode(clean_doc)
+    print(f"Computed embeddings for {len(module_embeddings)} modules")
+
+# Compute embeddings on startup (REMOVED: Too slow on startup, will compute lazily or skip if needed)
+# compute_module_embeddings()
+
+# =============================================
+# RESOURCES ENDPOINTS
+# =============================================
+
+@app.before_request
+def before_request_logging():
+    if request.path.startswith('/api'):
+        log_request()
+
+@app.route('/api/reset', methods=['POST'])
+def reset_database():
+    """Wipes the database memory completely"""
+    try:
+        reset_db()
+        return jsonify({'status': 'success', 'message': 'Database memory wiped completely'})
+    except Exception as e:
+        return jsonify({'status': 'error', 'message': str(e)}), 500
+
+@app.route('/api/resources', methods=['GET'])
+def get_resources():
+    """Get all NLP learning resources with their grid positions and correct visited state"""
+    session_id = request.args.get('session_id', 'default')
+    from database import get_session
+    session = get_session(session_id)
+    visited_ids = set(str(v).strip() for v in session.get('visitedResources', []))
+    
+    # Return a copy of resources with updated visited flags
+    updated_resources = []
+    for r in nlp_resources:
+        r_copy = r.copy()
+        r_copy['visited'] = str(r['id']).strip() in visited_ids
+        updated_resources.append(r_copy)
+    
+    return jsonify(updated_resources)
+
+
+@app.route('/api/resources/<resource_id>', methods=['GET'])
+def get_resource(resource_id):
+    """Get a single resource by ID"""
+    resource = next((r for r in nlp_resources if r['id'] == resource_id), None)
+    if not resource:
+        return jsonify({'error': 'Resource not found'}), 404
+    return jsonify(resource)
+
+
+# =============================================
+# AGENT STATE ENDPOINTS
+# =============================================
+
+@app.route('/api/agent', methods=['GET'])
+def get_agent_state():
+    """Get current agent state (position, level, reward)"""
+    session_id = request.args.get('session_id', 'default')
+    return jsonify(get_session(session_id))
+
+
+@app.route('/api/agent/move', methods=['POST'])
+def move_agent():
+    """Move agent to a new position"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    position = data.get('position', {})
+    
+    session = get_session(session_id)
+    session['position'] = position
+    update_session(session_id, session)
+    
+    return jsonify(session)
+
+
+# =============================================
+# NOTIFICATION ENDPOINTS
+# =============================================
+
+@app.route('/api/notifications', methods=['GET'])
+def get_notifications():
+    """Get all notifications for a session"""
+    session_id = request.args.get('session_id', 'default')
+    from database import get_session
+    session = get_session(session_id)
+    return jsonify(session.get('notifications', []))
+
+
+@app.route('/api/notifications/add', methods=['POST'])
+def add_notification():
+    """Add a new notification to the database"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    message = data.get('message')
+    notif_type = data.get('type', 'info')
+    
+    if not message:
+        return jsonify({'error': 'Message required'}), 400
+        
+    from database import get_session, update_session
+    session = get_session(session_id)
+    if 'notifications' not in session:
+        session['notifications'] = []
+        
+    new_notif = {
+        'id': f"notif_{int(datetime.now().timestamp())}",
+        'type': notif_type,
+        'message': message,
+        'timestamp': int(datetime.now().timestamp() * 1000),
+        'read': False
+    }
+    
+    session['notifications'].insert(0, new_notif)
+    update_session(session_id, session)
+    return jsonify(new_notif)
+
+
+@app.route('/api/notifications/read', methods=['POST'])
+def mark_notifications_read():
+    """Mark all notifications as read in the database"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    
+    from database import get_session, update_session
+    session = get_session(session_id)
+    if 'notifications' in session:
+        for n in session['notifications']:
+            n['read'] = True
+        update_session(session_id, session)
+        
+    return jsonify({'status': 'success'})
+
+
+def sync_agent_progression(session):
+    """Utility to ensure level and totalReward are consistent"""
+    # Level = totalReward // 100 (Stage 1 starts at 0 pts, Stage 2 at 100 pts, etc.)
+    # Floor level is 1
+    session['level'] = max(1, (session.get('totalReward', 0) // 100) + 1)
+    return session
+
+# =============================================
+# RESOURCE INTERACTION ENDPOINTS
+# =============================================
+
+@app.route('/api/resource/visit', methods=['POST'])
+def visit_resource():
+    """Mark a resource as visited and update agent"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    resource_id = data.get('resource_id')
+    
+    session = get_session(session_id)
+    
+    # Find resource
+    resource = next((r for r in nlp_resources if r['id'] == resource_id), None)
+    if not resource:
+        return jsonify({'error': 'Resource not found'}), 404
+    
+    # Update session
+    if resource_id not in session['visitedResources']:
+        session['visitedResources'].append(resource_id)
+        # Add reward
+        session['totalReward'] = session.get('totalReward', 0) + resource.get('reward', 0)
+    
+    # Sync progression
+    session = sync_agent_progression(session)
+    
+    update_session(session_id, session)
+    return jsonify(session)
+
+
+# =============================================
+# LEARNING SUMMARY ENDPOINTS
+# =============================================
+
+@app.route('/api/summary/create', methods=['POST'])
+def create_learning_summary():
+    """
+    Create a learning summary from visited resources
+    """
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    session = get_session(session_id)
+    title = data.get('title', '')
+    summary = data.get('summary', '')
+    visited_ids = data.get('visited_resources', [])
+    
+    if not title or not summary:
+        return jsonify({'error': 'Title and summary required'}), 400
+    
+    # Get visited resources using robust ID matching
+    visited_set = set(str(v).strip() for v in visited_ids)
+    visited_resources = [r for r in nlp_resources if str(r['id']).strip() in visited_set]
+    
+    print(f"[DEBUG] create_learning_summary: incoming visited_ids={visited_ids}, matched count={len(visited_resources)}")
+    
+    # Calculate learning metrics
+    total_difficulty = sum(r['difficulty'] for r in visited_resources)
+    total_reward = sum(r['reward'] for r in visited_resources)
+    avg_difficulty = total_difficulty / len(visited_resources) if visited_resources else 0
+    
+    # Extract unique modules from resources (preserving order)
+    seen_modules = set()
+    ordered_modules = []
+    for r in nlp_resources:
+        m = r['module']
+        if m not in seen_modules:
+            ordered_modules.append(m)
+            seen_modules.add(m)
+    
+    # Module Aliases for better keyword matching
+    module_aliases = {
+        'Pre training objectives': ['pre-training', 'pre training', 'objectives'],
+        'Pre trained models': ['pre-trained', 'pre trained'],
+        'Tutorial: Introduction to huggingface': ['huggingface', 'hugging face'],
+        'Fine tuning LLM': ['fine-tuning', 'fine tuning', 'ft'],
+        'Instruction tuning': ['instruction tuning', 'instruction-tuning'],
+        'Prompt based learning': ['prompt based', 'prompt-based'],
+        'Parameter efficient fine tuning': ['peft', 'parameter efficient'],
+        'Incontext Learning': ['in-context', 'incontext', 'icl'],
+        'Prompting methods': ['prompting'],
+        'Retrieval Methods': ['retrieval'],
+        'Retrieval Augmented Generation': ['rag', 'retrieval augmented'],
+        'Quantization': ['quantization', 'quantized'],
+        'Mixture of Experts Model': ['moe', 'mixture of experts'],
+        'Agentic AI': ['agentic', 'agents'],
+        'Multimodal LLMs': ['multimodal', 'multi-modal'],
+        'Vision Language Models': ['vlm', 'vision-language', 'vision language'],
+        'Policy learning using DQN': ['dqn', 'deep q', 'policy gradient'],
+        'RLHF': ['rlhf', 'reinforcement learning from human feedback']
+    }
+
+    # Check for keywords in summary text
+    summary_lower = summary.lower()
+    keywords_found = []
+    
+    for module in ordered_modules:
+        if module.lower() in summary_lower:
+            keywords_found.append(module)
+            continue
+        aliases = module_aliases.get(module, [])
+        for alias in aliases:
+            if alias.lower() in summary_lower:
+                keywords_found.append(module)
+                break
+    for r in visited_resources:
+        if r['title'].lower() in summary_lower and r['title'] not in keywords_found:
+            keywords_found.append(r['title'])
+
+    # Calculate module scores for polyline
+    module_scores = []
+    log_polyline_step("START_GENERATION", f"Generating polyline for summary: '{summary[:100]}...'")
+
+    bert_model = get_bert_model()
+    if bert_model:
+        if not module_embeddings:
+            compute_module_embeddings()
+            
+        try:
+            clean_summary = utils_preprocess_text(summary, flg_stemm=False, flg_lemm=True, lst_stopwords=stop_words)
+            summary_embedding = bert_model.encode(clean_summary)
+            for module in ordered_modules:
+                score = 0.0
+                if module in module_embeddings:
+                    sim = get_cos_sim(summary_embedding, module_embeddings[module])
+                    score = max(0.0, sim)
+                if module in keywords_found: score += 0.3
+                module_visited_count = sum(1 for r in visited_resources if r['module'] == module)
+                if module_visited_count > 0: score += 0.1 * module_visited_count
+                module_scores.append(float(max(0.0, min(1.0, score))))
+        except Exception as e:
+            print(f"Error computing BERT scores: {e}")
+            for module in ordered_modules:
+                score = 0.5 + (np.random.random() - 0.5) * 0.1
+                if module in keywords_found: score += 0.2
+                module_visited_count = sum(1 for r in visited_resources if r['module'] == module)
+                if module_visited_count > 0: score += 0.1 * module_visited_count
+                module_scores.append(float(max(0.0, min(1.0, score))))
+    else:
+        for module in ordered_modules:
+            score = 0.5 + (np.random.random() - 0.5) * 0.1
+            if module in keywords_found: score += 0.2
+            module_visited_count = sum(1 for r in visited_resources if r['module'] == module)
+            if module_visited_count > 0: score += 0.1 * module_visited_count
+            module_scores.append(float(max(0.0, min(1.0, score))))
+
+    # ── DQN Recommendation ──
+    rec_result = navigator.recommend_next(visited_ids, module_scores, nlp_resources)
+    next_recommendation_obj = rec_result.get('resource')
+    
+    recommendations = []
+    if next_recommendation_obj:
+        recommendations.append(next_recommendation_obj['title'])
+    
+    unvisited_remaining = [r for r in nlp_resources if r['id'] not in visited_ids and r['title'] not in recommendations]
+    unvisited_remaining.sort(key=lambda r: (-r.get('reward', 0), r.get('difficulty', 0)))
+    for r in unvisited_remaining:
+        if len(recommendations) < 3: recommendations.append(r['title'])
+        else: break
+        
+    strengths = keywords_found if keywords_found else [r['title'] for r in visited_resources if r.get('difficulty', 0) <= 2]
+
+    # Analysis results
+    polylines = get_db_polylines()
+    from collections import Counter
+    all_keywords = []
+    for p in polylines.values():
+        if 'keywords_found' in p: all_keywords.extend(p['keywords_found'])
+    all_keywords.extend(keywords_found)
+    keyword_counts = Counter(all_keywords)
+    most_common_keywords = [k for k, v in keyword_counts.most_common(3)]
+    dominant_topics = most_common_keywords
+    
+    # Define scored_modules for recommendation logic
+    scored_modules = list(zip(ordered_modules, module_scores))
+
+    # Calculate XP based on high lines
+    current_polyline_sum = sum(module_scores)
+    total_earned_base_pts = 0
+    high_line_sum = 0
+    for module, score in scored_modules:
+        resource = next((r for r in nlp_resources if r['module'] == module), None)
+        if resource:
+            hl = float(resource.get('high_line', 0.8))
+            high_line_sum += hl
+            if score >= hl:
+                total_earned_base_pts += resource.get('base_points', 50)
+    
+    high_line_sum = max(0.1, high_line_sum)
+    xp_earned = int(total_earned_base_pts * (current_polyline_sum / high_line_sum))
+    
+    # Update session with new XP
+    session['totalReward'] = session.get('totalReward', 0) + xp_earned
+    session = sync_agent_progression(session)
+    update_session(session_id, session)
+    
+    # Generate generic AI analysis
+    ai_analysis = f"Learning profile enriched by modules like {', '.join(keywords_found[:3]) if keywords_found else 'Basics'}. Stage {session['level']} achieved with {session['totalReward']} points."
+
+    # Recommendations: Unvisited modules with high rewards or logical next steps
+    visited_module_names = set(r['module'] for r in visited_resources)
+    all_module_names = set(r['module'] for r in nlp_resources)
+    unvisited_modules = list(all_module_names - visited_module_names)
+    
+    # Sort unvisited modules by order in ORDERED_MODULES
+    unvisited_modules.sort(key=lambda m: ordered_modules.index(m) if m in ordered_modules else 99)
+    
+    # Combine BERT scores with sequential progression for recommendations
+    recommendations = unvisited_modules[:3] if unvisited_modules else [m for m, s in scored_modules if s <= 0.3][:3]
+
+    timestamp_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+    summary_result = {
+        'id': f"summary_{session_id}_{timestamp_id}",
+        'title': title, 'summary': summary, 'keywords_found': keywords_found,
+        'totalResources': len(nlp_resources), 'visitedResources': len(visited_resources),
+        'currentLevel': session['level'],
+        'strengths': strengths, 'recommendations': recommendations,
+        'ai_analysis': ai_analysis,
+        'avgDifficulty': round(avg_difficulty, 2), 'totalReward': session['totalReward'],
+        'xp_earned': xp_earned
+    }
+    save_summary(summary_result)
+
+    # Final result construction
+    agent_pos = session.get('position', {'x': 10, 'y': 10})
+    assimilation_position = {'x': agent_pos.get('x', 10), 'y': agent_pos.get('y', 10)}
+    
+    polyline_id = f"polyline_{timestamp_id}"
+    new_polyline = {
+        'id': polyline_id, 'name': title, 'path': [r['position'] for r in visited_resources],
+        'color': f'rgba({np.random.randint(100,200)}, {np.random.randint(100,200)}, 255, 0.4)',
+        'isActive': True, 'summary': summary, 'keywords_found': keywords_found,
+        'module_scores': module_scores, 'strengths': strengths, 'dominant_topics': dominant_topics,
+        'ai_analysis': ai_analysis, 'assimilation_position': assimilation_position,
+        'next_recommendation': {
+            'id': next_recommendation_obj['id'], 'title': next_recommendation_obj['title'],
+            'position': next_recommendation_obj['position'], 'module': rec_result['module'], 'reason': rec_result['reason']
+        } if next_recommendation_obj else None
+    }
+    save_polyline(polyline_id, new_polyline)
+    
+    return jsonify({
+        'summary': summary_result,
+        'polyline': new_polyline,
+        'assimilation_position': assimilation_position,
+        'next_recommendation': new_polyline['next_recommendation']
+    })
+
+
+# =============================================
+# POLYLINE ENDPOINTS
+# =============================================
+
+@app.route('/api/polylines', methods=['GET'])
+@app.route('/api/polylines', methods=['GET'])
+def get_polylines_route():
+    """Get all polylines including dynamically generated High Line and Current Average polylines"""
+    polylines = get_db_polylines()
+    
+    # Generate ordered_modules to ensure consistent mapping
+    seen_modules = set()
+    ordered_modules = []
+    for r in nlp_resources:
+        m = r['module']
+        if m not in seen_modules:
+            ordered_modules.append(m)
+            seen_modules.add(m)
+            
+    # Compute average module scores across all historical polylines
+    import math
+    history_scores = [p.get('module_scores', []) for p in polylines.values() if p.get('module_scores')]
+    num_histories = len(history_scores)
+    
+    avg_module_scores = [0.0] * len(ordered_modules)
+    if num_histories > 0:
+        for scores in history_scores:
+            for i, s in enumerate(scores):
+                if i < len(avg_module_scores):
+                    avg_module_scores[i] += s
+        avg_module_scores = [s / num_histories for s in avg_module_scores]
+        
+    # Sort resources by angle (origin is 0, 19)
+    def compute_angle(r):
+        return math.atan2(19 - r['position']['y'], r['position']['x'])
+        
+    resources_sorted = sorted(nlp_resources, key=compute_angle)
+    
+    high_line_path = []
+    current_path = []
+    
+    for r in resources_sorted:
+        dx = r['position']['x']
+        dy = 19 - r['position']['y']
+        radius = math.hypot(dx, dy)
+        theta = math.atan2(dy, dx)
+        
+        # High Line
+        hl = float(r.get('high_line', 0.8))
+        hl_rad = radius * hl
+        hl_x = hl_rad * math.cos(theta)
+        hl_y = 19 - hl_rad * math.sin(theta)
+        high_line_path.append({'x': hl_x, 'y': hl_y})
+        
+        # Current Average
+        try:
+            m_idx = ordered_modules.index(r['module'])
+            avg_s = avg_module_scores[m_idx] if num_histories > 0 else 0.0
+        except ValueError:
+            avg_s = 0.0
+            
+        cur_rad = radius * avg_s
+        cur_x = cur_rad * math.cos(theta)
+        cur_y = 19 - cur_rad * math.sin(theta)
+        current_path.append({'x': cur_x, 'y': cur_y})
+        
+    # Create the virtual polylines. Close the loops by adding the first point to the end.
+    if high_line_path:
+        high_line_path.append(high_line_path[0])
+    if current_path:
+        current_path.append(current_path[0])
+
+    hl_polyline = {
+        'id': 'high_line',
+        'name': 'High Line Target',
+        'path': high_line_path,
+        'color': 'rgba(239, 68, 68, 0.8)', # Red
+        'isActive': True,
+        'confidence': 1.0,
+        'summary': 'Target threshold for each module'
+    }
+    
+    cur_polyline = {
+        'id': 'current_average',
+        'name': 'Current Knowledge Base',
+        'path': current_path,
+        'color': 'rgba(59, 130, 246, 0.8)', # Blue
+        'isActive': True,
+        'confidence': 1.0,
+        'summary': 'Your overall average knowledge across all summaries'
+    }
+
+    # Format result: Return ONLY the virtual polylines, or include histories?
+    # User said "everywhere it should be shown like a high polyline... and current should be average of all histories"
+    # We will return the historical ones but set them to inactive, and these two to strictly active.
+    
+    result = list(polylines.values())
+    for p in result:
+        p['isActive'] = False # Disable historical polylines by default
+        
+    result.append(hl_polyline)
+    result.append(cur_polyline)
+    
+    return jsonify(result)
+
+
+@app.route('/api/polylines/<polyline_id>', methods=['GET'])
+def get_polyline(polyline_id):
+    """Get a specific polyline"""
+    polylines = get_db_polylines()
+    polyline = polylines.get(polyline_id)
+    if not polyline:
+        return jsonify({'error': 'Polyline not found'}), 404
+    return jsonify(polyline)
+
+
+@app.route('/api/polylines/<polyline_id>/toggle', methods=['POST'])
+def toggle_polyline(polyline_id):
+    """Toggle polyline visibility"""
+    data = request.get_json()
+    is_active = data.get('isActive', False)
+    
+    polylines = get_db_polylines()
+    polyline = polylines.get(polyline_id)
+    if not polyline:
+        return jsonify({'error': 'Polyline not found'}), 404
+    
+    polyline['isActive'] = is_active
+    save_polyline(polyline_id, polyline)
+    return jsonify(polyline)
+
+
+
+# =============================================
+# DQN PATH ENDPOINTS
+# =============================================
+
+@app.route('/api/dqn-path', methods=['POST'])
+def generate_dqn_path():
+    """
+    Generate DQN optimal path using the Navigator module.
+    
+    Request JSON:
+    {
+        "session_id": "str",
+        "agent_position": {"x": int, "y": int},
+        "visited_resource_ids": ["id1", "id2", ...]
+    }
+    """
+    data = request.get_json()
+    agent_pos = data.get('agent_position', {'x': 10, 'y': 10})
+    visited_ids = list(data.get('visited_resource_ids', []))
+
+    # Get latest module scores from most recent polyline (if any)
+    polylines = get_db_polylines()
+    latest_scores = []
+    if polylines:
+        last_polyline = list(polylines.values())[-1]
+        latest_scores = last_polyline.get('module_scores', [])
+
+    # Use DQN navigator to get top recommendation
+    rec = navigator.recommend_next(
+        visited_ids=visited_ids,
+        module_scores=latest_scores,
+        nlp_resources=nlp_resources
+    )
+
+    # Build a path: agent → recommended resource, plus up to 4 more close unvisited
+    path = [agent_pos]
+    visited_set = set(str(v).strip() for v in visited_ids)
+    
+    if rec['resource']:
+        path.append(rec['resource']['position'])
+        # Add up to 4 more nearest unvisited resources
+        remaining = [r for r in nlp_resources 
+                     if str(r['id']).strip() not in visited_set and r['id'] != rec['resource']['id']]
+        remaining.sort(key=lambda r: (
+            (r['position']['x'] - rec['resource']['position']['x'])**2 +
+            (r['position']['y'] - rec['resource']['position']['y'])**2
+        ))
+        for r in remaining[:4]:
+            path.append(r['position'])
+
+    final_resource = rec['resource']
+    total_reward = sum(r['reward'] for r in nlp_resources
+                       if r['position'] in path[1:]) if path else 0
+
+    return jsonify({
+        'path': path,
+        'finalResource': final_resource,
+        'totalReward': total_reward,
+        'pathLength': len(path),
+        'navigatorReason': rec['reason']
+    })
+
+
+@app.route('/api/next-recommendation', methods=['GET'])
+def get_next_recommendation():
+    """
+    Get the DQN navigator's next resource recommendation for a session.
+    Returns: { resource, module, reason, q_values }
+    """
+    session_id = request.args.get('session_id', 'default')
+    session = get_session(session_id)
+    visited_ids = [str(v).strip() for v in session.get('visitedResources', [])]
+
+    # Get latest module scores from most recent polyline
+    polylines = get_db_polylines()
+    latest_scores = []
+    if polylines:
+        last_polyline = list(polylines.values())[-1]
+        latest_scores = last_polyline.get('module_scores', [])
+
+    rec = navigator.recommend_next(
+        visited_ids=visited_ids,
+        module_scores=latest_scores,
+        nlp_resources=nlp_resources
+    )
+
+    return jsonify(rec)
+
+
+# =============================================
+# LEARNING DATA ENDPOINTS
+# =============================================
+
+@app.route('/api/learning-data', methods=['GET'])
+def get_learning_data():
+    """Get comprehensive learning data based on session history and latest summary"""
+    session_id = request.args.get('session_id', 'default')
+    session = get_session(session_id)
+    
+    visited_ids = set(str(v).strip() for v in session.get('visitedResources', []))
+    visited_resources = [r for r in nlp_resources if str(r['id']).strip() in visited_ids]
+    
+    # Defaults
+    strengths = [r['title'] for r in visited_resources if r.get('difficulty', 0) <= 2]
+    # Recommendations using rewarding modules that are unvisited
+    unvisited = [r for r in nlp_resources if str(r['id']).strip() not in visited_ids]
+    unvisited.sort(key=lambda r: (-r.get('reward', 0), r.get('difficulty', 0)))
+    recommendations = [r['title'] for r in unvisited[:3]]
+    
+    # Try to augment with results from the latest summary analysis
+    ai_analysis = ""
+    xp_earned = 0
+    try:
+        from database import load_db
+        db = load_db()
+        # Find latest summary for this session (they contain session_id in their ID or we match title)
+        matching_summaries = [s for s in db.get('summaries', []) if f"summary_{session_id}" in s.get('id', '')]
+        if matching_summaries:
+            latest = matching_summaries[-1]
+            if latest.get('strengths'):
+                strengths = latest['strengths']
+            if latest.get('recommendations'):
+                recommendations = latest['recommendations']
+            if latest.get('ai_analysis'):
+                ai_analysis = latest['ai_analysis']
+            xp_earned = latest.get('xp_earned', 0)
+    except Exception as e:
+        print(f"Error augmenting learning data from summaries: {e}")
+
+    # Calculate activity log and heatmap from all summaries for this session
+    activity_heatmap = {}
+    activity_log = []
+    try:
+        from database import load_db
+        db = load_db()
+        all_summaries = db.get('summaries', [])
+        
+        # 1. Add Summary Activity
+        for s in all_summaries:
+            s_id = s.get('id', '')
+            # Robust parsing for summary_{session_id}_{YYYYMMDD}_{HHMMSS}
+            # We look for the YYYYMMDD part after the first two underscores
+            if f"summary_" in s_id:
+                parts = s_id.split('_')
+                # For summary_default_20260403_032235, parts are: ['summary', 'default', '20260403', '032235']
+                # Search for the part that is exactly 8 digits (YYYYMMDD) and >= 2024
+                date_str = None
+                for p in parts[2:]:
+                    if len(p) == 8 and p.isdigit() and p.startswith('20'):
+                        date_str = p
+                        break
+                
+                if date_str:
+                    formatted_date = f"{date_str[:4]}-{date_str[4:6]}-{date_str[6:]}"
+                    # Weighted count: Summaries (deep learning) count as 2, visits/notifs as 1
+                    activity_heatmap[formatted_date] = activity_heatmap.get(formatted_date, 0) + 2
+                
+                # Add to activity log (list of recent events)
+                activity_log.append({
+                    'id': s_id,
+                    'type': 'summary',
+                    'title': s.get('title', 'Summary Written'),
+                    'timestamp': s.get('timestamp', int(datetime.now().timestamp() * 1000))
+                })
+
+        # 2. Add Notification/Visit Activity
+        notifs = session.get('notifications', [])
+        for n in notifs:
+            ts = n.get('timestamp')
+            if ts:
+                # Convert ms timestamp to YYYY-MM-DD
+                dt = datetime.fromtimestamp(ts / 1000.0)
+                formatted_date = dt.strftime('%Y-%m-%d')
+                activity_heatmap[formatted_date] = activity_heatmap.get(formatted_date, 0) + 1
+        
+        # Sort log by timestamp descending to show most recent at the top
+        activity_log.sort(key=lambda x: str(x.get('timestamp', '')), reverse=True)
+        activity_log = activity_log[:50] # Limit window
+
+    except Exception as e:
+        print(f"Error calculating activity log: {e}")
+
+    # Find most visited module
+    from collections import Counter
+    module_counts = Counter(r['module'] for r in visited_resources)
+    most_visited_module = module_counts.most_common(1)[0][0] if module_counts else "None"
+
+    return jsonify({
+        'totalResources': len(nlp_resources),
+        'visitedResources': len(visited_resources),
+        'currentLevel': session.get('level', 1),
+        'strengths': strengths[:3],
+        'recommendations': recommendations[:3],
+        'ai_analysis': ai_analysis,
+        'activityHeatmap': activity_heatmap,
+        'activityLog': activity_log,
+        'nextOptimalResource': unvisited[0]['position'] if unvisited else None,
+        'totalReward': session.get('totalReward', 0),
+        'mostVisitedModule': most_visited_module,
+        'xp_earned': xp_earned
+    })
+
+
+# =============================================
+# BOOKMARK ENDPOINTS
+# =============================================
+
+@app.route('/api/bookmarks', methods=['GET'])
+def get_bookmarks():
+    """Get all bookmarked resources for a session"""
+    session_id = request.args.get('session_id', 'default')
+    from database import get_bookmarks as get_db_bookmarks
+    return jsonify(get_db_bookmarks(session_id))
+
+
+@app.route('/api/bookmarks/add', methods=['POST'])
+def add_bookmark():
+    """Add a resource to bookmarks"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    resource_id = data.get('resource_id')
+    
+    if not resource_id:
+        return jsonify({'error': 'Resource ID required'}), 400
+        
+    from database import add_bookmark as add_db_bookmark
+    add_db_bookmark(session_id, resource_id)
+    return jsonify({'status': 'success', 'resource_id': resource_id})
+
+
+@app.route('/api/bookmarks/remove', methods=['POST'])
+def remove_bookmark():
+    """Remove a resource from bookmarks"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    resource_id = data.get('resource_id')
+    
+    if not resource_id:
+        return jsonify({'error': 'Resource ID required'}), 400
+        
+    from database import remove_bookmark as remove_db_bookmark
+    remove_db_bookmark(session_id, resource_id)
+    return jsonify({'status': 'success', 'resource_id': resource_id})
+
+
+# =============================================
+# NOTES ENDPOINTS
+# =============================================
+
+@app.route('/api/notes', methods=['GET'])
+def get_notes_route():
+    """Get all notes for a session"""
+    session_id = request.args.get('session_id', 'default')
+    return jsonify(get_notes(session_id))
+
+
+@app.route('/api/notes', methods=['POST'])
+def add_note_route():
+    """Add a new note"""
+    data = request.get_json()
+    session_id = data.get('session_id', 'default')
+    note_data = data.get('note')
+    
+    if not note_data:
+        return jsonify({'error': 'Note data required'}), 400
+        
+    new_note = add_note(session_id, note_data)
+    return jsonify(new_note)
+
+
+# =============================================
+# LECTURES ENDPOINTS
+# =============================================
+
+@app.route('/api/lectures', methods=['GET'])
+def get_lectures_route():
+    """Get all available lectures"""
+    return jsonify(get_lectures())
+
+
+
+# =============================================
+# AI SIDER CHAT ENDPOINT
+# =============================================
+
+# Load YouTube transcripts
+_transcripts_path = os.path.join(os.path.dirname(__file__), 'data', 'youtube_transcripts.json')
+try:
+    if os.path.exists(_transcripts_path):
+        with open(_transcripts_path, 'r', encoding='utf-8') as f:
+            raw_transcripts = json.load(f)
+        # Normalize keys to lowercase for robust matching
+        _youtube_transcripts = {str(k).strip().lower(): v for k, v in raw_transcripts.items()}
+        print(f"Loaded and normalized transcripts for {len(_youtube_transcripts)} modules")
+    else:
+        print(f"Transcripts file not found: {_transcripts_path}")
+        _youtube_transcripts = {}
+except Exception as e:
+    print(f"Could not load transcripts: {e}")
+    _youtube_transcripts = {}
+
+
+from openai import OpenAI
+
+# AI Client configuration
+# Using Groq (OpenAI-compatible) for free high-quality inference
+_ai_client = None
+try:
+    _api_key = os.getenv("GROQ_API_KEY") or os.getenv("OPENAI_API_KEY") or "FIXME_YOUR_API_KEY"
+    _base_url = "https://api.groq.com/openai/v1" if "GROQ" in _api_key or _api_key == "FIXME_YOUR_API_KEY" else None
+    _ai_client = OpenAI(api_key=_api_key, base_url=_base_url)
+except Exception as e:
+    print(f"AI Client initialization warning: {e}")
+
+@app.route('/api/chat', methods=['POST'])
+def chat_with_ai():
+    """
+    AI Sider chat endpoint - upgraded to use the openai package.
+    Uses YouTube transcript context and a premium model for better answers.
+    """
+    data = request.get_json()
+    module = data.get('module', '')
+    question = data.get('question', '')
+    history = data.get('history', [])
+    
+    if not question.strip():
+        return jsonify({'answer': 'Please ask a question about this lesson.', 'source': 'none'})
+    
+    # 1. Find transcript/context with better matching
+    # Normalize input module for lookup
+    module_norm = str(module).strip().lower()
+    transcript = _youtube_transcripts.get(module_norm, '')
+    
+    if not transcript:
+        # Try finding the resource first to get its formal title
+        resource_match = None
+        for r in nlp_resources:
+            if r['id'] == module or r['title'].lower() == module_norm or r.get('module', '').lower() == module_norm:
+                resource_match = r
+                break
+        
+        target_name = resource_match['title'] if resource_match else module_norm
+        target_name_lower = target_name.lower()
+        
+        # Fuzzy match on transcripts keys
+        for key, val in _youtube_transcripts.items():
+            if key in target_name_lower or target_name_lower in key:
+                transcript = val
+                break
+                
+    resource_desc = ''
+    for r in nlp_resources:
+        if r.get('module', '').lower() == module_norm or r.get('title', '').lower() == module_norm:
+            resource_desc = r.get('description', '')[:1000]
+            break
+            
+    context = transcript[:4500] if transcript else resource_desc[:1500]
+    
+    # 2. Try Premium Inference via OpenAI Package
+    # Check for actual keys, not just the placeholder
+    _key = os.getenv("GROQ_API_KEY") or os.getenv("OPENAI_API_KEY")
+    if _ai_client and _key and _key != "FIXME_YOUR_API_KEY":
+        try:
+            # Determine model based on provider
+            if "groq" in (_ai_client.base_url or "").lower():
+                model = "llama-3.3-70b-versatile"
+            else:
+                model = "gpt-3.5-turbo"
+            
+            system_prompt = f"""You are 'Sider AI', a premium learning assistant for an Advanced NLP course.
+Your goal is to help students understand the current lesson module: '{module}'.
+
+Use the following context from the lesson's YouTube transcript/description to answer the student's question accurately:
+---
+{context}
+---
+
+INSTRUCTIONS:
+- Be concise, professional, and encouraging.
+- If the answer is in the context, prioritize that information.
+- If the answer isn't in the context, use your general LLM knowledge to explain the concept.
+- Format your response using clean Markdown."""
+
+            messages = [{"role": "system", "content": system_prompt}]
+            # Add limited history for continuity
+            for msg in history[-4:]:
+                role = "user" if msg.get("role") == "user" else "assistant"
+                messages.append({"role": role, "content": msg.get("content", "")})
+            
+            messages.append({"role": "user", "content": question})
+            
+            completion = _ai_client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=0.7,
+                max_tokens=800
+            )
+            answer = completion.choices[0].message.content
+            return jsonify({'answer': answer, 'source': f'openai-{model}'})
+            
+        except Exception as e:
+            print(f"[CHAT] Premium AI error: {e}")
+            # Fall through to lookup if premium fails
+            
+    # 3. Fallback to Search/Lookup (Avoiding T5 to prevent worker timeouts on HF)
+    relevant_context = ""
+    if context:
+        sentences = context.split('.')
+        # Find sentences containing keywords from the question
+        keywords = [w.lower() for w in question.split() if len(w) > 3]
+        matching = []
+        for s in sentences:
+            if any(k in s.lower() for k in keywords):
+                matching.append(s.strip())
+        relevant_context = ". ".join(matching[:3])
+    
+    if relevant_context:
+        answer = f"I found some relevant information in the lesson material: {relevant_context}. For a deeper explanation, please ensure an API key is configured in the environment."
+    else:
+        answer = f"I'm here to help with the lesson on '{module}'. I couldn't find a specific answer in the local material, but you should review the module description for more details. (Tip: Configure an AI API key for better responses)."
+
+    return jsonify({'answer': answer, 'source': 'transcript-lookup'})
+
+
+if __name__ == '__main__':
+    print(f"Loaded {len(nlp_resources)} NLP resources")

backend/request_logger.py

@@ -0,0 +1,28 @@
+import os
+from datetime import datetime
+from flask import request
+
+LOG_FILE = os.path.join(os.path.dirname(__file__), 'backend_logs.txt')
+
+def log_request(info=None):
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    method = request.method
+    url = request.url
+    
+    log_entry = f"[{timestamp}] {method} {url}\n"
+    
+    if info:
+        log_entry += f"Info: {info}\n"
+    
+    if method in ['POST', 'PUT']:
+        try:
+            json_data = request.get_json(silent=True)
+            if json_data:
+                log_entry += f"Payload: {json_data}\n"
+        except Exception:
+            pass
+            
+    log_entry += "-" * 50 + "\n"
+    
+    with open(LOG_FILE, 'a', encoding='utf-8') as f:
+        f.write(log_entry)

backend/requirements.txt

@@ -0,0 +1,19 @@
+beautifulsoup4==4.12.3
+bs4==0.0.2
+Flask==3.0.3
+Flask-Cors==4.0.1
+gunicorn
+Jinja2==3.1.4
+keybert==0.8.5
+nltk==3.8.1
+numpy
+pandas
+pdfplumber==0.11.5
+requests==2.32.3
+scikit-learn
+sentence-transformers==3.0.1
+torch
+Werkzeug==3.0.3
+youtube-transcript-api
+lxml
+openai

backend/utils.py

@@ -0,0 +1,266 @@
+"""
+=========================================================
+        Polyline & Vector Utility Functions
+=========================================================
+
+This file contains utility (i.e. globally used) functions in accordance with DRY principle :
+- Handling polylines (multi-dimensional paths) used in courses/resources.
+- Computing geometric and vector operations (centroids, distances, cosine similarity).
+- Finding nearest resources for a learner based on polyline similarity.
+- Converting NumPy arrays to standard Python lists for JSON serialization.
+(more to be added with time...)
+=========================================================
+"""
+
+import numpy as np
+import math
+import heapq
+import re
+from bs4 import BeautifulSoup
+import nltk
+from nltk.stem import WordNetLemmatizer, PorterStemmer
+from nltk.corpus import stopwords
+
+# Ensure NLTK data is downloaded
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords')
+
+try:
+    nltk.data.find('corpora/wordnet')
+except LookupError:
+    nltk.download('wordnet')
+
+# ===========================
+# utils_preprocess_text
+# ===========================
+def utils_preprocess_text(text: str, flg_stemm: bool = False, flg_lemm: bool = True, lst_stopwords: list = None) -> str:
+    """
+    Preprocess text by removing HTML tags, punctuations, numbers, stopwords, and applying stemming/lemmatization.
+
+    Parameters:
+        text (str): The text to preprocess.
+        flg_stemm (bool): Flag to apply stemming. Default is False.
+        flg_lemm (bool): Flag to apply lemmatization. Default is True.
+        lst_stopwords (list): List of stopwords to remove. Default is None.
+
+    Returns:
+        str: The preprocessed text.
+    """
+    if not text:
+        return ""
+
+    # Remove HTML
+    soup = BeautifulSoup(text, 'lxml')
+    text = soup.get_text()
+
+    # Remove punctuations and numbers
+    text = re.sub('[^a-zA-Z]', ' ', text)
+
+    # Single character removal
+    text = re.sub(r"\s+[a-zA-Z]\s+", ' ', text)
+
+    # Remove multiple spaces
+    text = re.sub(r'\s+', ' ', text)
+
+    # Tokenize text
+    lst_text = text.split()
+
+    # Remove stopwords
+    if lst_stopwords is not None:
+        lst_text = [word for word in lst_text if word not in lst_stopwords]
+
+    # Apply stemming
+    if flg_stemm:
+        ps = PorterStemmer()
+        lst_text = [ps.stem(word) for word in lst_text]
+
+    # Apply lemmatization
+    if flg_lemm:
+        lem = WordNetLemmatizer()
+        lst_text = [lem.lemmatize(word) for word in lst_text]
+
+    text = " ".join(lst_text)
+    return text
+
+# ===========================
+# convert_to_lists
+# ===========================
+def convert_to_lists(data):
+    """
+    Recursively convert NumPy arrays to standard Python lists.
+
+    Parameters:
+        data (np.ndarray | list | dict | other): Input data structure.
+
+    Returns:
+        list | dict | original type: Data converted to lists recursively.
+    """
+    if isinstance(data, np.ndarray):
+        return data.tolist()
+    elif isinstance(data, list):
+        return [convert_to_lists(item) for item in data]
+    elif isinstance(data, dict):
+        return {key: convert_to_lists(value) for key, value in data.items()}
+    else:
+        return data
+
+
+# ===========================
+# get_lowline_of_polylines
+# ===========================
+def get_lowline_of_polylines(polylines):
+    """
+    Get the minimum value along each dimension across all polylines.
+
+    Parameters:
+        polylines (list of lists): Each inner list is a polyline vector.
+
+    Returns:
+        list: Minimum values for each dimension (lowline).
+    """
+    if not polylines:
+        return [0] * 12  # Default 12-dimension zero vector
+
+    lowline = [min([polylines[i][j] for i in range(len(polylines))])
+               for j in range(len(polylines[0]))]
+    return lowline
+
+
+# ===========================
+# get_highline_of_polylines
+# ===========================
+def get_highline_of_polylines(polylines):
+    """
+    Get the maximum value along each dimension across all polylines.
+
+    Parameters:
+        polylines (list of lists): Each inner list is a polyline vector.
+
+    Returns:
+        list: Maximum values for each dimension (highline).
+    """
+    return [max([polylines[i][j] for i in range(len(polylines))])
+            for j in range(len(polylines[0]))]
+
+
+# ===========================
+# get_cos_sim
+# ===========================
+def get_cos_sim(a: np.ndarray, b: np.ndarray) -> float:
+    """
+    Calculate the cosine similarity between two vectors.
+
+    Cosine similarity measures how similar two vectors are in direction
+    regardless of their magnitude.
+
+    Parameters:
+        a (np.ndarray): First vector.
+        b (np.ndarray): Second vector.
+
+    Returns:
+        float: Cosine similarity (1 = identical direction, -1 = opposite).
+    """
+    dot_product = np.dot(a, b)
+    norm_a = np.linalg.norm(a)
+    norm_b = np.linalg.norm(b)
+    return dot_product / (norm_a * norm_b)
+
+
+# ===========================
+# calculate_centroid
+# ===========================
+def calculate_centroid(polylines):
+    """
+    Calculate the centroid (mean point) of a list of polylines.
+
+    Parameters:
+        polylines (list of lists): List of N-dimension polyline vectors.
+
+    Returns:
+        list: Centroid coordinates (mean along each dimension).
+    """
+    polyline_array = np.array(polylines)
+    centroid = np.mean(polyline_array, axis=0)
+    return centroid.tolist()
+
+
+# ===========================
+# two_polyline_distance
+# ===========================
+def two_polyline_distance(point1, point2):
+    """
+    Calculate Euclidean distance between two polylines (points in N-dimensional space).
+
+    Parameters:
+        point1 (list | np.ndarray): First polyline coordinates.
+        point2 (list | np.ndarray): Second polyline coordinates.
+
+    Returns:
+        float: Euclidean distance between the two polylines.
+    """
+    if len(point1) != len(point2):
+        raise ValueError("Points must have the same dimensions")
+
+    return math.sqrt(sum((p2 - p1) ** 2 for p1, p2 in zip(point1, point2)))
+
+
+# ===========================
+# nearest_seven
+# ===========================
+def nearest_seven(learner_polyline, resources_id_polylines):
+    """
+    Find the 7 nearest resources to the learner based on polyline distance.
+
+    Parameters:
+        learner_polyline (list): Learner's current polyline coordinates.
+        resources_id_polylines (list of tuples): Each tuple is (resource_id, polyline).
+
+    Returns:
+        list: IDs of the 7 nearest resources.
+    """
+    top7 = []
+    for id_polyline in resources_id_polylines:
+        distance = two_polyline_distance(learner_polyline, id_polyline[1])
+        heapq.heappush(top7, (-distance, id_polyline[0]))  # Use negative distance for max-heap
+        if len(top7) > 7:
+            heapq.heappop(top7)
+    return [id[1] for id in top7]
+
+
+# ===========================
+# calculate_distance
+# ===========================
+def calculate_distance(pos1, pos2):
+    """
+    Compute Euclidean distance between two 2D points.
+
+    Parameters:
+        pos1 (list | tuple): [x, y] of first point.
+        pos2 (list | tuple): [x, y] of second point.
+
+    Returns:
+        float: Euclidean distance between pos1 and pos2.
+    """
+    return np.sqrt((pos1[0] - pos2[0]) ** 2 + (pos1[1] - pos2[1]) ** 2)
+
+
+# ===========================
+# is_valid_id
+# ===========================
+def is_valid_id(id):
+    """
+    Check if a given ID is valid (convertible to integer).
+
+    Parameters:
+        id (any): ID to validate.
+
+    Returns:
+        bool: True if valid integer, False otherwise.
+    """
+    try:
+        _ = int(id)
+        return True
+    except:
+        return False

docker-compose.yml

@@ -0,0 +1,16 @@
+version: '3.8'
+
+services:
+  nlp-learning-grid:
+    build: .
+    image: nlp-learning-grid:latest
+    container_name: nlp-learning-grid
+    ports:
+      - "5000:5000"
+    environment:
+      - PORT=5000
+      - GROQ_API_KEY=${GROQ_API_KEY:-}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+    volumes:
+      - ./backend/data:/app/backend/data
+    restart: unless-stopped

eslint.config.js

@@ -0,0 +1,28 @@
+import js from '@eslint/js';
+import globals from 'globals';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  { ignores: ['dist'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  }
+);

index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DQN Agent Learning Environment</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "vite-react-typescript-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@react-three/drei": "^10.7.7",
+    "@react-three/fiber": "^9.5.0",
+    "@supabase/supabase-js": "^2.57.4",
+    "@types/canvas-confetti": "^1.9.0",
+    "canvas-confetti": "^1.9.4",
+    "framer-motion": "^12.38.0",
+    "lucide-react": "^0.344.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^7.13.2",
+    "three": "^0.183.2",
+    "zustand": "^5.0.12"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.9.1",
+    "@types/react": "^18.3.5",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.1",
+    "autoprefixer": "^10.4.18",
+    "eslint": "^9.9.1",
+    "eslint-plugin-react-hooks": "^5.1.0-rc.0",
+    "eslint-plugin-react-refresh": "^0.4.11",
+    "globals": "^15.9.0",
+    "postcss": "^8.4.35",
+    "tailwindcss": "^3.4.1",
+    "typescript": "^5.5.3",
+    "typescript-eslint": "^8.3.0",
+    "vite": "^5.4.2"
+  }
+}

postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

scripts/deploy_hf.ps1

@@ -0,0 +1,28 @@
+# Hugging Face Deployment Script for NL Main
+
+$HF_TOKEN = $env:HF_TOKEN # Set this in your local environment
+if (-not $HF_TOKEN) { $HF_TOKEN = "YOUR_HF_TOKEN_HERE" }
+$HF_USERNAME = "minowau" # Guessed from GitHub remote
+$SPACE_NAME = "NavigatedLearning"
+
+Write-Host "--- 1. Building Frontend ---" -ForegroundColor Cyan
+npm run build
+
+Write-Host "--- 2. Setting up Hugging Face Remote ---" -ForegroundColor Cyan
+$HF_REMOTE_URL = "https://user:$($HF_TOKEN)@huggingface.co/spaces/$($HF_USERNAME)/$($SPACE_NAME)"
+
+# Check if HF remote already exists
+$existingRemote = git remote | Select-String "^hf$"
+if ($existingRemote) {
+    git remote set-url hf $HF_REMOTE_URL
+} else {
+    git remote add hf $HF_REMOTE_URL
+}
+
+Write-Host "--- 3. Pushing to Hugging Face ---" -ForegroundColor Cyan
+# Ensure we are on a branch
+$currentBranch = git rev-parse --abbrev-ref HEAD
+git push hf "$($currentBranch):main" --force
+
+Write-Host "--- Deployment Request Sent! ---" -ForegroundColor Green
+Write-Host "Check your Space at: https://huggingface.co/spaces/$($HF_USERNAME)/$($SPACE_NAME)" -ForegroundColor Yellow

scripts/deploy_minro.ps1

@@ -0,0 +1,45 @@
+# deploy_minro.ps1
+# PowerShell script to bundle and deploy the application to MINRO server
+
+$SERVER_IP = "113.30.156.94"
+$SERVER_PORT = "33010"
+$SERVER_USER = "ubuntu"
+$REMOTE_PATH = "/home/ubuntu/nl_main"
+$ZIP_FILE = "nl_main_deployment.zip"
+
+Write-Host "--- 1. Cleaning up previous bundles ---" -ForegroundColor Cyan
+if (Test-Path $ZIP_FILE) { Remove-Item $ZIP_FILE }
+
+Write-Host "--- 2. Building Frontend ---" -ForegroundColor Cyan
+npm run build
+
+Write-Host "--- 3. Bundling Source Code (Excluding large/sensitive files) ---" -ForegroundColor Cyan
+# Create a temporary list for inclusion
+$include = @(
+    "backend/*",
+    "dist/*",
+    "Dockerfile",
+    "docker-compose.yml",
+    "package.json",
+    "render.yaml",
+    "scripts/*"
+)
+
+# Use Compress-Archive to create the bundle
+Compress-Archive -Path $include -DestinationPath $ZIP_FILE -Force
+
+Write-Host "--- 4. Transferring to Server ($SERVER_IP) ---" -ForegroundColor Cyan
+scp -P $SERVER_PORT $ZIP_FILE "$($SERVER_USER)@$($SERVER_IP):$REMOTE_PATH/"
+
+Write-Host "--- 5. Remote Execution: Unzip & Restart ---" -ForegroundColor Cyan
+$remoteCmd = @"
+cd $REMOTE_PATH
+unzip -o $ZIP_FILE
+docker-compose down
+docker-compose up --build -d
+"@
+
+ssh -p $SERVER_PORT "$($SERVER_USER)@$($SERVER_IP)" $remoteCmd
+
+Write-Host "--- Deployment Complete! ---" -ForegroundColor Green
+Write-Host "App should be running on: http://113.30.156.101:5000" -ForegroundColor Yellow

scripts/deploy_remote.ps1

@@ -0,0 +1,34 @@
+
+$SERVER_IP = "172.16.193.4"
+$SERVER_PORT = "22" 
+$SERVER_USER = "suhan" 
+$SERVER_PASS = "Test@123"
+$REMOTE_PATH = "/home/suhan/nl_main" 
+$ZIP_FILE = "nl_main_deployment.tar.gz"
+$PASS = $SERVER_PASS
+
+Write-Host "--- 1. Cleaning up previous bundles ---" -ForegroundColor Cyan
+if (Test-Path $ZIP_FILE) { Remove-Item $ZIP_FILE }
+
+Write-Host "--- 2. Building Frontend ---" -ForegroundColor Cyan
+npm run build
+
+Write-Host "--- 3. Bundling Source Code with Tar ---" -ForegroundColor Cyan
+tar -czf $ZIP_FILE backend dist Dockerfile docker-compose.yml package.json scripts
+
+Write-Host "--- 4. Transferring to Server ($SERVER_IP) ---" -ForegroundColor Cyan
+scp -P $SERVER_PORT $ZIP_FILE "$($SERVER_USER)@$($SERVER_IP):$REMOTE_PATH/"
+
+Write-Host "--- 5. Remote Execution: Untar & Restart ---" -ForegroundColor Cyan
+$remoteCmd = @"
+echo $PASS | sudo -S mkdir -p $REMOTE_PATH
+cd $REMOTE_PATH
+echo $PASS | sudo -S rm -rf *
+echo $PASS | sudo -S tar -xzf $ZIP_FILE
+echo $PASS | sudo -S docker-compose down
+echo $PASS | sudo -S docker-compose up --build -d
+"@
+
+ssh -p $SERVER_PORT "$($SERVER_USER)@$($SERVER_IP)" $remoteCmd
+
+Write-Host "--- Deployment Complete! ---" -ForegroundColor Green

src/App.tsx

@@ -0,0 +1,35 @@
+import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
+import { LoginPage } from './pages/auth/LoginPage';
+import { SignupPage } from './pages/auth/SignupPage';
+import { ForgotPasswordPage } from './pages/auth/ForgotPasswordPage';
+import { ResourcesDashboard } from './pages/dashboard/ResourcesDashboard';
+import NavigatorDashboard from './pages/dashboard/NavigatorDashboard';
+import GridMatrixPage from './pages/dashboard/GridMatrixPage';
+import KnowledgeHubPage from './pages/dashboard/KnowledgeHubPage';
+import { AppProvider } from './context/AppContext';
+import { CustomCursor } from './components/ui/CustomCursor';
+
+function App() {
+  return (
+    <BrowserRouter>
+      <AppProvider>
+        <CustomCursor />
+        <Routes>
+          <Route path="/login" element={<LoginPage />} />
+          <Route path="/signup" element={<SignupPage />} />
+          <Route path="/forgot-password" element={<ForgotPasswordPage />} />
+          <Route path="/dashboard" element={<ResourcesDashboard />} />
+          <Route path="/navigator" element={<NavigatorDashboard />} />
+          <Route path="/navigator/course" element={<GridMatrixPage />} />
+          
+          {/* Redirects */}
+          <Route path="/" element={<Navigate to="/login" replace />} />
+          <Route path="/resources" element={<KnowledgeHubPage />} />
+          <Route path="*" element={<Navigate to="/dashboard" replace />} />
+        </Routes>
+      </AppProvider>
+    </BrowserRouter>
+  );
+}
+
+export default App;

src/components/ControlPanel.tsx

@@ -0,0 +1,788 @@
+import React, { useState } from 'react';
+import { motion } from 'framer-motion';
+import { LearningSummary, Polyline, Resource } from '../types';
+import { X, BookOpen, Activity, Map, PlayCircle, HelpCircle, Sparkles, CheckCircle, TrendingUp, Search, Award, Bookmark } from 'lucide-react';
+
+interface ControlPanelProps {
+  onSummarizeLearning: (title: string, summary: string) => void;
+  onShowPolyline: (polylineId: string) => void;
+  onToggleSimulation: () => void;
+  onPlayPath: () => void;
+  learningData: LearningSummary;
+  polylines: Polyline[];
+  isSimulationRunning: boolean;
+  isLoading: boolean;
+  learningPath: string[];
+  bookmarks: string[];
+  toggleBookmark: (id: string) => void;
+  resources: Resource[];
+  onResourceClick: (resource: Resource) => void;
+  onStartTutorial: () => void;
+  agent: any;
+}
+
+export const ControlPanel: React.FC<ControlPanelProps> = ({
+  onSummarizeLearning,
+  onShowPolyline,
+  onToggleSimulation,
+  onPlayPath,
+  learningData,
+  polylines,
+  isSimulationRunning,
+  isLoading,
+  learningPath,
+  bookmarks,
+  toggleBookmark,
+  resources,
+  onResourceClick,
+  onStartTutorial,
+  agent
+}) => {
+  const [showSummaryModal, setShowSummaryModal] = useState(false);
+  const [showPolylineModal, setShowPolylineModal] = useState(false);
+  const [showPolylineListModal, setShowPolylineListModal] = useState(false);
+  const [title, setTitle] = useState('');
+  const [summary, setSummary] = useState('');
+  const [selectedPolyline, setSelectedPolyline] = useState<Polyline | null>(null);
+
+  const handleSummarySubmit = () => {
+    if (title.trim() && summary.trim()) {
+      onSummarizeLearning(title, summary);
+      setTitle('');
+      setSummary('');
+      setShowSummaryModal(false);
+    }
+  };
+
+  const handleShowPolyline = () => {
+    const activePolyline = polylines.find(p => p.isActive);
+    if (activePolyline) {
+      setSelectedPolyline(activePolyline);
+      setShowPolylineModal(true);
+    }
+  };
+
+  // Generate chart data for polyline visualization
+  const generateChartData = (polyline: Polyline) => {
+    if (polyline.module_scores && polyline.module_scores.length > 0) {
+      return polyline.module_scores.map((score, index) => ({
+        x: index + 1,
+        y: score
+      }));
+    }
+
+    const data = [];
+    for (let i = 1; i <= 18; i++) {
+      data.push({
+        x: i,
+        y: 0.5 + (Math.random() - 0.5) * 0.1 + Math.sin(i * 0.5) * 0.05
+      });
+    }
+    return data;
+  };
+
+  const topicLegendItems = [
+    "Pre training objectives", "Pre trained models", "Tutorial: Introduction to huggingface",
+    "Fine tuning LLM", "Instruction tuning", "Prompt based learning",
+    "Parameter efficient fine tuning", "Incontext Learning", "Prompting methods",
+    "Retrieval Methods", "Retrieval Augmented Generation", "Quantization",
+    "Mixture of Experts Model", "Agentic AI", "Multimodal LLMs",
+    "Vision Language Models", "Policy learning using DQN", "RLHF"
+  ];
+
+  const activePolyline = polylines.find(p => p.isActive);
+  
+  const generateHighLineData = () => {
+    return topicLegendItems.map((topic, i) => {
+        const res = resources.find(r => r.module === topic);
+        return { x: i + 1, y: res?.high_line || 0.8 };
+    });
+  };
+  const highLineChartData = generateHighLineData();
+
+
+  return (
+    <div className="bg-white h-full flex flex-col">
+      {/* Header */}
+      <div className="px-6 py-5 border-b border-gray-100 bg-white sticky top-0 z-10">
+        <div className="flex items-center justify-between mb-1">
+          <h2 className="text-lg font-black text-slate-900 tracking-tight uppercase">Control <span className="text-brand">Center</span></h2>
+          <button 
+            onClick={onStartTutorial}
+            className="text-slate-300 hover:text-brand transition-all hover:scale-110 active:scale-95"
+          >
+            <HelpCircle className="w-5 h-5" />
+          </button>
+        </div>
+        <p className="text-[10px] text-slate-400 font-bold uppercase tracking-widest">Manage your neural sync and analysis</p>
+      </div>
+
+      {/* Profile Section */}
+      <div className="px-6 py-6 border-b border-gray-100 bg-slate-50/30 flex items-center gap-6">
+        <div className="relative w-16 h-16 shrink-0">
+            <svg className="w-full h-full transform -rotate-90 overflow-visible">
+                <circle cx="32" cy="32" r="28" fill="none" stroke="#E2E8F0" strokeWidth="4" />
+                <motion.circle 
+                    cx="32" cy="32" r="28" fill="none" stroke="#6366F1" strokeWidth="4"
+                    strokeDasharray={2 * Math.PI * 28}
+                    initial={{ strokeDashoffset: 2 * Math.PI * 28 }}
+                    animate={{ strokeDashoffset: (2 * Math.PI * 28) * (1 - (agent.exp || 0) / 100) }}
+                    transition={{ duration: 1.5 }}
+                    strokeLinecap="round"
+                />
+            </svg>
+            <div className="absolute inset-2 rounded-full overflow-hidden bg-white border-2 border-white shadow-sm">
+                <img 
+                    src="https://api.dicebear.com/7.x/avataaars/svg?seed=Felix&backgroundColor=f1f5f9" 
+                    alt="Agent Avatar" 
+                    className="w-full h-full object-cover"
+                />
+            </div>
+        </div>
+        <div className="flex flex-col">
+            <h4 className="text-[10px] font-black text-brand tracking-[0.2em] mb-1">STUDENT</h4>
+            <div className="flex items-center gap-3">
+                <motion.div 
+                    animate={{ scale: [1, 1.05, 1], filter: ["drop-shadow(0 0 0px rgba(99,102,241,0))", "drop-shadow(0 0 8px rgba(99,102,241,0.5))", "drop-shadow(0 0 0px rgba(99,102,241,0))"] }}
+                    transition={{ duration: 3, repeat: Infinity }}
+                    className="text-lg bg-brand text-white px-3 py-1 rounded-xl font-black shadow-lg shadow-brand/20 border border-brand/20"
+                >
+                    LVL {agent.level}
+                </motion.div>
+                <div className="flex flex-col">
+                    <div className="flex items-center gap-2">
+                        <span className="text-[14px] text-slate-900 font-black tracking-tight">{agent.totalReward} pts</span>
+                        {(learningData.xp_earned ?? 0) > 0 && (
+                            <span className="text-[10px] font-black text-emerald-600 bg-emerald-50 px-1.5 py-0.5 rounded-md border border-emerald-100">
+                                +{learningData.xp_earned}
+                            </span>
+                        )}
+                    </div>
+                    <span className="text-[8px] text-slate-400 font-bold uppercase tracking-widest leading-none mt-1">STUDY POINTS</span>
+                </div>
+            </div>
+        </div>
+      </div>
+      {/* Scrollable Content Area */}
+      <div className="flex-1 overflow-y-auto overflow-x-hidden scrollbar-thin scrollbar-thumb-gray-200 scrollbar-track-transparent">
+        {/* Control Actions */}
+        <div className="p-6 space-y-3 bg-gray-50/50 border-b border-gray-100">
+          <label className="text-xs font-semibold text-gray-500 uppercase tracking-wider mb-2 block">Actions</label>
+          <button
+            onClick={() => setShowSummaryModal(true)}
+            disabled={isLoading}
+            className="w-full flex items-center justify-center gap-2 py-2.5 px-4 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-400 text-white text-sm rounded-xl font-medium transition-all shadow-sm hover:shadow-md"
+          >
+            <BookOpen className="w-4 h-4" />
+            Summarize Learning
+          </button>
+
+          <div className="grid grid-cols-2 gap-3">
+            <button
+              onClick={handleShowPolyline}
+              className="flex items-center justify-center gap-2 py-2.5 px-4 bg-white border border-gray-200 hover:bg-gray-50 text-gray-700 text-sm rounded-xl font-medium transition-all"
+            >
+              <Activity className="w-4 h-4 text-blue-500" />
+              Current Polyline
+            </button>
+
+            <button
+              onClick={() => setShowPolylineListModal(true)}
+              className="flex items-center justify-center gap-2 py-2.5 px-4 bg-white border border-gray-200 hover:bg-gray-50 text-gray-700 text-sm rounded-xl font-medium transition-all"
+            >
+              <Map className="w-4 h-4 text-purple-500" />
+              History
+            </button>
+
+            <button
+              onClick={onPlayPath}
+              disabled={learningPath.length < 2}
+              className="col-span-2 flex items-center justify-center gap-2 py-2.5 px-4 bg-white border border-gray-200 hover:bg-gray-50 disabled:bg-gray-50 disabled:text-gray-400 text-gray-700 text-sm rounded-xl font-medium transition-all"
+            >
+              <PlayCircle className="w-4 h-4 text-green-500" />
+              Play Path Animation
+            </button>
+          </div>
+
+          <button
+            onClick={onToggleSimulation}
+            className={`w-full flex items-center justify-center gap-2 py-2.5 px-4 border text-sm rounded-xl font-medium transition-all ${isSimulationRunning
+              ? 'bg-red-50 border-red-200 text-red-600 hover:bg-red-100'
+              : 'bg-indigo-50 border-indigo-200 text-indigo-600 hover:bg-indigo-100'
+              }`}
+          >
+            <PlayCircle className="w-4 h-4" />
+            {isSimulationRunning ? 'Stop DQN Simulation' : 'Start DQN Simulation'}
+          </button>
+        </div>
+
+        {/* Learning Stats / Insights */}
+        {(learningData.strengths.length > 0 || learningData.recommendations.length > 0 || learningData.ai_analysis) && (
+          <div className="px-6 py-4 bg-white border-b border-gray-100">
+            <h3 className="text-xs font-bold text-gray-500 uppercase tracking-wider mb-3">Insights</h3>
+
+            {learningData.ai_analysis && (
+              <div className="mb-4 p-3 bg-indigo-50/50 border border-indigo-100 rounded-xl">
+                <div className="flex items-center gap-2 mb-1.5 text-indigo-600">
+                  <Sparkles className="w-3.5 h-3.5" />
+                  <span className="text-[10px] font-bold uppercase tracking-wider">AI feedback</span>
+                </div>
+                <p className="text-xs text-indigo-900 leading-relaxed font-medium italic">
+                  "{learningData.ai_analysis}"
+                </p>
+              </div>
+            )}
+
+            <div className="flex flex-wrap gap-4 mb-3">
+              {learningData.strengths.length > 0 && (
+                <div className="flex-1 min-w-[120px]">
+                  <span className="text-[10px] font-bold text-slate-400 uppercase tracking-widest mb-1 block">Strengths</span>
+                  <div className="flex flex-wrap gap-1">
+                    {learningData.strengths.slice(0, 2).map((strength, i) => (
+                      <span key={i} className="px-1.5 py-0.5 bg-green-50 text-green-700 text-[9px] font-bold rounded border border-green-100">
+                        {strength}
+                      </span>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {/* Bookmarks Section */}
+        <div className="px-6 py-4 bg-white border-b border-gray-100">
+          <div className="flex items-center justify-between mb-4">
+            <h3 className="text-sm font-bold text-gray-900 flex items-center gap-2">
+              <Bookmark className="w-4 h-4 text-blue-600 fill-blue-600" />
+              Bookmarks
+            </h3>
+            <span className="text-xs bg-blue-50 text-blue-600 px-2 py-0.5 rounded-full font-bold">{bookmarks.length}</span>
+          </div>
+          
+          <div className="space-y-2 max-h-48 overflow-y-auto pr-1">
+            {bookmarks.length > 0 ? (
+              bookmarks.map(id => {
+                const resource = resources.find(r => r.id === id);
+                if (!resource) return null;
+                return (
+                  <div 
+                    key={id} 
+                    className="flex items-center justify-between p-2.5 rounded-xl border border-gray-100 hover:border-blue-200 hover:bg-blue-50/30 transition-all group shadow-sm bg-white"
+                  >
+                    <div 
+                      className="flex-1 min-w-0 cursor-pointer"
+                      onClick={() => onResourceClick(resource)}
+                    >
+                      <h4 className="text-xs font-bold text-gray-800 truncate group-hover:text-blue-600 transition-colors">
+                        {resource.title}
+                      </h4>
+                      <p className="text-[9px] text-gray-400 uppercase tracking-widest font-black">
+                        {resource.module || 'Resource'}
+                      </p>
+                    </div>
+                    <button 
+                      onClick={() => toggleBookmark(id)}
+                      className="text-blue-600 hover:text-blue-700 p-1.5 rounded-lg hover:bg-white transition-all ml-2"
+                      title="Remove Bookmark"
+                    >
+                      <Bookmark className="w-3.5 h-3.5 fill-current" />
+                    </button>
+                  </div>
+                );
+              })
+            ) : (
+              <p className="text-[10px] text-gray-400 text-center py-4 italic font-medium">No bookmarks saved yet.</p>
+            )}
+          </div>
+        </div>
+
+        {/* Learning Timeline */}
+        <div className="p-6 bg-white">
+          <div className="flex items-center justify-between mb-4">
+            <h3 className="text-sm font-bold text-gray-900">Activity Log</h3>
+            <span className="text-xs bg-gray-100 text-gray-600 px-2 py-0.5 rounded-full">{learningPath.length} items</span>
+          </div>
+
+          <div className="space-y-0">
+            <div className="relative pl-4 border-l-2 border-gray-100 space-y-6 py-2">
+              {learningData.activityLog && learningData.activityLog.length > 0 ? (
+                learningData.activityLog.slice(0, 15).map((log) => (
+                  <div key={log.id} className="relative group">
+                    <div className={`absolute -left-[21px] top-1.5 w-4 h-4 bg-white border-2 rounded-full group-hover:scale-110 transition-transform duration-200 flex items-center justify-center p-0.5
+                      ${log.type === 'visit' ? 'border-green-500 text-green-500' : 
+                        log.type === 'summary' ? 'border-purple-500 text-purple-500' : 
+                        log.type === 'optimal' ? 'border-amber-500 text-amber-500' : 
+                        log.type === 'search' ? 'border-blue-500 text-blue-500' : 'border-blue-400 text-blue-400'}`}>
+                      {log.type === 'visit' && <CheckCircle className="w-full h-full" />}
+                      {log.type === 'summary' && <Sparkles className="w-full h-full" />}
+                      {log.type === 'optimal' && <TrendingUp className="w-full h-full" />}
+                      {log.type === 'search' && <Search className="w-full h-full" />}
+                      {log.type === 'start' && <PlayCircle className="w-full h-full" />}
+                    </div>
+                    <div className="flex flex-col">
+                      <div className="flex items-center gap-2 mb-0.5">
+                        <span className="text-[10px] text-gray-400 font-bold uppercase tracking-wider">{log.timestamp}</span>
+                        {log.type === 'optimal' && <span className="text-[10px] bg-amber-100 text-amber-700 px-1.5 py-0.5 rounded font-bold uppercase tracking-tighter">AI Optimized</span>}
+                      </div>
+                      <span className="text-sm font-semibold text-gray-800 leading-tight group-hover:text-blue-600 transition-colors">
+                        {log.title}
+                      </span>
+                    </div>
+                  </div>
+                ))
+              ) : (
+                <div className="relative">
+                  <div className="absolute -left-[21px] top-1.5 w-3 h-3 bg-gray-200 rounded-full"></div>
+                  <div className="flex flex-col">
+                    <span className="text-xs text-gray-400">Environment Ready</span>
+                    <span className="text-sm text-gray-500">Initialized learning grid</span>
+                  </div>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Summary Modal */}
+      {showSummaryModal && (
+        <div className="fixed inset-0 bg-gray-900/40 backdrop-blur-sm flex items-center justify-center z-50 p-4 animate-in fade-in duration-200">
+          <div className="bg-white rounded-2xl shadow-2xl max-w-lg w-full overflow-hidden scale-100 animate-in zoom-in-95 duration-200">
+            <div className="p-6 border-b border-gray-100 flex justify-between items-center">
+              <h3 className="text-lg font-bold text-gray-900">Summarize Learning</h3>
+              <button
+                onClick={() => setShowSummaryModal(false)}
+                className="p-1 rounded-full hover:bg-gray-100 text-gray-400 hover:text-gray-600 transition-colors"
+              >
+                <X className="w-5 h-5" />
+              </button>
+            </div>
+
+            <div className="p-6 space-y-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1.5">Title</label>
+                <input
+                  type="text"
+                  value={title}
+                  onChange={(e) => setTitle(e.target.value)}
+                  placeholder="e.g., Introduction to Transformers"
+                  className="w-full px-4 py-2.5 bg-gray-50 border border-gray-200 rounded-xl focus:ring-2 focus:ring-blue-500/20 focus:border-blue-500 outline-none transition-all placeholder:text-gray-400"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1.5">Key Takeaways</label>
+                <textarea
+                  value={summary}
+                  onChange={(e) => setSummary(e.target.value)}
+                  placeholder="Describe what you learned..."
+                  className="w-full h-32 px-4 py-3 bg-gray-50 border border-gray-200 rounded-xl resize-none focus:ring-2 focus:ring-blue-500/20 focus:border-blue-500 outline-none transition-all placeholder:text-gray-400"
+                />
+              </div>
+            </div>
+
+            <div className="p-6 bg-gray-50 border-t border-gray-100 flex justify-end gap-3">
+              <button
+                onClick={() => setShowSummaryModal(false)}
+                className="px-4 py-2 text-sm font-medium text-gray-600 hover:text-gray-800 hover:bg-gray-200/50 rounded-lg transition-colors"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleSummarySubmit}
+                disabled={!title.trim() || !summary.trim() || isLoading}
+                className="px-6 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-blue-400 disabled:cursor-not-allowed text-white text-sm font-medium rounded-lg shadow-sm shadow-blue-200 transition-all transform active:scale-95"
+              >
+                {isLoading ? 'Processing...' : 'Save Summary'}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Polyline Chart Modal */}
+      {showPolylineModal && selectedPolyline && (
+        <div className="fixed inset-0 bg-gray-900/40 backdrop-blur-sm flex items-center justify-center z-50 p-4">
+          <div className="bg-white rounded-2xl shadow-2xl max-w-4xl w-full max-h-[90vh] overflow-y-auto">
+            <div className="p-6 border-b border-gray-100 flex justify-between items-center sticky top-0 bg-white z-10">
+              <div>
+                <h3 className="text-xl font-bold text-gray-900">Learning Analysis</h3>
+                <div className="flex flex-col sm:flex-row sm:items-center gap-2 sm:gap-6 mt-1">
+                  <p className="text-sm text-gray-500">Polyline visualization of your learning path</p>
+                  <div className="flex items-center gap-3 text-xs font-semibold text-gray-600 bg-gray-50 px-2 py-1 rounded-md">
+                    <span className="flex items-center gap-1.5"><div className="w-3 h-0.5 bg-blue-600"></div> Current Score</span>
+                    <span className="flex items-center gap-1.5"><div className="w-3 h-0.5 border-t-2 border-dashed border-red-500"></div> Highline Target</span>
+                  </div>
+                </div>
+              </div>
+              <button
+                onClick={() => setShowPolylineModal(false)}
+                className="p-1.5 rounded-full hover:bg-gray-100 text-gray-400 hover:text-gray-600 transition-colors"
+              >
+                <X className="w-5 h-5" />
+              </button>
+            </div>
+
+            <div className="p-6">
+              {/* Keywords Detected */}
+              {selectedPolyline.keywords_found && selectedPolyline.keywords_found.length > 0 && (
+                <div className="mb-6">
+                  <h4 className="text-xs font-semibold text-gray-500 uppercase tracking-wider mb-3">Detected Keywords</h4>
+                  <div className="flex flex-wrap gap-2">
+                    {selectedPolyline.keywords_found.map((keyword: string, idx: number) => (
+                      <span key={idx} className="px-3 py-1 bg-blue-50 text-blue-700 text-sm font-medium rounded-full border border-blue-100">
+                        {keyword}
+                      </span>
+                    ))}
+                  </div>
+                </div>
+              )}
+
+              {/* AI Analysis Section */}
+              {(selectedPolyline.ai_analysis || (selectedPolyline.dominant_topics && selectedPolyline.dominant_topics.length > 0)) && (
+                <div className="mb-6 bg-gradient-to-br from-indigo-50 to-purple-50 border border-indigo-100 rounded-xl p-5">
+                  <div className="flex items-start gap-4">
+                    <div className="p-2.5 bg-white rounded-lg shadow-sm text-indigo-600 shrink-0">
+                      <Sparkles className="w-5 h-5" />
+                    </div>
+                    <div>
+                      <h4 className="text-sm font-bold text-gray-900 mb-1">AI Path Analysis</h4>
+                      {selectedPolyline.ai_analysis && (
+                        <p className="text-sm text-gray-700 leading-relaxed max-w-2xl mb-3">
+                          {selectedPolyline.ai_analysis}
+                        </p>
+                      )}
+
+                      {selectedPolyline.dominant_topics && selectedPolyline.dominant_topics.length > 0 && (
+                        <div className="flex flex-wrap items-center gap-2">
+                          <span className="text-xs font-bold text-gray-500 uppercase tracking-wider">Key Focus:</span>
+                          {selectedPolyline.dominant_topics.map((topic: string, i: number) => (
+                            <span key={i} className="px-2 py-1 bg-white/60 text-indigo-700 text-xs font-semibold rounded border border-indigo-100 shadow-sm">
+                              {topic}
+                            </span>
+                          ))}
+                        </div>
+                      )}
+                    </div>
+                  </div>
+                </div>
+              )}
+
+              {/* Chart Container */}
+              <div className="bg-gray-50/50 border border-gray-200 rounded-2xl p-6 mb-6">
+                <div className="relative h-80 w-full">
+                  <svg width="100%" height="100%" viewBox="0 0 600 300" className="overflow-visible">
+                    {/* Grid lines */}
+                    <defs>
+                      <pattern id="grid" width="33.33" height="50" patternUnits="userSpaceOnUse">
+                        <path d="M 33.33 0 L 0 0 0 50" fill="none" stroke="#e5e7eb" strokeWidth="1" strokeDasharray="3,3" />
+                      </pattern>
+                    </defs>
+                    <rect width="100%" height="100%" fill="url(#grid)" opacity="0.6" />
+
+                    {/* Y-axis labels */}
+                    <g className="text-[10px] fill-gray-400">
+                      <text x="-10" y="30" textAnchor="end">1.0</text>
+                      <text x="-10" y="155" textAnchor="end">0.5</text>
+                      <text x="-10" y="280" textAnchor="end">0.0</text>
+                    </g>
+
+                    {/* X-axis labels */}
+                    {Array.from({ length: 18 }, (_, i) => i + 1).map(i => (
+                      <text key={i} x={33.33 * i - 16} y="315" fontSize="10" fill="#9ca3af" textAnchor="middle">{i}</text>
+                    ))}
+
+                    {/* Chart area */}
+                    <path
+                      d={`M 0 300 ${generateChartData(selectedPolyline).map((point, i) =>
+                        `L ${33.33 * (i + 1)} ${280 - point.y * 250}`
+                      ).join(' ')} L 600 300 Z`}
+                      fill="url(#gradient)"
+                      opacity="0.1"
+                    />
+                    <defs>
+                      <linearGradient id="gradient" x1="0" x2="0" y1="0" y2="1">
+                        <stop offset="0%" stopColor="#2563eb" />
+                        <stop offset="100%" stopColor="#2563eb" stopOpacity="0" />
+                      </linearGradient>
+                    </defs>
+
+                    <polyline
+                      fill="none"
+                      stroke="#2563eb"
+                      strokeWidth="3"
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                      points={generateChartData(selectedPolyline).map((point, i) =>
+                        `${33.33 * (i + 1)},${280 - point.y * 250}`
+                      ).join(' ')}
+                      className="drop-shadow-sm"
+                    />
+
+                    {/* High Line Overlay */}
+                    <polyline
+                      fill="none"
+                      stroke="#ef4444"
+                      strokeWidth="2"
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                      strokeDasharray="4 4"
+                      points={highLineChartData.map((point, i) =>
+                        `${33.33 * (i + 1)},${280 - point.y * 250}`
+                      ).join(' ')}
+                      className="opacity-70"
+                    />
+
+                    {/* Data points */}
+                    {generateChartData(selectedPolyline).map((point, i) => (
+                      <circle
+                        key={i}
+                        cx={33.33 * (i + 1)}
+                        cy={280 - point.y * 250}
+                        r="4"
+                        className="fill-white stroke-blue-600 stroke-2 hover:r-6 hover:stroke-4 transition-all cursor-pointer"
+                      />
+                    ))}
+
+                    {/* High Line Data points */}
+                    {highLineChartData.map((point, i) => (
+                      <circle
+                        key={`hl-${i}`}
+                        cx={33.33 * (i + 1)}
+                        cy={280 - point.y * 250}
+                        r="3"
+                        className="fill-white stroke-red-500 stroke-2 opacity-80"
+                      />
+                    ))}
+                  </svg>
+
+                  {/* Axis titles */}
+                  <div className="absolute -left-12 top-1/2 transform -rotate-90 -translate-y-1/2 text-xs font-semibold text-gray-400 tracking-wider">
+                    ASSIMILATION SCORE
+                  </div>
+                  <div className="absolute -bottom-10 left-1/2 transform -translate-x-1/2 text-xs font-semibold text-gray-400 tracking-wider">
+                    TOPIC INDEX
+                  </div>
+                </div>
+              </div>
+
+              {/* Topic Legend */}
+              <div className="grid grid-cols-2 md:grid-cols-3 gap-3">
+                {topicLegendItems.map((item, index) => (
+                  <div key={index} className="flex items-start gap-2 p-2 rounded-lg hover:bg-gray-50 transition-colors">
+                    <span className="flex-shrink-0 flex items-center justify-center w-5 h-5 bg-gray-100 rounded text-[10px] font-bold text-gray-600">
+                      {index + 1}
+                    </span>
+                    <span className="text-xs text-gray-600 leading-tight" title={item}>{item}</span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Polylines List Modal — Journey History (Revamped Timeline) */}
+      {showPolylineListModal && (
+        <div className="fixed inset-0 bg-gray-900/50 backdrop-blur-sm flex items-center justify-center z-50 p-4">
+          <div className="bg-white rounded-2xl shadow-2xl w-full max-w-2xl max-h-[90vh] flex flex-col overflow-hidden">
+
+            {/* Header */}
+            <div className="px-6 py-5 border-b border-gray-100 flex justify-between items-center bg-white">
+              <div>
+                <h3 className="text-xl font-bold text-gray-900">Journey History</h3>
+                <p className="text-sm text-gray-400 mt-0.5">Your learning assimilation over time</p>
+              </div>
+              <button
+                onClick={() => setShowPolylineListModal(false)}
+                className="p-1.5 rounded-full hover:bg-gray-100 text-gray-400 hover:text-gray-600 transition-colors"
+              >
+                <X className="w-5 h-5" />
+              </button>
+            </div>
+
+            {/* Timeline Body */}
+            <div className="flex-1 overflow-y-auto px-6 py-6">
+              {(() => {
+                const filteredPolylines = polylines.filter(p => !['learning-path-1', 'dqn-simulation', 'high_line', 'current_average'].includes(p.id));
+
+                if (filteredPolylines.length === 0) {
+                  return (
+                    <div className="flex flex-col items-center justify-center py-16 text-center">
+                      <div className="w-16 h-16 rounded-2xl bg-gray-50 border border-dashed border-gray-200 flex items-center justify-center mb-4">
+                        <BookOpen className="w-8 h-8 text-gray-300" />
+                      </div>
+                      <p className="text-gray-500 font-medium">No history yet</p>
+                      <p className="text-sm text-gray-400 mt-1">Submit a learning summary to start tracking your journey.</p>
+                    </div>
+                  );
+                }
+
+                return (
+                  <div className="relative">
+                    {/* Vertical spine */}
+                    <div className="absolute left-5 top-0 bottom-0 w-0.5 bg-gradient-to-b from-blue-200 via-purple-200 to-gray-100" />
+
+                    <div className="space-y-8">
+                      {filteredPolylines.map((polyline, index) => {
+                        const chartData = generateChartData(polyline);
+                        const peakScore = chartData.length ? Math.max(...chartData.map(d => d.y)) : 0;
+
+                        return (
+                          <div key={polyline.id} className="relative flex gap-5 group">
+                            {/* Numbered bubble */}
+                            <div className="flex-shrink-0 w-10 h-10 rounded-full flex items-center justify-center font-bold text-sm shadow-sm z-10
+                            bg-gradient-to-br from-blue-500 to-indigo-600 text-white border-2 border-white">
+                              {index + 1}
+                            </div>
+
+                            {/* Card */}
+                            <div className="flex-1 bg-white border border-gray-100 rounded-2xl shadow-sm hover:shadow-md transition-shadow overflow-hidden">
+
+                              {/* Card top bar */}
+                              <div className="px-4 py-3 border-b border-gray-50 flex items-center justify-between bg-gray-50/50">
+                                <div className="flex items-center gap-2 min-w-0">
+                                  <h4 className="font-semibold text-gray-900 text-sm truncate max-w-[200px]">
+                                    {polyline.name || `Summary #${index + 1}`}
+                                  </h4>
+                                  {polyline.next_recommendation && (
+                                    <span className={`flex-shrink-0 text-[9px] font-bold px-1.5 py-0.5 rounded uppercase tracking-wider
+                                    ${polyline.next_recommendation.reason === 'dqn'
+                                        ? 'bg-indigo-100 text-indigo-700'
+                                        : 'bg-amber-100 text-amber-700'
+                                      }`}>
+                                      {polyline.next_recommendation.reason === 'dqn' ? '🧠 DQN' : '⚡ Fallback'}
+                                    </span>
+                                  )}
+                                </div>
+                                <div className="flex items-center gap-2 flex-shrink-0">
+                                  {polyline.assimilation_position && (
+                                    <span className="text-[10px] font-mono bg-blue-50 text-blue-600 px-2 py-0.5 rounded-lg border border-blue-100">
+                                      📍 ({polyline.assimilation_position.x}, {polyline.assimilation_position.y})
+                                    </span>
+                                  )}
+                                  {polyline.confidence && (
+                                    <span className="text-[10px] text-gray-400 font-medium">
+                                      {(polyline.confidence * 100).toFixed(0)}%
+                                    </span>
+                                  )}
+                                </div>
+                              </div>
+
+                              <div className="p-4 space-y-3">
+                                {/* Keywords */}
+                                {polyline.keywords_found && polyline.keywords_found.length > 0 && (
+                                  <div className="flex flex-wrap gap-1">
+                                    {polyline.keywords_found.slice(0, 5).map((kw, i) => (
+                                      <span key={i} className="px-2 py-0.5 bg-blue-50 text-blue-600 text-[10px] font-medium rounded-full border border-blue-100">
+                                        {kw}
+                                      </span>
+                                    ))}
+                                    {polyline.keywords_found.length > 5 && (
+                                      <span className="px-2 py-0.5 bg-gray-100 text-gray-500 text-[10px] rounded-full">
+                                        +{polyline.keywords_found.length - 5}
+                                      </span>
+                                    )}
+                                  </div>
+                                )}
+
+                                {/* Dominant topics */}
+                                {polyline.dominant_topics && polyline.dominant_topics.length > 0 && (
+                                  <div className="flex flex-wrap gap-1">
+                                    {polyline.dominant_topics.map((topic, i) => (
+                                      <span key={i} className="px-2 py-0.5 bg-purple-50 text-purple-600 text-[10px] font-semibold rounded-full border border-purple-100">
+                                        ★ {topic}
+                                      </span>
+                                    ))}
+                                  </div>
+                                )}
+
+                                {/* Next recommendation from navigator */}
+                                {polyline.next_recommendation && (
+                                  <div className="flex items-center gap-2 bg-indigo-50 border border-indigo-100 rounded-xl px-3 py-2">
+                                    <Sparkles className="w-3.5 h-3.5 text-indigo-500 flex-shrink-0" />
+                                    <div className="min-w-0">
+                                      <span className="text-[9px] font-bold text-indigo-400 uppercase tracking-wider block leading-none mb-0.5">Next Recommended</span>
+                                      <span className="text-xs font-medium text-indigo-800 truncate block">{polyline.next_recommendation.title}</span>
+                                    </div>
+                                    {polyline.next_recommendation.module && (
+                                      <span className="flex-shrink-0 ml-auto text-[9px] text-indigo-400 font-medium max-w-[80px] text-right truncate">
+                                        {polyline.next_recommendation.module}
+                                      </span>
+                                    )}
+                                  </div>
+                                )}
+
+                                {/* Mini sparkline + peak */}
+                                <div className="flex items-end gap-3">
+                                  <div className="flex-1 bg-gray-50 rounded-xl p-2 border border-gray-100">
+                                    <svg width="100%" height="50" viewBox="0 0 280 50" preserveAspectRatio="none">
+                                      <defs>
+                                        <linearGradient id={`sg-${polyline.id}`} x1="0" x2="0" y1="0" y2="1">
+                                          <stop offset="0%" stopColor="#6366f1" stopOpacity="0.25" />
+                                          <stop offset="100%" stopColor="#6366f1" stopOpacity="0" />
+                                        </linearGradient>
+                                      </defs>
+                                      <path
+                                        d={`M 0 50 ${chartData.map((p, i) => `L ${(280 / 18) * (i + 1)} ${46 - p.y * 40}`).join(' ')} L 280 50 Z`}
+                                        fill={`url(#sg-${polyline.id})`}
+                                      />
+                                      <polyline
+                                        fill="none"
+                                        stroke={index === polylines.length - 1 ? '#6366f1' : '#94a3b8'}
+                                        strokeWidth="2"
+                                        strokeLinecap="round"
+                                        strokeLinejoin="round"
+                                        points={chartData.map((p, i) =>
+                                          `${(280 / 18) * (i + 1)},${46 - p.y * 40}`
+                                        ).join(' ')}
+                                      />
+                                      <polyline
+                                        fill="none"
+                                        stroke="#ef4444"
+                                        strokeWidth="1.5"
+                                        strokeLinecap="round"
+                                        strokeLinejoin="round"
+                                        strokeDasharray="2 3"
+                                        points={highLineChartData.map((p, i) =>
+                                          `${(280 / 18) * (i + 1)},${46 - p.y * 40}`
+                                        ).join(' ')}
+                                        className="opacity-70"
+                                      />
+                                    </svg>
+                                  </div>
+                                  <div className="text-right flex-shrink-0 w-12">
+                                    <span className="text-sm font-bold text-gray-800 block">{(peakScore * 100).toFixed(0)}%</span>
+                                    <span className="text-[10px] text-gray-400">peak</span>
+                                  </div>
+                                </div>
+
+                                {/* View details */}
+                                <button
+                                  onClick={() => {
+                                    onShowPolyline(polyline.id);
+                                    setSelectedPolyline(polyline);
+                                    setShowPolylineListModal(false);
+                                    setShowPolylineModal(true);
+                                  }}
+                                  className="w-full text-center text-xs font-semibold text-blue-600 hover:text-blue-700 hover:bg-blue-50 py-2 rounded-lg transition-colors border border-blue-100"
+                                >
+                                  View Full Analysis →
+                                </button>
+                              </div>
+                            </div>
+                          </div>
+                        );
+                      })}
+                    </div>
+                  </div>
+                );
+              })()}
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};

src/components/Dashboard/DashboardTutorial.tsx

@@ -0,0 +1,209 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { RobotAssistant } from './RobotAssistant';
+import { X, ChevronRight, CheckCircle2 } from 'lucide-react';
+
+interface TutorialStep {
+  targetId: string;
+  title: string;
+  description: string;
+  robotMessage: string;
+  offset: { x: number; y: number };
+}
+
+const dashboardSteps: TutorialStep[] = [
+  {
+    targetId: 'hero-title',
+    title: 'Mission Control',
+    description: 'Welcome to your central command. This is where high-level objectives are deployed.',
+    robotMessage: "Systems ONLINE! I'm your tactical interface. Let's start the tour!",
+    offset: { x: 50, y: 150 }
+  },
+  {
+    targetId: 'progress-bar',
+    title: 'Neural Synchronization',
+    description: 'Your level progress represents your synchronization with the core matrix.',
+    robotMessage: "Keep this bar full! We need maximum sync for deep-dive missions.",
+    offset: { x: 50, y: 100 }
+  },
+  {
+    targetId: 'missions-matrix',
+    title: 'Mission Matrix',
+    description: 'Select a node to begin deployment. Each card acts as a secure cover page for your mission intel.',
+    robotMessage: "The Matrix is loaded with fresh intel! Overload these nodes to gain XP.",
+    offset: { x: -350, y: -50 }
+  },
+  {
+    targetId: 'intel-feed',
+    title: 'Intel Feed',
+    description: 'Direct streams from the NLP Academy. Stay sharp with decrypted field reports.',
+    robotMessage: "Intel is power, recruit! Check the feed before every mission.",
+    offset: { x: 50, y: -250 }
+  }
+];
+
+const navigatorSteps: TutorialStep[] = [
+  {
+    targetId: 'matrix-grid',
+    title: 'Navigator Matrix',
+    description: 'Interact with the 2D grid to navigate through complex neural architectures.',
+    robotMessage: "Check the grid! We use DQN algorithms here to find the optimal learning path.",
+    offset: { x: 200, y: 200 }
+  },
+  {
+    targetId: 'control-center',
+    title: 'Control Center',
+    description: 'Analyze your progress, manage bookmarks, and run simulations.',
+    robotMessage: "This is the brain! Run simulations to see how the agent optimizes objectives.",
+    offset: { x: -400, y: 100 }
+  }
+];
+
+interface DashboardTutorialProps {
+  onComplete: () => void;
+  page?: 'dashboard' | 'navigator';
+}
+
+const DashboardTutorial: React.FC<DashboardTutorialProps> = ({ onComplete, page = 'dashboard' }) => {
+  const [currentStep, setCurrentStep] = useState(0);
+  const [robotPos, setRobotPos] = useState({ x: 0, y: 0 });
+  const [targetRect, setTargetRect] = useState<DOMRect | null>(null);
+
+  const steps = page === 'dashboard' ? dashboardSteps : navigatorSteps;
+
+  useEffect(() => {
+    const updatePosition = () => {
+      const step = steps[currentStep];
+      if (!step) return;
+      
+      const element = document.getElementById(step.targetId);
+      if (element) {
+        // Scroll element into view first
+        element.scrollIntoView({ behavior: 'smooth', block: 'center' });
+
+        // Small delay to allow scroll to complete before measuring
+        setTimeout(() => {
+          const rect = element.getBoundingClientRect();
+          setTargetRect(rect);
+          
+          // Calculate desired positions
+          let nx = rect.left + step.offset.x;
+          let ny = rect.top + step.offset.y;
+
+          // Viewport clamping (Robot is ~100x100 scaled 2x = 200x200)
+          const margin = 20;
+          nx = Math.max(margin, Math.min(nx, window.innerWidth - 220));
+          ny = Math.max(margin, Math.min(ny, window.innerHeight - 220));
+
+          setRobotPos({ x: nx, y: ny });
+        }, 600); 
+      }
+    };
+
+    updatePosition();
+    window.addEventListener('resize', updatePosition);
+    return () => window.removeEventListener('resize', updatePosition);
+  }, [currentStep, steps]);
+
+  const nextStep = () => {
+    if (currentStep < steps.length - 1) {
+      setCurrentStep(prev => prev + 1);
+    } else {
+      onComplete();
+    }
+  };
+
+  const step = steps[currentStep];
+
+  return (
+    <div className="fixed inset-0 z-[110] pointer-events-none overflow-hidden">
+      {/* Dynamic Reveal Highlight */}
+      <AnimatePresence>
+          {targetRect && (
+              <motion.div 
+                initial={{ opacity: 0 }}
+                animate={{ opacity: 1 }}
+                exit={{ opacity: 0 }}
+                className="absolute inset-0 bg-slate-950/40 backdrop-blur-[2px] pointer-events-auto"
+                style={{
+                    clipPath: `polygon(
+                        0% 0%, 0% 100%, 
+                        ${targetRect.left - 20}px 100%, 
+                        ${targetRect.left - 20}px ${targetRect.top - 20}px, 
+                        ${targetRect.right + 20}px ${targetRect.top - 20}px, 
+                        ${targetRect.right + 20}px ${targetRect.bottom + 20}px, 
+                        ${targetRect.left - 20}px ${targetRect.bottom + 20}px, 
+                        ${targetRect.left - 20}px 100%, 
+                        100% 100%, 100% 0%
+                    )`
+                }}
+                onClick={onComplete}
+              />
+          )}
+      </AnimatePresence>
+
+      {/* Moving Robot Assistant */}
+      <motion.div 
+        animate={{ 
+            x: robotPos.x, 
+            y: robotPos.y,
+            scale: 2
+        }}
+        transition={{ type: "spring", stiffness: 100, damping: 20 }}
+        className="absolute top-0 left-0"
+      >
+        <RobotAssistant tutorialMessage={step?.robotMessage || "Synchronizing..."} />
+      </motion.div>
+
+      {/* Instructional Speech Bubble */}
+      <motion.div 
+        animate={{ 
+            x: Math.max(20, Math.min(robotPos.x + 100, window.innerWidth - 340)), 
+            y: Math.max(20, Math.min(robotPos.y - 180, window.innerHeight - 250))
+        }}
+        transition={{ type: "spring", stiffness: 80, damping: 20 }}
+        className="absolute top-0 left-0 w-80 bg-white rounded-[32px] p-6 shadow-2xl border-4 border-brand/20 pointer-events-auto"
+      >
+        <div className="flex items-center justify-between mb-4">
+            <h3 className="text-lg font-black text-slate-900 uppercase tracking-tighter">{step?.title}</h3>
+            <button onClick={onComplete} className="text-slate-300 hover:text-brand transition-colors">
+                <X size={16} />
+            </button>
+        </div>
+        
+        <p className="text-slate-500 text-sm italic mb-6">"{step?.description}"</p>
+
+        <div className="flex items-center justify-between">
+            <div className="flex gap-1">
+                {steps.map((_, idx) => (
+                    <div 
+                        key={idx}
+                        className={`h-1 rounded-full transition-all ${idx === currentStep ? 'w-4 bg-brand' : 'w-1 bg-slate-200'}`}
+                    />
+                ))}
+            </div>
+            <button 
+                onClick={nextStep}
+                className="bg-brand text-white px-5 py-2 rounded-xl font-black text-[9px] uppercase tracking-widest flex items-center gap-2 hover:bg-brand-light transition-all shadow-lg active:scale-95"
+            >
+                {currentStep === steps.length - 1 ? 'Finish' : 'Next'} 
+                {currentStep === steps.length - 1 ? <CheckCircle2 size={12} /> : <ChevronRight size={12} />}
+            </button>
+        </div>
+
+        {/* Tail for the speech bubble */}
+        <div className="absolute -bottom-4 left-10 w-8 h-8 bg-white border-b-4 border-l-4 border-brand/20 rotate-[-45deg] rounded-bl-xl" />
+      </motion.div>
+
+      {/* Skip Button */}
+      <button 
+        onClick={onComplete}
+        className="absolute bottom-12 right-12 px-6 py-3 bg-white/10 backdrop-blur-md rounded-2xl text-[10px] font-black uppercase tracking-[0.3em] text-white/40 hover:text-white border border-white/5 pointer-events-auto"
+      >
+        Skip Tutorial
+      </button>
+    </div>
+  );
+};
+
+export default DashboardTutorial;

src/components/Dashboard/MissionGrid.tsx

@@ -0,0 +1,110 @@
+import { motion } from 'framer-motion';
+import { Trophy, ArrowUpRight, Clock, Users, Bookmark, Sparkles } from 'lucide-react';
+
+
+
+import { useAppContext } from '../../context/AppContext';
+import { useNavigate } from 'react-router-dom';
+
+const MissionGrid = () => {
+  const { resources, agent, bookmarks, toggleBookmark } = useAppContext();
+  const navigate = useNavigate();
+
+  // Dynamically map curriculum queue isolating unvisited remaining modules
+  const unvisitedNodes = resources.filter(r => !agent.visitedResources.includes(r.id)).slice(0, 4);
+  
+  // Transform the explicit resource API payloads into compatible Mission display blocks natively synced
+  const dynamicMissions = unvisitedNodes.map((r, index) => ({
+    id: r.id,
+    title: r.title,
+    description: `Explore parameters defining the behavior surrounding ${r.module} architecture sets natively inside our remote neural matrices.`,
+    image: r.youtube_url ? `https://img.youtube.com/vi/${r.youtube_url.split('v=')[1]?.split('&')[0] || r.youtube_url.split('/').pop()}/maxresdefault.jpg` : "https://images.unsplash.com/photo-1677442136019-21780ecad995?q=80&w=800&auto=format&fit=crop",
+    bannerColor: index % 2 === 0 ? 'from-brand/20 to-brand-dark/40' : 'from-slate-600/20 to-slate-900/40',
+    score: r.reward || 150,
+    stage: r.difficulty || 1,
+    duration: "45m",
+    participants: Math.floor(Math.random() * 1500) + 500,
+    isBookmarked: bookmarks.includes(r.id)
+  }));
+  return (
+    <div id="missions-matrix" className="grid grid-cols-1 md:grid-cols-2 gap-8 pb-12">
+      {dynamicMissions.map((mission, idx) => (
+        <motion.div
+          key={mission.id}
+          initial={{ opacity: 0, y: 10 }}
+          animate={{ opacity: 1, y: 0 }}
+          transition={{ delay: idx * 0.1, duration: 0.5 }}
+          className="group relative bg-white rounded-2xl overflow-hidden shadow-sm border border-slate-200 hover:border-brand/40 transition-all duration-300"
+        >
+          {/* Card Header Image */}
+          <div className="relative h-48 w-full overflow-hidden bg-slate-100">
+            <img 
+              src={mission.image} 
+              alt={mission.title}
+              className="w-full h-full object-cover transition-transform duration-700 group-hover:scale-105"
+            />
+            <div className={`absolute inset-0 bg-gradient-to-t ${mission.bannerColor} opacity-40`} />
+            <div className="absolute inset-0 bg-gradient-to-t from-black/20 to-transparent" />
+            
+            <div className="absolute top-4 left-4">
+              <div className="bg-white/80 backdrop-blur-md px-3 py-1 rounded-lg flex items-center gap-2 border border-white/20 shadow-sm">
+                <Sparkles size={12} className="text-brand" />
+                <span className="text-[10px] font-bold uppercase text-slate-800 tracking-wider">Stage {mission.stage}</span>
+              </div>
+            </div>
+
+            <div className="absolute top-4 right-4">
+              <button 
+                onClick={(e) => { e.stopPropagation(); toggleBookmark(mission.id); }}
+                className={`w-8 h-8 ${mission.isBookmarked ? 'bg-brand/90 text-white' : 'bg-white/80 text-slate-600'} backdrop-blur-md rounded-lg flex items-center justify-center shadow-sm hover:scale-105 transition-all border border-white/20`}
+              >
+                <Bookmark size={14} className={mission.isBookmarked ? 'fill-current' : ''} />
+              </button>
+            </div>
+
+            <div className="absolute bottom-4 left-4">
+               <div className="bg-brand px-3 py-1 rounded-lg flex items-center gap-2 shadow-lg border border-white/20">
+                  <Trophy size={12} className="text-white" />
+                  <span className="text-[10px] font-bold text-white">+{mission.score} Score</span>
+              </div>
+            </div>
+          </div>
+
+          {/* Card Body */}
+          <div className="p-6 flex flex-col gap-4">
+            <div className="flex flex-col gap-1">
+                <h3 className="text-xl font-bold text-slate-900 group-hover:text-brand transition-colors">
+                    {mission.title}
+                </h3>
+                <div className="flex items-center gap-3">
+                    <span className="text-[10px] items-center font-bold text-slate-400 uppercase tracking-widest flex gap-1.5 align-middle">
+                      <Clock size={12} className="text-slate-300"/> {mission.duration}
+                    </span>
+                    <span className="text-[10px] items-center font-bold text-slate-400 uppercase tracking-widest flex gap-1.5 align-middle">
+                      <Users size={12} className="text-slate-300"/> {mission.participants.toLocaleString()} Active
+                    </span>
+                </div>
+            </div>
+
+            <p className="text-slate-500 text-sm leading-relaxed font-medium line-clamp-2">
+              {mission.description}
+            </p>
+
+            <div className="pt-4 flex justify-end">
+                <motion.button
+                  whileHover={{ y: -1 }}
+                  whileTap={{ scale: 0.98 }}
+                  onClick={() => navigate(`/navigator/course?resource=${mission.id}`)}
+                  className="bg-brand text-white px-6 py-2 rounded-xl font-bold text-[11px] uppercase tracking-wider flex items-center gap-2 hover:bg-brand-dark transition-all shadow-sm shadow-brand/10 border border-white/10"
+                >
+                  Engage <ArrowUpRight size={14} />
+                </motion.button>
+            </div>
+          </div>
+        </motion.div>
+      ))}
+    </div>
+  );
+};
+
+export default MissionGrid;

src/components/Dashboard/RobotAssistant.tsx

@@ -0,0 +1,166 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { motion, AnimatePresence, useSpring } from 'framer-motion';
+
+interface RobotAssistantProps {
+  tutorialMessage?: string;
+  layoutId?: string;
+  size?: 'sm' | 'md' | 'lg' | 'xl';
+}
+
+export const RobotAssistant: React.FC<RobotAssistantProps> = ({ 
+  tutorialMessage,
+  layoutId = "robot-assistant",
+  size = 'md'
+}) => {
+  const [messages] = useState([
+    "Careful there.",
+    "Interaction registered.",
+    "That was unnecessary 🙂",
+    "Processing request...",
+    "Scanning patterns.",
+    "Always helpful.",
+    "System sync: Stable.",
+    "Data points collected."
+  ]);
+  
+  const [activeMessage, setActiveMessage] = useState<string | null>(null);
+  const [isHovered, setIsHovered] = useState(false);
+  const containerRef = useRef<HTMLDivElement>(null);
+  
+  // Mouse tracking for eyes
+  const mouseX = useSpring(0, { stiffness: 100, damping: 25 });
+  const mouseY = useSpring(0, { stiffness: 100, damping: 25 });
+
+  useEffect(() => {
+    const handleMouseMove = (e: MouseEvent) => {
+      if (containerRef.current) {
+        const rect = containerRef.current.getBoundingClientRect();
+        const centerX = rect.left + rect.width / 2;
+        const centerY = rect.top + rect.height / 2;
+        
+        // Smoother, slower tracking
+        const dx = (e.clientX - centerX) / (window.innerWidth / 4);
+        const dy = (e.clientY - centerY) / (window.innerHeight / 4);
+        
+        mouseX.set(Math.max(-8, Math.min(8, dx * 10)));
+        mouseY.set(Math.max(-8, Math.min(8, dy * 10)));
+      }
+    };
+    
+    window.addEventListener('mousemove', handleMouseMove);
+    return () => window.removeEventListener('mousemove', handleMouseMove);
+  }, [mouseX, mouseY]);
+
+  const handleClick = () => {
+    const randomIndex = Math.floor(Math.random() * messages.length);
+    setActiveMessage(messages[randomIndex]);
+    
+    // Clear message after 2s
+    setTimeout(() => setActiveMessage(null), 2000);
+  };
+
+  return (
+    <motion.div 
+      layoutId={layoutId}
+      className="relative group/robot" 
+      ref={containerRef}
+    >
+      {/* Speech Bubble (Minimal Tooltip Style) */}
+      <AnimatePresence>
+        {activeMessage && (
+          <motion.div
+            initial={{ opacity: 0, y: 10, scale: 0.9 }}
+            animate={{ opacity: 1, y: 0, scale: 1 }}
+            exit={{ opacity: 0, y: 10, scale: 0.9 }}
+            className="absolute -top-12 left-1/2 -translate-x-1/2 z-50 pointer-events-none whitespace-nowrap"
+          >
+            <div className="text-[10px] font-bold text-slate-600 bg-white shadow-xl shadow-slate-200/50 px-3 py-1.5 rounded-xl border border-slate-100 flex items-center gap-2">
+              <div className="w-1.5 h-1.5 bg-brand rounded-full animate-pulse" />
+              {activeMessage}
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+
+      {/* Robot Container */}
+      <motion.div
+        onClick={handleClick}
+        onMouseEnter={() => setIsHovered(true)}
+        onMouseLeave={() => setIsHovered(false)}
+        whileHover={{ y: -2 }}
+        animate={{ 
+          y: [-2, 2, -2],
+        }}
+        transition={{ 
+          y: { duration: 5, repeat: Infinity, ease: "easeInOut" },
+        }}
+        className="cursor-pointer flex flex-col items-center gap-4 relative group transition-all"
+      >
+        {/* Subtle Backdrop Glow */}
+        <div className="absolute inset-0 bg-brand/3 rounded-full blur-2xl opacity-0 group-hover:opacity-100 transition-opacity" />
+
+        {/* Robot head/SVG */}
+        <div className={`relative transition-all duration-500 ${
+            size === 'xl' ? 'w-80 h-80' : 
+            size === 'lg' ? 'w-48 h-48' : 
+            size === 'md' ? 'w-24 h-24' : 'w-12 h-12'
+        }`}>
+            <svg viewBox="0 0 120 120" className="w-full h-full overflow-visible">
+                {/* Robot Body (Midnight Slate) */}
+                <defs>
+                    <radialGradient id="robot-body-shine" cx="50%" cy="40%" r="50%" fx="50%" fy="40%">
+                        <stop offset="0%" stopColor="#334155" />
+                        <stop offset="100%" stopColor="#1E293B" />
+                    </radialGradient>
+                    <filter id="inner-glow">
+                        <feFlood floodColor="#334155" floodOpacity="0.3" result="offsetColor"/>
+                        <feComposite in="offsetColor" in2="SourceAlpha" operator="in" result="offsetBlur"/>
+                        <feGaussianBlur in="offsetBlur" stdDeviation="2" result="blur"/>
+                        <feComposite in="SourceAlpha" in2="blur" operator="out" result="glow"/>
+                    </filter>
+                </defs>
+                <motion.rect 
+                    x="20" y="30" width="80" height="70" rx="16" 
+                    fill="url(#robot-body-shine)"
+                    stroke="#0F172A" strokeWidth="2"
+                    className="shadow-2xl"
+                />
+                <rect x="28" y="38" width="64" height="44" rx="10" fill="#020617" filter="url(#inner-glow)" />
+                
+                {/* Screen Eyes (Proper SVG Rects) */}
+                <motion.g animate={{ scale: isHovered ? 1.05 : 1 }} transition={{ duration: 0.3 }}>
+                    {/* Left Eye Shell */}
+                    <rect x="38" y="50" width="14" height="20" rx="3" fill="#334155" />
+                    <motion.rect 
+                        x="41" y="54" width="8" height="12" rx="2" fill="#64748B"
+                        style={{ x: mouseX, y: mouseY }}
+                        animate={{ height: [12, 1, 12, 12, 12] }} 
+                        transition={{ duration: 4, repeat: Infinity, times: [0, 0.05, 0.1, 0.8, 1] }} 
+                    />
+                    
+                    {/* Right Eye Shell */}
+                    <rect x="68" y="50" width="14" height="20" rx="3" fill="#334155" />
+                    <motion.rect 
+                        x="71" y="54" width="8" height="12" rx="2" fill="#64748B"
+                        style={{ x: mouseX, y: mouseY }}
+                        animate={{ height: [12, 1, 12, 12, 12] }}
+                        transition={{ duration: 4, repeat: Infinity, times: [0, 0.05, 0.1, 0.8, 1] }}
+                    />
+                </motion.g>
+
+                {/* Antenna */}
+                <rect x="58" y="12" width="4" height="18" fill="#CBD5E1" />
+                <motion.circle 
+                    cx="60" cy="12" r="4" fill="#64748B"
+                    animate={{ 
+                        opacity: [1, 0.6, 1],
+                        scale: [1, 1.2, 1],
+                    }}
+                    transition={{ duration: 3, repeat: Infinity }}
+                />
+            </svg>
+        </div>
+      </motion.div>
+    </motion.div>
+  );
+};

src/components/Dashboard/StatisticCard.tsx

@@ -0,0 +1,138 @@
+import React from 'react';
+import { motion } from 'framer-motion';
+import { Target, Clock, TrendingUp, MoreHorizontal } from 'lucide-react';
+import { useAppContext } from '../../context/AppContext';
+
+export const StatisticCard: React.FC = () => {
+  const { agent, resources } = useAppContext();
+
+  // Dynamic Telemetry Calculations
+  const tasksCompleted = agent.visitedResources.length;
+  const timeSpent = `${(tasksCompleted * 45 / 60).toFixed(1)}h`; // 45 mins per module
+  const progressPercent = agent.totalReward % 100;
+  const stageFormatted = `STAGE ${(agent.level || 0).toString().padStart(2, '0')}`;
+  
+  // Find Active Objective (Next Unvisited Module)
+  const unvisitedNodes = resources.filter(r => !agent.visitedResources.includes(r.id));
+  const currentObjective = unvisitedNodes.length > 0 ? unvisitedNodes[0].title : "Matrix Complete";
+
+
+
+  return (
+    <motion.div 
+      initial={{ opacity: 0, y: 10 }}
+      animate={{ opacity: 1, y: 0 }}
+      className="bg-white rounded-[32px] p-8 shadow-[0_8px_30px_rgb(0,0,0,0.02)] border border-slate-100 w-full flex flex-col gap-8 relative overflow-hidden group"
+    >
+      {/* Complex Background Accents */}
+      <div className="absolute top-0 right-0 w-48 h-48 bg-brand/5 rounded-full blur-[80px] -translate-y-1/2 translate-x-1/2 opacity-60" />
+      <div className="absolute bottom-0 left-0 w-32 h-32 bg-emerald-500/5 rounded-full blur-[60px] translate-y-1/2 -translate-x-1/2 opacity-40" />
+      <div className="absolute inset-0 bg-[url('https://www.transparenttextures.com/patterns/carbon-fibre.png')] opacity-[0.015] pointer-events-none" />
+
+      {/* Header */}
+      <div className="flex justify-between items-center relative z-10 px-1">
+        <div className="flex items-center gap-4">
+          <div className="relative">
+            <div className="absolute inset-0 bg-brand/10 rounded-2xl blur-lg animate-pulse opacity-40" />
+            <div className="w-12 h-12 rounded-2xl bg-white border border-slate-100 flex items-center justify-center overflow-hidden shadow-sm relative z-10 p-0.5">
+              <img 
+                src="https://api.dicebear.com/7.x/avataaars/svg?seed=Felix&backgroundColor=f1f5f9" 
+                alt="Avatar" 
+                className="w-full h-full object-cover rounded-[14px]"
+              />
+            </div>
+          </div>
+          <div>
+            <div className="flex items-center gap-2 mb-1.5">
+                <div className="w-1.5 h-1.5 bg-brand rounded-full shadow-[0_0_8px_rgba(108,99,255,0.6)]" />
+                <h3 className="text-[11px] font-black text-slate-400 uppercase tracking-[0.2em] leading-none">Intelligence Hub</h3>
+            </div>
+            <p className="text-sm font-bold text-slate-900">Analysis: Learner</p>
+          </div>
+        </div>
+        <button className="w-10 h-10 flex items-center justify-center text-slate-300 hover:text-slate-600 hover:bg-slate-50 rounded-xl transition-all">
+          <MoreHorizontal size={20} />
+        </button>
+      </div>
+
+      {/* Analytical Metrics Section */}
+      <div className="flex flex-col gap-6 relative z-10 px-1">
+        {/* Tasks Analytics */}
+        <div className="flex flex-col gap-3 group transition-all">
+          <div className="flex items-end justify-between">
+            <div className="flex items-center gap-2.5 px-3 py-1.5 bg-slate-50/80 border border-slate-100/50 rounded-full">
+               <div className="text-emerald-500">
+                 <Target size={14} />
+               </div>
+               <span className="text-[10px] font-bold text-slate-500 uppercase tracking-widest">Summaries</span>
+            </div>
+            <div className="flex items-baseline gap-1.5">
+               <span className="text-2xl font-black text-slate-900 tracking-tighter">{tasksCompleted}</span>
+               <span className="text-[10px] font-bold text-emerald-600 bg-emerald-50 px-1.5 py-0.5 rounded-md">+12%</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Objective Progress */}
+        <div className="p-5 bg-gradient-to-br from-slate-50/80 to-white rounded-3xl border border-slate-100 hover:border-brand/20 transition-all shadow-[0_4px_20px_rgba(0,0,0,0.01)] group/objective">
+          <div className="flex flex-col gap-4">
+            <div className="flex justify-between items-center">
+                <div className="flex items-center gap-2.5">
+                    <div className="p-1.5 bg-brand/5 rounded-lg">
+                        <Target size={14} className="text-brand shadow-[0_0_10px_rgba(108,99,255,0.2)]" />
+                    </div>
+                    <span className="text-[9px] font-black text-slate-400 uppercase tracking-widest">Active Objective</span>
+                </div>
+                <div className="px-2 py-1 bg-white border border-slate-100 rounded-lg shadow-sm">
+                    <span className="text-[10px] font-black text-brand tracking-tight">{stageFormatted}</span>
+                </div>
+            </div>
+            <h4 className="text-xs font-bold text-slate-700 leading-tight group-hover/objective:text-slate-900 transition-colors uppercase tracking-tight">{currentObjective}</h4>
+            <div className="w-full bg-slate-200/60 h-2 rounded-full overflow-hidden p-[1px] shadow-inner">
+                <motion.div 
+                   initial={{ width: 0 }}
+                   animate={{ width: `${progressPercent}%` }}
+                   transition={{ duration: 1.2, delay: 0.5 }}
+                   className="bg-brand h-full rounded-full shadow-[0_0_12px_rgba(108,99,255,0.3)] relative overflow-hidden"
+                >
+                    <div className="absolute inset-0 bg-gradient-to-r from-transparent via-white/20 to-transparent animate-shimmer" />
+                </motion.div>
+            </div>
+          </div>
+        </div>
+
+        {/* Time Multi-Metric */}
+        <div className="flex items-center justify-between pt-3">
+            <div className="flex items-center gap-4">
+                <div className="w-11 h-11 flex items-center justify-center bg-indigo-50/50 border border-indigo-100/50 text-indigo-500 rounded-2xl shadow-sm">
+                    <Clock size={18} />
+                </div>
+                <div>
+                   <p className="text-[9px] font-black text-slate-400 uppercase tracking-widest leading-none mb-1.5">Time Invested</p>
+                   <p className="text-base font-black text-slate-900 leading-none">{timeSpent}</p>
+                </div>
+            </div>
+            <div className="flex flex-col items-end">
+                <div className="flex items-center gap-1.5 text-emerald-500 mb-2 px-2 py-1 bg-emerald-50/50 rounded-lg border border-emerald-100/50">
+                    <TrendingUp size={12} />
+                    <span className="text-[10px] font-black tracking-tighter">Sync: {progressPercent}%</span>
+                </div>
+                <div className="w-14 h-1.5 bg-slate-100 rounded-full overflow-hidden p-[1px]">
+                    <div className="w-full h-full bg-emerald-500/20 rounded-full" />
+                </div>
+            </div>
+        </div>
+      </div>
+
+      {/* High-Fidelity Footer */}
+      <div className="pt-4 border-t border-slate-50 mt-2">
+        <div className="flex items-center justify-center gap-2">
+            <div className="w-1 h-1 bg-emerald-400 rounded-full" />
+            <p className="text-[8px] text-slate-300 font-bold uppercase tracking-[0.4em]">
+              Security Matrix : Operational
+            </p>
+        </div>
+      </div>
+    </motion.div>
+  );
+};

src/components/GridVisualization.tsx

@@ -0,0 +1,876 @@
+import React, { useState } from 'react';
+import { motion } from 'framer-motion';
+import { Resource, Agent, GridPosition, Polyline } from '../types';
+import { BookOpen, Play, FileText, PenTool, RefreshCw, MapPin, Sparkles, Search, X, ChevronRight, ZoomIn, ZoomOut } from 'lucide-react';
+import { nlpApi } from '../services/nlpApi';
+const avatar = "https://api.dicebear.com/7.x/avataaars/svg?seed=Felix&backgroundColor=f1f5f9";
+
+interface GridVisualizationProps {
+  resources: Resource[];
+  agent: Agent;
+  polylines: Polyline[];
+  onResourceClick: (resource: Resource) => void;
+  onAgentMove: (position: GridPosition) => void;
+  isSimulationRunning: boolean;
+  dqnPathInfo: { resource: Resource | null, reward: number } | null;
+  onRefreshDQNPath: () => void;
+  isPlaying?: boolean;
+  playbackPath?: GridPosition[];
+  onPlaybackComplete?: () => void;
+}
+
+const GRID_SIZE = 20;
+
+const ResourceIcon = ({ type }: { type: Resource['type'] }) => {
+  const iconProps = { size: 14, className: "text-white drop-shadow-sm" };
+
+  switch (type) {
+    case 'book':
+      return <BookOpen {...iconProps} />;
+    case 'video':
+      return <Play {...iconProps} />;
+    case 'quiz':
+      return <FileText {...iconProps} />;
+    case 'assignment':
+      return <PenTool {...iconProps} />;
+    default:
+      return <BookOpen {...iconProps} />;
+  }
+};
+
+const SocialAgent: React.FC<{ isMoving: boolean }> = ({ isMoving }) => {
+  return (
+    <motion.div
+      className="relative flex flex-col items-center justify-center -translate-y-4"
+      animate={isMoving ? { 
+        scale: [1, 1.1, 1],
+        rotateY: 0
+      } : { rotateY: 0 }}
+      transition={{ duration: 0.3 }}
+    >
+      {/* Tooltip */}
+      <div className="absolute -bottom-8 bg-[#1A1F2E] text-white text-[10px] font-medium px-2 py-0.5 rounded shadow-lg whitespace-nowrap z-50">
+          You are here
+          <div className="absolute -top-1 left-1/2 -translate-x-1/2 w-0 h-0 border-l-4 border-l-transparent border-r-4 border-r-transparent border-b-4 border-b-[#1A1F2E]" />
+      </div>
+
+      {/* Main Avatar Container */}
+      <div className="relative w-12 h-12 rounded-full border-2 border-white shadow-xl overflow-visible p-0.5 bg-white">
+        <img 
+          src={avatar} 
+          alt="User Profile" 
+          className="w-full h-full rounded-full object-cover"
+        />
+        {/* Online Indicator */}
+        <div className="absolute top-0 right-0 w-3 h-3 bg-green-500 border-2 border-white rounded-full shadow-sm animate-pulse" />
+      </div>
+    </motion.div>
+  );
+};
+
+export const GridVisualization: React.FC<GridVisualizationProps> = ({
+  resources,
+  agent,
+  polylines,
+  onResourceClick,
+  onAgentMove,
+  isSimulationRunning,
+  dqnPathInfo,
+  onRefreshDQNPath,
+  isPlaying = false,
+  playbackPath = [],
+  onPlaybackComplete
+}) => {
+  const [selectedResource, setSelectedResource] = useState<Resource | null>(null);
+  const [hoveredResource, setHoveredResource] = useState<string | null>(null);
+  const hoverTimeout = React.useRef<NodeJS.Timeout | null>(null);
+  const [pathProgress, setPathProgress] = useState(0);
+  const [isSearching, setIsSearching] = useState(false);
+  const [searchQuery, setSearchQuery] = useState('');
+  const [zoomLevel, setZoomLevel] = useState(1.5);
+  const gridRef = React.useRef<HTMLDivElement>(null);
+
+  // Auto-scroll to agent on load or movement
+  React.useEffect(() => {
+    if (gridRef.current && agent.position) {
+      const scrollY = (agent.position.y * (1000 / GRID_SIZE) * zoomLevel) - (gridRef.current.clientHeight / 2);
+      const scrollX = (agent.position.x * (1000 / GRID_SIZE) * zoomLevel) - (gridRef.current.clientWidth / 2);
+      
+      gridRef.current.scrollTo({
+        top: scrollY,
+        left: scrollX,
+        behavior: 'smooth'
+      });
+    }
+  }, [agent.position.x, agent.position.y, zoomLevel]);
+  const [videoResource, setVideoResource] = useState<Resource | null>(null);
+  const [chatMessages, setChatMessages] = useState<{ role: string; content: string }[]>([]);
+  const [chatInput, setChatInput] = useState('');
+  const [chatLoading, setChatLoading] = useState(false);
+  // @ts-ignore
+  const chatEndRef = React.useRef<HTMLDivElement | null>(null);
+
+  // Tracking agent movement for animation
+  const [prevPosition, setPrevPosition] = useState<GridPosition>(agent.position);
+  const [showTravelArrow, setShowTravelArrow] = useState(false);
+
+  React.useEffect(() => {
+    if (agent.position.x !== prevPosition.x || agent.position.y !== prevPosition.y) {
+      setShowTravelArrow(true);
+      const timer = setTimeout(() => {
+        setShowTravelArrow(false);
+        setPrevPosition(agent.position);
+      }, 1500); // Duration of arrow visibility
+      return () => clearTimeout(timer);
+    }
+  }, [agent.position, prevPosition]);
+
+  // Convert YouTube URL to embed URL
+  const getYouTubeEmbedUrl = (url: string): string | null => {
+    if (!url) return null;
+    // Handle youtu.be/ID and youtube.com/watch?v=ID formats
+    let videoId = '';
+    if (url.includes('youtu.be/')) {
+      videoId = url.split('youtu.be/')[1]?.split(/[?&#]/)[0] || '';
+    } else if (url.includes('watch?v=')) {
+      videoId = url.split('watch?v=')[1]?.split(/[?&#]/)[0] || '';
+    } else if (url.includes('youtube.com/embed/')) {
+      return url; // Already embed URL
+    }
+    return videoId ? `https://www.youtube.com/embed/${videoId}?autoplay=1&rel=0` : null;
+  };
+
+  const handleMouseEnter = (id: string) => {
+    if (hoverTimeout.current) clearTimeout(hoverTimeout.current);
+    setHoveredResource(id);
+  };
+
+  const handleMouseLeave = () => {
+    hoverTimeout.current = setTimeout(() => {
+      setHoveredResource(null);
+    }, 200);
+  };
+
+  // Handle Playback Animation
+  React.useEffect(() => {
+    if (isPlaying && playbackPath.length > 1) {
+      setPathProgress(0);
+      const totalDuration = playbackPath.length * 800; // 800ms per segment
+      const startTime = Date.now();
+
+      const interval = setInterval(() => {
+        const elapsed = Date.now() - startTime;
+        const progress = Math.min(elapsed / totalDuration, 1);
+        setPathProgress(progress);
+
+        if (progress >= 1) {
+          clearInterval(interval);
+          if (onPlaybackComplete) onPlaybackComplete();
+        }
+      }, 16);
+
+      return () => clearInterval(interval);
+    }
+  }, [isPlaying, playbackPath, onPlaybackComplete]);
+
+  const handleCellClick = (x: number, y: number) => {
+    const resource = resources.find(r => r.position.x === x && r.position.y === y);
+    if (resource) {
+      setSelectedResource(resource);
+      onResourceClick(resource);
+    } else {
+      onAgentMove({ x, y });
+    }
+  };
+
+  const renderNeuralRoad = () => {
+    return polylines.filter(p => p.isActive).map(polyline => (
+        <svg key={polyline.id} className="absolute inset-0 w-full h-full pointer-events-none z-10">
+            <path
+                d={polyline.path.map((pos, i) => 
+                    `${i === 0 ? 'M' : 'L'} ${(pos.x + 0.5) * 50} ${(pos.y + 0.5) * 50}`
+                ).join(' ')}
+                fill="none"
+                stroke={polyline.color}
+                strokeWidth="12"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                className="opacity-20 filter blur-[2px]"
+            />
+            <path
+                d={polyline.path.map((pos, i) => 
+                    `${i === 0 ? 'M' : 'L'} ${(pos.x + 0.5) * 50} ${(pos.y + 0.5) * 50}`
+                ).join(' ')}
+                fill="none"
+                stroke={polyline.color}
+                strokeWidth="4"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                strokeDasharray="1 8"
+                className="opacity-40"
+            />
+        </svg>
+    ));
+  };
+
+  const renderPlaybackOverlay = () => {
+    if (!isPlaying || playbackPath.length < 2) return null;
+
+    // Convert grid coordinates to percentages (assuming 1fr grid)
+    // Grid matches 1000x1000px container
+    const CELL_SIZE = 1000 / GRID_SIZE;
+    const HALF_CELL = CELL_SIZE / 2;
+
+    const pathSegments = [];
+    for (let i = 0; i < playbackPath.length - 1; i++) {
+      const start = playbackPath[i];
+      const end = playbackPath[i + 1];
+
+      const x1 = start.x * CELL_SIZE + HALF_CELL;
+      const y1 = start.y * CELL_SIZE + HALF_CELL;
+      const x2 = end.x * CELL_SIZE + HALF_CELL;
+      const y2 = end.y * CELL_SIZE + HALF_CELL;
+
+      // Calculate control point for arc
+      // Midpoint
+      const mx = (x1 + x2) / 2;
+      const my = (y1 + y2) / 2;
+      // Vector
+      const dx = x2 - x1;
+      const dy = y2 - y1;
+      // Perpendicular vector (scaled) - Fixed arc height
+      const arcHeight = 30;
+      // Normalize
+      const len = Math.sqrt(dx * dx + dy * dy) || 1;
+      const px = -dy / len * arcHeight;
+      const py = dx / len * arcHeight;
+
+      const cx = mx + px;
+      const cy = my + py;
+
+      const d = `M ${x1} ${y1} Q ${cx} ${cy} ${x2} ${y2}`;
+      pathSegments.push({ d, id: i }); // Add index to stagger animation
+    }
+
+    return (
+      <div className="absolute inset-0 z-50 pointer-events-none">
+        <svg width="100%" height="100%" viewBox="0 0 1000 1000" className="overflow-visible">
+          <defs>
+            <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
+              <feGaussianBlur stdDeviation="2" result="blur" />
+              <feComposite in="SourceGraphic" in2="blur" operator="over" />
+            </filter>
+            <linearGradient id="pathGradient" x1="0%" y1="0%" x2="100%" y2="0%">
+              <stop offset="0%" stopColor="#3b82f6" />
+              <stop offset="50%" stopColor="#8b5cf6" />
+              <stop offset="100%" stopColor="#d946ef" />
+            </linearGradient>
+            <marker id="arrowhead-swallowtail" markerWidth="6" markerHeight="6" refX="5" refY="3" orient="auto">
+              <path d="M 0 0 L 6 3 L 0 6 L 2 3 z" fill="#d946ef" />
+            </marker>
+          </defs>
+          {pathSegments.map((seg, idx) => {
+            const segmentProgress = Math.max(0, Math.min(1, (pathProgress * playbackPath.length) - idx));
+            const dashLen = 1000;
+
+            if (segmentProgress <= 0) return null;
+
+            return (
+              <g key={idx}>
+                {/* Background trace */}
+                <path d={seg.d} fill="none" stroke="rgba(139, 92, 246, 0.1)" strokeWidth="4" strokeLinecap="round" />
+
+                {/* Animated Glowing Line */}
+                <path
+                  d={seg.d}
+                  fill="none"
+                  stroke="url(#pathGradient)"
+                  strokeWidth="3"
+                  strokeLinecap="round"
+                  strokeDasharray="8 6"
+                  markerEnd="url(#arrowhead-swallowtail)"
+                  filter="url(#glow)"
+                  strokeDashoffset={dashLen * (1 - segmentProgress)}
+                />
+              </g>
+            );
+          })}
+        </svg>
+      </div>
+    );
+  };
+
+  const renderGrid = () => {
+    const cells = [];
+
+    for (let y = 0; y < GRID_SIZE; y++) {
+      for (let x = 0; x < GRID_SIZE; x++) {
+        const resource = resources.find(r => r.position.x === x && r.position.y === y);
+        const isAgent = agent.position.x === x && agent.position.y === y;
+
+        // Dynamic Tooltip Positioning
+        let tooltipClass = "absolute bottom-full left-1/2 -translate-x-1/2 mb-2";
+        let arrowClass = "absolute left-1/2 -translate-x-1/2 -bottom-2";
+
+        if (x < 4) {
+          tooltipClass = "absolute bottom-full left-0 mb-2";
+          arrowClass = "absolute left-4 -bottom-2";
+        } else if (x > 15) {
+          tooltipClass = "absolute bottom-full right-0 mb-2";
+          arrowClass = "absolute right-4 -bottom-2";
+        }
+
+        if (y < 4) {
+          if (x < 4) {
+            tooltipClass = "absolute top-full left-0 mt-2";
+            arrowClass = "absolute left-4 -top-2";
+          } else if (x > 15) {
+            tooltipClass = "absolute top-full right-0 mt-2";
+            arrowClass = "absolute right-4 -top-2";
+          } else {
+            tooltipClass = "absolute top-full left-1/2 -translate-x-1/2 mt-2";
+            arrowClass = "absolute left-1/2 -translate-x-1/2 -top-2";
+          }
+        }
+
+        const showTooltip = resource && hoveredResource === resource.id;
+
+        cells.push(
+            <div
+            key={`${x}-${y}`}
+            className={`
+              relative transition-all duration-300
+              ${isAgent ? 'z-40' : 'z-30'}
+              ${showTooltip ? 'z-[100]' : ''}
+            `}
+            style={{
+              gridColumn: x + 1,
+              gridRow: y + 1,
+            }}
+            onClick={() => handleCellClick(x, y)}
+          >
+            {resource && (
+              <div
+                className="absolute inset-0 m-auto flex items-center justify-center w-full h-full"
+                onMouseEnter={() => handleMouseEnter(resource.id)}
+                onMouseLeave={handleMouseLeave}
+              >
+                {/* Circular Reference Marker */}
+                <div className={`
+                  relative flex items-center justify-center
+                  w-10 h-10 transform transition-all duration-300
+                  ${selectedResource?.id === resource.id ? 'scale-110' : 'hover:scale-110 hover:-translate-y-1'}
+                `}>
+                  {/* Outer Glow */}
+                  <div className={`absolute inset-0 rounded-full blur-[8px] opacity-25 ${
+                    resource.visited ? 'bg-green-400' :
+                    resource.difficulty <= 2 ? 'bg-purple-400' : 
+                    resource.difficulty <= 4 ? 'bg-blue-400' : 
+                    resource.difficulty <= 6 ? 'bg-amber-400' : 'bg-red-400'
+                  }`} />
+                  
+                  {/* Pin Head — green when visited */}
+                  <div className={`
+                    w-8 h-8 rounded-full shadow-lg flex items-center justify-center border-2 border-white
+                    transition-colors duration-500
+                    ${resource.visited ? 'bg-emerald-500' :
+                      resource.difficulty <= 2 ? 'bg-[#A855F7]' :
+                      resource.difficulty <= 4 ? 'bg-[#3B82F6]' :
+                      resource.difficulty <= 6 ? 'bg-[#F59E0B]' : 'bg-[#EF4444]'}
+                  `}>
+                    <ResourceIcon type={resource.type} />
+                  </div>
+
+                  <div
+                    className={`${tooltipClass} w-72 transition-opacity duration-200 z-50 ${showTooltip ? 'opacity-100 pointer-events-auto' : 'opacity-0 pointer-events-none'}`}
+                    onMouseEnter={() => handleMouseEnter(resource.id)}
+                    onMouseLeave={handleMouseLeave}
+                  >
+                    <div className="bg-white rounded-xl shadow-2xl border border-gray-100 overflow-hidden cursor-default" onClick={(e) => e.stopPropagation()}>
+                      <div className={`h-32 w-full relative ${resource.visited ? 'bg-gradient-to-tr from-emerald-500 to-teal-400' : 'bg-gradient-to-tr from-blue-600 to-indigo-500'}`}>
+                        <div className="absolute inset-0 opacity-20" style={{ backgroundImage: 'radial-gradient(circle at 2px 2px, white 1px, transparent 0)', backgroundSize: '16px 16px' }}></div>
+                        <div className="absolute inset-0 flex items-center justify-center">
+                          <ResourceIcon type={resource.type} />
+                          <div className="absolute transform scale-[5] opacity-10"><ResourceIcon type={resource.type} /></div>
+                        </div>
+                      </div>
+
+                      <div className="p-4 text-left">
+                        <div className="flex justify-between items-start mb-2">
+                          <h4 className="font-bold text-gray-900 text-lg leading-tight line-clamp-2">{resource.title}</h4>
+                          {resource.visited && (
+                            <span className="bg-green-100 text-green-700 text-[10px] font-bold px-2 py-0.5 rounded uppercase tracking-wide shrink-0 ml-2">
+                              Completed
+                            </span>
+                          )}
+                        </div>
+
+                        <div className="flex items-center gap-2 text-xs text-gray-500 mb-3">
+                          <span className="capitalize">{resource.type} Lesson</span>
+                          <span>•</span>
+                          <span>{['Beginner', 'Intermediate', 'Advanced', 'Expert', 'Master'][resource.difficulty - 1] || 'Intermediate'}</span>
+                        </div>
+
+                        <div className="flex items-center gap-4 text-xs text-gray-500 font-medium mb-4">
+                          <div className="flex items-center gap-1">
+                            <span className="text-gray-400">⏱</span>
+                            <span>{10 + (resource.title.length % 20)} mins</span>
+                          </div>
+                          <div className="flex items-center gap-1">
+                            <span className="text-emerald-400">🎯</span>
+                            <span>Target: {(resource.high_line ? resource.high_line * 100 : 80).toFixed(0)}%</span>
+                          </div>
+                          <div className="flex items-center gap-1">
+                            <span className="text-amber-400">★</span>
+                            <span>{resource.base_points ?? 50} pts</span>
+                          </div>
+                        </div>
+
+                        <button
+                          onClick={(e) => {
+                            e.stopPropagation();
+                            if (isAgent && resource.youtube_url) {
+                              setVideoResource(resource);
+                              setHoveredResource(null);
+                            } else {
+                              handleCellClick(x, y);
+                            }
+                          }}
+                          className={`w-full py-2.5 ${isAgent ? 'bg-indigo-600 hover:bg-indigo-700 border-indigo-500/20 shadow-indigo-500/20' : 'bg-blue-600 hover:bg-blue-700 border-blue-500/20 shadow-blue-500/10'} text-white text-sm font-semibold rounded-xl transition-all flex items-center justify-center gap-2 shadow-lg active:scale-95 transform duration-100 border`}
+                        >
+                          {isAgent ? '▶ Start Lesson' : 'Travel to Lesson'}
+                          <span className="text-lg leading-none">→</span>
+                        </button>
+                      </div>
+                    </div>
+                    <div className={`w-4 h-4 bg-white transform rotate-45 shadow-lg z-[-1] ${arrowClass}`}></div>
+                  </div>
+                </div>
+              </div>
+            )}
+
+            {/* Resource cell placeholder */}
+          </div>
+        );
+      }
+    }
+    return cells;
+  };
+
+  const handleChatSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!chatInput.trim() || !videoResource || chatLoading) return;
+
+    const userMessage = chatInput;
+    setChatInput('');
+    setChatMessages(prev => [...prev, { role: 'user', content: userMessage }]);
+    setChatLoading(true);
+
+    try {
+      const data = await nlpApi.chat(videoResource.title, userMessage, chatMessages);
+      setChatMessages(prev => [...prev, { role: 'ai', content: data.answer }]);
+    } catch (error) {
+      console.error('Chat error:', error);
+      setChatMessages(prev => [...prev, { role: 'ai', content: 'Sorry, I failed to process your request.' }]);
+    } finally {
+      setChatLoading(false);
+    }
+  };
+
+  return (
+    <div className="flex flex-col h-full bg-gray-50/30 overflow-hidden">
+      <div className="flex-none px-6 py-4 bg-white/90 backdrop-blur-sm border-b border-gray-100 flex justify-between items-center z-10">
+        <div>
+          <h2 className="text-lg font-bold text-gray-900 flex items-center gap-2">
+            <MapPin className="w-5 h-5 text-blue-600" />
+            Learning Environment
+          </h2>
+          <p className="text-xs text-gray-500 mt-0.5">Explore resources and track your journey</p>
+        </div>
+
+        <div className="flex items-center gap-4">
+          <div className="flex items-center bg-white border border-gray-100 rounded-lg shadow-sm p-1">
+             <button 
+              onClick={() => setZoomLevel(prev => Math.max(1, prev - 0.25))}
+              className="p-1.5 hover:bg-gray-50 text-gray-500 transition-colors rounded-md"
+              title="Zoom Out"
+             >
+                <ZoomOut size={16} />
+             </button>
+             <div className="w-px h-4 bg-gray-100 mx-1"></div>
+             <button 
+              onClick={() => setZoomLevel(1.5)}
+              className="px-2 py-1 hover:bg-gray-50 text-gray-400 text-[10px] font-bold transition-colors rounded-md"
+              title="Reset Zoom"
+             >
+                {Math.round(zoomLevel * 100)}%
+             </button>
+             <div className="w-px h-4 bg-gray-100 mx-1"></div>
+             <button 
+              onClick={() => setZoomLevel(prev => Math.min(3, prev + 0.25))}
+              className="p-1.5 hover:bg-gray-50 text-gray-500 transition-colors rounded-md"
+              title="Zoom In"
+             >
+                <ZoomIn size={16} />
+             </button>
+          </div>
+
+          <button
+            onClick={() => setIsSearching(true)}
+            className="flex items-center gap-2 px-3 py-1.5 bg-white border border-blue-200 hover:bg-blue-50 text-blue-600 text-xs font-semibold rounded-lg transition-all shadow-sm"
+          >
+            <Search className="w-3.5 h-3.5" />
+            <span>Search</span>
+          </button>
+          
+          {isSimulationRunning && (
+            <button
+              onClick={onRefreshDQNPath}
+              className="flex items-center gap-2 px-3 py-1.5 bg-white border border-red-200 hover:bg-red-50 text-red-600 text-xs font-semibold rounded-lg transition-all shadow-sm group"
+            >
+              <RefreshCw className="w-3.5 h-3.5 group-hover:rotate-180 transition-transform duration-500" />
+              <span>Optimize Path</span>
+            </button>
+          )}
+
+          <div className="flex items-center gap-3 bg-gray-50 px-3 py-1.5 rounded-lg border border-gray-100">
+                  <div className="flex items-center gap-2">
+                    <div className="w-5 h-5 rounded-full border border-blue-200 overflow-hidden bg-white shadow-sm">
+                        <img src={avatar} alt="Avatar" className="w-full h-full object-cover" />
+                    </div>
+                    <span className="text-xs font-medium text-gray-600">You (Agent)</span>
+                  </div>
+            <div className="w-px h-3 bg-gray-200"></div>
+            <div className="flex items-center gap-1.5">
+              <div className="w-2.5 h-2.5 bg-[#A855F7] rounded-full"></div>
+              <span className="text-xs font-medium text-gray-600">Resource</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {isSimulationRunning && dqnPathInfo?.resource && (
+        <div className="absolute top-20 right-6 z-20 animate-in slide-in-from-top-4 fade-in duration-300 pointer-events-none">
+          <div className="bg-white/95 backdrop-blur-md px-4 py-3 rounded-xl shadow-lg border border-red-100 ring-1 ring-red-50 w-64 pointer-events-auto">
+            <div className="flex items-start justify-between gap-3">
+              <div>
+                <span className="text-[10px] font-bold tracking-wider text-red-500 uppercase">Recommendation</span>
+                <h3 className="text-sm font-semibold text-gray-900 mt-0.5 line-clamp-1">{dqnPathInfo.resource.title}</h3>
+              </div>
+              <div className="flex flex-col items-end">
+                <span className="text-lg font-bold text-red-600 leading-none">+{dqnPathInfo.reward}</span>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      <div className="flex-1 w-full relative overflow-auto bg-gray-50/30" ref={gridRef}>
+        <div className="min-w-full min-h-full flex items-center justify-center p-8">
+          <div
+            className="grid gap-0 bg-[#F8FAFC] rounded-3xl shadow-2xl p-4 shrink-0 relative overflow-hidden"
+            style={{
+              width: `${1000 * zoomLevel}px`,
+              height: `${1000 * zoomLevel}px`,
+              gridTemplateColumns: `repeat(${GRID_SIZE}, 1fr)`,
+              gridTemplateRows: `repeat(${GRID_SIZE}, 1fr)`,
+              backgroundImage: `radial-gradient(#E2E8F0 1.5px, transparent 1.5px)`,
+              backgroundSize: `${24 * zoomLevel}px ${24 * zoomLevel}px`,
+              transition: 'width 0.3s ease-out, height 0.3s ease-out'
+            }}
+          >
+            {/* Map Terrain: color-coded 0°-90° quarter-circle arcs with hover tooltips */}
+            <div className="absolute inset-0 pointer-events-none z-0">
+              <svg className="absolute inset-0 w-full h-full" viewBox="0 0 1000 1000" preserveAspectRatio="none">
+                {/* Color-coded concentric arcs — each arc belongs to a tier */}
+                {(() => {
+                  // Tier boundaries based on radii 3,7,11,15 grid units × 50px/unit
+                  // Boundaries (midpoints between radii): 0-250, 250-450, 450-650, 650-900
+                  const tierDefs = [
+                    { name: 'Fundamentals', color: '#A855F7', from: 0,   to: 250 },
+                    { name: 'Intermediate', color: '#3B82F6', from: 250, to: 450 },
+                    { name: 'Advance',      color: '#F59E0B', from: 450, to: 650 },
+                    { name: 'Mastery',      color: '#EF4444', from: 650, to: 900 },
+                  ];
+                  const allArcs = [100,200,300,400,500,600,700,800,900];
+                  return allArcs.map((r) => {
+                    const tier = tierDefs.find(t => r > t.from && r <= t.to) || tierDefs[tierDefs.length - 1];
+                    return (
+                      <path key={`arc-${r}`}
+                        d={`M ${r} 1000 A ${r} ${r} 0 0 0 0 ${1000 - r}`}
+                        fill="none"
+                        stroke={tier.color}
+                        strokeWidth="1.5"
+                        strokeDasharray="5 7"
+                        opacity="0.5"
+                        style={{ pointerEvents: 'stroke', cursor: 'default' }}
+                      >
+                        <title>{tier.name}</title>
+                      </path>
+                    );
+                  });
+                })()}
+                {/* Radial spokes every 10° */}
+                {[10,20,30,40,50,60,70,80].map((deg) => {
+                  const rad = (deg * Math.PI) / 180;
+                  return <line key={`sp-${deg}`}
+                    x1={0} y1={1000}
+                    x2={950 * Math.cos(rad)}
+                    y2={1000 - 950 * Math.sin(rad)}
+                    stroke="#94A3B8" strokeWidth="0.8"
+                    strokeDasharray="4 7" opacity="0.35"
+                  />;
+                })}
+                {/* X-axis (bottom) and Y-axis (left) */}
+                <line x1="0" y1="999" x2="980" y2="999" stroke="#94A3B8" strokeWidth="1.5"/>
+                <line x1="1" y1="1000" x2="1" y2="20" stroke="#94A3B8" strokeWidth="1.5"/>
+                {/* Tier boundary tick marks */}
+                {[250,450,650].map(x => (
+                  <line key={`tick-${x}`} x1={x} y1={992} x2={x} y2={1000} stroke="#94A3B8" strokeWidth="1.5"/>
+                ))}
+              </svg>
+              {/* Bottom tier labels aligned to arc radii */}
+              <div className="absolute bottom-1 left-0 w-full pointer-events-none">
+                {[
+                  { label: 'FUNDAMENTALS', pct: '12.5%', color: 'text-purple-400' },
+                  { label: 'INTERMEDIATE', pct: '35%',   color: 'text-blue-400'   },
+                  { label: 'ADVANCE',      pct: '55%',   color: 'text-amber-400'  },
+                  { label: 'MASTERY',      pct: '77.5%', color: 'text-red-400'    },
+                ].map((t) => (
+                  <span key={t.label}
+                    className={`absolute text-[9px] font-black uppercase tracking-[0.15em] -translate-x-1/2 ${t.color}`}
+                    style={{ left: t.pct, bottom: 0 }}>
+                    {t.label}
+                  </span>
+                ))}
+              </div>
+            </div>
+
+
+            {renderGrid()}
+            {renderPlaybackOverlay()}
+
+            {/* Animated Student Agent Marker */}
+            <motion.div
+              key={`agent-at-${agent.position.x}-${agent.position.y}`}
+              className="absolute pointer-events-none z-40 flex items-center justify-center"
+              initial={false}
+              transition={{
+                left: { type: "spring", damping: 25, stiffness: 120 },
+                top: { type: "spring", damping: 25, stiffness: 120 },
+                scale: { duration: 0.4 },
+                rotate: { duration: 0.4 }
+              }}
+              animate={{
+                left: `${(agent.position.x + 0.5) * (100 / GRID_SIZE)}%`,
+                top: `${(agent.position.y + 0.5) * (100 / GRID_SIZE)}%`,
+                scale: isPlaying ? [1, 1.15, 1] : 1, // Subtle bounce effect during playback
+                rotateY: 0 // Force orientation reset to clear potential mirrored state
+              }}
+              style={{
+                width: `${100 / GRID_SIZE}%`,
+                height: `${100 / GRID_SIZE}%`,
+                x: '-50%',
+                y: '-50%',
+              }}
+            >
+              <SocialAgent isMoving={isPlaying} />
+            </motion.div>
+
+            {showTravelArrow && (
+              <svg className="absolute inset-0 w-full h-full pointer-events-none z-30">
+                <defs>
+                  <linearGradient id="travelGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+                    <stop offset="0%" stopColor="#ef4444" stopOpacity="0.8" />
+                    <stop offset="100%" stopColor="#ec4899" stopOpacity="0.8" />
+                  </linearGradient>
+                  <marker id="travel-arrowhead" markerWidth="12" markerHeight="8" refX="10" refY="4" orient="auto">
+                    <path d="M0,0 L12,4 L0,8 Z" fill="#ef4444" />
+                  </marker>
+                </defs>
+                <line
+                  x1={`${(prevPosition.x + 0.5) * (100 / GRID_SIZE)}%`}
+                  y1={`${(prevPosition.y + 0.5) * (100 / GRID_SIZE)}%`}
+                  x2={`${(agent.position.x + 0.5) * (100 / GRID_SIZE)}%`}
+                  y2={`${(agent.position.y + 0.5) * (100 / GRID_SIZE)}%`}
+                  stroke="url(#travelGradient)"
+                  strokeWidth="4"
+                  strokeDasharray="12 6"
+                  className="animate-pulse"
+                  markerEnd="url(#travel-arrowhead)"
+                  opacity="0.8"
+                >
+                  <animate attributeName="stroke-dashoffset" from="100" to="0" dur="2s" repeatCount="indefinite" />
+                </line>
+              </svg>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {selectedResource && (
+        <div className="flex-none w-full bg-white/95 backdrop-blur-md p-4 border-t border-blue-100 z-10 animate-in slide-in-from-bottom-4 fade-in duration-300">
+          <div className="max-w-4xl mx-auto flex items-center gap-4">
+            <div className={`p-3 rounded-lg ${selectedResource.visited ? 'bg-green-100 text-green-600' : 'bg-blue-100 text-blue-600'}`}>
+              <ResourceIcon type={selectedResource.type} />
+            </div>
+            <div className="flex-1">
+              <h3 className="font-semibold text-gray-900">{selectedResource.title}</h3>
+              <div className="flex items-center gap-3 mt-1 text-sm text-gray-500">
+                <span className="px-2 py-0.5 bg-gray-100 rounded text-xs font-medium uppercase tracking-wide">{selectedResource.type}</span>
+              </div>
+            </div>
+            <div className="flex flex-col items-end border-l border-gray-100 pl-4">
+              <span className="text-xs text-gray-400 uppercase font-semibold">Reward</span>
+              <span className="text-xl font-bold text-gray-900">+{selectedResource.reward}</span>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {isSearching && (
+        <div className="fixed inset-0 bg-gray-950/40 backdrop-blur-md flex items-center justify-center z-[250] p-4 animate-in fade-in duration-300">
+          <div className="bg-white/95 backdrop-blur-2xl rounded-[2rem] shadow-2xl w-full max-w-lg overflow-hidden border border-white/20 animate-in zoom-in-95 duration-300 flex flex-col max-h-[80vh]">
+            <div className="px-6 py-5 border-b border-gray-100 flex items-center justify-between bg-white/50">
+              <div className="flex items-center gap-3">
+                <div className="w-10 h-10 rounded-xl bg-blue-600 flex items-center justify-center text-white shadow-lg shadow-blue-500/20">
+                  <Search className="w-5 h-5" />
+                </div>
+                <div>
+                  <h3 className="text-lg font-bold text-gray-900">Resource Navigator</h3>
+                </div>
+              </div>
+              <button 
+                onClick={() => setIsSearching(false)}
+                className="p-2 rounded-full hover:bg-gray-100 text-gray-400 hover:text-gray-600 transition-colors"
+              >
+                <X className="w-5 h-5" />
+              </button>
+            </div>
+
+            <div className="p-4 border-b border-gray-100 bg-gray-50/50">
+              <div className="relative">
+                <Search className="absolute left-4 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400" />
+                <input
+                  autoFocus
+                  type="text"
+                  placeholder="Filter resources..."
+                  value={searchQuery}
+                  onChange={(e) => setSearchQuery(e.target.value)}
+                  className="w-full pl-11 pr-4 py-3 bg-white border border-gray-200 rounded-2xl outline-none focus:ring-2 focus:ring-blue-500/20 focus:border-blue-500 transition-all font-medium text-gray-800"
+                />
+              </div>
+            </div>
+
+            <div className="flex-1 overflow-y-auto p-4 space-y-2">
+              {resources
+                .filter(r => r.title.toLowerCase().includes(searchQuery.toLowerCase()))
+                .map(resource => (
+                  <button
+                    key={resource.id}
+                    onClick={() => {
+                      onAgentMove(resource.position);
+                      onResourceClick(resource);
+                      setIsSearching(false);
+                      setSearchQuery('');
+                    }}
+                    className="w-full flex items-center gap-4 p-3 rounded-2xl hover:bg-blue-50/50 border border-transparent hover:border-blue-100 transition-all group text-left"
+                  >
+                    <div className={`p-2.5 rounded-xl ${resource.visited ? 'bg-green-100 text-green-600' : 'bg-blue-100 text-blue-600'} group-hover:scale-110 transition-transform`}>
+                      <ResourceIcon type={resource.type} />
+                    </div>
+                    <div className="flex-1 min-w-0">
+                      <h4 className="font-semibold text-gray-900 text-sm truncate">{resource.title}</h4>
+                    </div>
+                    <ChevronRight className="w-4 h-4 text-gray-300 group-hover:text-blue-500 group-hover:translate-x-1 transition-all" />
+                  </button>
+                ))}
+            </div>
+          </div>
+        </div>
+      )}
+
+      {videoResource && videoResource.youtube_url && (
+        <div
+          className="fixed inset-0 bg-gray-950/80 backdrop-blur-3xl flex items-center justify-center z-[200] p-4 sm:p-8"
+          onClick={() => { setVideoResource(null); setChatMessages([]); setChatInput(''); }}
+        >
+          <div
+            className="bg-[#0f111a]/95 backdrop-blur-md rounded-[2.5rem] shadow-[0_0_80px_-15px_rgba(79,70,229,0.25)] w-full max-w-7xl h-[90vh] overflow-hidden flex flex-col border border-white/10 animate-in zoom-in-90 fade-in duration-500 ease-out relative z-10"
+            onClick={(e) => e.stopPropagation()}
+          >
+            <div className="bg-[#131620]/80 backdrop-blur-3xl px-8 py-5 flex items-center justify-between border-b border-white/5 flex-shrink-0 relative z-20">
+              <div className="flex items-center gap-5 text-white min-w-0">
+                <div className="w-12 h-12 rounded-2xl bg-gradient-to-br from-red-500 via-rose-500 to-pink-600 flex items-center justify-center flex-shrink-0 shadow-lg shadow-red-500/30 border border-white/10">
+                  <Play size={20} className="text-white fill-current ml-0.5" />
+                </div>
+                <div className="min-w-0">
+                  <h3 className="font-bold text-lg truncate text-white tracking-tight drop-shadow-sm">{videoResource.title}</h3>
+                </div>
+              </div>
+              <button
+                onClick={() => { setVideoResource(null); setChatMessages([]); setChatInput(''); }}
+                className="w-12 h-12 rounded-full bg-white/5 hover:bg-red-500/20 hover:border-red-500/30 text-gray-400 hover:text-red-400 transition-all flex items-center justify-center border border-white/5 group"
+              >
+                <X size={22} className="group-hover:rotate-90 transition-transform duration-300" />
+              </button>
+            </div>
+
+            <div className="flex flex-1 min-h-0 bg-[#090b10]">
+              <div className="flex-[65] relative bg-black overflow-hidden z-10">
+                <iframe
+                  className="w-full h-full"
+                  src={getYouTubeEmbedUrl(videoResource.youtube_url) || ''}
+                  title={videoResource.title}
+                  frameBorder="0"
+                  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+                  allowFullScreen
+                />
+              </div>
+
+              <div className="flex-[35] flex flex-col bg-[#0f111a] border-l border-white/5 relative overflow-hidden z-20">
+                <div className="bg-gradient-to-r from-indigo-500/10 to-purple-500/10 backdrop-blur-2xl px-6 py-5 flex items-center gap-4 border-b border-white/5 flex-shrink-0 relative z-30">
+                  <div className="w-10 h-10 rounded-[14px] bg-gradient-to-tr from-indigo-500 via-purple-500 to-fuchsia-500 flex items-center justify-center shadow-lg border border-white/10 ring-2 ring-white/5">
+                    <Sparkles size={18} className="text-white" />
+                  </div>
+                  <div>
+                    <h4 className="font-extrabold text-white text-[15px] tracking-tight">Learning Assistant</h4>
+                  </div>
+                </div>
+
+                <div className="flex-1 overflow-y-auto p-6 space-y-5 relative z-20">
+                  {chatMessages.map((msg, i) => (
+                    <div key={i} className={`flex ${msg.role === 'user' ? 'justify-end' : 'justify-start'}`}>
+                      <div className={`max-w-[85%] px-5 py-3.5 rounded-2xl text-[15px] leading-relaxed relative ${msg.role === 'user'
+                        ? 'bg-indigo-600 text-white rounded-br-sm'
+                        : 'bg-white/5 border border-white/10 text-gray-200 rounded-bl-sm'
+                        }`}>
+                        {msg.content}
+                      </div>
+                    </div>
+                  ))}
+                  {chatLoading && <div className="text-gray-500 text-xs animate-pulse">Thinking...</div>}
+                </div>
+
+                <form onSubmit={handleChatSubmit} className="p-4 border-t border-white/5 relative z-30">
+                  <div className="relative">
+                    <input
+                      type="text"
+                      value={chatInput}
+                      onChange={(e) => setChatInput(e.target.value)}
+                      placeholder="Ask Sider AI..."
+                      className="w-full bg-white/5 border border-white/10 rounded-xl px-4 py-3 text-white text-sm outline-none focus:border-indigo-500/50 transition-all"
+                    />
+                    <button type="submit" className="absolute right-2 top-1/2 -translate-y-1/2 p-1.5 text-indigo-400 hover:text-indigo-300">
+                      <ChevronRight size={18} />
+                    </button>
+                  </div>
+                </form>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};

src/components/Layout/AuthLayout.tsx

@@ -0,0 +1,33 @@
+import React from 'react';
+
+interface AuthLayoutProps {
+  children: React.ReactNode;
+  illustration?: React.ReactNode;
+}
+
+export const AuthLayout: React.FC<AuthLayoutProps> = ({ children, illustration }) => {
+  return (
+    <div className="min-h-screen w-full flex items-center justify-center bg-[#F8FAFC] overflow-hidden relative font-['Poppins']">
+      {/* Dynamic Background Gradients - Lighter & Softer */}
+      <div className="absolute top-[-10%] left-[-10%] w-[50%] h-[50%] bg-brand/10 rounded-full blur-[120px] animate-pulse" />
+      <div className="absolute bottom-[-10%] right-[-10%] w-[50%] h-[50%] bg-brand-light/10 rounded-full blur-[120px] animate-pulse" />
+      <div className="absolute top-[20%] right-[10%] w-[30%] h-[30%] bg-[#E0E7FF]/20 rounded-full blur-[100px]" />
+
+      <div className="container mx-auto px-4 z-10 flex items-center justify-center">
+        <div className="flex w-full max-w-5xl bg-white/40 backdrop-blur-md rounded-[40px] border border-white/60 overflow-hidden shadow-[0_20px_50px_rgba(0,0,0,0.05)]">
+          {/* Illustration Side (Desktop) */}
+          {illustration && (
+            <div className="hidden lg:flex lg:w-1/2 p-12 items-center justify-center bg-gradient-to-br from-brand/5 to-brand-dark/5 border-r border-white/40">
+              {illustration}
+            </div>
+          )}
+
+          {/* Form Side */}
+          <div className={`w-full ${illustration ? 'lg:w-1/2' : ''} p-8 lg:p-12`}>
+            {children}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

src/components/Layout/DashboardLayout.tsx

@@ -0,0 +1,483 @@
+import React, { useState } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { 
+  LayoutDashboard, 
+  BookOpen, 
+  Bookmark, 
+  Settings, 
+  LogOut, 
+  Search, 
+  Bell, 
+  Menu, 
+  X,
+  ChevronRight,
+  TrendingUp,
+  User,
+  Activity,
+  Award
+} from 'lucide-react';
+import { Link, useLocation, useNavigate } from 'react-router-dom';
+import { useAppContext } from '../../context/AppContext';
+
+interface DashboardLayoutProps {
+  children: React.ReactNode;
+}
+
+const sidebarItems = [
+  { icon: LayoutDashboard, label: 'Dashboard', path: '/dashboard' },
+  { icon: BookOpen, label: 'Navigator', path: '/navigator' },
+  { icon: Bookmark, label: 'Resources', path: '/resources' },
+  { icon: Settings, label: 'Settings', path: '#' },
+];
+
+export const DashboardLayout: React.FC<DashboardLayoutProps> = ({ children }) => {
+  const [isSidebarOpen, setIsSidebarOpen] = useState(true);
+  const [isMobileMenuOpen, setIsMobileMenuOpen] = useState(false);
+  const location = useLocation();
+  const navigate = useNavigate();
+  const [isSettingsOpen, setIsSettingsOpen] = useState(false);
+  const [isProfileOpen, setIsProfileOpen] = useState(false);
+  const [isNotificationsOpen, setIsNotificationsOpen] = useState(false);
+  const { agent, levelUpMessage, setLevelUpMessage, notifications, markNotificationsAsRead } = useAppContext();
+  
+  const progressPercent = agent.totalReward % 100;
+  const unreadCount = notifications.filter(n => !n.read).length;
+
+  const handleSignOut = () => {
+    // Basic sign out
+    navigate('/login');
+  };
+
+  return (
+    <div className="min-h-screen bg-[#F0F4F8] text-slate-800 font-['Poppins'] overflow-hidden flex transition-colors duration-500">
+      {/* Background Blobs - Subtle & Airy */}
+      <div className="fixed top-[-10%] left-[-10%] w-[40%] h-[40%] bg-brand/5 rounded-full blur-[120px] pointer-events-none" />
+      <div className="fixed bottom-[-10%] right-[-10%] w-[40%] h-[40%] bg-brand-light/5 rounded-full blur-[120px] pointer-events-none" />
+
+      {/* Sidebar - Desktop */}
+      <motion.aside
+        initial={false}
+        animate={{ width: isSidebarOpen ? 280 : 88 }}
+        className="hidden lg:flex flex-col bg-white/60 backdrop-blur-xl border-r border-slate-200 relative z-30 h-screen transition-all duration-300 shadow-xl shadow-slate-200/50"
+      >
+        <div className="p-6 flex items-center gap-3">
+          <AnimatePresence>
+            {isSidebarOpen && (
+              <motion.span
+                initial={{ opacity: 0, x: -10 }}
+                animate={{ opacity: 1, x: 0 }}
+                exit={{ opacity: 0, x: -10 }}
+                className="text-xl font-extrabold whitespace-nowrap bg-clip-text text-transparent bg-gradient-to-r from-brand to-brand-dark uppercase tracking-tighter"
+              >
+                Navigated Learning
+              </motion.span>
+            )}
+          </AnimatePresence>
+        </div>
+
+        <nav className="flex-1 px-4 py-10 space-y-3">
+          {sidebarItems.map((item) => {
+            const isActive = location.pathname === item.path;
+            return (
+              <Link
+                key={item.path}
+                to={item.path}
+                onClick={(e) => {
+                if (item.label === 'Settings') {
+                  e.preventDefault();
+                  setIsSettingsOpen(true);
+                }
+              }}
+              className={`
+                  flex items-center gap-4 px-4 py-3.5 rounded-2xl transition-all duration-300 group relative
+                  ${isActive ? 'bg-white text-brand shadow-lg shadow-brand/10' : 'text-slate-500 hover:bg-white/40 hover:text-brand'}
+                `}
+              >
+                {isActive && (
+                    <motion.div layoutId="activePill" className="absolute left-0 w-1.5 h-6 bg-brand rounded-full" />
+                )}
+                <item.icon size={22} className={`${isActive ? 'text-brand' : 'group-hover:scale-110 transition-transform'}`} />
+                {isSidebarOpen && <span className="font-bold">{item.label}</span>}
+                {isActive && isSidebarOpen && (
+                  <motion.div layoutId="activeTab" className="ml-auto">
+                    <ChevronRight size={16} />
+                  </motion.div>
+                )}
+              </Link>
+            );
+          })}
+        </nav>
+
+        <div className="p-6 border-t border-slate-100">
+          <button 
+           onClick={handleSignOut}
+           className="flex items-center gap-4 px-4 py-3 w-full rounded-2xl text-slate-400 hover:bg-red-50 hover:text-red-500 transition-all duration-300 font-bold">
+            <LogOut size={22} />
+            {isSidebarOpen && <span>Sign Out</span>}
+          </button>
+        </div>
+
+        {/* Toggle Button */}
+        <button
+          onClick={() => setIsSidebarOpen(!isSidebarOpen)}
+          className="absolute -right-3 top-20 w-7 h-7 bg-white rounded-full flex items-center justify-center border border-slate-200 shadow-xl hover:scale-110 hover:border-brand transition-all group"
+        >
+          <ChevronRight size={14} className={`text-slate-400 group-hover:text-brand transition-transform duration-300 ${isSidebarOpen ? 'rotate-180' : ''}`} />
+        </button>
+      </motion.aside>
+
+      {/* Main Content Area */}
+      <div className="flex-1 flex flex-col h-screen overflow-hidden">
+        {/* Navbar */}
+        <header className="h-20 bg-white/40 backdrop-blur-md border-b border-white/80 flex items-center justify-between px-6 lg:px-12 shrink-0 z-20">
+          <div className="flex items-center gap-4 flex-1">
+            <button 
+                className="lg:hidden p-2 text-slate-500 hover:text-brand transition-colors"
+                onClick={() => setIsMobileMenuOpen(true)}
+            >
+              <Menu size={24} />
+            </button>
+            
+            <div className="relative w-full max-w-md hidden sm:block">
+              <Search className="absolute left-4 top-1/2 -translate-y-1/2 text-slate-400" size={18} />
+              <input
+                type="text"
+                placeholder="Find a module or project..."
+                className="w-full bg-white/80 border border-slate-200 rounded-2xl py-3 pl-12 pr-4 outline-none focus:border-brand focus:ring-4 focus:ring-brand/10 transition-all text-sm shadow-sm"
+              />
+            </div>
+          </div>
+
+          <div className="flex items-center gap-4 lg:gap-8">
+            <button 
+               onClick={() => {
+                 setIsNotificationsOpen(!isNotificationsOpen);
+                 if (!isNotificationsOpen) markNotificationsAsRead();
+               }}
+               className="relative p-2.5 bg-white border border-slate-100 rounded-xl text-slate-500 hover:text-brand hover:border-brand/20 transition-all group shadow-sm"
+            >
+              <Bell size={20} />
+              {unreadCount > 0 && (
+                <span className="absolute top-2 right-2 w-2.5 h-2.5 bg-brand rounded-full ring-4 ring-white" />
+              )}
+            </button>
+            
+            <div className="h-8 w-px bg-slate-200 hidden sm:block" />
+            
+            <div className="flex items-center gap-4 pl-2 group">
+              <div className="text-right hidden sm:block">
+                <p className="text-sm font-extrabold text-slate-900 group-hover:text-brand transition-colors">Learner</p>
+                <div className="flex items-center gap-2 justify-end mt-0.5">
+                   <div className="w-16 h-1 bg-slate-100 rounded-full overflow-hidden">
+                      <motion.div 
+                        initial={{ width: 0 }}
+                        animate={{ width: `${progressPercent}%` }}
+                        className="h-full bg-brand"
+                      />
+                   </div>
+                   <p className="text-[9px] text-slate-400 font-bold uppercase tracking-widest">{progressPercent}% SYNC</p>
+                </div>
+              </div>
+              <motion.div 
+                whileHover={{ scale: 1.05 }}
+                onClick={() => setIsProfileOpen(true)}
+                className="w-11 h-11 rounded-2xl bg-gradient-to-tr from-brand to-brand-light p-0.5 shadow-lg shadow-brand/20 cursor-pointer"
+              >
+                <div className="w-full h-full rounded-[14px] bg-white flex items-center justify-center overflow-hidden">
+                  <img src="https://api.dicebear.com/7.x/avataaars/svg?seed=Felix" alt="Avatar" className="w-full h-full object-cover" />
+                </div>
+              </motion.div>
+            </div>
+          </div>
+        </header>
+
+        {/* Scrollable Content */}
+        <main className="flex-1 overflow-y-auto custom-scrollbar p-6 lg:p-12 relative">
+          <motion.div
+            initial={{ opacity: 0, y: 20 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{ duration: 0.5 }}
+          >
+            {children}
+          </motion.div>
+        </main>
+      </div>
+
+      {/* Mobile Menu Overlay */}
+      <AnimatePresence>
+        {isMobileMenuOpen && (
+          <>
+            <motion.div
+              initial={{ opacity: 0 }}
+              animate={{ opacity: 1 }}
+              exit={{ opacity: 0 }}
+              onClick={() => setIsMobileMenuOpen(false)}
+              className="fixed inset-0 bg-black/60 backdrop-blur-sm z-40 lg:hidden"
+            />
+            <motion.aside
+              initial={{ x: '-100%' }}
+              animate={{ x: 0 }}
+              exit={{ x: '-100%' }}
+              className="fixed inset-y-0 left-0 w-72 bg-white border-r border-slate-200 z-50 lg:hidden p-6 shadow-2xl"
+            >
+              <div className="flex items-center justify-between mb-10">
+                <div className="flex items-center gap-3">
+                  <span className="text-lg font-black text-brand uppercase tracking-tighter">Navigated Learning</span>
+                </div>
+                <button onClick={() => setIsMobileMenuOpen(false)} className="p-2 text-slate-400 hover:text-brand transition-colors">
+                  <X size={24} />
+                </button>
+              </div>
+              
+              <nav className="space-y-3">
+                {sidebarItems.map((item) => {
+                  const isActive = location.pathname === item.path;
+                  return (
+                    <Link
+                      key={item.path}
+                      to={item.path}
+                      onClick={() => setIsMobileMenuOpen(false)}
+                      className={`flex items-center gap-4 px-4 py-3.5 rounded-2xl transition-all ${isActive ? 'bg-brand/10 text-brand font-bold' : 'text-slate-500 hover:bg-slate-50'}`}
+                    >
+                      <item.icon size={20} className={isActive ? 'text-brand' : ''} />
+                      <span>{item.label}</span>
+                    </Link>
+                  );
+                })}
+              </nav>
+            </motion.aside>
+          </>
+        )}
+      </AnimatePresence>
+
+      <style dangerouslySetInnerHTML={{ __html: `
+        .custom-scrollbar::-webkit-scrollbar {
+          width: 6px;
+        }
+        .custom-scrollbar::-webkit-scrollbar-track {
+          background: transparent;
+        }
+        .custom-scrollbar::-webkit-scrollbar-thumb {
+          background: rgba(255, 255, 255, 0.1);
+          border-radius: 10px;
+        }
+        .custom-scrollbar::-webkit-scrollbar-thumb:hover {
+          background: rgba(255, 255, 255, 0.2);
+        }
+      `}} />
+
+      {/* Notifications Dropdown */}
+      <AnimatePresence>
+        {isNotificationsOpen && (
+          <>
+            <div className="fixed inset-0 z-[140]" onClick={() => setIsNotificationsOpen(false)} />
+            <motion.div
+              initial={{ opacity: 0, y: 10, scale: 0.95 }}
+              animate={{ opacity: 1, y: 0, scale: 1 }}
+              exit={{ opacity: 0, y: 10, scale: 0.95 }}
+              className="fixed top-24 right-12 w-80 bg-white rounded-3xl shadow-2xl border border-slate-100 z-[150] overflow-hidden"
+            >
+              <div className="p-5 border-b border-slate-100 bg-slate-50/50 flex justify-between items-center">
+                <h3 className="font-bold text-slate-800">Intelligence Briefing</h3>
+                <span className="text-[10px] font-black text-brand uppercase tracking-widest">{notifications.length} Events</span>
+              </div>
+              <div className="max-h-[400px] overflow-y-auto">
+                {notifications.length > 0 ? (
+                  notifications.map((n) => (
+                    <div key={n.id} className="p-5 border-b border-slate-50 last:border-0 hover:bg-slate-50 transition-colors">
+                      <div className="flex gap-4">
+                        <div className={`w-2 h-2 rounded-full mt-1.5 shrink-0 ${n.type === 'success' ? 'bg-green-500' : 'bg-brand'}`} />
+                        <div>
+                          <p className="text-xs font-medium text-slate-700 leading-relaxed">{n.message}</p>
+                          <p className="text-[9px] text-slate-400 font-bold uppercase mt-2">{new Date(n.timestamp).toLocaleTimeString()}</p>
+                        </div>
+                      </div>
+                    </div>
+                  ))
+                ) : (
+                  <div className="p-10 text-center text-slate-400">
+                    <p className="text-xs font-bold uppercase tracking-widest">Awaiting Intel...</p>
+                  </div>
+                )}
+              </div>
+            </motion.div>
+          </>
+        )}
+      </AnimatePresence>
+
+      {/* Profile Modal */}
+      <AnimatePresence>
+        {isProfileOpen && (
+          <div className="fixed inset-0 bg-slate-900/60 backdrop-blur-md z-[100] flex items-center justify-center p-4">
+            <motion.div 
+              initial={{ scale: 0.9, opacity: 0, y: 20 }}
+              animate={{ scale: 1, opacity: 1, y: 0 }}
+              exit={{ scale: 0.9, opacity: 0, y: 20 }}
+              className="bg-white rounded-[3rem] shadow-2xl w-full max-w-lg overflow-hidden relative border border-white/20"
+            >
+              {/* Profile Background Header */}
+              <div className="h-40 bg-gradient-to-br from-brand to-brand-dark relative">
+                 <button 
+                  onClick={() => setIsProfileOpen(false)}
+                  className="absolute top-6 right-6 p-2 bg-white/20 hover:bg-white/40 text-white rounded-full transition-all"
+                 >
+                    <X size={20} />
+                 </button>
+              </div>
+
+              <div className="px-10 pb-10 -mt-16 relative">
+                 <div className="flex items-end justify-between mb-8">
+                    <div className="w-32 h-32 rounded-[2.5rem] bg-white p-1.5 shadow-2xl border border-slate-100">
+                       <div className="w-full h-full rounded-[2rem] overflow-hidden bg-slate-50">
+                          <img src="https://api.dicebear.com/7.x/avataaars/svg?seed=Felix" alt="Profile" className="w-full h-full object-cover" />
+                       </div>
+                    </div>
+                    <div className="flex flex-col items-end pb-2">
+                       <span className="px-4 py-1.5 bg-brand text-white text-[10px] font-black uppercase tracking-widest rounded-xl shadow-lg shadow-brand/20">Stage {agent.level} Explorer</span>
+                       <p className="text-[10px] text-slate-400 font-bold uppercase tracking-widest mt-2">ID: Learner_NL_01</p>
+                    </div>
+                 </div>
+
+                 <div className="mb-8">
+                    <h2 className="text-3xl font-black text-slate-900 uppercase tracking-tighter">Learner</h2>
+                    <p className="text-slate-500 font-medium mt-1">Neural Architect & NLP Specialist</p>
+                 </div>
+
+                 <div className="grid grid-cols-2 gap-4 mb-8">
+                    <div className="bg-slate-50 p-5 rounded-3xl border border-slate-100">
+                       <div className="flex items-center gap-2 text-brand mb-2">
+                          <Activity size={16} />
+                          <span className="text-[9px] font-black uppercase tracking-widest">Total XP</span>
+                       </div>
+                       <p className="text-2xl font-black text-slate-900 tracking-tight">{agent.totalReward}</p>
+                    </div>
+                    <div className="bg-slate-50 p-5 rounded-3xl border border-slate-100">
+                       <div className="flex items-center gap-2 text-green-500 mb-2">
+                          <Award size={16} />
+                          <span className="text-[9px] font-black uppercase tracking-widest">Matrix Clear</span>
+                       </div>
+                       <p className="text-2xl font-black text-slate-900 tracking-tight">{agent.visitedResources.length}/18</p>
+                    </div>
+                 </div>
+
+                 <div className="space-y-3">
+                    <div className="flex justify-between items-end">
+                       <span className="text-[10px] font-black text-slate-400 uppercase tracking-widest">Current Stage Synchronization</span>
+                       <span className="text-lg font-black text-brand tracking-tighter">{progressPercent}%</span>
+                    </div>
+                    <div className="h-3 bg-slate-100 rounded-full overflow-hidden border border-slate-200">
+                       <motion.div 
+                        initial={{ width: 0 }}
+                        animate={{ width: `${progressPercent}%` }}
+                        className="h-full bg-brand"
+                       />
+                    </div>
+                 </div>
+
+                 <div className="mt-10 flex gap-4">
+                    <button className="flex-1 py-4 bg-slate-900 text-white rounded-2xl font-black text-[10px] uppercase tracking-widest shadow-xl shadow-slate-900/20 hover:scale-[1.02] active:scale-95 transition-all flex items-center justify-center gap-3">
+                       Edit Profile <TrendingUp size={18} />
+                    </button>
+                    <button 
+                      onClick={handleSignOut}
+                      className="p-4 bg-slate-100 text-slate-500 rounded-2xl hover:bg-red-50 hover:text-red-500 transition-all active:scale-95"
+                    >
+                       <LogOut size={20} />
+                    </button>
+                 </div>
+              </div>
+            </motion.div>
+          </div>
+        )}
+      </AnimatePresence>
+
+      {/* Settings Modal */}
+      <AnimatePresence>
+        {isSettingsOpen && (
+          <div className="fixed inset-0 bg-slate-900/40 backdrop-blur-sm z-[100] flex items-center justify-center p-4">
+            <motion.div 
+              initial={{ scale: 0.95, opacity: 0 }}
+              animate={{ scale: 1, opacity: 1 }}
+              exit={{ scale: 0.95, opacity: 0 }}
+              className="bg-white rounded-[2rem] shadow-2xl w-full max-w-md overflow-hidden relative"
+            >
+              <div className="p-6 border-b border-slate-100 flex items-center justify-between bg-slate-50/50">
+                <div className="flex items-center gap-3">
+                  <div className="p-2 bg-slate-200/50 rounded-xl text-slate-600">
+                    <Settings size={20} />
+                  </div>
+                  <h3 className="font-bold text-lg text-slate-800">Preferences</h3>
+                </div>
+                <button onClick={() => setIsSettingsOpen(false)} className="p-2 text-slate-400 hover:bg-slate-200/50 hover:text-slate-600 rounded-full transition-colors">
+                  <X size={20} />
+                </button>
+              </div>
+
+              <div className="p-6 space-y-6 bg-white">
+                <div>
+                  <h4 className="text-xs font-bold text-slate-400 uppercase tracking-wider mb-4">Neural Settings</h4>
+                  <div className="space-y-3">
+                    <div className="flex items-center justify-between p-3 rounded-2xl border border-slate-100 bg-slate-50/50">
+                      <div>
+                        <p className="text-sm font-semibold text-slate-700">High-Performance Engine</p>
+                        <p className="text-[10px] text-slate-400 font-medium mt-0.5">Accelerate matrix polyline generation</p>
+                      </div>
+                      <div className="w-10 h-6 bg-brand rounded-full relative cursor-pointer shadow-inner">
+                        <div className="absolute right-1 top-1 w-4 h-4 bg-white rounded-full shadow-sm" />
+                      </div>
+                    </div>
+                  </div>
+                </div>
+
+                <div>
+                  <h4 className="text-xs font-bold text-slate-400 uppercase tracking-wider mb-4">Danger Zone</h4>
+                  <button 
+                    onClick={async () => {
+                      try {
+                        const res = await fetch('http://localhost:5000/api/reset', { method: 'POST' });
+                        if (res.ok) window.location.reload();
+                      } catch (e) {
+                         console.error(e);
+                      }
+                    }}
+                    className="w-full flex items-center justify-between p-3 rounded-2xl border border-red-100 bg-red-50 hover:bg-red-100 transition-colors group"
+                  >
+                    <div className="text-left">
+                      <p className="text-sm font-semibold text-red-600 group-hover:text-red-700">Wipe Database Memory</p>
+                      <p className="text-[10px] text-red-400 mt-0.5">Permanently resets all learning progress & histories</p>
+                    </div>
+                    <LogOut size={18} className="text-red-400 group-hover:text-red-600" />
+                  </button>
+                </div>
+              </div>
+            </motion.div>
+          </div>
+        )}
+      </AnimatePresence>
+
+      {/* Global Level Up Toast Notification */}
+      <AnimatePresence>
+        {levelUpMessage && (
+          <motion.div 
+            initial={{ opacity: 0, y: -50, scale: 0.9 }}
+            animate={{ opacity: 1, y: 0, scale: 1 }}
+            exit={{ opacity: 0, y: -20, scale: 0.9 }}
+            className="fixed top-8 left-1/2 -translate-x-1/2 z-[200] bg-[#0f111a] text-white px-8 py-5 rounded-[2rem] shadow-[0_0_80px_-15px_rgba(79,70,229,0.5)] border border-white/10 flex items-center gap-6"
+          >
+             <div className="w-14 h-14 rounded-2xl bg-gradient-to-tr from-brand via-purple-500 to-pink-500 flex items-center justify-center shadow-inner relative overflow-hidden">
+                <div className="absolute inset-0 bg-[linear-gradient(45deg,transparent_25%,rgba(255,255,255,0.3)_50%,transparent_75%,transparent_100%)] bg-[length:200%_200%] animate-[shine_2s_infinite]" />
+                <span className="text-xl font-black drop-shadow-md">{agent.level}</span>
+             </div>
+             <div>
+                <p className="text-[10px] font-bold text-brand uppercase tracking-[0.3em] mb-1">Rank Up</p>
+                <h3 className="text-xl font-bold tracking-tight">{levelUpMessage}</h3>
+             </div>
+             <button onClick={() => setLevelUpMessage(null)} className="ml-4 p-2 text-white/50 hover:text-white transition-colors">
+                <X size={20} />
+             </button>
+          </motion.div>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+};

src/components/LearningRoadmap.tsx

@@ -0,0 +1,155 @@
+import React, { useState } from 'react';
+import { LearningActivity, LearningMap } from '../types';
+import { CheckCircle, Clock, Lock, ArrowDown, Target } from 'lucide-react';
+
+interface LearningRoadmapProps {
+  learningMap: LearningMap;
+  onActivitySelect: (activityId: string) => void;
+}
+
+export const LearningRoadmap: React.FC<LearningRoadmapProps> = ({
+  learningMap,
+  onActivitySelect
+}) => {
+  const [selectedActivity, setSelectedActivity] = useState<string | null>(null);
+
+  const isActivityUnlocked = (activity: LearningActivity) => {
+    if (activity.prerequisites.length === 0) return true;
+    return activity.prerequisites.every(prereqId =>
+      learningMap.activities.find(a => a.id === prereqId)?.completed
+    );
+  };
+
+  const getActivityIcon = (activity: LearningActivity) => {
+    if (activity.completed) {
+      return <CheckCircle className="w-5 h-5 text-green-500" />;
+    } else if (isActivityUnlocked(activity)) {
+      return <Target className="w-5 h-5 text-blue-500" />;
+    } else {
+      return <Lock className="w-5 h-5 text-gray-400" />;
+    }
+  };
+
+  const getActivityStyle = (activity: LearningActivity) => {
+    if (activity.completed) {
+      return 'bg-green-50 border-green-200 text-green-800 shadow-sm';
+    } else if (isActivityUnlocked(activity)) {
+      return 'bg-blue-50 border-blue-200 text-blue-800 hover:bg-blue-100 cursor-pointer shadow-sm hover:shadow-md transform hover:scale-[1.02] transition-all duration-200';
+    } else {
+      return 'bg-gray-50 border-gray-200 text-gray-500';
+    }
+  };
+
+  const handleActivityClick = (activity: LearningActivity) => {
+    if (isActivityUnlocked(activity) && !activity.completed) {
+      setSelectedActivity(activity.id);
+      onActivitySelect(activity.id);
+    }
+  };
+
+  return (
+    <div className="bg-white p-3 lg:p-4 rounded-lg shadow-lg h-full flex flex-col">
+      <div className="mb-6">
+        <h2 className="text-sm lg:text-base font-semibold text-gray-800 mb-2">Learning Roadmap</h2>
+        <div className="flex items-center justify-between">
+          <p className="text-xs text-gray-600">Track your learning journey</p>
+          <div className="flex items-center space-x-2">
+            <div className="text-xs text-gray-600">Progress:</div>
+            <div className="text-xs font-semibold text-blue-600">
+              {Math.round(learningMap.progressPercentage)}%
+            </div>
+          </div>
+        </div>
+        <div className="w-full bg-gray-200 rounded-full h-2 mt-2">
+          <div 
+            className="bg-gradient-to-r from-blue-500 to-blue-600 h-2 rounded-full transition-all duration-500"
+            style={{ width: `${learningMap.progressPercentage}%` }}
+          ></div>
+        </div>
+      </div>
+
+      <div className="space-y-3 flex-1 overflow-y-auto">
+        {learningMap.activities.map((activity, index) => (
+          <div key={activity.id} className="relative">
+            <div
+              className={`
+                p-4 rounded-lg border-2 transition-all duration-300 
+                ${getActivityStyle(activity)}
+                ${selectedActivity === activity.id ? 'ring-2 ring-blue-400 ring-offset-2' : ''}
+              `}
+              onClick={() => handleActivityClick(activity)}
+            >
+              <div className="flex items-start space-x-2">
+                <div className="flex-shrink-0 mt-1">
+                  {getActivityIcon(activity)}
+                </div>
+                <div className="flex-1 min-w-0">
+                  <h3 className="font-semibold text-sm mb-1">{activity.name}</h3>
+                  <p className="text-xs opacity-80 mb-2">{activity.description}</p>
+                  
+                  <div className="flex flex-col gap-1">
+                    <div className="flex items-center space-x-3">
+                      <div className="flex items-center space-x-1">
+                        <Clock className="w-3 h-3" />
+                        <span>{activity.estimatedTime}</span>
+                      </div>
+                      <div className="flex items-center space-x-1">
+                        <div className={`
+                          w-3 h-3 rounded-full shadow-sm
+                          ${activity.difficulty <= 2 ? 'bg-green-400' : 
+                            activity.difficulty <= 4 ? 'bg-yellow-400' : 'bg-red-400'}
+                        `}></div>
+                        <span>Level {activity.difficulty}</span>
+                      </div>
+                    </div>
+                    
+                    {activity.prerequisites.length > 0 && (
+                      <div className="text-xs text-gray-500">
+                        Prerequisites: {activity.prerequisites.length}
+                      </div>
+                    )}
+                  </div>
+                </div>
+              </div>
+              
+              {learningMap.currentActivity === activity.id && (
+                <div className="absolute -left-2 top-1/2 transform -translate-y-1/2">
+                  <div className="w-1 h-8 bg-gradient-to-b from-blue-400 to-blue-600 rounded-full shadow-sm"></div>
+                </div>
+              )}
+            </div>
+            
+            {index < learningMap.activities.length - 1 && (
+              <div className="flex justify-center py-2">
+                <div className="flex flex-col items-center">
+                  <div className="w-px h-4 bg-gray-300"></div>
+                  <ArrowDown className="w-4 h-4 text-gray-400" />
+                  <div className="w-px h-4 bg-gray-300"></div>
+                </div>
+              </div>
+            )}
+          </div>
+        ))}
+      </div>
+
+      {/* Legend */}
+      <div className="mt-6 p-3 bg-gradient-to-r from-gray-50 to-gray-100 rounded-lg border">
+        <h4 className="text-xs font-semibold text-gray-700 mb-2">Legend</h4>
+        <div className="grid grid-cols-3 gap-2 text-xs">
+          <div className="flex items-center space-x-1">
+            <CheckCircle className="w-3 h-3 text-green-500" />
+            <span className="text-gray-600">Completed</span>
+          </div>
+          <div className="flex items-center space-x-1">
+            <Target className="w-3 h-3 text-blue-500" />
+            <span className="text-gray-600">Available</span>
+          </div>
+          <div className="flex items-center space-x-1">
+            <Lock className="w-3 h-3 text-gray-400" />
+            <span className="text-gray-600">Locked</span>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

src/components/ui/AnimatedButton.tsx

@@ -0,0 +1,67 @@
+import React from 'react';
+import { motion } from 'framer-motion';
+import { LucideIcon } from 'lucide-react';
+
+interface AnimatedButtonProps {
+  children: React.ReactNode;
+  onClick?: () => void;
+  variant?: 'primary' | 'secondary';
+  icon?: LucideIcon;
+  className?: string;
+  id?: string;
+}
+
+export const AnimatedButton: React.FC<AnimatedButtonProps> = ({ 
+  children, 
+  onClick, 
+  variant = 'primary', 
+  icon: Icon,
+  className = '',
+  id
+}) => {
+  const isPrimary = variant === 'primary';
+
+  return (
+    <>
+      <motion.button
+        id={id}
+        onClick={onClick}
+        whileHover={{ y: -2 }}
+        whileTap={{ scale: 0.98 }}
+        initial={{ opacity: 0, y: 10 }}
+        animate={{ 
+          opacity: 1, 
+          y: 0,
+        }}
+        transition={{
+          opacity: { duration: 0.4 },
+          y: { duration: 0.4, ease: "easeOut" }
+        }}
+        className={`
+          relative overflow-hidden group flex items-center justify-center gap-3 px-8 py-3.5 rounded-xl font-bold uppercase tracking-wider text-[11px] transition-all duration-300
+          ${isPrimary 
+            ? 'bg-brand hover:bg-brand-dark text-white shadow-lg shadow-brand/10 border border-white/10' 
+            : 'bg-white border border-slate-200 text-slate-600 hover:border-brand/40 hover:text-brand shadow-sm'
+          }
+          ${className}
+        `}
+      >
+        {/* Subtle Highlight (Primary) */}
+        {isPrimary && (
+          <div className="absolute inset-0 bg-white/10 opacity-0 group-hover:opacity-100 transition-opacity duration-300" />
+        )}
+
+        {/* Content */}
+        <span className="relative z-10 flex items-center gap-2">
+          {Icon && <Icon size={16} className="transition-transform group-hover:rotate-0" />}
+          {children}
+        </span>
+
+        {/* Professional Border Highlight */}
+        {isPrimary && (
+          <div className="absolute inset-x-0 inset-y-0 border border-white/20 rounded-xl pointer-events-none" />
+        )}
+      </motion.button>
+    </>
+  );
+};

src/components/ui/Button.tsx

@@ -0,0 +1,38 @@
+import React from 'react';
+import { motion, HTMLMotionProps } from 'framer-motion';
+
+interface ButtonProps extends HTMLMotionProps<'button'> {
+  variant?: 'primary' | 'secondary' | 'outline' | 'ghost';
+  isLoading?: boolean;
+}
+
+export const Button: React.FC<ButtonProps> = ({
+  variant = 'primary',
+  isLoading,
+  children,
+  className = '',
+  ...props
+}) => {
+  const baseStyles = "px-6 py-3 rounded-2xl font-semibold transition-all duration-300 flex items-center justify-center gap-2 active:scale-95 disabled:opacity-50 disabled:cursor-not-allowed";
+  
+  const variants = {
+    primary: "bg-gradient-to-r from-brand to-brand-dark text-white shadow-lg shadow-brand/30 hover:shadow-brand/50 hover:scale-[1.02]",
+    secondary: "bg-white/40 backdrop-blur-md text-brand border border-brand/20 hover:bg-white/60 hover:border-brand/40 shadow-sm",
+    outline: "border-2 border-brand text-brand hover:bg-brand hover:text-white",
+    ghost: "text-brand hover:bg-brand/10"
+  };
+
+  return (
+    <motion.button
+      whileHover={{ scale: 1.02 }}
+      whileTap={{ scale: 0.98 }}
+      className={`${baseStyles} ${variants[variant]} ${className}`}
+      disabled={isLoading || props.disabled}
+      {...props}
+    >
+      {isLoading ? (
+        <div className="w-5 h-5 border-2 border-white/30 border-t-white rounded-full animate-spin" />
+      ) : children}
+    </motion.button>
+  );
+};

src/components/ui/CustomCursor.tsx

@@ -0,0 +1,116 @@
+import React, { useEffect, useState } from 'react';
+import { motion, useSpring, useMotionValue } from 'framer-motion';
+
+export const CustomCursor: React.FC = () => {
+  const cursorX = useMotionValue(-100);
+  const cursorY = useMotionValue(-100);
+  
+  const [isHovering, setIsHovering] = useState(false);
+
+  // Trailing Effect - Create 4 dots with staggered spring physics
+  const trail1X = useSpring(cursorX, { damping: 20, stiffness: 200 });
+  const trail1Y = useSpring(cursorY, { damping: 20, stiffness: 200 });
+  
+  const trail2X = useSpring(cursorX, { damping: 30, stiffness: 150 });
+  const trail2Y = useSpring(cursorY, { damping: 30, stiffness: 150 });
+  
+  const trail3X = useSpring(cursorX, { damping: 40, stiffness: 100 });
+  const trail3Y = useSpring(cursorY, { damping: 40, stiffness: 100 });
+
+  useEffect(() => {
+    const moveCursor = (e: MouseEvent) => {
+      cursorX.set(e.clientX);
+      cursorY.set(e.clientY);
+    };
+
+    const handleMouseOver = (e: MouseEvent) => {
+      const target = e.target as HTMLElement;
+      const isClickable = target.closest('button, a, input, select, [role="button"]');
+      setIsHovering(!!isClickable);
+    };
+
+    window.addEventListener('mousemove', moveCursor);
+    window.addEventListener('mouseover', handleMouseOver);
+
+    return () => {
+      window.removeEventListener('mousemove', moveCursor);
+      window.removeEventListener('mouseover', handleMouseOver);
+    };
+  }, [cursorX, cursorY]);
+
+  const trails = [
+    { x: trail1X, y: trail1Y, scale: 0.8, opacity: 0.6, delay: 0 },
+    { x: trail2X, y: trail2Y, scale: 0.6, opacity: 0.4, delay: 0.05 },
+    { x: trail3X, y: trail3Y, scale: 0.4, opacity: 0.2, delay: 0.1 },
+  ];
+
+  return (
+    <>
+      <style>{`
+        body, a, button, input, select {
+          cursor: none !important;
+        }
+      `}</style>
+      
+      {/* Trailing Dots (The "Dragging" effect) */}
+      {trails.map((trail, i) => (
+        <motion.div
+            key={i}
+            className="fixed top-0 left-0 bg-brand rounded-full pointer-events-none z-[9996]"
+            style={{
+                width: 12,
+                height: 12,
+                x: trail.x,
+                y: trail.y,
+                scale: trail.scale,
+                opacity: trail.opacity,
+                translateX: '-50%',
+                translateY: '-50%',
+            }}
+        />
+      ))}
+
+      {/* Main Lead Dot */}
+      <motion.div
+        className="fixed top-0 left-0 w-3 h-3 bg-brand rounded-full pointer-events-none z-[9999] mix-blend-difference"
+        style={{
+          x: cursorX,
+          y: cursorY,
+          translateX: '-50%',
+          translateY: '-50%',
+        }}
+      />
+
+      {/* Pulsing Outer Ring */}
+      <motion.div
+        className="fixed top-0 left-0 w-10 h-10 border-2 border-brand/40 rounded-full pointer-events-none z-[9998]"
+        animate={{
+          scale: isHovering ? 1.6 : 1,
+          borderColor: isHovering ? 'rgba(59, 130, 246, 0.8)' : 'rgba(59, 130, 246, 0.3)',
+          backgroundColor: isHovering ? 'rgba(59, 130, 246, 0.15)' : 'rgba(0,0,0,0)',
+        }}
+        style={{
+          x: trail1X,
+          y: trail1Y,
+          translateX: '-50%',
+          translateY: '-50%',
+        }}
+        transition={{ type: 'spring', damping: 20, stiffness: 150 }}
+      />
+
+      {/* Technical HUD Crosshair (Centered on lead) */}
+      <motion.div
+        className="fixed top-0 left-0 pointer-events-none z-[9997]"
+        style={{
+          x: cursorX,
+          y: cursorY,
+          translateX: '-50%',
+          translateY: '-50%',
+        }}
+      >
+        <div className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-8 h-[1px] bg-brand/30"></div>
+        <div className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 h-8 w-[1px] bg-brand/30"></div>
+      </motion.div>
+    </>
+  );
+};

src/components/ui/GlassCard.tsx

@@ -0,0 +1,24 @@
+import React from 'react';
+import { motion } from 'framer-motion';
+
+interface GlassCardProps {
+  children: React.ReactNode;
+  className?: string;
+  animate?: any;
+  transition?: any;
+}
+
+export const GlassCard: React.FC<GlassCardProps> = ({ children, className = '', ...props }) => {
+  return (
+    <motion.div
+      {...props}
+      className={`
+        bg-white/70 backdrop-blur-xl border border-white/40 
+        shadow-[0_8px_32px_0_rgba(108,99,255,0.1)] 
+        rounded-3xl p-8 ${className}
+      `}
+    >
+      {children}
+    </motion.div>
+  );
+};

src/components/ui/Input.tsx

@@ -0,0 +1,70 @@
+import React, { useState } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { Eye, EyeOff } from 'lucide-react';
+
+interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+  label: string;
+  error?: string;
+  type?: string;
+}
+
+export const Input: React.FC<InputProps> = ({ label, error, type = 'text', className = '', ...props }) => {
+  const [isFocused, setIsFocused] = useState(false);
+  const [showPassword, setShowPassword] = useState(false);
+  const isPassword = type === 'password';
+
+  return (
+    <div className={`relative w-full mb-6 ${className}`}>
+      <div className={`
+        relative flex items-center transition-all duration-300 rounded-2xl border
+        ${isFocused ? 'border-brand ring-4 ring-brand/10' : 'border-slate-200'}
+        bg-white/60 backdrop-blur-md overflow-hidden
+      `}>
+        <input
+          {...props}
+          type={isPassword && showPassword ? 'text' : type}
+          onFocus={(e) => {
+            setIsFocused(true);
+            props.onFocus?.(e);
+          }}
+          onBlur={(e) => {
+            setIsFocused(false);
+            props.onBlur?.(e);
+          }}
+          className="peer w-full px-4 py-3 bg-transparent text-slate-800 outline-none placeholder-transparent"
+          placeholder={label}
+        />
+        
+        <label className={`
+          absolute left-4 transition-all duration-300 pointer-events-none text-slate-400
+          ${(isFocused || props.value) ? '-top-2 text-xs text-brand font-bold bg-white px-2 rounded-full shadow-sm' : 'top-3.5 text-base'}
+        `}>
+          {label}
+        </label>
+
+        {isPassword && (
+          <button
+            type="button"
+            onClick={() => setShowPassword(!showPassword)}
+            className="p-3 text-slate-400 hover:text-brand transition-colors"
+          >
+            {showPassword ? <EyeOff size={20} /> : <Eye size={20} />}
+          </button>
+        )}
+      </div>
+      
+      <AnimatePresence>
+        {error && (
+          <motion.p
+            initial={{ opacity: 0, y: -10 }}
+            animate={{ opacity: 1, y: 0 }}
+            exit={{ opacity: 0, y: -10 }}
+            className="text-red-400 text-sm mt-1 px-2"
+          >
+            {error}
+          </motion.p>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+};

src/components/ui/Mascot.tsx

@@ -0,0 +1,220 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { motion, useSpring, useTransform } from 'framer-motion';
+
+interface MascotProps {
+  type: 'fox' | 'owl' | 'robot';
+  isPasswordFocused: boolean;
+  mousePos: { x: number; y: number };
+}
+
+export const Mascot: React.FC<MascotProps> = ({ type, isPasswordFocused, mousePos }) => {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [targetPos, setTargetPos] = useState({ x: 0, y: 0 });
+
+  useEffect(() => {
+    if (containerRef.current) {
+      const rect = containerRef.current.getBoundingClientRect();
+      const centerX = rect.left + rect.width / 2;
+      const centerY = rect.top + rect.height / 2;
+      
+      // Calculate pixel distance for more responsive tracking
+      const distX = mousePos.x - centerX;
+      const distY = mousePos.y - centerY;
+      
+      // Max displacement 
+      const maxMove = 12;
+      const dx = Math.max(-maxMove, Math.min(maxMove, distX / 30));
+      const dy = Math.max(-maxMove, Math.min(maxMove, distY / 30));
+      
+      setTargetPos({ x: dx, y: dy });
+    }
+  }, [mousePos]);
+
+  const x = useSpring(targetPos.x, { stiffness: 100, damping: 25 });
+  const y = useSpring(targetPos.y, { stiffness: 100, damping: 25 });
+
+  const renderMascot = () => {
+    switch (type) {
+      case 'fox':
+        return (
+          <svg viewBox="0 0 100 100" className="w-full h-full drop-shadow-2xl overflow-visible">
+            <defs>
+              <clipPath id="fox-eye-left">
+                <circle cx="40" cy="62" r="6" />
+              </clipPath>
+              <clipPath id="fox-eye-right">
+                <circle cx="60" cy="62" r="6" />
+              </clipPath>
+            </defs>
+            {/* Body */}
+            <motion.path 
+                d="M20 80 Q50 95 80 80 Q90 60 80 40 Q50 30 20 40 Q10 60 20 80" 
+                fill="#FF6B35" 
+                animate={{ scale: [1, 1.02, 1] }}
+                transition={{ duration: 3, repeat: Infinity }}
+            />
+            {/* Ears */}
+            <path d="M25 45 L15 20 L40 35" fill="#FF6B35" />
+            <path d="M75 45 L85 20 L60 35" fill="#FF6B35" />
+            
+            {/* Face White */}
+            <path d="M30 65 Q50 75 70 65 Q65 50 35 50 Z" fill="white" />
+
+            {/* Eyes */}
+            <motion.g animate={isPasswordFocused ? { scaleY: 0, scaleX: 1.2 } : { scaleY: 1, scaleX: 1 }}>
+                {/* Left Eye */}
+                <circle cx="40" cy="62" r="6" fill="white" />
+                <motion.circle 
+                    cx={40} cy={62} r="3.5" fill="#1A1A1A" 
+                    clipPath="url(#fox-eye-left)"
+                    style={{ x: useTransform(x, v => v * 0.4), y: useTransform(y, v => v * 0.4) }} 
+                />
+                {/* Right Eye */}
+                <circle cx="60" cy="62" r="6" fill="white" />
+                <motion.circle 
+                    cx={60} cy={62} r="3.5" fill="#1A1A1A"
+                    clipPath="url(#fox-eye-right)"
+                    style={{ x: useTransform(x, v => v * 0.4), y: useTransform(y, v => v * 0.4) }}
+                />
+            </motion.g>
+
+            <motion.g 
+                initial={{ y: 20, opacity: 0 }}
+                animate={isPasswordFocused ? { y: 0, opacity: 1 } : { y: 20, opacity: 0 }}
+                transition={{ type: 'spring', stiffness: 300, damping: 20 }}
+            >
+                <path d="M30 85 Q35 70 45 75" stroke="#FF6B35" strokeWidth="6" strokeLinecap="round" fill="none" />
+                <path d="M70 85 Q65 70 55 75" stroke="#FF6B35" strokeWidth="6" strokeLinecap="round" fill="none" />
+            </motion.g>
+          </svg>
+        );
+      case 'owl':
+        return (
+          <svg viewBox="0 0 100 100" className="w-full h-full drop-shadow-2xl overflow-visible">
+            <defs>
+              <clipPath id="owl-eye-left">
+                <circle cx="35" cy="50" r="15" />
+              </clipPath>
+              <clipPath id="owl-eye-right">
+                <circle cx="65" cy="50" r="15" />
+              </clipPath>
+            </defs>
+            {/* Body */}
+            <motion.ellipse 
+                cx="50" cy="60" rx="35" ry="30" fill="#4A4E69"
+                animate={{ y: [0, -2, 0] }}
+                transition={{ duration: 4, repeat: Infinity }}
+            />
+            {/* Big Eyes Shell */}
+            <circle cx="35" cy="50" r="15" fill="white" />
+            <circle cx="65" cy="50" r="15" fill="white" />
+            
+            {/* Pupils */}
+            <motion.g animate={isPasswordFocused ? { scaleY: 0.1 } : { scaleY: 1 }}>
+                <motion.circle 
+                    cx="35" cy="50" r="9" fill="#22223B"
+                    clipPath="url(#owl-eye-left)"
+                    style={{ x: useTransform(x, v => v * 0.6), y: useTransform(y, val => val * 0.8) }}
+                />
+                <motion.circle 
+                    cx="65" cy="50" r="9" fill="#22223B"
+                    clipPath="url(#owl-eye-right)"
+                    style={{ x: useTransform(x, v => v * 0.6), y: useTransform(y, val => val * 0.8) }}
+                />
+            </motion.g>
+            
+            <path d="M45 60 L50 70 L55 60" fill="#F4A261" />
+
+            <motion.path 
+                d="M15 60 Q0 40 35 45" 
+                fill="none" stroke="#4A4E69" strokeWidth="8" strokeLinecap="round"
+                animate={isPasswordFocused ? { d: "M15 60 Q20 30 40 45" } : { d: "M15 60 Q0 40 35 45" }}
+            />
+            <motion.path 
+                d="M85 60 Q100 40 65 45" 
+                fill="none" stroke="#4A4E69" strokeWidth="8" strokeLinecap="round"
+                animate={isPasswordFocused ? { d: "M85 60 Q80 30 60 45" } : { d: "M85 60 Q100 40 65 45" }}
+            />
+          </svg>
+        );
+      case 'robot':
+        return (
+          <svg viewBox="0 0 100 100" className="w-full h-full drop-shadow-2xl overflow-visible">
+            <defs>
+              <clipPath id="robot-screen">
+                <rect x="25" y="35" width="50" height="40" rx="8" />
+              </clipPath>
+            </defs>
+            {/* Case (Midnight Slate) */}
+            <defs>
+                <radialGradient id="robot-mascot-shine" cx="50%" cy="40%" r="50%" fx="50%" fy="40%">
+                    <stop offset="0%" stopColor="#334155" />
+                    <stop offset="100%" stopColor="#1E293B" />
+                </radialGradient>
+            </defs>
+            <motion.rect 
+                x="20" y="30" width="60" height="50" rx="12" 
+                fill="url(#robot-mascot-shine)"
+                stroke="#0F172A" strokeWidth="2"
+                animate={{ rotate: [-0.5, 0.5, -0.5] }}
+                transition={{ duration: 2, repeat: Infinity, ease: "easeInOut" }}
+            />
+            <rect x="25" y="35" width="50" height="40" rx="8" fill="#020617" />
+            
+            {/* Screen Eyes (Proper SVG Rects) */}
+            <motion.g 
+                clipPath="url(#robot-screen)"
+                animate={isPasswordFocused ? { opacity: 0 } : { opacity: 1 }}
+            >
+                {/* Left Eye */}
+                <motion.rect 
+                    x="35" y="48" width="8" height="12" rx="2" fill="#64748B"
+                    style={{ x: useTransform(x, v => v * 0.4), y: useTransform(y, v => v * 0.4) }}
+                    animate={{ height: [12, 1, 12] }}
+                    transition={{ times: [0, 0.05, 0.1], duration: 3, repeat: Infinity, repeatDelay: 2 }}
+                />
+                {/* Right Eye */}
+                <motion.rect 
+                    x="57" y="48" width="8" height="12" rx="2" fill="#64748B"
+                    style={{ x: useTransform(x, v => v * 0.4), y: useTransform(y, v => v * 0.4) }}
+                    animate={{ height: [12, 1, 12] }}
+                    transition={{ times: [0, 0.05, 0.1], duration: 3, repeat: Infinity, repeatDelay: 2 }}
+                />
+            </motion.g>
+
+            <motion.text 
+                x="50" y="60" textAnchor="middle" fill="#EF4444" fontSize="10" fontWeight="black"
+                initial={{ opacity: 0 }}
+                animate={isPasswordFocused ? { opacity: 1 } : { opacity: 0 }}
+            >
+                ENCRYPTED
+            </motion.text>
+            
+            <rect x="48" y="15" width="4" height="15" fill="#94A3B8" />
+            <motion.circle 
+                cx="50" cy="15" r="4" fill="#64748B"
+                animate={{ opacity: [1, 0.4, 1], scale: [1, 1.2, 1] }}
+                transition={{ duration: 1.5, repeat: Infinity }}
+            />
+          </svg>
+        );
+    }
+  };
+
+  return (
+    <motion.div 
+      ref={containerRef}
+      className="w-32 h-32 lg:w-48 lg:h-48 flex items-center justify-center pointer-events-none"
+      style={{
+        x: useTransform(x, v => v * 0.6),
+        y: useTransform(y, v => v * 0.6),
+        rotate: useTransform(x, v => v * 0.3),
+      }}
+      initial={{ scale: 0.9, opacity: 0 }}
+      animate={{ scale: 1, opacity: 1 }}
+      transition={{ duration: 0.5, ease: "easeOut" }}
+    >
+      {renderMascot()}
+    </motion.div>
+  );
+};