feat: Implement Sample Paper Generator with format detection and question generation

backend/alembic/versions/983ad2983d5c_add_selected_resource_ids_to_chat_.py

@@ -0,0 +1,32 @@
+"""add selected_resource_ids to chat_sessions
+
+Revision ID: 983ad2983d5c
+Revises: d3dcf6b6fe3f
+Create Date: 2026-05-18 20:55:14.773697
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '983ad2983d5c'
+down_revision: Union[str, Sequence[str], None] = 'd3dcf6b6fe3f'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('chat_sessions', sa.Column('selected_resource_ids', sa.JSON(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('chat_sessions', 'selected_resource_ids')
+    # ### end Alembic commands ###

backend/app/llm/client.py

@@ -9,6 +9,7 @@ def __init__(self):
         self.base_url = "https://openrouter.ai/api/v1/chat/completions"
 
     async def stream_chat(self, messages: list, model: str = "openrouter/owl-alpha") -> AsyncGenerator[str, None]:
+    # async def stream_chat(self, messages: list, model: str = "nvidia/nemotron-3-super-120b-a12b:free") -> AsyncGenerator[str, None]:
         headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",

backend/app/llm/prompts.py

@@ -20,3 +20,42 @@
 Question:
 {question}
 """
+
+DETECT_FORMAT_PROMPT = """
+Analyse this past year paper and extract the question format.
+Return ONLY a JSON object with this exact structure, no explanation:
+
+{
+  "mcq": <count>,
+  "short": <count>,
+  "long": <count>,
+  "mcq_marks": <marks each>,
+  "short_marks": <marks each>,
+  "long_marks": <marks each>,
+  "total_marks": <total>,
+  "duration_minutes": <duration or null>
+}
+"""
+
+GENERATE_PAPER_PROMPT = """
+You are generating a sample exam paper for a student.
+
+Format config: {format_config}
+Subject context from student's material:
+{context_chunks}
+
+Generate exactly the number of questions specified in the format config.
+Return ONLY a JSON array of question objects. Each object must have:
+  - type (mcq | short | long)
+  - marks (integer)
+  - topic (string)
+  - question_text (string)
+  - For MCQ: also include options (array of 4 strings) and answer (correct option text)
+  - For short/long: also include answer (model answer string) and explanation (string)
+
+Rules:
+- Distribute questions across different topics evenly.
+- No repeated questions.
+- Difficulty should match a real exam for this level.
+- JSON array only. No preamble, no explanation, no markdown fences.
+"""

backend/app/main.py

@@ -1,6 +1,6 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from .routers import auth, resources, solver
+from .routers import auth, resources, solver, papers
 from .config import settings
 
 app = FastAPI(title="PYQ Solver API")
@@ -18,6 +18,7 @@
 app.include_router(auth.router, prefix="/api")
 app.include_router(resources.router, prefix="/api")
 app.include_router(solver.router, prefix="/api")
+app.include_router(papers.router, prefix="/api")
 
 @app.get("/")
 async def root():

backend/app/models/chat_session.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, String, DateTime, UUID, ForeignKey
+from sqlalchemy import Column, String, DateTime, UUID, ForeignKey, JSON
 from sqlalchemy.orm import relationship
 from datetime import datetime
 import uuid
@@ -10,6 +10,7 @@ class ChatSession(Base):
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
     title = Column(String, default="New Chat")
+    selected_resource_ids = Column(JSON, default=list)
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
 

backend/app/routers/papers.py

