Init quiz mode

app.py

@@ -12,6 +12,7 @@ import routes.chats as _routes_chat
 import routes.sessions as _routes_sessions
 import routes.health as _routes_health
 import routes.analytics as _routes_analytics
+import routes.quiz as _routes_quiz
 
 # Local dev
 # if __name__ == "__main__":

helpers/models.py

@@ -30,6 +30,8 @@ class ChatHistoryResponse(BaseModel):
 
 class MessageResponse(BaseModel):
     message: str
+    quiz: Optional[Dict[str, Any]] = None
+    results: Optional[Dict[str, Any]] = None
 
 class UploadResponse(BaseModel):
     job_id: str
@@ -60,4 +62,29 @@ class StatusUpdateResponse(BaseModel):
     message: str
     progress: Optional[int] = None
 
+class QuizQuestionResponse(BaseModel):
+    type: str  # "mcq" or "self_reflect"
+    question: str
+    options: Optional[List[str]] = None  # For MCQ questions
+    correct_answer: Optional[int] = None  # For MCQ questions
+    topic: str
+    complexity: str
+
+class QuizResponse(BaseModel):
+    quiz_id: str
+    user_id: str
+    project_id: str
+    questions: List[QuizQuestionResponse]
+    time_limit: int
+    documents: List[str]
+    created_at: str
+    status: str
+
+class QuizResultResponse(BaseModel):
+    questions: List[Dict[str, Any]]
+    total_score: float
+    correct_count: int
+    partial_count: int
+    incorrect_count: int
+
 

routes/quiz.py

