I Built a Private Local AI Study Buddy for a Friend Who Hates Rereading Notes
This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
The Problem
We've all had that moment.
You have pages and pages of lecture notes sitting in front of you. You know you need to study them. You know the exam is coming.
But instead of actually learning, you find yourself rereading the same pages over and over again.
That was the problem I wanted to solve for a friend.
They didn't need another generic chatbot. They needed something much simpler:
Give me my notes, help me understand them, test me on them, and tell me what I still need to revise.
So I built StudyBuddy.
What I Built
StudyBuddy is a local AI study companion designed around four things a student actually needs when dealing with large amounts of study material:
Summarize
Long notes become a shorter version containing the important information.
Explain Simply
Instead of just shortening the material, StudyBuddy can explain difficult concepts in simpler language.
Generate Quiz
The same study material can be turned into questions for active recall and self-testing.
Revision Checklist
StudyBuddy can turn a large amount of material into a structured list of things to revise.
The idea is simple:
Notes → Understand → Practice → Revise
Rather than building another general-purpose AI assistant, I wanted to build something small enough to be useful and focused enough to solve one real problem.
Demo
Here is the working demonstration of StudyBuddy:
https://drive.google.com/file/d/1ZQlQThPF4fCZLhcOOdNjj8jpV9wAiwUw/view?usp=sharing
In the demo, I select a local AI model, paste study material into StudyBuddy, and use the different study workflows to transform the same material into summaries, explanations, quizzes, and revision tasks.
The demonstration also shows Gemma 3 1B running locally.
I used ElevenLabs to generate the narration for the demo video.
How It Works
The architecture is intentionally simple:
Student → StudyBuddy → Ollama → Local Open-Weight Model → Study Output
StudyBuddy is built with:
- Python
- Streamlit
- Ollama
- Llama 3.2 3B
- Google Gemma 3 1B
The application communicates with a locally running Ollama server.
When the student submits their study material, StudyBuddy sends it to the selected local model and displays the generated result.
There is no OpenAI, Gemini, or Anthropic API sitting in the middle of the core study workflow.
The student can choose between Llama 3.2 3B and Gemma 3 1B directly inside the application.
That model choice was important to me because I didn't want the application to be permanently tied to one AI provider.
Why Gemma?
For this project, I wanted a model that could realistically run on a personal computer rather than requiring a large cloud GPU.
That's where Gemma 3 1B fits particularly well.
I integrated Gemma alongside Llama 3.2 3B and tested it directly inside StudyBuddy.
The result is a simple model-selection workflow:
Choose your local model → provide your notes → choose how you want to study.
The model itself is not stored inside the repository. It is installed separately through Ollama, keeping the project lightweight while allowing the user to run inference locally.
Why Does Open Innovation Matter?
This is probably the most important part of the project for me.
A student's lecture notes can contain personal information, unfinished assignments, private study material, or simply information they don't want to send to another service.
With a typical closed cloud AI API, the application would send that material to an external service for processing.
StudyBuddy takes a different approach.
The core AI inference happens on the student's own computer.
That changes what the application can offer.
Your study material can stay local
Instead of sending the material to a cloud AI API for the core inference, StudyBuddy can process it locally.
There is no per-request cloud AI API cost
The application does not need to pay a cloud AI provider for every summary, explanation, or quiz.
The trade-off is that the user's own computer performs the computation.
The model is replaceable
The application is not locked to one cloud model.
Today it can use Llama or Gemma. Tomorrow, another compatible local model can be tested without rebuilding the entire concept.
The application can work without relying on a cloud AI service
Once the required model and dependencies have been installed, the core inference does not need to send requests to an online AI service.
For me, this is what makes the open approach meaningful.
I wasn't just trying to make an AI application.
I was trying to give the person using it more control over where their study material goes and which model processes it.
The Technology Behind the Project
The core application is intentionally lightweight.
Frontend / Application: Streamlit
Language: Python
Local AI Runtime: Ollama
Open-Weight Models: Llama 3.2 3B and Gemma 3 1B
The models are downloaded locally through Ollama rather than being committed to the GitHub repository.
This also means the project can remain relatively small while the actual AI model is managed separately on the user's machine.
My Agent Session
I used an AI coding agent during development to help implement and refine the project.
The agent helped with the application implementation, local Ollama integration, model selection, testing, documentation, and project setup.
The important part, however, was deciding what to build and why.
The agent helped turn the idea into software, but the product itself was driven by the problem I wanted to solve for my friend.
Code
The complete project is open source:
https://github.com/aejaz-sarah/Study-Buddy
The repository includes the StudyBuddy application, setup instructions, documentation, demo material, and supporting project files.
Prize Categories
Best Use of Gemma
StudyBuddy uses Google's Gemma 3 1B open-weight model through Ollama for local inference.
Gemma is available directly inside the application alongside Llama 3.2 3B.
I tested Gemma as a local model powering the study workflows demonstrated in the video, including generating study-related outputs from user-provided material without relying on a cloud AI API.
Best Use of ElevenLabs
I used ElevenLabs to generate the AI narration for the StudyBuddy working demonstration.
Rather than leaving the technical demo as a silent screen recording, I used ElevenLabs to turn the walkthrough into a narrated explanation of the problem, the local AI architecture, the Gemma integration, and the different study workflows.
This made the demonstration easier to follow while the actual StudyBuddy inference remained local.
What I Learned
The biggest thing I learned from building StudyBuddy is that building for a person is different from building for a category.
"Build an AI education tool" is a huge problem.
"Build something that helps my friend deal with long lecture notes" is much easier to reason about.
It changes the questions you ask.
What does the person actually struggle with?
What would they use repeatedly?
What information do they want to give the application?
What should the application do instead of making them figure everything out themselves?
Those questions shaped StudyBuddy more than the technology did.
Final Thoughts
StudyBuddy started with a very ordinary problem:
My friend has too much to study and doesn't want to spend hours rereading it.
The solution didn't need to be another massive AI platform.
It needed to be something focused.
Something that could take their notes and help them move from:
"I have no idea where to start."
to:
"I know what this means, I can test myself, and I know what I need to revise."
That's what I wanted StudyBuddy to be.
A small AI tool built for one real person, powered by local open-weight AI, and designed around the way they actually study.
And that, to me, is the most interesting part of building for a friend.
Top comments (0)