@@ -0,0 +1,213 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import List
+import uuid
+import json
+import logging
+
+from ..database import get_db
+from ..models.user import User
+from ..models.resource import Resource
+from ..models.paper import Paper, paper_resources
+from ..models.paper_output import PaperOutput
+from ..schemas.paper import (
+    PaperCreate, PaperOut, PaperUpdate, 
+    PaperOutputOut, PaperOutputToggle, 
+    FormatDetectionRequest
+)
+from .auth import get_current_user
+from ..llm.client import open_router_client
+from ..llm.prompts import DETECT_FORMAT_PROMPT
+from ..config import settings
+from arq import create_pool
+from arq.connections import RedisSettings
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/papers", tags=["papers"])
+
+@router.post("/detect-format")
+async def detect_format(
+    data: FormatDetectionRequest,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    # Fetch the resource
+    result = await db.execute(
+        select(Resource).where(Resource.id == data.resource_id, Resource.user_id == current_user.id)
+    )
+    resource = result.scalar_one_or_none()
+
+    if not resource:
+        raise HTTPException(status_code=404, detail="Resource not found")
+
+    if not resource.extracted_text:
+        raise HTTPException(status_code=400, detail="Resource has no extracted text. Please wait for processing.")
+
+    # Call LLM for format detection
+    messages = [
+        {"role": "system", "content": "You are a document analyzer."},
+        {"role": "user", "content": f"{DETECT_FORMAT_PROMPT}\n\nPaper Content:\n{resource.extracted_text[:10000]}"}
+    ]
+
+    try:
+        # Collect stream into full response
+        full_response = ""
+        async for chunk in open_router_client.stream_chat(messages):
+            full_response += chunk
+
+        # Parse JSON from response
+        # LLM might return markdown code blocks, strip them if present
+        clean_json = full_response.strip()
+        if clean_json.startswith("```json"):
+            clean_json = clean_json[7:]
+        if clean_json.endswith("```"):
+            clean_json = clean_json[:-3]
+
+        format_config = json.loads(clean_json)
+        return format_config
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to detect format: {str(e)}")
+
+@router.post("", response_model=PaperOut)
+async def create_paper(
+    data: PaperCreate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    if not data.resources:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="At least one resource must be selected."
+        )
+
+    # 2. Create Paper record
+    new_paper = Paper(
+        user_id=current_user.id,
+        title=data.title,
+        format_config=data.format_config or {},
+        delivery_mode=data.delivery_mode,
+        status="pending"
+    )
+    db.add(new_paper)
+    await db.flush()
+
+    # 3. Link Resources
+    for res_link in data.resources:
+        # Verify resource exists and belongs to user
+        res_result = await db.execute(
+            select(Resource).where(Resource.id == res_link.resource_id, Resource.user_id == current_user.id)
+        )
+        if not res_result.scalar_one_or_none():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Resource {res_link.resource_id} not found or unauthorized."
+            )
+
+        # Insert into association table
+        await db.execute(
+            paper_resources.insert().values(
+                paper_id=new_paper.id,
+                resource_id=res_link.resource_id,
+                resource_role=res_link.role
+            )
+        )
+
+    await db.commit()
+    await db.refresh(new_paper)
+
+    # 4. Enqueue background task
+    redis = await create_pool(RedisSettings.from_dsn(settings.REDIS_URL))
+    try:
+        job = await redis.enqueue_job("generate_paper_task", str(new_paper.id))
+        if job is None:
+            raise RuntimeError("Failed to enqueue generate_paper_task")
+    except Exception as e:
+        logger.error(f"Redis enqueue error: {e}")
+        new_paper.status = "failed"
+        await db.commit()
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE, 
+            detail="Paper generation queued failed, please retry."
+        )
+    finally:
+        await redis.close()
+
+    return new_paper
+
+@router.get("", response_model=List[PaperOut])
+async def list_papers(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    result = await db.execute(
+        select(Paper).where(Paper.user_id == current_user.id).order_by(Paper.created_at.desc())
+    )
+    return result.scalars().all()
+
+@router.get("/{paper_id}", response_model=PaperOut)
+async def get_paper(
+    paper_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    result = await db.execute(
+        select(Paper).where(Paper.id == paper_id, Paper.user_id == current_user.id)
+    )
+    paper = result.scalar_one_or_none()
+    if not paper:
+        raise HTTPException(status_code=404, detail="Paper not found")
+    return paper
+
+@router.get("/{paper_id}/output", response_model=PaperOutputOut)
+async def get_paper_output(
+    paper_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    # Verify paper ownership
+    result = await db.execute(
+        select(Paper).where(Paper.id == paper_id, Paper.user_id == current_user.id)
+    )
+    if not result.scalar_one_or_none():
+        raise HTTPException(status_code=404, detail="Paper not found")
+
+    output_result = await db.execute(
+        select(PaperOutput).where(PaperOutput.paper_id == paper_id)
+    )
+    output = output_result.scalar_one_or_none()
+    if not output:
+        raise HTTPException(status_code=404, detail="Paper output not yet generated")
+
+    return output
+
+@router.patch("/{paper_id}/output", response_model=PaperOutputOut)
+async def toggle_output_settings(
+    paper_id: uuid.UUID,
+    data: PaperOutputToggle,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    # Verify paper ownership
+    result = await db.execute(
+        select(Paper).where(Paper.id == paper_id, Paper.user_id == current_user.id)
+    )
+    if not result.scalar_one_or_none():
+        raise HTTPException(status_code=404, detail="Paper not found")
+
+    output_result = await db.execute(
+        select(PaperOutput).where(PaperOutput.paper_id == paper_id)
+    )
+    output = output_result.scalar_one_or_none()
+    if not output:
+        raise HTTPException(status_code=404, detail="Paper output not found")
+
+    if data.include_answers is not None:
+        output.include_answers = data.include_answers
+    if data.include_explanations is not None:
+        output.include_explanations = data.include_explanations
+
+    await db.commit()
+    await db.refresh(output)
+    return output

backend/app/routers/solver.py

@@ -116,6 +116,9 @@ async def update_session(
 
     if data.title:
         session.title = data.title
+    if data.selected_resource_ids is not None:
+        # Convert UUIDs to strings for JSON storage
+        session.selected_resource_ids = [str(rid) for rid in data.selected_resource_ids]
 
     await db.commit()
     await db.refresh(session)
@@ -165,12 +168,22 @@ async def ask_question(
         sess_result = await db.execute(
             select(ChatSession).where(ChatSession.id == data.session_id, ChatSession.user_id == current_user.id)
         )
-        if not sess_result.scalar_one_or_none():
+        session = sess_result.scalar_one_or_none()
+        if not session:
             raise HTTPException(status_code=404, detail="Chat session not found")
         session_id = data.session_id
+
+        # Update persistent resource selection if changed
+        new_resource_ids = [str(rid) for rid in data.resource_ids]
+        if session.selected_resource_ids != new_resource_ids:
+            session.selected_resource_ids = new_resource_ids
     else:
         # Auto-create session if none provided
-        new_sess = ChatSession(user_id=current_user.id, title=data.content[:30] + "...")
+        new_sess = ChatSession(
+            user_id=current_user.id, 
+            title=data.content[:30] + "...",
+            selected_resource_ids=[str(rid) for rid in data.resource_ids]
+        )
         db.add(new_sess)
         await db.flush()
         session_id = new_sess.id

backend/app/schemas/chat_session.py

@@ -11,10 +11,12 @@ class ChatSessionCreate(ChatSessionBase):
 
 class ChatSessionUpdate(BaseModel):
     title: Optional[str] = None
+    selected_resource_ids: Optional[List[UUID]] = None
 
 class ChatSessionOut(ChatSessionBase):
     id: UUID
     user_id: UUID
+    selected_resource_ids: Optional[List[UUID]] = []
     created_at: datetime
     updated_at: datetime