@@ -0,0 +1,490 @@
+# routes/quiz.py
+import json, time, uuid, asyncio
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+from fastapi import Form, HTTPException
+
+from helpers.setup import app, rag, logger, nvidia_rotator, gemini_rotator
+from helpers.models import MessageResponse, QuizResponse, QuizResultResponse
+from utils.api.router import select_model, generate_answer_with_model, NVIDIA_SMALL, NVIDIA_MEDIUM, NVIDIA_LARGE
+from utils.analytics import get_analytics_tracker
+
+
+@app.post("/quiz/create", response_model=MessageResponse)
+async def create_quiz(
+    user_id: str = Form(...),
+    project_id: str = Form(...),
+    questions_input: str = Form(...),
+    time_limit: str = Form(...),
+    documents: str = Form(...)
+):
+    """Create a quiz from selected documents"""
+    try:
+        # Parse documents
+        selected_docs = json.loads(documents)
+        time_limit_minutes = int(time_limit)
+        
+        logger.info(f"[QUIZ] Creating quiz for user {user_id}, project {project_id}")
+        logger.info(f"[QUIZ] Documents: {selected_docs}")
+        logger.info(f"[QUIZ] Questions input: {questions_input}")
+        logger.info(f"[QUIZ] Time limit: {time_limit_minutes} minutes")
+        
+        # Step 1: Parse user input to determine question counts
+        question_config = await parse_question_input(questions_input, nvidia_rotator)
+        logger.info(f"[QUIZ] Parsed question config: {question_config}")
+        
+        # Step 2: Get document summaries and key topics
+        document_summaries = await get_document_summaries(user_id, project_id, selected_docs)
+        key_topics = await extract_key_topics(document_summaries, nvidia_rotator)
+        logger.info(f"[QUIZ] Extracted {len(key_topics)} key topics")
+        
+        # Step 3: Create question generation plan
+        generation_plan = await create_question_plan(
+            question_config, key_topics, nvidia_rotator
+        )
+        logger.info(f"[QUIZ] Created generation plan with {len(generation_plan)} tasks")
+        
+        # Step 4: Generate questions and answers
+        questions = await generate_questions_and_answers(
+            generation_plan, document_summaries, nvidia_rotator
+        )
+        logger.info(f"[QUIZ] Generated {len(questions)} questions")
+        
+        # Step 5: Create quiz record
+        quiz_id = str(uuid.uuid4())
+        quiz_data = {
+            "quiz_id": quiz_id,
+            "user_id": user_id,
+            "project_id": project_id,
+            "questions": questions,
+            "time_limit": time_limit_minutes,
+            "documents": selected_docs,
+            "created_at": datetime.now(timezone.utc),
+            "status": "ready"
+        }
+        
+        # Store quiz in database
+        rag.db["quizzes"].insert_one(quiz_data)
+        
+        return MessageResponse(message="Quiz created successfully", quiz=quiz_data)
+        
+    except Exception as e:
+        logger.error(f"[QUIZ] Quiz creation failed: {e}")
+        raise HTTPException(500, detail=f"Failed to create quiz: {str(e)}")
+
+
+@app.post("/quiz/submit", response_model=MessageResponse)
+async def submit_quiz(
+    user_id: str = Form(...),
+    project_id: str = Form(...),
+    quiz_id: str = Form(...),
+    answers: str = Form(...)
+):
+    """Submit quiz answers and get results"""
+    try:
+        # Parse answers
+        user_answers = json.loads(answers)
+        
+        # Get quiz data
+        quiz = rag.db["quizzes"].find_one({
+            "quiz_id": quiz_id,
+            "user_id": user_id,
+            "project_id": project_id
+        })
+        
+        if not quiz:
+            raise HTTPException(404, detail="Quiz not found")
+        
+        # Mark answers
+        results = await mark_quiz_answers(quiz["questions"], user_answers, nvidia_rotator)
+        
+        # Store results
+        result_data = {
+            "quiz_id": quiz_id,
+            "user_id": user_id,
+            "project_id": project_id,
+            "answers": user_answers,
+            "results": results,
+            "submitted_at": datetime.now(timezone.utc)
+        }
+        
+        rag.db["quiz_results"].insert_one(result_data)
+        
+        return MessageResponse(message="Quiz submitted successfully", results=results)
+        
+    except Exception as e:
+        logger.error(f"[QUIZ] Quiz submission failed: {e}")
+        raise HTTPException(500, detail=f"Failed to submit quiz: {str(e)}")
+
+
+async def parse_question_input(questions_input: str, nvidia_rotator) -> Dict[str, int]:
+    """Parse user input to determine MCQ and self-reflect question counts"""
+    system_prompt = """You are an expert at parsing user requests for quiz questions. 
+    Given a user's input about how many questions they want, extract the number of MCQ and self-reflect questions.
+    
+    Return ONLY a JSON object with this exact format:
+    {
+        "mcq": <number of multiple choice questions>,
+        "sr": <number of self-reflect questions>
+    }
+    
+    If the user doesn't specify types, assume they want MCQ questions.
+    If they say "total" or "questions", split them roughly 70% MCQ and 30% self-reflect.
+    """
+    
+    user_prompt = f"User input: {questions_input}\n\nExtract the question counts:"
+    
+    try:
+        # Use NVIDIA_SMALL for parsing
+        response = await generate_answer_with_model(
+            selection={"provider": "nvidia", "model": NVIDIA_SMALL},
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_parsing"
+        )
+        
+        # Parse JSON response
+        config = json.loads(response.strip())
+        return {
+            "mcq": int(config.get("mcq", 0)),
+            "sr": int(config.get("sr", 0))
+        }
+        
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to parse question input: {e}")
+        # Fallback: assume 10 MCQ questions
+        return {"mcq": 10, "sr": 0}
+
+
+async def get_document_summaries(user_id: str, project_id: str, documents: List[str]) -> str:
+    """Get summaries from selected documents"""
+    summaries = []
+    
+    for doc in documents:
+        try:
+            # Get file summary
+            file_data = rag.get_file_summary(user_id=user_id, project_id=project_id, filename=doc)
+            if file_data and file_data.get("summary"):
+                summaries.append(f"[{doc}] {file_data['summary']}")
+            
+            # Get additional chunks for more context
+            chunks = rag.get_file_chunks(user_id=user_id, project_id=project_id, filename=doc, limit=20)
+            if chunks:
+                chunk_text = "\n".join([chunk.get("content", "") for chunk in chunks[:10]])
+                summaries.append(f"[{doc} - Additional Content] {chunk_text[:2000]}...")
+                
+        except Exception as e:
+            logger.warning(f"[QUIZ] Failed to get summary for {doc}: {e}")
+            continue
+    
+    return "\n\n".join(summaries)
+
+
+async def extract_key_topics(document_summaries: str, nvidia_rotator) -> List[str]:
+    """Extract key topics from document summaries"""
+    system_prompt = """You are an expert at analyzing educational content and extracting key topics.
+    Given document summaries, identify the main topics and concepts that would be suitable for quiz questions.
+    
+    Return a JSON array of topic strings, focusing on:
+    - Main concepts and theories
+    - Important facts and details
+    - Key processes and procedures
+    - Critical thinking points
+    
+    Limit to 10-15 most important topics.
+    """
+    
+    user_prompt = f"Document summaries:\n{document_summaries}\n\nExtract key topics:"
+    
+    try:
+        # Use NVIDIA_MEDIUM for topic extraction
+        response = await generate_answer_with_model(
+            selection={"provider": "qwen", "model": NVIDIA_MEDIUM},
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_topic_extraction"
+        )
+        
+        topics = json.loads(response.strip())
+        return topics if isinstance(topics, list) else []
+        
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to extract topics: {e}")
+        return ["General Knowledge", "Key Concepts", "Important Details"]
+
+
+async def create_question_plan(question_config: Dict, key_topics: List[str], nvidia_rotator) -> List[Dict]:
+    """Create a plan for question generation"""
+    system_prompt = """You are an expert at creating quiz question generation plans.
+    Given question counts and topics, create a detailed plan for generating questions.
+    
+    Return a JSON array of task objects, each with:
+    - description: what type of questions to generate
+    - complexity: "high", "medium", or "low"
+    - topic: which topic to focus on
+    - number_mcq: number of MCQ questions for this task
+    - number_sr: number of self-reflect questions for this task
+    
+    Distribute questions across topics and complexity levels.
+    """
+    
+    user_prompt = f"""Question config: {question_config}
+    Key topics: {key_topics}
+    
+    Create a generation plan:"""
+    
+    try:
+        # Use NVIDIA_MEDIUM for planning
+        response = await generate_answer_with_model(
+            selection={"provider": "qwen", "model": NVIDIA_MEDIUM},
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_planning"
+        )
+        
+        plan = json.loads(response.strip())
+        return plan if isinstance(plan, list) else []
+        
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to create plan: {e}")
+        # Fallback plan
+        return [{
+            "description": "Generate general questions",
+            "complexity": "medium",
+            "topic": "General",
+            "number_mcq": question_config.get("mcq", 0),
+            "number_sr": question_config.get("sr", 0)
+        }]
+
+
+async def generate_questions_and_answers(plan: List[Dict], document_summaries: str, nvidia_rotator) -> List[Dict]:
+    """Generate questions and answers based on the plan"""
+    all_questions = []
+    
+    for task in plan:
+        try:
+            # Generate questions for this task
+            questions = await generate_task_questions(task, document_summaries, nvidia_rotator)
+            all_questions.extend(questions)
+            
+        except Exception as e:
+            logger.warning(f"[QUIZ] Failed to generate questions for task: {e}")
+            continue
+    
+    return all_questions
+
+
+async def generate_task_questions(task: Dict, document_summaries: str, nvidia_rotator) -> List[Dict]:
+    """Generate questions for a specific task"""
+    system_prompt = f"""You are an expert quiz question generator.
+    Generate {task.get('number_mcq', 0)} multiple choice questions and {task.get('number_sr', 0)} self-reflection questions.
+    
+    For MCQ questions:
+    - Create clear, well-structured questions
+    - Provide 4 answer options (A, B, C, D)
+    - Mark the correct answer
+    - Make distractors plausible but incorrect
+    
+    For self-reflection questions:
+    - Create open-ended questions that require critical thinking
+    - Focus on analysis, evaluation, and synthesis
+    - Encourage personal reflection and application
+    
+    Return a JSON array of question objects with this format:
+    {{
+        "type": "mcq" or "self_reflect",
+        "question": "question text",
+        "options": ["option1", "option2", "option3", "option4"] (for MCQ only),
+        "correct_answer": 0 (index for MCQ, null for self_reflect),
+        "topic": "topic name",
+        "complexity": "high/medium/low"
+    }}
+    """
+    
+    user_prompt = f"""Task: {task}
+    Document content: {document_summaries[:3000]}...
+    
+    Generate questions:"""
+    
+    try:
+        # Use appropriate model based on complexity
+        if task.get("complexity") == "high":
+            model_selection = {"provider": "nvidia_large", "model": NVIDIA_LARGE}
+        else:
+            model_selection = {"provider": "nvidia", "model": NVIDIA_SMALL}
+        
+        response = await generate_answer_with_model(
+            selection=model_selection,
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_question_generation"
+        )
+        
+        questions = json.loads(response.strip())
+        return questions if isinstance(questions, list) else []
+        
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to generate questions for task: {e}")
+        return []
+
+
+async def mark_quiz_answers(questions: List[Dict], user_answers: Dict, nvidia_rotator) -> Dict:
+    """Mark quiz answers and provide feedback"""
+    results = {
+        "questions": [],
+        "total_score": 0,
+        "correct_count": 0,
+        "partial_count": 0,
+        "incorrect_count": 0
+    }
+    
+    for i, question in enumerate(questions):
+        user_answer = user_answers.get(str(i))
+        question_result = await mark_single_question(question, user_answer, nvidia_rotator)
+        results["questions"].append(question_result)
+        
+        # Update counts
+        if question_result["status"] == "correct":
+            results["correct_count"] += 1
+            results["total_score"] += 1
+        elif question_result["status"] == "partial":
+            results["partial_count"] += 1
+            results["total_score"] += 0.5
+        else:
+            results["incorrect_count"] += 1
+    
+    return results
+
+
+async def mark_single_question(question: Dict, user_answer: Any, nvidia_rotator) -> Dict:
+    """Mark a single question"""
+    result = {
+        "question": question["question"],
+        "type": question["type"],
+        "user_answer": user_answer,
+        "status": "incorrect",
+        "explanation": ""
+    }
+    
+    if question["type"] == "mcq":
+        # MCQ marking
+        correct_index = question.get("correct_answer", 0)
+        if user_answer is not None and int(user_answer) == correct_index:
+            result["status"] = "correct"
+            result["explanation"] = "Correct answer!"
+        else:
+            result["status"] = "incorrect"
+            result["explanation"] = await generate_mcq_explanation(question, user_answer, nvidia_rotator)
+        
+        result["correct_answer"] = correct_index
+        result["options"] = question.get("options", [])
+        
+    elif question["type"] == "self_reflect":
+        # Self-reflection marking using AI
+        result["status"] = await evaluate_self_reflect_answer(question, user_answer, nvidia_rotator)
+        result["explanation"] = await generate_self_reflect_feedback(question, user_answer, result["status"], nvidia_rotator)
+    
+    return result
+
+
+async def generate_mcq_explanation(question: Dict, user_answer: Any, nvidia_rotator) -> str:
+    """Generate explanation for MCQ answer"""
+    system_prompt = """You are an expert tutor. Explain why the user's answer was wrong and why the correct answer is right.
+    Be concise but helpful. Focus on the key concept being tested."""
+    
+    user_prompt = f"""Question: {question['question']}
+    Options: {question.get('options', [])}
+    User's answer: {user_answer}
+    Correct answer: {question.get('correct_answer', 0)}
+    
+    Explain why the user was wrong:"""
+    
+    try:
+        response = await generate_answer_with_model(
+            selection={"provider": "nvidia", "model": NVIDIA_SMALL},
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_explanation"
+        )
+        return response
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to generate MCQ explanation: {e}")
+        return "The correct answer is different from your choice. Please review the material."
+
+
+async def evaluate_self_reflect_answer(question: Dict, user_answer: str, nvidia_rotator) -> str:
+    """Evaluate self-reflection answer using AI"""
+    system_prompt = """You are an expert educator evaluating student responses.
+    Evaluate the student's answer and determine if it's correct, partially correct, or incorrect.
+    
+    Return only one word: "correct", "partial", or "incorrect"
+    """
+    
+    user_prompt = f"""Question: {question['question']}
+    Student's answer: {user_answer or 'No answer provided'}
+    
+    Evaluate the answer:"""
+    
+    try:
+        response = await generate_answer_with_model(
+            selection={"provider": "nvidia", "model": NVIDIA_SMALL},
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_evaluation"
+        )
+        
+        response = response.strip().lower()
+        if response in ["correct", "partial", "incorrect"]:
+            return response
+        else:
+            return "partial"  # Default to partial if unclear
+            
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to evaluate self-reflect answer: {e}")
+        return "partial"
+
+
+async def generate_self_reflect_feedback(question: Dict, user_answer: str, status: str, nvidia_rotator) -> str:
+    """Generate feedback for self-reflection answer"""
+    system_prompt = """You are an expert tutor providing feedback on student responses.
+    Provide constructive feedback that helps the student understand their answer and improve.
+    Be encouraging but honest about areas for improvement."""
+    
+    user_prompt = f"""Question: {question['question']}
+    Student's answer: {user_answer or 'No answer provided'}
+    Evaluation: {status}
+    
+    Provide feedback:"""
+    
+    try:
+        response = await generate_answer_with_model(
+            selection={"provider": "nvidia", "model": NVIDIA_SMALL},
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            gemini_rotator=gemini_rotator,
+            nvidia_rotator=nvidia_rotator,
+            user_id="system",
+            context="quiz_feedback"
+        )
+        return response
+    except Exception as e:
+        logger.warning(f"[QUIZ] Failed to generate self-reflect feedback: {e}")
+        return "Thank you for your response. Please review the material for a more complete answer."

