Buddy: A Private AI Companion Built for a Friend with Local Gemma

Himanshu Rane — Sun, 04 Oct 2026 06:06:51 +0000

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

HimanshuRane / buddy-ai-companion

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!

DEV Community: Himanshu Rane