This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.
What I Built
Meet Buddy — a personal AI companion I built for a friend who wanted a more natural and private way to interact with an AI assistant.
Instead of relying entirely on a cloud-based AI API, Buddy uses an open-weight Gemma model running locally through Ollama.
The idea was simple:
What if you could have your own AI companion that you can talk to, ask questions, and interact with without every conversation having to leave your computer?
Buddy is designed around that idea.
It provides a simple interface for interacting with the AI, while the underlying model runs locally.
Why I Built It
My friend wanted an AI assistant that felt less like a traditional chatbot and more like something they could actually interact with naturally.
The main things I wanted Buddy to provide were:
- 💬 Natural AI conversations
- 🤖 A local open-weight AI model
- 🎙️ Voice interaction
- 📁 Interaction with user-provided content
- 🔒 A more privacy-focused approach
- ⚡ A lightweight setup that can run on a personal computer
Rather than just building another chatbot wrapper, I wanted to experiment with what a personal AI companion could look like when the AI model itself can run locally.
Code
The project is built with a focus on keeping the architecture simple enough to run on a personal machine.
How I Built It
The core of Buddy is powered by Gemma, an open-weight model from Google.
I run Gemma locally using Ollama, which allows the application to communicate with the model without depending on a hosted LLM API for the core AI interaction.
The application layer is built using Python and Flask.
The basic architecture looks like this:
User
↓
Buddy Interface
↓
Flask Application
↓
Ollama
↓
Gemma
↓
AI Response
I also experimented with voice interaction so that Buddy could feel more like an assistant rather than simply a text box.
For voice output, I experimented with ElevenLabs to make the interaction feel more natural.
Why Open Innovation Matters
One of the biggest things I enjoyed about building Buddy was being able to experiment with an open-weight model locally.
With a traditional hosted AI API, the application is heavily dependent on an external provider.
Using a model such as Gemma locally changes that relationship.
It gives developers more control over:
- Where inference happens
- How the application is built
- Experimentation with models
- Privacy considerations
- Cost and API dependency
- Local development
It also makes AI experimentation much more accessible.
You don't necessarily need to build an application around a proprietary API to create something useful.
You can take an open-weight model, run it locally, and build your own experience around it.
What I Learned
Building Buddy taught me that the interesting part of AI applications isn't always the model itself.
A large part of the experience comes from everything around the model:
- The interface
- Prompt design
- Model selection
- Local inference
- Voice interaction
- Application architecture
- Handling user input
- Making the experience feel natural
I also learned that running AI locally requires thinking about hardware limitations and model performance differently from using a cloud API.
That made the project a useful experiment in practical local AI development.
What's Next
Buddy is still an experiment, and there are several things I want to improve:
- Better long-term memory
- More natural conversations
- Better multimodal capabilities
- Improved voice interaction
- More efficient local inference
- Better personalization
- A cleaner mobile experience
The goal is to keep turning Buddy into something that feels less like a chatbot and more like a personal AI companion.
Prize Categories
I'm submitting Buddy for:
- Best Use of Gemma
Thanks to the Hacktoberfest community for the challenge!
Top comments (0)