EDUPATH-AI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Inspiration

Modern educational technology platforms face a fundamental scaling trilemma: they must balance computational cost, execution latency, and data privacy. Features like AI tutoring, complex algorithmic evaluation, and Retrieval-Augmented Generation (RAG) typically require massive, centralized cloud infrastructures, Docker clusters, and expensive vector databases.

We were inspired by the concept of Edge Computing and Cognitive Load Theory. We asked ourselves: What if we could strip away the entire cloud backend and build an enterprise-grade, multimodal learning platform that runs entirely within the student's browser? We wanted to democratize access to advanced computer science education (Operating Systems, Algorithms, System Design) by creating a zero-latency, highly resilient learning companion that guarantees user privacy and operates at literally zero server cost.

What it does

EduPath AI is a fully edge-computed, multimodal adaptive learning platform. Without relying on a live backend server, it provides:

Live WebAssembly Code Lab: A secure, in-browser terminal where students can write, compile, and execute real Python code to test algorithms (like Dijkstra's Banker's Algorithm) instantly.

3-Phase Adaptive Studio: A pedagogical engine that dynamically adjusts to the student's cognitive load, guiding them through Phase 1 (Foundation), Phase 2 (Application), and Phase 3 (Mastery).

Grounded Socratic Tutor: An AI mentor that utilizes hybrid in-memory lexical and semantic search to answer questions grounded strictly in course materials.

Cognitive Diagnosis: A 15-question Grand Quiz that generates a mathematical breakdown of a student's prerequisite gaps and conceptual mastery.

How we built it

EduPath AI is built as a highly resilient React + Vite Progressive Web Application (PWA) deployed statically via GitHub Pages. To achieve zero-server functionality, we shifted massive computational workloads to the client side:In-Browser Python Compilation: We embedded Pyodide (WASM v0.25.0) to compile and run CPython 3.12 directly in the browser's memory space. We trapped sys.stdout using io.StringIO() to redirect native Python execution streams and tracebacks safely to the UI terminal.Zero-Server Hybrid RAG: We engineered a ClientIntelligenceEngine that performs in-memory Okapi BM25 lexical scoring alongside a pre-computed 384-dimensional cosine similarity index, merging results via Reciprocal Rank Fusion (RRF).Bayesian Knowledge Tracing (BKT): The adaptive curriculum uses Bayesian probability to model student understanding. After each interaction, the system updates the latent mastery probability $P(L_n)$ based on the evidence $D$ (correct/incorrect response), incorporating slip $P(S)$ and guess $P(G)$ parameters:$$P(L_n \vert{} D_{correct}) = \frac{(1 - P(S)) \cdot P(L_{n-1})}{(1 - P(S)) \cdot P(L_{n-1}) + P(G) \cdot (1 - P(L_{n-1}))}$$Edge AI Orchestration: We built an ApiKeyManager and intent-routing gateway that securely proxies the Google Gemini 1.5 Flash API directly from the client via HTTPS CORS, bypassing the need for a backend proxy entirely.

Challenges we ran into:

Our most critical challenge occurred precisely two hours before the submission deadline. We initially architected a massive enterprise backend featuring an async Python/FastAPI server, PyTorch sentence-transformers for vector embeddings, Whisper for video transcription, and a 30-entity PostgreSQL database.

However, cloud deployment bottlenecks, CORS issues, and container build times threatened to leave us with a broken URL at submission. We had to execute a violent architectural pivot. In under 120 minutes, we completely decoupled the frontend, migrated the core execution logic to the WebAssembly edge, mocked our retrieval corpora into a local HTML5 localStorage state cache, and implemented the resilient fetch gateway.

Accomplishments that we're proud of

We successfully proved that you do not need heavy cloud infrastructure to deliver advanced computational education. We are incredibly proud of:

Zero RCE Vulnerability: By executing Python natively in WebAssembly rather than routing it to Docker containers, we achieved mathematically perfect sandboxing with zero risk of Remote Code Execution (RCE) attacks.

Graceful Offline Degradation: If the LLM API drops or network connectivity is lost, our 16-class deterministic router seamlessly falls back to local rule-based pedagogical synthesis without crashing the application.

The UX Pivot: Engineering the platform to instantly seed impressive, hyper-realistic user data directly into localStorage on the first load, transforming what would have been a blank PWA into a living, breathing user profile for evaluators.

What we learned

We learned that modern browsers are no longer just document viewers; they are incredibly powerful distributed compute engines. We deeply explored the mechanics of WebAssembly and Pyodide, mastering how to share memory boundaries between JavaScript and native C-compiled Python. Furthermore, integrating Bayesian knowledge modeling taught us how to mathematically quantify human learning, proving that an algorithm can dynamically shape a curriculum based on cognitive state rather than just a linear syllabus.

What's next for EDUPATH-AI

The edge-computed prototype is just the beginning. Our next steps include:

Hybrid Edge-Cloud Sync: Re-attaching our fully developed FastAPI/PostgreSQL backend as a pure synchronization layer. The edge client will still handle the heavy compute (Pyodide execution, BM25 indexing), but state will periodically sync via WebSockets for cross-device persistence.

Multi-Language WASM Lab: Expanding the WebAssembly execution sandbox to support C++ (via WebAssembly LLVM) and Rust to accommodate a broader range of system design and algorithms courses.

Peer-to-Peer Collaborative Study: Integrating WebRTC to allow students to form ad-hoc study rooms, sharing their Pyodide execution states and Knowledge Graphs in real-time without centralized routing servers.