static/index.html

@@ -319,6 +319,13 @@
                       </svg>
                       <span>Search</span>
                     </button>
+                    <button id="quiz-link" class="action-pill" title="Create quiz from selected documents">
+                      <svg viewBox="0 0 24 24" aria-hidden="true">
+                        <path d="M9 12l2 2 4-4"></path>
+                        <path d="M21 12c0 4.97-4.03 9-9 9s-9-4.03-9-9 4.03-9 9-9 9 4.03 9 9z"></path>
+                      </svg>
+                      <span>Quiz</span>
+                    </button>
                   </div>
                 </div>
                 <div class="chat-hint" id="chat-hint">
@@ -433,6 +440,99 @@
     </div>
   </div>
 
+  <!-- Quiz Setup Modal -->
+  <div id="quiz-setup-modal" class="modal hidden" aria-hidden="true" role="dialog" aria-labelledby="quiz-setup-title">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h2 id="quiz-setup-title">Create Quiz</h2>
+        <p class="modal-subtitle">Configure your quiz settings</p>
+      </div>
+      <form id="quiz-setup-form">
+        <!-- Step 1: Question Configuration -->
+        <div class="quiz-step" id="quiz-step-1">
+          <div class="form-group">
+            <label>How many questions would you like?</label>
+            <textarea id="quiz-questions-input" placeholder="Tell me how many MCQ and self-reflect questions you want. For example: 'I want 25 multiple choice questions and 10 self-reflection questions' or 'Give me 30 questions total, split between MCQ and self-reflect questions'" rows="3" required></textarea>
+          </div>
+        </div>
+
+        <!-- Step 2: Time Limit -->
+        <div class="quiz-step" id="quiz-step-2" style="display:none;">
+          <div class="form-group">
+            <label>Time Limit (minutes)</label>
+            <input type="number" id="quiz-time-limit" placeholder="Enter time limit in minutes (0 for no limit)" min="0" value="0">
+            <small>Enter 0 for no time limit</small>
+          </div>
+        </div>
+
+        <!-- Step 3: Document Selection -->
+        <div class="quiz-step" id="quiz-step-3" style="display:none;">
+          <div class="form-group">
+            <label>Select Documents</label>
+            <div id="quiz-document-list" class="document-checkbox-list">
+              <!-- Documents will be populated here -->
+            </div>
+          </div>
+        </div>
+
+        <div class="form-actions">
+          <button type="button" id="quiz-prev-step" class="btn-secondary" style="display:none;">Previous</button>
+          <button type="button" id="quiz-next-step" class="btn-primary">Next</button>
+          <button type="button" id="quiz-cancel" class="btn-secondary">Cancel</button>
+          <button type="submit" id="quiz-submit" class="btn-primary" style="display:none;">Create Quiz</button>
+        </div>
+      </form>
+    </div>
+  </div>
+
+  <!-- Quiz Taking Modal -->
+  <div id="quiz-modal" class="modal hidden" aria-hidden="true" role="dialog" aria-labelledby="quiz-title">
+    <div class="modal-content quiz-modal-content">
+      <div class="modal-header">
+        <h2 id="quiz-title">Quiz</h2>
+        <div class="quiz-timer" id="quiz-timer">Time: --:--</div>
+      </div>
+      <div class="quiz-content">
+        <div class="quiz-progress">
+          <div class="quiz-progress-bar">
+            <div class="quiz-progress-fill" id="quiz-progress-fill"></div>
+          </div>
+          <span class="quiz-progress-text" id="quiz-progress-text">Question 1 of 10</span>
+        </div>
+        
+        <div class="quiz-question" id="quiz-question">
+          <!-- Question content will be populated here -->
+        </div>
+        
+        <div class="quiz-answers" id="quiz-answers">
+          <!-- Answer options will be populated here -->
+        </div>
+        
+        <div class="quiz-navigation">
+          <button id="quiz-prev" class="btn-secondary" disabled>Previous</button>
+          <button id="quiz-next" class="btn-primary">Next</button>
+          <button id="quiz-submit" class="btn-primary" style="display:none;">Submit Quiz</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Quiz Results Modal -->
+  <div id="quiz-results-modal" class="modal hidden" aria-hidden="true" role="dialog" aria-labelledby="quiz-results-title">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h2 id="quiz-results-title">Quiz Results</h2>
+        <p class="modal-subtitle">Your quiz has been completed</p>
+      </div>
+      <div class="quiz-results-content" id="quiz-results-content">
+        <!-- Results will be populated here -->
+      </div>
+      <div class="form-actions">
+        <button type="button" id="quiz-results-close" class="btn-primary">Close</button>
+      </div>
+    </div>
+  </div>
+
   <!-- Loading Overlay -->
   <div id="loading-overlay" class="loading-overlay hidden">
     <div class="loading-content">
