EduMind

EduMind — a local-first AI operating system for students Inspiration Most students don't suffer from a lack of tools. They suffer from too many that don't talk to each other. Classes live in a calendar, notes in a document app, revision in a flashcard tool, research across a dozen browser tabs, and questions go to a general chatbot that knows nothing about any of it. Every AI answer starts from zero, schedules get ignored, and study time leaks away to re-explaining context.

Two frustrations pushed me to build EduMind:

Lectures in my classrooms mix Bengali and English. Generic transcription tools mangle code-switched speech, so the one artifact that should anchor my notes was unreliable. Cloud-first study apps demand your data up front. To get help, you hand over your notes, recordings, and schedule. I wanted the opposite trade: keep everything on the student's device, and make the AI earn trust by showing its evidence and asking before it changes anything. So I built two things that work as one system: EduMind, a local-first desktop study OS, and MeetMind, an Android lecture companion that turns real, bilingual lectures into trustworthy study material.

What it does EduMind (desktop) EduMind unifies the whole study loop in a single private desktop app, where every module reads from one canonical source and every consequential change needs your confirmation.

Home dashboard — today's priorities, a focus timer, system readiness, and a confirmed Monday-to-Sunday schedule. Student Planner — the single canonical schedule, with review-and-confirm timetable image import. Routine Coach — reads the planner as read-only context and drafts study blocks with stated assumptions and trade-offs. Nothing enters your schedule until you explicitly approve it. Class Notes — turns supplied slides and material into structured, source-aware notes, and renders math as real LaTeX, so a limit like $\lim_{x \to a} f(x) = L$ shows up correctly instead of as broken text. Exam Practice — builds clearly labeled practice with objectives, difficulty, evidence, and explanations. It never presents generated questions as official exam content. Study Review — a deterministic spaced-repetition scheduler that previews the exact next review date for every possible grade before you commit it. Research — focused discovery, full-text ingestion, source-linked answers with citations, claim validation, and honest gap reporting. Group Study — invite-code rooms where classmates chat and share trustworthy links, and can pull in an AI facilitator that only sees the discussion when a member explicitly asks. MeetMind (Android) MeetMind is EduMind's ears in the lecture hall. It:

Records lecture audio through a foreground microphone service into app-private storage. Uploads to AssemblyAI (universal-2) for speaker-labelled English and Bengali transcription. Runs sync through a persistent WorkManager queue with bounded retries, so a dropped network doesn't lose a lecture. Delivers the finished transcript to exactly one destination: a deliberately provisioned HTTPS EduMind gateway/reverse proxy, or a Supabase meetings table. How they relate The two apps form a capture → transcribe → review → ground pipeline:

$$\text{MeetMind (record)} ;\rightarrow; \text{AssemblyAI (transcribe)} ;\rightarrow; \text{HTTPS / Supabase} ;\rightarrow; \text{EduMind Class Notes (review + import)}$$

In EduMind's desktop Class Notes, those transcripts arrive in a MeetMind inbox. You review each one before it's imported into local Class Notes memory, and from then on it becomes additional evidence (content_type: transcript) that grounds your notes, practice, and review, without ever replacing the analysis of your actual slides.

The trust boundary is the important part: MeetMind never connects to the desktop's loopback gateway. That gateway is private to the device and uses a per-launch token. Mobile sync always goes over an explicit HTTPS bridge, cleartext is disabled at the Android network layer, and audio and transcripts are handled as sensitive educational data end to end.

How I built it EduMind is a Rust gateway paired with a desktop shell:

The UI is React + Vite, packaged with Tauri v2. The Tauri shell starts the Rust (Axum) gateway in-process on an OS-assigned loopback port with a per-launch bearer token, so there's no separate backend to run and nothing exposed to the network. Canonical state lives in versioned local SQLite with transactional migrations. The code splits into a pure edumind-core crate (domain types: evidence, learning, runs) and an edumind crate (gateway, agents, memory, research). MeetMind is native Kotlin on Android. The intelligence layer is a Master Agent coordinating module managers, with deny-by-default tools, allow-lists, capability grants scoped by run and module, a write sandbox, and audit logging that never stores content.

Several parts are deliberately deterministic so they work offline and in CI:

