DEV Community: Lagnadeep Samal

mealmate: a meal planner that can't serve my roommate their allergens

Lagnadeep Samal — Wed, 07 Oct 2026 07:54:32 +0000

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

What I Built

mealmate is a weekly meal planner for my roommate om, who has food allergies who has food allergies (peanuts, tree nuts and shellfish). Cooking for the two of us used to mean checking every recipe and every label by hand. A vague "it's probably fine" isn't good enough when the stakes are real.

You enter your housemate's allergies, favourite foods, dislikes and cooking time. mealmate plans breakfast, lunch and dinner for each day and makes a printable page with a week grid, recipes, a shopping list, and a "read the label on these" list for packaged items like stock and sauces. It runs as a small web app on your own computer.

Demo

https://drive.google.com/drive/folders/1eMKFDevAiV6uzxoCuBSizH1RcuCls2T9?usp=sharing

The progress log shows the safety layer working. With the demo model it looks like this:

Monday...
  attempt 1 rejected: Pad thai: 'shrimp' is crustacean (+1 more)
  ok on attempt 2

Code

Lagnadeep-samal / mealmate

mealmate

A weekly meal planner for a housemate with food allergies. A local open-weight model proposes meals; a plain word-list checker decides whether they are allowed. Nothing leaves the laptop.

Run it

# 1. a local model (one-time)
ollama pull qwen2.5:7b          # older laptop? try llama3.2:3b

# 2. describe your housemate
cp profile.example.json profile.json     # edit allergies, likes, dislikes

# 3a. use it in the browser (recommended)
python mealmate.py serve                 # then open http://localhost:8000

# 3b. or from the terminal
python mealmate.py plan --days 5         # writes plan.html and plan.json

# no model handy? watch the guard work with a fake one that gets it wrong first
python mealmate.py plan --profile profile.example.json --mock

# quick check of any recipe or shopping list
python mealmate.py check "soy sauce, pesto, oat milk"

# tests (no model or network needed)
python -m unittest -v

The web app listens on 127.0.0.1 only…

View on GitHub

Python standard library only, plus tests that run without a model or a network connection.

How I Built It

Model: an open-weight model (qwen2.5:7b, or llama3.2:3b for slower machines) running locally through Ollama. It returns structured JSON that follows a schema.
Planning loop: the model plans one day at a time, with the allergies in its system prompt.
The safety layer is not AI. allergens.py is a plain word-list checker. It scans every dish name, ingredient and cooking step, so "drizzle with tahini" in a recipe step can't slip past a clean ingredient list. It knows hidden sources (ghee, casein, Worcestershire sauce, pesto, hummus) and avoids false alarms (peanut butter isn't dairy, eggplant isn't egg).
Retry with feedback: when the checker rejects a meal, the model is told exactly what was found and tries again, up to four times. If it still can't produce a safe day, that day is left blank instead of showing something unsafe.
Fail loudly: an allergy the checker doesn't recognise is treated as a literal word to avoid and is never silently dropped.
Interface: a tiny local web server on 127.0.0.1 only, with a form, a live log and the finished plan.

mealmate is not a medical device. It can't see inside a packet or catch cross-contact in a shared kitchen, and it deliberately over-blocks. The page says so, and for severe allergies the person should read each plan before cooking.

Why Does Open Innovation Matter?

Privacy: an allergy list is health information. It never leaves the laptop. There's no account, no upload and no third-party terms.
Cost: it costs nothing to run, so my roommate can use it for years without a subscription.
Swappable: I can change the model with one setting, or add another local runtime with a few lines. If a model plans badly, I can replace it without rewriting the app.
Inspectable safety: the part that matters most is code anyone can read and test, not a prompt I'm hoping holds. With a closed API I couldn't put a deterministic guard between the model and my roommate, and I couldn't be sure the model behind it wouldn't change underneath me.

My Agent Session

