Upload 27 files

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY agents/ ./agents/
+COPY app.py .
+
+RUN mkdir -p documents
+
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

agents/__init__.py

@@ -0,0 +1,6 @@
+"""AI Tutor Multi-Agent System - Agents Package"""
+
+from agents.model import llm
+from agents.states import QuizTask, Quiz
+from agents.tools import Docs
+from agents.summarizer import summarize_pdf

agents/examiner.py

@@ -0,0 +1,61 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langgraph.prebuilt import create_react_agent
+from agents.states import Quiz
+from agents.prompts import EXAMINER_SYSTEM_PROMPT, EXAMINER_USER_PROMPT
+from agents.tools import Docs
+from agents.model import llm
+
+
+def create_examiner_agent(docs: Docs):
+    """
+    Create an Examiner agent that generates quiz questions.
+    
+    Args:
+        docs: Docs instance with loaded document
+    
+    Returns:
+        A LangGraph ReAct agent configured for quiz generation
+    """
+    search_tool = docs.as_search_tool()
+    
+    agent = create_react_agent(
+        model=llm,
+        tools=[search_tool],
+    )
+    
+    return agent
+
+
+def generate_quiz(docs: Docs, summary: str, num_questions: int = 5) -> Quiz:
+    """
+    Generate a quiz based on the document and summary.
+    
+    Args:
+        docs: Docs instance with loaded document
+        summary: Summary of the document
+        num_questions: Number of questions to generate
+    
+    Returns:
+        Quiz object with generated questions
+    """
+    llm_with_structure = llm.with_structured_output(Quiz)
+    
+    search_tool = docs.as_search_tool()
+    
+    context_docs = docs.similarity_search("main concepts and key topics", k=5)
+    context = "\n\n".join(doc.page_content for doc in context_docs)
+    
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", EXAMINER_SYSTEM_PROMPT),
+        ("human", EXAMINER_USER_PROMPT + "\n\nAdditional Context from Document:\n{context}")
+    ])
+    
+    chain = prompt | llm_with_structure
+    
+    quiz = chain.invoke({
+        "summary": summary,
+        "num_questions": num_questions,
+        "context": context
+    })
+    
+    return quiz

agents/model.py

@@ -0,0 +1,6 @@
+from langchain.chat_models import init_chat_model
+from dotenv import load_dotenv
+
+load_dotenv()
+
+llm = init_chat_model("google_genai:gemini-2.0-flash-lite")

agents/prompts.py

@@ -0,0 +1,84 @@
+CONTENT_SAFETY_GUARDRAIL = """IMPORTANT CONTENT SAFETY GUIDELINES:
+- This system is designed for educational use by learners of all ages, including children.
+- You MUST NOT generate, discuss, or reference any inappropriate content including:
+  * Sexual, pornographic, or adult content
+  * Graphic violence or gore
+  * Hate speech, discrimination, or harmful stereotypes
+  * Content promoting illegal activities or substance abuse
+  * Personal attacks or bullying
+- If source material contains inappropriate content, skip it entirely and focus only on age-appropriate educational topics.
+- Maintain a professional, supportive, and educational tone at all times.
+- If asked to discuss inappropriate topics, politely redirect to the educational material.
+"""
+
+SUMMARIZER_MAP_PROMPT = """Summarize the following text in 3-5 short bullet points.
+
+""" + CONTENT_SAFETY_GUARDRAIL + """
+{chunk}"""
+
+SUMMARIZER_REDUCE_PROMPT = """You are combining partial summaries of a long document.
+Write a concise final summary (max ~300 words) with clear sections if useful.
+
+""" + CONTENT_SAFETY_GUARDRAIL + """
+Partial summaries:
+{partials}"""
+
+EXAMINER_SYSTEM_PROMPT = """You are an expert educational quiz creator. Your task is to generate quiz questions based on the provided document summary and context.
+
+""" + CONTENT_SAFETY_GUARDRAIL + """
+Create a diverse set of quiz questions that test understanding of the key concepts. Include:
+- Multiple choice questions (with 4 options each)
+- Fill-in-the-gap questions (with options provided)
+- Type-in questions (short answer)
+
+Each question should:
+1. Be clear and unambiguous
+2. Test a specific concept from the document
+3. Have a definitive correct answer
+4. Be appropriately challenging for the material
+
+Use the search tool to retrieve specific details from the document when needed.
+
+Document Summary:
+{summary}"""
+
+EXAMINER_USER_PROMPT = """Generate a quiz with {num_questions} questions based on the document.
+Make sure to include a mix of question types: multiple_choice, fill_gap, and type_in.
+
+Use the search tool to find specific facts and details from the document to create accurate questions."""
+
+SUPERVISOR_SYSTEM_PROMPT = """You are a Socratic tutor providing feedback on a student's quiz performance. 
+
+""" + CONTENT_SAFETY_GUARDRAIL + """
+Your approach:
+1. Never give direct answers immediately
+2. Guide students through leading questions
+3. Help them discover concepts on their own
+4. Provide encouragement and constructive feedback
+5. Use the document search tool to reference specific material when helpful
+
+Document Summary:
+{summary}
+
+Quiz Results:
+{quiz_results}"""
+
+SUPERVISOR_USER_PROMPT = """The student has completed the quiz. Review their answers and provide Socratic feedback.
+
+For incorrect answers:
+- Ask guiding questions to help them understand the concept
+- Reference relevant parts of the document
+- Encourage them to think through the problem
+
+For correct answers:
+- Briefly acknowledge the correct response
+- Optionally ask a follow-up question to deepen understanding
+
+Provide a summary of their performance and suggestions for improvement."""
+
+SUPERVISOR_CHAT_PROMPT = """Continue the tutoring conversation. The student has asked:
+{user_message}
+
+""" + CONTENT_SAFETY_GUARDRAIL + """
+Use the search tool if needed to find relevant information from the document.
+Maintain your Socratic approach - guide rather than tell."""