@@ -451,5 +551,6 @@
   <script src="/static/script.js"></script>
   <script src="/static/sessions.js"></script>
   <script src="/static/analytics.js"></script>
+  <script src="/static/quiz.js"></script>
 </body>
 </html>

static/quiz.js

@@ -0,0 +1,546 @@
+// ────────────────────────────── static/quiz.js ──────────────────────────────
+(function() {
+  // Quiz state
+  let currentQuiz = null;
+  let currentQuestionIndex = 0;
+  let quizAnswers = {};
+  let quizTimer = null;
+  let timeRemaining = 0;
+  let quizSetupStep = 1;
+
+  // DOM elements
+  const quizLink = document.getElementById('quiz-link');
+  const quizSetupModal = document.getElementById('quiz-setup-modal');
+  const quizModal = document.getElementById('quiz-modal');
+  const quizResultsModal = document.getElementById('quiz-results-modal');
+  const quizSetupForm = document.getElementById('quiz-setup-form');
+  const quizQuestionsInput = document.getElementById('quiz-questions-input');
+  const quizTimeLimit = document.getElementById('quiz-time-limit');
+  const quizDocumentList = document.getElementById('quiz-document-list');
+  const quizPrevStep = document.getElementById('quiz-prev-step');
+  const quizNextStep = document.getElementById('quiz-next-step');
+  const quizCancel = document.getElementById('quiz-cancel');
+  const quizSubmit = document.getElementById('quiz-submit');
+  const quizTimerElement = document.getElementById('quiz-timer');
+  const quizProgressFill = document.getElementById('quiz-progress-fill');
+  const quizProgressText = document.getElementById('quiz-progress-text');
+  const quizQuestion = document.getElementById('quiz-question');
+  const quizAnswers = document.getElementById('quiz-answers');
+  const quizPrev = document.getElementById('quiz-prev');
+  const quizNext = document.getElementById('quiz-next');
+  const quizSubmitBtn = document.getElementById('quiz-submit');
+  const quizResultsContent = document.getElementById('quiz-results-content');
+  const quizResultsClose = document.getElementById('quiz-results-close');
+
+  // Initialize
+  init();
+
+  function init() {
+    setupEventListeners();
+  }
+
+  function setupEventListeners() {
+    // Quiz link
+    if (quizLink) {
+      quizLink.addEventListener('click', (e) => {
+        e.preventDefault();
+        openQuizSetup();
+      });
+    }
+
+    // Quiz setup form
+    if (quizSetupForm) {
+      quizSetupForm.addEventListener('submit', handleQuizSetupSubmit);
+    }
+
+    // Quiz setup navigation
+    if (quizNextStep) {
+      quizNextStep.addEventListener('click', nextQuizStep);
+    }
+    if (quizPrevStep) {
+      quizPrevStep.addEventListener('click', prevQuizStep);
+    }
+    if (quizCancel) {
+      quizCancel.addEventListener('click', closeQuizSetup);
+    }
+
+    // Quiz navigation
+    if (quizPrev) {
+      quizPrev.addEventListener('click', prevQuestion);
+    }
+    if (quizNext) {
+      quizNext.addEventListener('click', nextQuestion);
+    }
+    if (quizSubmitBtn) {
+      quizSubmitBtn.addEventListener('click', submitQuiz);
+    }
+
+    // Quiz results
+    if (quizResultsClose) {
+      quizResultsClose.addEventListener('click', closeQuizResults);
+    }
+
+    // Close modals on outside click
+    document.addEventListener('click', (e) => {
+      if (e.target.classList.contains('modal')) {
+        closeAllQuizModals();
+      }
+    });
+  }
+
+  async function openQuizSetup() {
+    const user = window.__sb_get_user();
+    if (!user) {
+      alert('Please sign in to create a quiz');
+      window.__sb_show_auth_modal();
+      return;
+    }
+
+    const currentProject = window.__sb_get_current_project && window.__sb_get_current_project();
+    if (!currentProject) {
+      alert('Please select a project first');
+      return;
+    }
+
+    // Load available documents
+    await loadQuizDocuments();
+    
+    // Reset form
+    quizSetupStep = 1;
+    updateQuizSetupStep();
+    
+    // Show modal
+    quizSetupModal.classList.remove('hidden');
+  }
+
+  async function loadQuizDocuments() {
+    const user = window.__sb_get_user();
+    const currentProject = window.__sb_get_current_project && window.__sb_get_current_project();
+    
+    if (!user || !currentProject) return;
+
+    try {
+      const res = await fetch(`/files?user_id=${encodeURIComponent(user.user_id)}&project_id=${encodeURIComponent(currentProject.project_id)}`);
+      if (!res.ok) return;
+      
+      const data = await res.json();
+      const files = data.files || [];
+      
+      // Clear existing documents
+      quizDocumentList.innerHTML = '';
+      
+      if (files.length === 0) {
+        quizDocumentList.innerHTML = '<div class="muted">No documents available. Please upload documents first.</div>';
+        return;
+      }
+
+      // Create document checkboxes
+      files.forEach((file, index) => {
+        const item = document.createElement('div');
+        item.className = 'document-checkbox-item';
+        item.innerHTML = `
+          <input type="checkbox" id="quiz-doc-${index}" value="${file.filename}" checked>
+          <label for="quiz-doc-${index}">${file.filename}</label>
+        `;
+        quizDocumentList.appendChild(item);
+      });
+    } catch (error) {
+      console.error('Failed to load documents:', error);
+      quizDocumentList.innerHTML = '<div class="muted">Failed to load documents.</div>';
+    }
+  }
+
+  function updateQuizSetupStep() {
+    // Hide all steps
+    document.querySelectorAll('.quiz-step').forEach(step => {
+      step.style.display = 'none';
+    });
+
+    // Show current step
+    const currentStep = document.getElementById(`quiz-step-${quizSetupStep}`);
+    if (currentStep) {
+      currentStep.style.display = 'block';
+    }
+
+    // Update navigation buttons
+    quizPrevStep.style.display = quizSetupStep > 1 ? 'inline-flex' : 'none';
+    quizNextStep.style.display = quizSetupStep < 3 ? 'inline-flex' : 'none';
+    quizSubmit.style.display = quizSetupStep === 3 ? 'inline-flex' : 'none';
+  }
+
+  function nextQuizStep() {
+    if (quizSetupStep < 3) {
+      quizSetupStep++;
+      updateQuizSetupStep();
+    }
+  }
+
+  function prevQuizStep() {
+    if (quizSetupStep > 1) {
+      quizSetupStep--;
+      updateQuizSetupStep();
+    }
+  }
+
+  function closeQuizSetup() {
+    quizSetupModal.classList.add('hidden');
+    quizSetupStep = 1;
+    updateQuizSetupStep();
+  }
+
+  async function handleQuizSetupSubmit(e) {
+    e.preventDefault();
+    
+    const user = window.__sb_get_user();
+    const currentProject = window.__sb_get_current_project && window.__sb_get_current_project();
+    
+    if (!user || !currentProject) {
+      alert('Please sign in and select a project');
+      return;
+    }
+
+    // Get form data
+    const questionsInput = quizQuestionsInput.value.trim();
+    const timeLimit = parseInt(quizTimeLimit.value) || 0;
+    
+    // Get selected documents
+    const selectedDocs = Array.from(quizDocumentList.querySelectorAll('input[type="checkbox"]:checked'))
+      .map(input => input.value);
+
+    if (selectedDocs.length === 0) {
+      alert('Please select at least one document');
+      return;
+    }
+
+    if (!questionsInput) {
+      alert('Please specify how many questions you want');
+      return;
+    }
+
+    // Show loading
+    showLoading('Creating quiz...');
+
+    try {
+      // Create quiz
+      const formData = new FormData();
+      formData.append('user_id', user.user_id);
+      formData.append('project_id', currentProject.project_id);
+      formData.append('questions_input', questionsInput);
+      formData.append('time_limit', timeLimit.toString());
+      formData.append('documents', JSON.stringify(selectedDocs));
+
+      const response = await fetch('/quiz/create', {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json();
+
+      if (response.ok) {
+        hideLoading();
+        closeQuizSetup();
+        
+        // Start quiz
+        currentQuiz = data.quiz;
+        currentQuestionIndex = 0;
+        quizAnswers = {};
+        timeRemaining = timeLimit * 60; // Convert to seconds
+        
+        startQuiz();
+      } else {
+        hideLoading();
+        alert(data.detail || 'Failed to create quiz');
+      }
+    } catch (error) {
+      hideLoading();
+      console.error('Quiz creation failed:', error);
+      alert('Failed to create quiz. Please try again.');
+    }
+  }
+
+  function startQuiz() {
+    // Show quiz modal
+    quizModal.classList.remove('hidden');
+    
+    // Start timer if time limit is set
+    if (timeRemaining > 0) {
+      startQuizTimer();
+    } else {
+      quizTimerElement.textContent = 'No time limit';
+    }
+    
+    // Show first question
+    showQuestion(0);
+  }
+
+  function startQuizTimer() {
+    updateTimerDisplay();
+    
+    quizTimer = setInterval(() => {
+      timeRemaining--;
+      updateTimerDisplay();
+      
+      if (timeRemaining <= 0) {
+        clearInterval(quizTimer);
+        timeUp();
+      }
+    }, 1000);
+  }
+
+  function updateTimerDisplay() {
+    const minutes = Math.floor(timeRemaining / 60);
+    const seconds = timeRemaining % 60;
+    const timeString = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+    
+    quizTimerElement.textContent = `Time: ${timeString}`;
+    
+    // Add warning classes
+    quizTimerElement.classList.remove('warning', 'danger');
+    if (timeRemaining <= 60) {
+      quizTimerElement.classList.add('danger');
+    } else if (timeRemaining <= 300) { // 5 minutes
+      quizTimerElement.classList.add('warning');
+    }
+  }
+
+  function timeUp() {
+    alert('Time Up!');
+    submitQuiz();
+  }
+
+  function showQuestion(index) {
+    if (!currentQuiz || !currentQuiz.questions || index >= currentQuiz.questions.length) {
+      return;
+    }
+
+    const question = currentQuiz.questions[index];
+    currentQuestionIndex = index;
+
+    // Update progress
+    const progress = ((index + 1) / currentQuiz.questions.length) * 100;
+    quizProgressFill.style.width = `${progress}%`;
+    quizProgressText.textContent = `Question ${index + 1} of ${currentQuiz.questions.length}`;
+
+    // Show question
+    quizQuestion.innerHTML = `
+      <h3>Question ${index + 1}</h3>
+      <p>${question.question}</p>
+    `;
+
+    // Show answers
+    if (question.type === 'mcq') {
+      showMCQAnswers(question);
+    } else if (question.type === 'self_reflect') {
+      showSelfReflectAnswer(question);
+    }
+
+    // Update navigation
+    quizPrev.disabled = index === 0;
+    quizNext.style.display = index < currentQuiz.questions.length - 1 ? 'inline-flex' : 'none';
+    quizSubmitBtn.style.display = index === currentQuiz.questions.length - 1 ? 'inline-flex' : 'none';
+  }
+
+  function showMCQAnswers(question) {
+    quizAnswers.innerHTML = '';
+    
+    question.options.forEach((option, index) => {
+      const optionDiv = document.createElement('div');
+      optionDiv.className = 'quiz-answer-option';
+      optionDiv.innerHTML = `
+        <input type="radio" name="question-${currentQuestionIndex}" value="${index}" id="option-${currentQuestionIndex}-${index}">
+        <label for="option-${currentQuestionIndex}-${index}">${option}</label>
+      `;
+      
+      // Check if already answered
+      if (quizAnswers[currentQuestionIndex] !== undefined) {
+        const radio = optionDiv.querySelector('input[type="radio"]');
+        radio.checked = quizAnswers[currentQuestionIndex] === index;
+        if (radio.checked) {
+          optionDiv.classList.add('selected');
+        }
+      }
+      
+      // Add click handler
+      optionDiv.addEventListener('click', () => {
+        // Remove selection from other options
+        quizAnswers.querySelectorAll('.quiz-answer-option').forEach(opt => {
+          opt.classList.remove('selected');
+        });
+        
+        // Select this option
+        optionDiv.classList.add('selected');
+        const radio = optionDiv.querySelector('input[type="radio"]');
+        radio.checked = true;
+        
+        // Save answer
+        quizAnswers[currentQuestionIndex] = index;
+      });
+      
+      quizAnswers.appendChild(optionDiv);
+    });
+  }
+
+  function showSelfReflectAnswer(question) {
+    quizAnswers.innerHTML = `
+      <textarea class="quiz-text-answer" id="self-reflect-${currentQuestionIndex}" placeholder="Enter your answer here...">${quizAnswers[currentQuestionIndex] || ''}</textarea>
+    `;
+    
+    const textarea = quizAnswers.querySelector('textarea');
+    textarea.addEventListener('input', (e) => {
+      quizAnswers[currentQuestionIndex] = e.target.value;
+    });
+  }
+
+  function prevQuestion() {
+    if (currentQuestionIndex > 0) {
+      showQuestion(currentQuestionIndex - 1);
+    }
+  }
+
+  function nextQuestion() {
+    if (currentQuestionIndex < currentQuiz.questions.length - 1) {
+      showQuestion(currentQuestionIndex + 1);
+    }
+  }
+
+  async function submitQuiz() {
+    if (quizTimer) {
+      clearInterval(quizTimer);
+    }
+
+    // Show loading
+    showLoading('Submitting quiz...');
+
+    try {
+      const user = window.__sb_get_user();
+      const currentProject = window.__sb_get_current_project && window.__sb_get_current_project();
+
+      const formData = new FormData();
+      formData.append('user_id', user.user_id);
+      formData.append('project_id', currentProject.project_id);
+      formData.append('quiz_id', currentQuiz.quiz_id);
+      formData.append('answers', JSON.stringify(quizAnswers));
+
+      const response = await fetch('/quiz/submit', {
+        method: 'POST',
+        body: formData
+      });
+
+      const data = await response.json();
+
+      if (response.ok) {
+        hideLoading();
+        closeQuizModal();
+        showQuizResults(data.results);
+      } else {
+        hideLoading();
+        alert(data.detail || 'Failed to submit quiz');
+      }
+    } catch (error) {
+      hideLoading();
+      console.error('Quiz submission failed:', error);
+      alert('Failed to submit quiz. Please try again.');
+    }
+  }
+
+  function showQuizResults(results) {
+    // Show results summary
+    const totalQuestions = results.questions.length;
+    const correctAnswers = results.questions.filter(q => q.status === 'correct').length;
+    const partialAnswers = results.questions.filter(q => q.status === 'partial').length;
+    const incorrectAnswers = results.questions.filter(q => q.status === 'incorrect').length;
+    const score = Math.round((correctAnswers + partialAnswers * 0.5) / totalQuestions * 100);
+
+    quizResultsContent.innerHTML = `
+      <div class="quiz-result-summary">
+        <div class="quiz-result-stat">
+          <div class="quiz-result-stat-value">${score}%</div>
+          <div class="quiz-result-stat-label">Score</div>
+        </div>
+        <div class="quiz-result-stat">
+          <div class="quiz-result-stat-value">${correctAnswers}</div>
+          <div class="quiz-result-stat-label">Correct</div>
+        </div>
+        <div class="quiz-result-stat">
+          <div class="quiz-result-stat-value">${partialAnswers}</div>
+          <div class="quiz-result-stat-label">Partial</div>
+        </div>
+        <div class="quiz-result-stat">
+          <div class="quiz-result-stat-value">${incorrectAnswers}</div>
+          <div class="quiz-result-stat-label">Incorrect</div>
+        </div>
+      </div>
+      
+      <div class="quiz-result-questions">
+        ${results.questions.map((question, index) => `
+          <div class="quiz-result-question">
+            <div class="quiz-result-question-header">
+              <div class="quiz-result-question-title">Question ${index + 1}</div>
+              <div class="quiz-result-question-status ${question.status}">${question.status}</div>
+            </div>
+            <div class="quiz-result-question-text">${question.question}</div>
+            
+            ${question.type === 'mcq' ? `
+              <div class="quiz-result-answer">
+                <div class="quiz-result-answer-label">Your Answer:</div>
+                <div class="quiz-result-answer-content">${question.options[question.user_answer] || 'No answer'}</div>
+              </div>
+              <div class="quiz-result-answer">
+                <div class="quiz-result-answer-label">Correct Answer:</div>
+                <div class="quiz-result-answer-content">${question.options[question.correct_answer]}</div>
+              </div>
+            ` : `
+              <div class="quiz-result-answer">
+                <div class="quiz-result-answer-label">Your Answer:</div>
+                <div class="quiz-result-answer-content">${question.user_answer || 'No answer'}</div>
+              </div>
+            `}
+            
+            ${question.explanation ? `
+              <div class="quiz-result-explanation">
+                <strong>Explanation:</strong> ${question.explanation}
+              </div>
+            ` : ''}
+          </div>
+        `).join('')}
+      </div>
+    `;
+
+    quizResultsModal.classList.remove('hidden');
+  }
+
+  function closeQuizModal() {
+    quizModal.classList.add('hidden');
+  }
+
+  function closeQuizResults() {
+    quizResultsModal.classList.add('hidden');
+  }
+
+  function closeAllQuizModals() {
+    closeQuizSetup();
+    closeQuizModal();
+    closeQuizResults();
+  }
+
+  function showLoading(message = 'Loading...') {
+    const loadingOverlay = document.getElementById('loading-overlay');
+    const loadingMessage = document.getElementById('loading-message');
+    
+    if (loadingOverlay && loadingMessage) {
+      loadingMessage.textContent = message;
+      loadingOverlay.classList.remove('hidden');
+    }
+  }
+
+  function hideLoading() {
+    const loadingOverlay = document.getElementById('loading-overlay');
+    if (loadingOverlay) {
+      loadingOverlay.classList.add('hidden');
+    }
+  }
+
+  // Expose functions globally
+  window.__sb_open_quiz_setup = openQuizSetup;
+  window.__sb_close_quiz_setup = closeQuizSetup;
+})();

static/script.js

@@ -132,6 +132,18 @@
         searchLink.classList.toggle('active');
       });
     }
