Inspiration
Students often study across disconnected tools: lecture notes in one place, questions in another, and revision plans somewhere else. This makes it difficult to turn studying into a clear next action.
We wanted to bring those activities together. LearnLoop AI is our attempt to build a personal study workspace where students can organize course materials, ask questions, practice, and plan revision.
Our guiding idea is simple: every study session should help inform the next useful learning action.
What it does
LearnLoop AI brings several parts of the learning workflow into one interface:
- Course workspaces: organize subjects and uploaded study materials.
- KEVIN study assistant: a tutoring interface connected to a backend designed to retrieve course passages and request explanations from a configured language model.
- Practice and progress: backend quiz scoring, attempt history, and updates to learning records.
- Learning memory: records for topic mastery and recurring difficulties.
- Study planning: an interface for organizing revision sessions.
- Private document storage: uploaded materials are associated with their owner and stored in a private storage bucket.
- Light and dark themes: a responsive interface designed for comfortable study sessions.
The project is a working prototype with both implemented features and integrations that are still being completed.
How we built it
We built the frontend with React, TypeScript, Vite, and Tailwind CSS. The interface includes course management, tutoring, practice, planning, and progress views.
Our backend uses Python and FastAPI. It handles authentication, ownership checks, document processing, quiz scoring, and learning-state updates.
Supabase provides PostgreSQL and private object storage. SQLAlchemy manages application models, while Alembic tracks database schema changes.
For tutoring, the backend extracts and chunks uploaded text, retrieves relevant course passages, and prepares a model request through an OpenAI-compatible client. API credentials stay on the server rather than in frontend code.
We also added automated tests, a CI workflow, deployment documentation, and migration scripts to make the project easier to maintain and extend.
Challenges we ran into
One challenge was keeping the interface connected to real application behavior. A dashboard can look complete before its data flows are complete, so we reviewed which features used database records, which remained browser-local, and which still needed implementation.
Another challenge was protecting student data across courses and accounts. We added ownership checks, private storage access, and tests around important backend boundaries.
External inference access also presented a challenge. Nebius onboarding required billing verification, which delayed our intended integration. We explored an alternative NVIDIA-hosted inference configuration, but configuration alone does not prove that a complete AI workflow is working.
We also learned that reliable learning features require more than generating an answer: retries must not duplicate results, citations must be checked, and progress should reflect actual activity.
Accomplishments that we're proud of
- Building a consistent study interface across multiple learning workflows.
- Establishing a PostgreSQL-backed application with versioned migrations.
- Connecting private document storage and user authentication.
- Implementing quiz scoring and learning-history foundations.
- Adding authentication lifecycle endpoints and security tests.
- Separating completed functionality from planned features instead of presenting simulated behavior as live AI.
In our latest local verification, 28 backend tests and five frontend tests passed, and the frontend production build completed successfully. These checks do not replace live-provider or full browser end-to-end testing.
What we learned
We learned how frontend experience, backend validation, and database design depend on one another.
We also learned that an API endpoint is only part of a finished feature. The interface must call it correctly, failures need clear recovery paths, and the behavior must be tested across users and sessions.
Most importantly, we learned to distinguish between a polished prototype and a production-ready product.
What's next for LearnLoop AI
Our next milestone is a verified end-to-end learning loop:
- Upload course materials.
- Ask a question and receive a source-grounded explanation.
- Generate and complete relevant practice.
- Update learning records from actual results.
- Use those results to improve the next revision plan.
We also plan to complete cross-device persistence, strengthen authentication and privacy controls, and validate the application through realistic student workflows.
Built With
- alembic
- css
- docker
- fastapi
- github
- openai
- pgvector
- postgresql
- python
- react
- sdk
- sqlalchemy
- supabase
- tailwind
- typescript
- vite