This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

My neighbour runs Rayor's Treat, a small business selling parfait and yoghurt. Customers reach her on WhatsApp, on TikTok, through referrals and by phone, and the question she gets most is simply "how much?". Answering the same few questions all day takes time away from making and delivering orders.

So I built her an assistant that answers those repeat questions from her own price list: prices, sizes, totals for a quantity, delivery, payment and order hours. When it doesn't know something, it says it will confirm with her instead of guessing.

I showed it to her in person and she tried it herself. She loved it and said it can help her business. She told me she will let her customers use it, and that she can keep updating it as the business grows.

Demo

In the video: a Pidgin price question, a total for three parfaits, an ambiguous yoghurt question where it asks which one, delivery and payment, a cake she doesn't sell where it hands over to the owner, and a message with several questions in one.

Code

customer message
      |
      v
Gemma (local) -> suggests: topic, product category, size
      |
      v
Rust checks the suggestion (is the size really in the message?
is the topic plausible?) and looks facts up in JSON
      |
      v
reply built from the business data, or "let me confirm with the owner"

Her real menu isn't in the repo. It ships with example data, a README and an MIT license, so any small food business can copy it and use their own prices.

How I Built It

The model is Gemma 3 4B, running locally through Ollama (about a 3 GB download, around 2.9 GB of memory once loaded). A Rust backend (Axum) serves a small chat page.

The key design decision: the model suggests and the code decides.

customer message
      |
      v
Gemma (local) -> suggests: topic, product category, size
      |
      v
Rust checks the suggestion, then looks facts up in JSON
      |
      v
reply built from her data, or "let me confirm with the owner"

1. Gemma reads the customer's message, in English, Pidgin or with typos, and returns a small JSON guess: a topic, a product category and a size.
2. Plain Rust code checks that guess. A size is only accepted if it actually appears in the message, and a topic is only accepted if related words are there.
3. Prices, totals and policies come from JSON files and Rust code, never from the model's memory. If the answer isn't in the data, the reply is "let me confirm with the owner".

Gemma does real work here: understanding how people actually write. But a 4B model also makes confident mistakes, and I found them by testing:

• A wrong price. Two yoghurts share a 330ml size and my lookup returned the first match, so "Greek yoghurt 330ml" showed the plain price. That was my bug, not the model's. Ambiguous matches now ask "which one did you mean?"
• An invented size. For a message that never mentioned a size, Gemma returned 550ml. The size check dropped it.
• An invented topic. Gemma made up a topic called "order" that wasn't on my list. It's ignored.
• A flaky answer. "Can I order today?" sometimes returned the delivery answer. My topic list was in a different random order on every run, which swayed the small model. I sorted it and added keyword checks.
• Dropped parts. A message asking for 2 parfaits and about delivery only got the price list. The assistant now answers every part it recognises.

Totals are worked out in code, not by the model. "I want 3 500ml parfaits" becomes 3 x ₦6,500 = ₦19,500, and if a message contains two different quantities, it hands over to the owner instead of guessing.

I kept a list of customer questions with expected answers: 17 in the main list and 12 in a harder list with Pidgin and compound questions. Both lists pass (17/17 and 12/12), but they only cover what I thought to ask. They don't prove it handles every message.

Speed is the weak spot. Gemma runs entirely on my laptop's CPU, with no GPU, and each reply takes about 10 seconds. That's slow for a chat. The model stays loaded for 30 minutes after the last question, so only the first reply after a quiet spell is slower still.

Why Does Open Innovation Matter?

• Cost. There are no per-message fees. For a small side business, a metered API is a bill she didn't ask for.
• Control. Because the model is one component I own, I could pin its randomness (temperature 0 and a fixed seed), wrap it in checks, and swap it later without touching her data.
• Privacy. Customer messages are handled on her own machine and are not sent to a third-party AI service. Once Ollama has downloaded the model, the assistant works without an internet connection.

To be honest about the limits: if this gets connected to WhatsApp, those messages would pass through Meta even though the AI stays local. I haven't built that part.

What's Next

She said she will let customers use it, so the next steps are about getting it in front of them:

• Run it on an always-on machine, or connect it to WhatsApp
• A page for her to update prices herself (today that means editing a JSON file)
• A way to tell her when a question goes to the owner
• Multi-item orders
• A faster setup, either a smaller model or a GPU

Prize Categories

Best Use of Gemma