I built StudyMate, a grounded AI study companion for a friend who was struggling with scattered PDFs, notes, and revision material.
The problem was simple: studying required constantly switching between PDFs, searching for specific topics, asking questions in separate AI tools, creating revision notes, and figuring out what was actually remembered.
StudyMate brings this workflow into one focused study space.
Its core loop is:
Learn → Ask → Practice → Identify Weakness → Revise → Improve
Students can upload their study PDFs and use them to:
The most important design rule is grounding.
StudyMate should not pretend to know something that is not present in the student's uploaded material. If the required information cannot be found, it responds:
"I couldn't find this information in your uploaded study material."
It also preserves source and page information so that answers can be traced back to the student's actual notes instead of using fabricated citations.
I built StudyMate specifically for a real student workflow rather than creating another general-purpose AI chatbot.
Try StudyMate here:
**Live Demo:** [https://studymate-frontend-hbi2.onrender.com](https://studymate-frontend-hbi2.onrender.com)
You can upload a study PDF, select your study material, ask grounded questions, generate summaries, create quizzes, practice flashcards, and build a personalized study plan.
The live demo is deployed on Render so anyone can open it and try the application directly in their browser.
Note: The current deployment is running on Render's free infrastructure, so uploaded study data should not be considered permanent storage. The live deployment is primarily intended for demonstrating and testing the application.
The complete source code for StudyMate is available on GitHub:
GitHub Repository: https://github.com/codewithvishuuu/studymate The project is open source and released under the MIT License.
The repository contains the complete React frontend, FastAPI backend, AI/RAG pipeline, document processing, database logic, tests, and deployment configuration.
The project was built as a full-stack application rather than a frontend-only AI demo, with the backend handling AI orchestration, retrieval, document processing, and application logic.
StudyMate is built as a full-stack AI application using React, TypeScript, Vite, Tailwind CSS, Python, FastAPI, ChromaDB, and Gemma.
The core AI workflow is based on Retrieval-Augmented Generation (RAG).
When a student uploads a PDF, StudyMate processes it through this pipeline:
↓
Text Extraction
↓
Cleaning
↓
Page-Aware Chunking
↓
Embeddings
↓
ChromaDB
For StudyMate, open innovation means having more flexibility and control over the AI layer instead of building the entire product around a closed, black-box system. I chose Gemma as the generation model because it gives me an open-weight model that I can experiment with as the project evolves.
With this approach, I can explore different possibilities in the future, such as:
This flexibility is important for StudyMate because the AI model is only one part of the system. The document processing, retrieval pipeline, source attribution, and study features can continue evolving independently.
The project also helped me understand that open innovation is not only about using an open model. It is about having the freedom to experiment, understand the technology, and build a system that can evolve with the needs of its users.
For a study application, that flexibility can eventually mean better control over cost, privacy, deployment, and model choice. I built StudyMate around a real problem faced by a friend: studying from scattered PDFs and notes was taking more effort than it should.
Instead of starting with the question, "What AI feature can I build?", I started with:
"What would actually make studying easier for my friend?"
That changed the direction of the project.
I focused on making the student's own study material the center of the experience.
That led to a few important decisions:
The goal was not to build another general-purpose chatbot.
The goal was to build something my friend could actually use as part of their study routine.
That is why the core experience of StudyMate is:
Upload → Understand → Ask → Practice → Revise → Improve
One of the biggest lessons from building StudyMate was that building an AI feature is very different from building a reliable AI product.
Getting an AI model to answer a question is relatively easy.
The harder part is making sure that the answer is based on the correct source, that relevant context is retrieved, that source information is preserved, and that the system knows when it does not have enough information to answer.
Working on the RAG pipeline also taught me how important retrieval quality is.
A powerful model with poor context can still produce a poor answer. Giving the model relevant and well-structured context makes the generation much more useful.
I also learned that the parts of an AI application that users don't immediately see are extremely important.
During the project, I spent significant time working on:
The project also reinforced an important principle for me:
AI should not just generate answers. It should behave reliably within the context of the problem it is solving.
For StudyMate, that means being grounded in the student's material and being honest when the material does not contain the answer. I wanted StudyMate to be more than a happy-path AI demo, so I tested both the backend and the frontend throughout the build.
The backend currently has:
46 passing tests
I also tested the frontend across different screen sizes:
The application was checked for:
I also tested the production deployment.
During deployment, I found a client-side routing issue where refreshing an internal React route could return a Not Found page. I fixed this by adding a Render SPA rewrite so routes such as /notes, /ask, /quiz, and /flashcards correctly load the React application when refreshed.
The goal was to make sure StudyMate works as an actual application that someone can use, rather than only working during development on my local machine.
I am entering StudyMate in the Best Use of Gemma category.
Gemma is not being used as a superficial add-on. It is part of the core generation pipeline that powers the grounded study experience.
When a student asks a question, StudyMate first retrieves relevant information from the student's uploaded study material using embeddings and ChromaDB. The retrieved context is then passed to Gemma to generate the final grounded response.
This architecture allows Gemma to work with the student's actual study material instead of treating StudyMate as a general-purpose chatbot.
For the current deployed version, Gemma is served through the Google Gemini API, while the backend handles the AI orchestration and retrieval pipeline.
Using Gemma also gives me room to explore future directions such as local inference, different Gemma variants, improved retrieval strategies, and other deployment approaches.
The model is therefore directly connected to the core problem StudyMate is solving: helping students understand and practice from their own study material.
I started with a simple problem: studying from scattered PDFs and notes was harder than it needed to be.
That problem became StudyMate.
Instead of building another general-purpose AI chatbot, I wanted to create a study companion that understands the student's own material, helps them practice, and supports their revision workflow.
The project taught me that building with AI is not only about choosing a powerful model. It is also about grounding, reliability, source attribution, good product design, and solving a real problem for a real person.
The core idea behind StudyMate is simple:
Learn → Ask → Practice → Revise → Improve
I hope StudyMate can make studying a little more focused, practical, and useful for the person I built it for.
Thanks for checking it out!
GitHub: https://github.com/codewithvishuuu/studymate I used AI-assisted development throughout the process of designing, implementing, testing, and polishing StudyMate.
The development process included planning the architecture, building the RAG pipeline, implementing the study features, testing the application across screen sizes, debugging deployment issues, and preparing the project for release.
I am not adding a DevRelay session link here because I do not want to publish an unverified or placeholder URL.
StudyMate is an open-source project built specifically around the idea of using AI to solve a practical study problem.
The project is intentionally focused on grounded AI rather than generic AI generation. The student's own study material remains at the center of the experience, while Gemma, RAG, retrieval, and the study tools work together to support learning and revision.
The project is still evolving, and future improvements will focus on better retrieval, stronger study analytics, more local inference options, and feedback from actual users.
Thank you for taking the time to check out StudyMate.
I hope this project shows how open AI and thoughtful product design can come together to solve a simple problem for a real person.
If you try StudyMate, I'd love to hear what you think and what I can improve next.