Memory retrieval uses an approximate-nearest-neighbor vector index over compact embeddings, ranked by cosine similarity: $$\mathrm{sim}(\mathbf{q}, \mathbf{d}) = \frac{\mathbf{q} \cdot \mathbf{d}}{\lVert \mathbf{q} \rVert , \lVert \mathbf{d} \rVert}$$ Spaced repetition grows the review interval multiplicatively with an ease factor $\mathrm{EF}$, roughly $$I_n = \left\lceil I_{n-1} \cdot \mathrm{EF} \right\rceil,$$ and the retention-risk intuition follows a forgetting curve $R(t) = e^{-t/S}$, where stability $S$ increases with each successful recall. The same engine computes the grade previews and the persisted schedule, so what you see is exactly what gets saved. I used AI development assistants throughout. GPT-5.6 (through Kiro) helped with repository-wide gap analysis, architecture and safety review, transactional migration design, canonical Planner/Routine ownership, telemetry hardening, release CI, and validation, with its output treated as untrusted and checked against typed contracts and deterministic tests.

Codex helped build EduMind as an AI software-development assistant, not as a student-facing feature inside the final app. It reads the existing Rust, React/Tauri, Kotlin, and configuration code; then helps design features, write implementation code, connect services, diagnose errors, and run builds and tests. For this project, Codex helped with the desktop dashboard and research workspace, multi-agent gateway logic, model-provider and NotebookLM integration, mobile lecture recording, AssemblyAI Bengali-English transcription, Supabase synchronization, UI improvements, security issues, and build/lint verification. It also helped maintain consistency across the desktop, backend, and mobile app while preserving the local-first architecture.

Challenges I ran into Killing the separate backend. Embedding the gateway inside the Tauri process, with authentication, a loopback bind, and a clean start/health/stop lifecycle, was hard to get right but turned EduMind into a true single install. Deterministic, offline-first testing. Ranking, SRS scheduling, and synthesis had to be network-free and reproducible so they pass in CI without models, OCR, or external services. Bilingual transcription. Code-switched Bengali-English audio is exactly where naive transcription breaks; getting speaker-labelled, mixed-language transcripts reliable took real tuning. Resilient, private mobile sync. I had to make MeetMind retry safely with bounded backoff (stopping after five automatic attempts), enforce a 100 MiB upload limit, forbid the desktop loopback endpoint, and never leave more local audio or transcript data than needed to recover. Holding the trust model as features grew. Deny-by-default tools, one canonical planner, and a confirmation gate on every consequential change required constant discipline. Toolchain friction. I hit Rust stable Clippy differences between local and CI, and an environment paging-file failure during parallel test runs, which I solved with targeted single-job test passes. Accomplishments that I'm proud of A genuinely local-first app that installs as one Windows bundle with zero manual backend steps. A concrete, visible trust model: canonical planner ownership, evidence-linked notes and research, deterministic SRS previews, and confirmation gates around every consequential action. A mobile-to-desktop pipeline that turns real bilingual lectures into reviewed, grounded study material without leaking sensitive audio. A broad, green validation matrix: Rust workspace tests, Tauri tests including a real embedded start/health/stop smoke, desktop unit and browser tests, Node safety checks, Android assemble and lint, and MSI/NSIS packaging. What I learned Trust is a feature. Students accept AI help far more readily when they can see the evidence and keep the final decision. "Propose, then confirm" beats silent automation. Determinism pays compounding interest. Designing for offline-first, reproducible behavior made testing, privacy, and reliability all easier at once. Security is cheaper built-in than bolted-on. Deny-by-default tools, write sandboxing, and keychain-backed secrets were painless when treated as part of each feature instead of an afterthought. Local-first has real trade-offs in indexing, storage, and packaging, and working through them taught me a lot about keeping performance acceptable on a single machine. The boundary between apps is a design surface. Deciding that MeetMind may only reach EduMind over explicit HTTPS, never the private loopback gateway, forced a cleaner and safer contract than "just make it work." What's next for EduMind Production code signing and notarization to remove SmartScreen friction, plus macOS and Linux builds. Broader language coverage for transcription and notes beyond Bengali-English. Interactive 3D knowledge and citation graphs across notes, research, and memory. Deeper study intelligence — mastery tracking, retention-risk forecasting, and next-best-action recommendations tuned from your own review history. Optional, privacy-preserving sync so a student can share state across their own devices without giving up local-first control.

Built With

• androidx
• axum
• css
• font-awesome
• gradle
• html
• javascript
• kotlin
• react
• react-dom
• react-force-graph-3d
• reqwest
• rusqlite
• rust
• sql
• sqlite
• tauri-v2
• three.js
• tokio
• tower-http
• vite
• windows-sys
• workmanager
• yaml