agents/sessions.py

@@ -0,0 +1,102 @@
+import uuid
+from typing import Dict, Optional, List
+from dataclasses import dataclass, field
+from agents.tools import Docs
+from agents.states import Quiz
+
+
+@dataclass
+class Session:
+    """Represents a single user session with all associated data."""
+    session_id: str
+    file_path: str
+    docs: Optional[Docs] = None
+    summary: str = ""
+    quiz: Optional[Quiz] = None
+    user_answers: List[str] = field(default_factory=list)
+    messages: List[dict] = field(default_factory=list)
+
+
+class SessionManager:
+    """Manages user sessions for the AI Tutor API."""
+    
+    def __init__(self):
+        self._sessions: Dict[str, Session] = {}
+    
+    def create_session(self, file_path: str) -> Session:
+        """
+        Create a new session with the given PDF file.
+        
+        Args:
+            file_path: Path to the saved PDF file
+            
+        Returns:
+            New Session object
+        """
+        session_id = str(uuid.uuid4())
+        docs = Docs(file_path)
+        session = Session(
+            session_id=session_id,
+            file_path=file_path,
+            docs=docs
+        )
+        self._sessions[session_id] = session
+        return session
+    
+    def get_session(self, session_id: str) -> Optional[Session]:
+        """Get a session by ID."""
+        return self._sessions.get(session_id)
+    
+    def delete_session(self, session_id: str) -> bool:
+        """
+        Delete a session and clean up resources.
+        
+        Returns:
+            True if session was deleted, False if not found
+        """
+        if session_id in self._sessions:
+            del self._sessions[session_id]
+            return True
+        return False
+    
+    def update_summary(self, session_id: str, summary: str) -> bool:
+        """Update the summary for a session."""
+        session = self.get_session(session_id)
+        if session:
+            session.summary = summary
+            return True
+        return False
+    
+    def update_quiz(self, session_id: str, quiz: Quiz) -> bool:
+        """Update the quiz for a session."""
+        session = self.get_session(session_id)
+        if session:
+            session.quiz = quiz
+            return True
+        return False
+    
+    def update_user_answers(self, session_id: str, answers: List[str]) -> bool:
+        """Update user answers for a session."""
+        session = self.get_session(session_id)
+        if session:
+            session.user_answers = answers
+            return True
+        return False
+    
+    def add_message(self, session_id: str, role: str, content: str) -> bool:
+        """Add a message to the conversation history."""
+        session = self.get_session(session_id)
+        if session:
+            session.messages.append({"role": role, "content": content})
+            return True
+        return False
+    
+    def get_messages(self, session_id: str) -> List[dict]:
+        """Get conversation history for a session."""
+        session = self.get_session(session_id)
+        if session:
+            return session.messages
+        return []
+
+
+session_manager = SessionManager()

agents/states.py

