RT Adaptive Learning Engine

It combines IRT for difficulty calibration, knowledge graphs for topic sequencing, and spaced repetition for retention — selecting the optimal next question after every student response.

Comment

RT Adaptive Learning Engine Inspiration

Traditional learning platforms deliver the same content to all students, regardless of their ability level. This often leads to boredom when the material is too easy or frustration when it is too difficult. Additionally, many systems fail to reinforce previously learned material, leading to forgetting over time.

The inspiration behind RT Adaptive Learning Engine was to build a system that behaves like a human tutor — continuously adapting in real time to a student’s performance. The goal was to combine established learning science theories into a single intelligent engine that selects the right question at the right time and at the right difficulty level.

What It Does

RT Adaptive Learning Engine is a real-time intelligent question selection system.

After every student response, the engine:

Estimates the student’s ability using Item Response Theory (IRT)

Enforces topic prerequisites using a knowledge graph

Schedules reviews using spaced repetition

Updates mastery using a Bayesian-inspired model

Selects the optimal next question based on difficulty and topic priority

The system ensures:

Students remain in an optimal learning zone (target accuracy 60–70%)

Topics unlock only after prerequisites are mastered

Learned material is reviewed at optimal intervals

Personalization happens per topic, not globally

All of this occurs within milliseconds, enabling real-time adaptation.

How We Built It

The system was designed as five independent, testable Python modules.

  1. IRT Module (irt.py)

Implements the Rasch (1PL) model

Estimates student ability (theta) using Maximum Likelihood Estimation

Computes target difficulty as theta + 0.3

  1. Knowledge Graph Module (knowledge_graph.py)

Represents topics as a Directed Acyclic Graph (DAG)

Enforces prerequisite mastery thresholds (≥ 80%)

Determines eligible topics for progression

  1. Spaced Repetition Module (spaced_repetition.py)

Implements the SM-2 algorithm

Dynamically adjusts review intervals

Updates ease factor based on performance

  1. Mastery Updater Module (mastery_updater.py)

Uses a Bayesian-inspired mastery update rule

Adjusts mastery based on correctness, hints, and response time

Adapts learning rate depending on mastery level

  1. Orchestrator (question_selector.py)

Executes the complete 8-step adaptive pipeline

Handles cold-start logic

Queries the database for best-matching questions

Updates mastery and review schedules after each response

System Architecture:

Redis for fast state caching

PostgreSQL for persistent storage

Asynchronous processing for low-latency execution

Modular design for scalability and testability

Challenges We Ran Into

Cold Start Problem IRT requires several responses to estimate ability reliably. Solution: Serve medium-difficulty questions for the first few attempts before enabling IRT-based selection.

Balancing Mastery Updates If updates were too aggressive, mastery jumped unrealistically. If too slow, the system felt unresponsive. We tuned learning rates dynamically based on mastery levels.

Integrating Multiple Theories Knowledge graphs control topic order, while IRT controls difficulty. Combining both required careful orchestration to avoid conflicts.

Maintaining Target Accuracy Achieving the 60–70% target range required repeated tuning of:

Difficulty offset (+0.3)

Topic urgency weights

Mastery learning rates

Performance Optimization Ensuring question selection time remained under 50ms required:

Efficient caching

Avoiding heavy computation during runtime

Designing lightweight mathematical models

Accomplishments That We’re Proud Of

Built a fully functional adaptive engine from scratch

Successfully integrated three major learning theories into one system

Achieved target session accuracy within the optimal range

Designed a modular and production-ready architecture

Implemented mathematical ability estimation without external ML frameworks

Enabled per-topic ability tracking instead of a single global score

Most importantly, we built a measurable adaptive system with clear evaluation metrics.

What We Learned

Technical Learnings:

Mathematical foundations of Item Response Theory

Implementing Maximum Likelihood Estimation

Designing Directed Acyclic Graphs for prerequisite modeling

Internal mechanics of spaced repetition algorithms

Real-time system design using caching and async processing

Research Learnings:

Adaptive learning is about balance, not maximizing correctness

Optimal learning happens at moderate difficulty (around 60–70% accuracy)

Theoretical models must be carefully integrated to work in practice

Product Learnings:

Cold start handling is critical in intelligent systems

Data quality strongly affects adaptive accuracy

Evaluation metrics are essential to prove system effectiveness

What’s Next for RT Adaptive Learning Engine

Data-Driven Refinement Collect real student interaction data and tune model parameters statistically.

Upgrade to Advanced IRT Models Move from 1PL (Rasch) to 2PL or 3PL models to include discrimination and guessing parameters.

Enhanced Mastery Modeling Implement full Bayesian Knowledge Tracing or Deep Knowledge Tracing (neural network-based).

Teacher Analytics Dashboard Provide ability growth charts, retention forecasts, and mastery insights.

Large-Scale Evaluation Conduct controlled experiments and apply statistical tests to validate learning improvements.

Multi-Subject Expansion Expand the knowledge graph dynamically across multiple domains.

RT Adaptive Learning Engine is a real-time, scientifically grounded personalized learning system that dynamically adapts difficulty, sequencing, and retention after every student response, ensuring optimal learning progression.

Built With

  • ability
  • adaptive
  • algorithm
  • algorithms
  • api
  • architecture
  • asynchronous
  • asyncio
  • backend
  • bank
  • bayesian
  • caching
  • calculation
  • cold-start
  • computations
  • computing
  • containerization
  • control
  • databases
  • decision
  • design
  • docker
  • educational
  • estimation
  • execution
  • fastapi
  • framework
  • git
  • github
  • handling
  • high-performance
  • implemented
  • in-memory
  • irt
  • logic
  • mastery
  • mathematical
  • mathematical-modeling
  • models
  • modular
  • non-blocking
  • numpy
  • operations
  • optimization
  • optional
  • orchestration
  • performance
  • persistent
  • pipeline
  • postgresql
  • postman
  • programming-language-python-?-core-engine-logic
  • pytest
  • python
  • question
  • queue
  • real-time
  • recent
  • records
  • redis
  • redis-based
  • repetition
  • request
  • responses
  • scientific
  • scipy
  • selection
  • sm-2
  • spaced
  • state
  • storage
  • structures
  • student
  • supporting
  • testing
  • tools
  • topic
  • tracing
  • unit
  • version
Share this project:

Updates