Adaptive-learning

Adaptive Learning AI turns course notes into an intelligent tutor with verified page citations, source-grounded quizzes, and an adaptive engine that personalizes what students should learn next.

Comment

Inspiration

Every student has experienced the frustration of studying dense lecture notes late into the night: traditional slide decks and textbooks are static, one-size-fits-all, and non-interactive. When students turn to modern AI chatbots for help, they face an equally dangerous problem: hallucinations and invented references. Standard LLMs sound confident even when stating falsehoods, and they have zero awareness of an individual student's actual learning curve.

We asked ourselves: What if an AI tutor answered strictly from verified course materials with exact page and slide citations, while a dynamic learner model tracked your mastery to guide exactly what you should learn next?

That core pedagogical insight—RAG answers from study materials, while the learner model and recommendation engine decide what to learn next—became the driving inspiration behind Adaptive Learning AI.

What it does

Adaptive Learning AI is an end-to-end intelligent tutoring and assessment system that turns course documents into a personalized, closed-loop mastery journey.

Multi-Format Course Ingestion: Students upload PDFs, PPTX slide decks, Word documents, or audio/video lecture recordings. The system parses content while strictly preserving structural metadata (document ID, page number, slide number, and media timestamps). Grounded RAG Tutor with Verified Citations: Students can ask questions against their materials. The tutor answers solely using retrieved evidence, providing clickable citations ([Document · Page 12]) that open a Source Evidence Sidebar showing the exact grounded excerpt. Strict Anti-Hallucination Sufficiency Checks: If a query is out-of-domain or the evidence is weak (e.g., asking about quantum computing in operating systems notes), the system refuses to guess and displays an amber alert: "Insufficient Evidence Grounding: Your indexed course documents do not contain enough verified evidence." Adaptive Assessment Engine: Generates targeted multiple-choice quizzes categorized by concept and weighted by difficulty (easy, medium, hard), with answer keys separated securely from the student view. Dynamic Learner Model: Evaluates student answers, records timestamped attempts, and recalibrates concept-level mastery scores ( 0  to  100 % 0 to 100%). Pedagogical Recommendation Engine: Automatically steers the student's next step: Low Mastery ( < 40 % <40%) → → Reteach: Prescribes targeted AI tutoring to close foundational gaps. Developing ( 40 % − 69 % 40%−69%) → → Guided Practice: Generates practice quizzes to build confidence. Demonstrated Mastery ( ≥ 70 % ≥70%) → → Advance / Spaced Revision: Recommends next-tier concepts or refresher quizzes to prevent retention decay.

How we built it

We architected the system according to a modular 5-layer pipeline:

Presentation Layer: Built with React 19, TypeScript, and Tailwind CSS using Vite. Designed with responsive layout grids, interactive quiz state machines, citation sidebars, and real-time mastery progress dashboards. Backend API: Engineered with Python, FastAPI, and Pydantic. Implemented asynchronous request routing, multipart file uploads, CORS middleware, and API contract error formatting ({ "error": "message" }). Ingestion & Knowledge Preparation: PDFs parsed page-by-page via PyMuPDF / pypdf. Slide decks extracted slide-by-slide via python-pptx. Documents processed via python-docx. Lecture audio/video transcribed with timestamp anchors. Section-aware chunking with sliding character windows and concept tagging. Knowledge Storage & Vector Search: Dense semantic embeddings generated via TF-IDF n-gram vectorization and Truncated SVD dimensionality reduction. Hybrid search combining cosine similarity with lexical keyword overlap to achieve sub-millisecond retrieval: Score ( 𝑞 , 𝑐

)