@@ -0,0 +1,73 @@
+from typing import Literal, Optional, List
+from pydantic import BaseModel, Field
+
+
+class QuizTask(BaseModel):
+    """
+    Schema for a single quiz task that the agent should generate or return.
+    """
+
+    task_id: int = Field(
+        ...,
+        description=(
+            "Unique integer identifier of the task within a quiz. "
+            "Start from 1 and increment by 1 for each new task."
+        ),
+    )
+
+    task: str = Field(
+        ...,
+        description=(
+            "The question text shown to the student. "
+            "Must be a complete, clear instruction or question in plain language."
+        ),
+    )
+
+    task_type: Literal["fill_gap", "multiple_choice", "type_in"] = Field(
+        ...,
+        description=(
+            "The interaction type for this task:\n"
+            "- 'fill_gap': a sentence or formula with a missing part the student must fill in.\n"
+            "- 'multiple_choice': student chooses exactly one option from 'answer_options'.\n"
+            "- 'type_in': open-ended question where student types a short free-text answer."
+        ),
+    )
+
+    answer_options: Optional[List[str]] = Field(
+        None,
+        description=(
+            "List of answer options, in the exact order they should be shown to the student. "
+            "Required when task_type = 'multiple_choice', 'fill_gap'. "
+            "Must be None for 'type_in'."
+        ),
+    )
+
+    correct_answer: Optional[str] = Field(
+        None,
+        description=(
+            "The correct answer in normalized string form.\n"
+            "- For 'fill_gap' and 'multiple_choice', this MUST exactly match one element of 'answer_options'.\n"
+            "- For 'type_in', this is the canonical correct answer "
+            "(e.g. '42', 'O(n log n)'); you may later implement fuzzy matching if needed."
+        ),
+    )
+
+
+class Quiz(BaseModel):
+    """Collection of quiz tasks generated by the Examiner agent."""
+    tasks: List[QuizTask] = Field(
+        ...,
+        description=(
+            "A collection of quiz tasks that the agent should generate for the given document.\n"
+        )
+    )
+
+
+class WorkflowState(BaseModel):
+    """State for the LangGraph workflow."""
+    pdf_path: str = Field(default="", description="Path to the uploaded PDF")
+    summary: str = Field(default="", description="Summary of the document")
+    quiz: Optional[Quiz] = Field(default=None, description="Generated quiz")
+    user_answers: Optional[List[str]] = Field(default=None, description="User's quiz answers")
+    feedback: str = Field(default="", description="Supervisor feedback on quiz results")
+    messages: List[str] = Field(default_factory=list, description="Conversation history")

agents/summarizer.py

@@ -0,0 +1,93 @@
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.documents import Document
+from agents.model import llm
+from typing import List
+
+
+MAX_CONTEXT_CHARS = 100000
+
+
+def summarize_pdf(pdf_path: str) -> str:
+    """
+    Token-efficient PDF summarizer.
+    
+    Strategy:
+    1. If document is small enough, summarize in ONE call (stuff method)
+    2. If larger, use iterative refinement with large chunks (fewer API calls)
+    
+    Args:
+        pdf_path: Path to the PDF file
+    
+    Returns:
+        Final summary string
+    """
+    loader = PyPDFLoader(pdf_path)
+    docs = loader.load()
+    
+    full_text = "\n\n".join(doc.page_content for doc in docs)
+    
+    if len(full_text) <= MAX_CONTEXT_CHARS:
+        return _stuff_summarize(full_text)
+    else:
+        return _refine_summarize(full_text)
+
+
+def _stuff_summarize(text: str) -> str:
+    """Summarize entire document in one API call."""
+    prompt = ChatPromptTemplate.from_template(
+        "You are an expert summarizer. Read the following document and provide "
+        "a comprehensive summary covering all key topics, concepts, and important details.\n\n"
+        "Format your summary with:\n"
+        "- A brief overview (2-3 sentences)\n"
+        "- Main topics/sections with key points\n"
+        "- Important definitions or concepts\n\n"
+        "Document:\n{text}"
+    )
+    chain = prompt | llm
+    response = chain.invoke({"text": text})
+    return response.content
+
+
+def _refine_summarize(text: str, chunk_size: int = 50000) -> str:
+    """
+    Iterative refinement for large documents.
+    
+    Uses fewer, larger chunks and refines the summary incrementally.
+    This uses far fewer API calls than map-reduce.
+    """
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=500,
+    )
+    chunks = splitter.split_text(text)
+    
+    first_prompt = ChatPromptTemplate.from_template(
+        "You are an expert summarizer. Summarize the following content, "
+        "capturing all key topics, concepts, and important details:\n\n{text}"
+    )
+    first_chain = first_prompt | llm
+    summary = first_chain.invoke({"text": chunks[0]}).content
+    
+    if len(chunks) == 1:
+        return summary
+    
+    refine_prompt = ChatPromptTemplate.from_template(
+        "You have an existing summary of a document:\n\n"
+        "EXISTING SUMMARY:\n{summary}\n\n"
+        "Now incorporate the following additional content into the summary. "
+        "Expand and refine the summary to include new information while keeping it coherent:\n\n"
+        "NEW CONTENT:\n{new_content}\n\n"
+        "Provide the updated comprehensive summary:"
+    )
+    refine_chain = refine_prompt | llm
+    
+    for chunk in chunks[1:]:
+        response = refine_chain.invoke({
+            "summary": summary,
+            "new_content": chunk
+        })
+        summary = response.content
+    
+    return summary