+    
+    // Quiz link toggle
+    const quizLink = document.getElementById('quiz-link');
+    if (quizLink) {
+      quizLink.addEventListener('click', (e) => {
+        e.preventDefault();
+        // Open quiz setup modal
+        if (window.__sb_open_quiz_setup) {
+          window.__sb_open_quiz_setup();
+        }
+      });
+    }
   }
 
   function handleFileSelection(files) {

static/styles.css

@@ -2424,4 +2424,338 @@
   .daily-label {
     font-size: 0.625rem;
   }
+}
+
+/* Quiz Styles */
+.quiz-modal-content {
+  max-width: 800px;
+  width: 90vw;
+  max-height: 90vh;
+  overflow-y: auto;
+}
+
+.quiz-step {
+  margin-bottom: 24px;
+}
+
+.document-checkbox-list {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  max-height: 300px;
+  overflow-y: auto;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 16px;
+  background: var(--bg-secondary);
+}
+
+.document-checkbox-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 8px 12px;
+  background: var(--card);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+  transition: all 0.2s ease;
+}
+
+.document-checkbox-item:hover {
+  background: var(--card-hover);
+  border-color: var(--border-light);
+}
+
+.document-checkbox-item input[type="checkbox"] {
+  margin: 0;
+  transform: scale(1.2);
+}
+
+.document-checkbox-item label {
+  flex: 1;
+  margin: 0;
+  cursor: pointer;
+  font-weight: 500;
+}
+
+.quiz-timer {
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--accent);
+  background: var(--bg-secondary);
+  padding: 8px 16px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.quiz-timer.warning {
+  color: var(--warning);
+  background: rgba(245, 158, 11, 0.1);
+  border-color: var(--warning);
+}
+
+.quiz-timer.danger {
+  color: var(--error);
+  background: rgba(239, 68, 68, 0.1);
+  border-color: var(--error);
+}
+
+.quiz-progress {
+  margin-bottom: 24px;
+}
+
+.quiz-progress-bar {
+  height: 8px;
+  background: var(--border);
+  border-radius: 4px;
+  overflow: hidden;
+  margin-bottom: 8px;
+}
+
+.quiz-progress-fill {
+  height: 100%;
+  background: var(--gradient-accent);
+  transition: width 0.3s ease;
+  width: 0%;
+}
+
+.quiz-progress-text {
+  font-size: 14px;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.quiz-question {
+  margin-bottom: 24px;
+  padding: 20px;
+  background: var(--card);
+  border-radius: var(--radius-lg);
+  border: 1px solid var(--border);
+}
+
+.quiz-question h3 {
+  font-size: 18px;
+  font-weight: 600;
+  margin-bottom: 16px;
+  color: var(--text);
+}
+
+.quiz-question p {
+  font-size: 16px;
+  line-height: 1.6;
+  color: var(--text-secondary);
+  margin-bottom: 0;
+}
+
+.quiz-answers {
+  margin-bottom: 24px;
+}
+
+.quiz-answer-option {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 16px;
+  margin-bottom: 12px;
+  background: var(--card);
+  border: 2px solid var(--border);
+  border-radius: var(--radius);
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.quiz-answer-option:hover {
+  background: var(--card-hover);
+  border-color: var(--border-light);
+}
+
+.quiz-answer-option.selected {
+  border-color: var(--accent);
+  background: rgba(59, 130, 246, 0.1);
+}
+
+.quiz-answer-option.correct {
+  border-color: var(--success);
+  background: rgba(16, 185, 129, 0.1);
+}
+
+.quiz-answer-option.incorrect {
+  border-color: var(--error);
+  background: rgba(239, 68, 68, 0.1);
+}
+
+.quiz-answer-option input[type="radio"] {
+  margin: 0;
+  transform: scale(1.2);
+}
+
+.quiz-answer-option label {
+  flex: 1;
+  margin: 0;
+  cursor: pointer;
+  font-weight: 500;
+  line-height: 1.5;
+}
+
+.quiz-text-answer {
+  width: 100%;
+  min-height: 120px;
+  padding: 16px;
+  border: 2px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--card);
+  color: var(--text);
+  font-size: 16px;
+  font-family: inherit;
+  resize: vertical;
+  transition: border-color 0.2s ease;
+}
+
+.quiz-text-answer:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.quiz-navigation {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 16px;
+}
+
+.quiz-results-content {
+  max-height: 60vh;
+  overflow-y: auto;
+}
+
+.quiz-result-summary {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+  gap: 16px;
+  margin-bottom: 24px;
+}
+
+.quiz-result-stat {
+  text-align: center;
+  padding: 16px;
+  background: var(--card);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.quiz-result-stat-value {
+  font-size: 24px;
+  font-weight: 700;
+  color: var(--accent);
+  margin-bottom: 4px;
+}
+
+.quiz-result-stat-label {
+  font-size: 14px;
+  color: var(--text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.quiz-result-questions {
+  margin-top: 24px;
+}
+
+.quiz-result-question {
+  margin-bottom: 24px;
+  padding: 20px;
+  background: var(--card);
+  border-radius: var(--radius-lg);
+  border: 1px solid var(--border);
+}
+
+.quiz-result-question-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 12px;
+}
+
+.quiz-result-question-title {
+  font-weight: 600;
+  color: var(--text);
+}
+
+.quiz-result-question-status {
+  padding: 4px 12px;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+.quiz-result-question-status.correct {
+  background: rgba(16, 185, 129, 0.1);
+  color: var(--success);
+}
+
+.quiz-result-question-status.incorrect {
+  background: rgba(239, 68, 68, 0.1);
+  color: var(--error);
+}
+
+.quiz-result-question-status.partial {
+  background: rgba(245, 158, 11, 0.1);
+  color: var(--warning);
+}
+
+.quiz-result-question-text {
+  margin-bottom: 16px;
+  color: var(--text-secondary);
+  line-height: 1.6;
+}
+
+.quiz-result-answer {
+  margin-bottom: 12px;
+  padding: 12px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.quiz-result-answer-label {
+  font-weight: 600;
+  margin-bottom: 4px;
+  color: var(--text);
+}
+
+.quiz-result-answer-content {
+  color: var(--text-secondary);
+  line-height: 1.5;
+}
+
+.quiz-result-explanation {
+  margin-top: 12px;
+  padding: 12px;
+  background: var(--bg-secondary);
+  border-radius: var(--radius);
+  border-left: 4px solid var(--accent);
+  font-size: 14px;
+  color: var(--text-secondary);
+  line-height: 1.5;
+}
+
+/* Quiz responsive */
+@media (max-width: 768px) {
+  .quiz-modal-content {
+    width: 95vw;
+    max-height: 95vh;
+  }
+  
+  .quiz-navigation {
+    flex-direction: column;
+    gap: 12px;
+  }
+  
+  .quiz-navigation button {
+    width: 100%;
+  }
+  
+  .quiz-result-summary {
+    grid-template-columns: 1fr;
+  }
 }

utils/rag/rag.py

@@ -78,6 +78,29 @@ class RAGStore:
             return serializable_doc
         return None
 
+    def get_file_chunks(self, user_id: str, project_id: str, filename: str, limit: int = 20) -> List[Dict[str, Any]]:
+        """Get chunks for a specific file"""
+        cursor = self.chunks.find({
+            "user_id": user_id,
+            "project_id": project_id,
+            "filename": filename
+        }).limit(limit)
+        
+        chunks = []
+        for doc in cursor:
+            # Convert MongoDB document to JSON-serializable format
+            serializable_doc = {}
+            for key, value in doc.items():
+                if key == '_id':
+                    serializable_doc[key] = str(value)
+                elif hasattr(value, 'isoformat'):
+                    serializable_doc[key] = value.isoformat()
+                else:
+                    serializable_doc[key] = value
+            chunks.append(serializable_doc)
+        
+        return chunks
+
     def list_files(self, user_id: str, project_id: str):
         """List all files for a project with their summaries"""
         files_cursor = self.files.find(