I built MealMate myself and wrote and debugged the code. I used Claude as a coding partner when I got stuck, but I made the development decisions and implemented the changes. I chose my roommate as the person to build for, decided what the tool needed to do, and added features like the browser version and a modern colour palette.

I also set up and debugged the local Ollama side myself: pulling the models, checking with ollama ps that they were running on CPU only, and fixing an outdated copy of the file. I used Git to push the project to GitHub so my work stays backed up and in sync.

Pocket Walk: an offline AI that plans your walk, then tells you to put the phone away

Lagnadeep Samal — Tue, 06 Oct 2026 06:48:53 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass*

What I Built

Pocket Walk is a walk planner that wants you off the screen as fast as possible.

You tell it your region, season, what you like looking for (birds, trees, bugs) and how much time you have. A local open-weight model turns a field guide into a pocket card: a handful of riddle-style clues for things to find on your walk. Then you hit "Start walk" and the screen goes dark, with just a breathing orb and a timer. When you're back, you tick off what you found and the model writes a short trail journal.

The metric I care about is the grass ratio: minutes outside per minute on screen. It sits in the corner of the app and fills up the more you walk. The goal is to make the screen the shortest part of the experience, so the app is built to be left.

It's for anyone who wants a nudge to look at their own surroundings more closely: casual walkers, kids, students between classes.

Demo

https://drive.google.com/file/d/1mpd6ITLpQCc5dACMfF3tALElSroYcZJ-/view?usp=sharing

Code

{https://github.com/Lagnadeep-samal/pocket_walk}

Run it in two commands, with no account and no API key:

ollama pull llama3.2:3b
python app.py   # open http://localhost:8000

It uses only the Python standard library, so there is nothing to pip install.

How I Built It

Open model, local inference: Llama 3.2 3B through Ollama, called over localhost. Setting POCKET_MODEL swaps in Qwen, Gemma or anything else Ollama serves.
Retrieval over a local field guide: guide.json holds the species, with habitat, season and an identification hint for each. A small BM25 search (pure Python) picks the best matches for your season, interest and time budget.
Grounded generation: the model only writes riddle clues from the retrieved notes, and the species list comes from the retrieval step, not from the model. A 3B model can't invent a bird that isn't in the guide.
Graceful fallback: if Ollama isn't running, the app still works and shows the plain field-guide clues.
Frontend: one HTML file with no framework and no CDN, so it works with no signal. Your walk log and grass ratio are stored in your browser's localStorage.

Why Does Open Innovation Matter?

Offline: the model, retrieval and UI all run on your own machine. Nothing here needs a connection, which matters when the whole point is to go where there's no signal.
Private: your location, your walks and your notes never leave the device. For something that tracks where you go and when, that matters.
Swappable: changing the model is one environment variable. Changing the region is editing a JSON file. I shipped two starter packs (South Asia and temperate north), and anyone can add their own local species without touching the code.
Free: there is no key, no quota and no per-request cost, so a school or a nature club can run it without a budget.

A closed API would have made this a cloud service that needs a connection and an account, and it would send your location off-device.

What I Learned Testing It Outside

My first launch was funny: instead of a setup screen, the app opened straight into walk mode with a giant 0:00 timer. A CSS rule was overriding my "hidden" class. It was a small bug, but a good reminder that even an app about leaving the screen has to work on the screen first.

Then I took it outside. I walked for 20 minutes around the KIIT campus and found 3 of 5 things on my card. My grass ratio ended up at 4.2:1, meaning I spent about four minutes outside for every minute looking at the screen.

It isn't perfect. A 3B model can write riddles that are vaguer than I'd like, so the plain field-guide hint is a useful backup. The starter guide only has 8 species per region, so repeat walks will show similar finds. And walk mode only blacks out the app, it doesn't lock the phone. That is where I'd improve it next.

What I'm happiest about is that it ran entirely on my laptop. No account, no API key, no data leaving the device.