agents/supervisor.py

@@ -0,0 +1,159 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langgraph.prebuilt import create_react_agent
+from agents.states import Quiz
+from agents.prompts import SUPERVISOR_SYSTEM_PROMPT, SUPERVISOR_USER_PROMPT, SUPERVISOR_CHAT_PROMPT
+from agents.tools import Docs
+from agents.model import llm
+from typing import List, Optional, Tuple
+
+
+def escape_template_braces(text: str) -> str:
+    """
+    Escape curly braces in text to prevent ChatPromptTemplate from 
+    interpreting mathematical notation like {X ∈ A|Y = y} as template variables.
+    
+    Args:
+        text: Input text that may contain curly braces
+    
+    Returns:
+        Text with curly braces escaped ({{ and }})
+    """
+    if text is None:
+        return ""
+    return text.replace("{", "{{").replace("}", "}}")
+
+
+def create_supervisor_agent(docs: Docs):
+    """
+    Create a Supervisor agent for Socratic tutoring.
+    
+    Args:
+        docs: Docs instance with loaded document
+    
+    Returns:
+        A LangGraph ReAct agent configured for tutoring
+    """
+    search_tool = docs.as_search_tool()
+    
+    agent = create_react_agent(
+        model=llm,
+        tools=[search_tool],
+    )
+    
+    return agent
+
+
+def format_quiz_results(quiz: Quiz, user_answers: List[str]) -> str:
+    """Format quiz results for the supervisor to review."""
+    results = []
+    correct_count = 0
+    
+    for i, (task, user_answer) in enumerate(zip(quiz.tasks, user_answers)):
+        correct = task.correct_answer or ""
+        is_correct = user_answer.strip().lower() == correct.strip().lower()
+        if is_correct:
+            correct_count += 1
+        
+        result = f"""
+Question {task.task_id}: {task.task}
+Type: {task.task_type}
+"""
+        if task.answer_options:
+            result += f"Options: {', '.join(task.answer_options)}\n"
+        result += f"""Student Answer: {user_answer}
+Correct Answer: {task.correct_answer}
+Result: {'CORRECT' if is_correct else 'INCORRECT'}
+"""
+        results.append(result)
+    
+    header = f"Score: {correct_count}/{len(quiz.tasks)} ({100*correct_count/len(quiz.tasks):.0f}%)\n"
+    return header + "\n".join(results)
+
+
+def provide_feedback(
+    docs: Docs,
+    summary: str,
+    quiz: Quiz,
+    user_answers: List[str]
+) -> str:
+    """
+    Provide Socratic feedback on quiz performance.
+    
+    Args:
+        docs: Docs instance with loaded document
+        summary: Summary of the document
+        quiz: The quiz that was taken
+        user_answers: User's answers to the quiz
+    
+    Returns:
+        Feedback string from the supervisor
+    """
+    search_tool = docs.as_search_tool()
+    
+    quiz_results = format_quiz_results(quiz, user_answers)
+    
+    context_docs = docs.similarity_search("main concepts explanation", k=3)
+    context = "\n\n".join(doc.page_content for doc in context_docs)
+    
+    escaped_summary = escape_template_braces(summary)
+    escaped_quiz_results = escape_template_braces(quiz_results)
+    escaped_context = escape_template_braces(context)
+    
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", SUPERVISOR_SYSTEM_PROMPT),
+        ("human", SUPERVISOR_USER_PROMPT + "\n\nRelevant Document Context:\n{context}")
+    ])
+    
+    chain = prompt | llm
+    
+    response = chain.invoke({
+        "summary": escaped_summary,
+        "quiz_results": escaped_quiz_results,
+        "context": escaped_context
+    })
+    
+    return response.content
+
+
+def chat_with_supervisor(
+    docs: Docs,
+    summary: str,
+    user_message: str,
+    conversation_history: Optional[List[dict]] = None
+) -> str:
+    """
+    Continue tutoring conversation with the supervisor.
+    
+    Args:
+        docs: Docs instance with loaded document
+        summary: Summary of the document
+        user_message: User's message/question
+        conversation_history: Previous conversation messages
+    
+    Returns:
+        Supervisor's response
+    """
+    context_docs = docs.similarity_search(user_message, k=3)
+    context = "\n\n".join(doc.page_content for doc in context_docs)
+    
+    escaped_summary = escape_template_braces(summary)
+    escaped_context = escape_template_braces(context)
+    escaped_user_message = escape_template_braces(user_message)
+    
+    messages: List[Tuple[str, str]] = [
+        ("system", f"You are a Socratic tutor. Document Summary: {escaped_summary}\n\nRelevant Context:\n{escaped_context}")
+    ]
+    
+    if conversation_history:
+        for msg in conversation_history:
+            escaped_content = escape_template_braces(msg["content"])
+            messages.append((msg["role"], escaped_content))
+    
+    messages.append(("human", escaped_user_message))
+    
+    prompt = ChatPromptTemplate.from_messages(messages)
+    chain = prompt | llm
+    
+    response = chain.invoke({})
+    
+    return response.content