0.70 ⋅ cos ⁡ ( 𝑞 ⃗ , 𝑐 ⃗ ) + 0.30 ⋅ LexicalRatio ( 𝑞 , 𝑐 ) Score(q,c)=0.70⋅cos( q ​

, c )+0.30⋅LexicalRatio(q,c) Learner Model Mathematics: Concept mastery 𝑀 ( 𝑐 ) ∈ [ 0 , 100 ] M(c)∈[0,100] is computed dynamically over attempt history using difficulty weights ( 𝑤

easy

1.0 , 𝑤

med

1.3 , 𝑤

hard

1.7 w easy ​

=1.0,w med ​

=1.3,w hard ​

=1.7) and exponential recency decay ( 𝑟 𝑖 r i ​

): 𝑀 ( 𝑐

)

min ⁡ ( 100 , 0.90 ⋅ ∑

𝑖

1 𝑁 𝑤 𝑖 ⋅ 𝑟 𝑖 ⋅ 𝑦 𝑖 ∑

𝑖

1 𝑁 𝑤 𝑖 ⋅ 𝑟 𝑖 × 100 + 𝐵 practice ) M(c)=min(100,0.90⋅ ∑ i=1 N ​

w i ​

⋅r i ​

∑ i=1 N ​

w i ​

⋅r i ​

⋅y i ​

​

×100+B practice ​

) where 𝑦 𝑖 ∈ { 0 , 1 } y i ​

∈{0,1} represents correctness and 𝐵 practice B practice ​

rewards consistent deliberate practice. Deployment: Packaged with Docker & Docker Compose orchestrating backend, frontend, PostgreSQL + pgvector, and Redis services, alongside 1-click Windows batch scripts (start_all.bat).

Challenges we ran into

Preventing LLM Citation Hallucination: Early experiments showed that asking an LLM to cite page numbers often resulted in made-up pages. We solved this by decoupling citation provenance: the LLM never generates citation metadata; citations are extracted directly from vector store chunk metadata and injected into the response payload. Harmonizing Multi-Format Location Metadata: PDFs use page, PowerPoint uses slide, and lecture videos use timestamp (e.g., 03:42). We constructed polymorphic data models and UI renderers to cleanly display location badges regardless of the file type. Zero-Setup Vector Search on Windows: Setting up heavyweight external vector databases can create friction for local evaluation. We built a high-performance vector search engine using scikit-learn and numpy that runs natively with SQLite for instantaneous local testing while supporting PostgreSQL + pgvector for production Docker deployments.

Accomplishments that we're proud of

100% Automated Contract Verification: Our test suite verifies all workflows (document upload, grounded chat, out-of-domain rejection, quiz generation, evaluation, and mastery recalculation) with zero test failures. Grounded Anti-Hallucination System: Asking "Does our material cover quantum computing?" when operating systems notes are indexed returns a transparent, verified refusal rather than a made-up answer. A True Pedagogical Loop: Unlike standard document chatbots that stop at Q&A, our system closes the loop: student quiz answers immediately alter the dashboard mastery graph and change the next recommended action. Seamless Developer Experience: Both the backend (port 8000) and frontend (port 5173) launch in seconds with single-click batch scripts.

What we learned

The Power of Grounded Constraints: Strict prompt boundaries and vector similarity thresholds are far more reliable than trusting an LLM's raw generation for academic rigor. Pedagogical Modeling: Calculating true student mastery requires balancing question difficulty and recency decay—a student who answered a hard question correctly today should not be penalized equally for an error made two weeks ago. Clean Architectural Boundaries: Strictly decoupling the UI, API contract, vector search, and learner model made debugging and testing fast and reliable.

What's next for Adaptive-learning

Bayesian Knowledge Tracing (BKT) & IRT: Expanding the rule-based learner model into full probabilistic Bayesian Knowledge Tracing to estimate latent student understanding and guessing/slip probabilities. Real-Time Multimodal Voice Tutoring: Adding WebSockets and Whisper/TTS for voice-based Socratic dialogue during study sessions. Spaced Repetition Scheduling: Incorporating SuperMemo SM-2 algorithms into the revision engine to prompt review right before the forgetting curve steepens. LMS Integrations: Building LTI 1.3 connectors to export learner mastery data into Canvas, Blackboard, and Google Classroom gradebooks.

Built With

Share this project:

Updates

Submission history