| """ |
| qa.py — Question Answering API router |
| |
| Endpoints: |
| POST /qa → Full RAG pipeline (classify + retrieve + answer + verify) |
| POST /classify → Classification only (BERT chapter + topic extraction) |
| """ |
|
|
| import traceback |
| from fastapi import APIRouter, HTTPException |
|
|
| from Backend.schemas import ( |
| QuestionRequest, |
| QAResponse, |
| ClassifyOnlyRequest, |
| ClassifyOnlyResponse, |
| ClassificationResult, |
| TopicInfo, |
| SourceChunk, |
| IsNeetBioRequest, |
| IsNeetBioResponse |
| ) |
| from rag.pipeline import run_pipeline |
| from Classification.classify_and_extract import classify_question, get_predictor |
|
|
| router = APIRouter(prefix="/api", tags=["Question Answering"]) |
|
|
|
|
| |
| |
| |
| @router.post( |
| "/qa", |
| response_model=QAResponse, |
| summary="Answer a NEET Biology question", |
| description=( |
| "Runs the full pipeline: BERT classifies the chapter, " |
| "retrieves relevant NCERT chunks, generates an answer with " |
| "justification, and verifies correctness." |
| ), |
| ) |
| async def answer_question(req: QuestionRequest): |
| """ |
| Full Q&A pipeline: |
| 1. BERT → chapter prediction + topic extraction |
| 2. Supabase → retrieve NCERT chunks (filtered by chapter) |
| 3. Groq LLM → generate answer + justification |
| 4. Groq LLM → verify answer |
| 5. Compute confidence score |
| """ |
| try: |
| result = run_pipeline( |
| question=req.question, |
| chapter_filter=req.chapter_filter, |
| top_k=req.top_k, |
| use_classifier=req.use_classifier, |
| ) |
|
|
| |
| classification = None |
| if result.get("classification"): |
| raw = result["classification"] |
| classification = ClassificationResult( |
| chapter=raw["chapter"], |
| chapter_id=raw["chapter_id"], |
| chapter_confidence=raw["chapter_confidence"], |
| rejected=raw.get("rejected", False), |
| rejection_reason=raw.get("rejection_reason", ""), |
| entropy=raw.get("entropy", 0.0), |
| margin=raw.get("margin", 0.0), |
| topics=[ |
| TopicInfo( |
| section_code=t["section_code"], |
| section_title=t["section_title"], |
| similarity=t["similarity"], |
| ) |
| for t in raw.get("topics", []) |
| ], |
| ) |
|
|
| |
| sources = [ |
| SourceChunk( |
| chapter=s.get("chapter"), |
| section=s.get("section"), |
| section_title=s.get("section_title"), |
| text_content=s.get("text_content"), |
| similarity=s.get("similarity", 0.0), |
| ) |
| for s in result.get("sources", []) |
| ] |
|
|
| return QAResponse( |
| question=result["question"], |
| classification=classification, |
| answer=result["answer"], |
| justification=result.get("justification", []), |
| sources=sources, |
| confidence=result.get("confidence", 0.0), |
| verified=result.get("verified", False), |
| verifier_note=result.get("verifier_note", ""), |
| ) |
|
|
| except Exception as e: |
| traceback.print_exc() |
| raise HTTPException( |
| status_code=500, |
| detail=f"Pipeline error: {str(e)}", |
| ) |
|
|
|
|
| |
| |
| |
| @router.post( |
| "/classify", |
| response_model=ClassifyOnlyResponse, |
| summary="Classify a question (chapter + topics only)", |
| description=( |
| "Runs only the BERT classifier + topic extraction. " |
| "Does NOT generate an answer. Useful for quick categorization." |
| ), |
| ) |
| async def classify_only(req: ClassifyOnlyRequest): |
| """ |
| Classification only (no RAG): |
| 1. BERT → chapter prediction |
| 2. Supabase retrieval → topic extraction |
| """ |
| try: |
| raw = classify_question(req.question) |
|
|
| classification = ClassificationResult( |
| chapter=raw["chapter"], |
| chapter_id=raw["chapter_id"], |
| chapter_confidence=raw["chapter_confidence"], |
| rejected=raw.get("rejected", False), |
| rejection_reason=raw.get("rejection_reason", ""), |
| entropy=raw.get("entropy", 0.0), |
| margin=raw.get("margin", 0.0), |
| topics=[ |
| TopicInfo( |
| section_code=t["section_code"], |
| section_title=t["section_title"], |
| similarity=t["similarity"], |
| ) |
| for t in raw.get("topics", []) |
| ], |
| ) |
|
|
| return ClassifyOnlyResponse( |
| question=req.question, |
| classification=classification, |
| ) |
|
|
| except Exception as e: |
| traceback.print_exc() |
| raise HTTPException( |
| status_code=500, |
| detail=f"Classification error: {str(e)}", |
| ) |
|
|
|
|
| |
| |
| |
| @router.post( |
| "/is-neet-bio", |
| response_model=IsNeetBioResponse, |
| summary="Quickly check if a string is a valid NEET Biology question", |
| ) |
| async def is_neet_bio(req: IsNeetBioRequest): |
| """ |
| Runs only the BERT classifier prediction to check OOD (Out-Of-Domain) logic. |
| Fast path validation for frontend to prevent garbage from triggering the RAG pipeline. |
| """ |
| try: |
| predictor = get_predictor() |
| bert_result = predictor.predict(req.question) |
| |
| rejected = bert_result.get("rejected", False) |
| reason = bert_result.get("rejection_reason", "") |
| |
| return IsNeetBioResponse( |
| is_valid=not rejected, |
| rejected=rejected, |
| reason=reason |
| ) |
| except Exception as e: |
| traceback.print_exc() |
| raise HTTPException( |
| status_code=500, |
| detail=f"Validation error: {str(e)}", |
| ) |
|
|