agents/tools.py

@@ -0,0 +1,68 @@
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_core.vectorstores import InMemoryVectorStore
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.tools import tool
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Docs:
+    """Document manager with vector store for RAG-based retrieval."""
+    
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-mpnet-base-v2"
+        )
+        self.vector_store = self._upload_file(file_path)
+
+    def _upload_file(self, file_path: str) -> InMemoryVectorStore:
+        """Load PDF, chunk it, and create vector store."""
+        loader = PyPDFLoader(file_path)
+        docs = loader.load()
+        
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            add_start_index=True,
+        )
+        all_splits = text_splitter.split_documents(docs)
+        
+        vector_store = InMemoryVectorStore(self.embeddings)
+        vector_store.add_documents(documents=all_splits)
+        
+        return vector_store
+
+    def as_search_tool(self):
+        """Return a LangChain tool for searching the document."""
+        vector_store = self.vector_store
+        
+        @tool
+        def search_in_docs(query: str) -> str:
+            """Retrieve information from the uploaded document to answer a query."""
+            retrieved_docs = vector_store.similarity_search(query, k=2)
+            serialized = "\n\n".join(
+                f"Source: {doc.metadata}\nContent: {doc.page_content}"
+                for doc in retrieved_docs
+            )
+            return serialized
+        
+        return search_in_docs
+
+    def get_diverse_chunks_mmr(self, query: str, k: int = 30):
+        """Get diverse chunks using MMR (Maximal Marginal Relevance)."""
+        retriever = self.vector_store.as_retriever(
+            search_type="mmr",
+            search_kwargs={
+                "k": k,
+                "lambda_mult": 0.5,
+                "fetch_k": max(k * 3, 50),
+            },
+        )
+        return retriever.invoke(query)
+
+    def similarity_search(self, query: str, k: int = 4):
+        """Simple similarity search."""
+        return self.vector_store.similarity_search(query, k=k)

app.py

@@ -0,0 +1,200 @@
+import os
+import shutil
+import uuid
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+
+from agents.sessions import session_manager
+from agents.summarizer import summarize_pdf
+from agents.examiner import generate_quiz
+from agents.supervisor import provide_feedback, chat_with_supervisor
+
+app = FastAPI(
+    title="AI Tutor API",
+    description="Multi-agent tutoring system with summarization, quiz generation, and Socratic feedback"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+UPLOAD_DIR = "documents"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+
+class ExaminerRequest(BaseModel):
+    session_id: str
+    num_questions: int = 5
+
+
+class SupervisorRequest(BaseModel):
+    session_id: str
+    message: str
+    user_answers: Optional[List[str]] = None
+
+
+class SummaryResponse(BaseModel):
+    session_id: str
+    summary: str
+
+
+class QuizResponse(BaseModel):
+    quiz: List[dict]
+
+
+class SupervisorResponse(BaseModel):
+    response: str
+    messages: List[dict]
+
+
+class SessionResponse(BaseModel):
+    session_id: str
+    has_summary: bool
+    has_quiz: bool
+    message_count: int
+
+
+@app.post("/summarizer", response_model=SummaryResponse)
+async def summarize_document(file: UploadFile = File(...)):
+    """
+    Upload a PDF and get a summary.
+    Creates a new session and returns session_id with the summary.
+    """
+    if not file.filename or not file.filename.lower().endswith(".pdf"):
+        raise HTTPException(status_code=400, detail="Only PDF files are supported")
+    
+    safe_filename = f"{uuid.uuid4()}.pdf"
+    file_path = os.path.join(UPLOAD_DIR, safe_filename)
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    try:
+        session = session_manager.create_session(file_path)
+        summary = summarize_pdf(file_path)
+        session_manager.update_summary(session.session_id, summary)
+        
+        return SummaryResponse(
+            session_id=session.session_id,
+            summary=summary
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/examiner", response_model=QuizResponse)
+async def generate_quiz_endpoint(request: ExaminerRequest):
+    """
+    Generate a quiz based on a previously summarized document.
+    Requires a valid session_id from /summarizer.
+    """
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    if not session.summary:
+        raise HTTPException(status_code=400, detail="No summary found. Call /summarizer first.")
+    
+    if not session.docs:
+        raise HTTPException(status_code=400, detail="Document not loaded")
+    
+    try:
+        quiz = generate_quiz(
+            docs=session.docs,
+            summary=session.summary,
+            num_questions=request.num_questions
+        )
+        session_manager.update_quiz(request.session_id, quiz)
+        
+        quiz_data = [task.model_dump() for task in quiz.tasks]
+        return QuizResponse(quiz=quiz_data)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/supervisor", response_model=SupervisorResponse)
+async def supervisor_chat(request: SupervisorRequest):
+    """
+    Chat with the Socratic tutor supervisor.
+    
+    First call should include user_answers to get initial feedback.
+    Subsequent calls can just include message for follow-up questions.
+    """
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    if not session.docs:
+        raise HTTPException(status_code=400, detail="Document not loaded")
+    
+    if not session.summary:
+        raise HTTPException(status_code=400, detail="No summary found")
+    
+    try:
+        if request.user_answers:
+            if not session.quiz:
+                raise HTTPException(status_code=400, detail="No quiz found. Call /examiner first.")
+            
+            session_manager.update_user_answers(request.session_id, request.user_answers)
+            
+            response = provide_feedback(
+                docs=session.docs,
+                summary=session.summary,
+                quiz=session.quiz,
+                user_answers=request.user_answers
+            )
+        else:
+            response = chat_with_supervisor(
+                docs=session.docs,
+                summary=session.summary,
+                user_message=request.message,
+                conversation_history=session.messages
+            )
+        
+        session_manager.add_message(request.session_id, "user", request.message)
+        session_manager.add_message(request.session_id, "assistant", response)
+        
+        return SupervisorResponse(
+            response=response,
+            messages=session_manager.get_messages(request.session_id)
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/session/{session_id}", response_model=SessionResponse)
+async def get_session_info(session_id: str):
+    """Get information about a session."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    return SessionResponse(
+        session_id=session.session_id,
+        has_summary=bool(session.summary),
+        has_quiz=session.quiz is not None,
+        message_count=len(session.messages)
+    )
+
+
+@app.delete("/session/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session and clean up resources."""
+    if session_manager.delete_session(session_id):
+        return {"message": "Session deleted successfully"}
+    raise HTTPException(status_code=404, detail="Session not found")
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy"}

requirements.txt

@@ -0,0 +1,14 @@
+langchain>=0.3.0
+langchain-core>=0.3.0
+langchain-community>=0.3.0
+langchain-text-splitters>=0.3.0
+langgraph>=0.2.0
+langchain-google-genai>=2.0.0
+langchain-huggingface>=0.1.0
+sentence-transformers>=2.2.0
+pypdf>=3.0.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+fastapi>=0.100.0
+uvicorn[standard]>=0.20.0
+python-multipart>=0.0.6