DEV Community: Sai Sri Madhav K

Ofrenda: a offline CLI that helps you remember someone, without inventing a word

Sai Sri Madhav K — Thu, 29 Oct 2026 10:35:50 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Ofrenda is a small command-line tool that helps you remember someone. You run ofrenda new, and a local model asks you quiet questions, one at a time: what they liked to eat, a song they hummed, something they always said, a place that was theirs. When you finish, it writes two plain Markdown files: a short remembrance, and a checklist of things you might put on an ofrenda.

I read "Ghost in the Machine" as the person who is no longer in the room, or no longer in your life, but still shows up in small habits and phrases. The idea started with Día de los Muertos, which treats memory as something to celebrate. But the tool isn't only for people who have died. It works just as well for a childhood friend you lost touch with.

I held myself to one rule: the model must never invent anything. The remembrance can only rearrange what you actually told it. If you give it little, the file is short. I would rather it say too little than make things up.

Demo

Here is the format, using a fictional friend (I wrote this example by hand to show the output; the person isn't real):

$ ofrenda new

Who are you remembering: Karthik
How did you know them: my childhood friend

What did Karthik love to eat?
> Mirchi bajji from the cart outside school. He'd buy two plates and always give me the bigger one.

[... more questions ...]

The resulting remembrance.md:

# Karthik

Karthik and I played cricket on the ground behind our colony until the
streetlights came on. Before every ball, he tapped his bat on the ground twice.

Outside school there was a cart that sold mirchi bajji. He would buy two plates
and always give me the bigger one. He hummed "Kal Ho Naa Ho" badly on purpose,
just to annoy me. He used to say, "Chill maar, bhai."

The cracked tennis-ball bat with his initials carved into it is still with me.

We lost touch after college. Last year I found out he had moved abroad.

Every sentence there traces back to something the user typed.

Code

madhav-1204 / Ofrenda-CLI

ofrenda

A small offline command-line tool that helps you remember someone.

You answer a few quiet questions about a person — what they cooked, a song they hummed, a phrase they always said — and the tool writes two plain Markdown files: a short remembrance and a checklist of things you might put on an ofrenda. Everything runs on a local model through Ollama, so nothing leaves your machine.

I made this during Hacktoberfest 2026, Week 4: Ghost in the Machine. The theme was about honoring the past, and Día de los Muertos felt like the right frame — a celebration of memory, not loss.

Install and run

1. Install Ollama

Download from ollama.com and make sure it's running.

2. Pull a model

ollama pull gemma3:4b

Any other small model works too. You can change it in the config (see below).

3. Install ofrenda

git clone https://github.com/madhav-1204/Ofrenda-CLI.git
cd ofrenda-cli
pip

…

View on GitHub

How I Built It

Model: Gemma, running locally through Ollama. The default is gemma3:4b, and you can change it in ~/.ofrenda.toml or with --model.
Language: Python with a small CLI. Output is plain Markdown and JSON in a local folder. No database, no API keys, no telemetry.
Prompts: They live in a prompts/ folder as plain text files, so anyone can read and edit them.
Interview: The model sees the conversation so far and asks one follow-up at a time, so each question reacts to your last answer instead of following a fixed script.
Writing step: The remembrance and checklist are built from your answers only, not from the interviewer's own comments. I made this change after noticing in an early example that something the model said out loud ended up in the output as if the user had said it.
Tests: pytest with a mocked model.

What didn't go smoothly: small models sometimes ask two questions at once even when told not to, and I left that in the README as a known limitation. Prompts are written and tested in English only. There's a language setting in the config, but I haven't verified other languages.

Why Does Open Innovation Matter?

Stories about family and friends are some of the most private things people have: names, how someone died, what they were like at home. I didn't want any of that going to a cloud API.

An open-weight model made these things possible:

It runs offline. Once the model is downloaded, the tool works with Wi-Fi off.
Nothing leaves the machine. There's no account, no key, and no server where your memories could be read.
You can inspect and change it. The prompts are plain text, so you can see exactly what the model is told.
You can swap the model. Use a smaller one on an old laptop or a bigger one if you have the hardware.
It costs nothing to run.

Prize Categories

Best Use of Gemma: the whole tool runs on a local Gemma model through Ollama.

sloth-sort: a lazy file tidier that runs on a local Gemma model

Sai Sri Madhav K — Fri, 23 Oct 2026 09:17:13 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

My Downloads folder is a graveyard. Invoices called Document (3) final FINAL.txt, installers I ran once and forgot, notes named scan0007. Every weekend I promise myself I'll clean it up, and every weekend I don't.

So I built sloth-sort, a small command-line tool that does the cleaning for me. Point it at a folder and it will:

Read each file's name and, when possible, the first bit of its content.
Ask a local AI model for a clean file name and a category folder (Invoices, Study, Photos, Installers, Misc).
Show me the plan as a table and wait. Nothing moves until I confirm.
Move the files and save an undo log, so one command puts everything back.

It never deletes anything, never overwrites a file, and never touches anything outside the folder you give it. All of it runs on my own laptop.

Demo

A dry run on my test folder:

Code

madhav-1204 / Sloth-Sort

sloth-sort

A small command-line tool that tidies a messy folder (like your Downloads directory) using a local open-weight model, so you never have to sort files by hand.

It reads the first few paragraphs of readable files (or just the file name and extension for binaries and images), asks a local model running on your machine to suggest a clean filename and a folder category, shows you a dry-run plan, and moves the files only when you tell it to.

Every operation is logged and can be completely reverted with one command.

Built for the DEV Hacktoberfest Open-Source AI Challenge (Week 3: Slow and Steady).

Why a local model?

Most file organizers either rely on hardcoded extension rules (dumping all PDFs into one folder regardless of whether they are tax returns, research papers, or appliance manuals) or send file names and contents to third-party cloud APIs.

sloth-sort runs entirely on…

View on GitHub

How I Built It

Stack: Python, Ollama for local inference, and Gemma 3 as the model. I tested with gemma3:1b and gemma3:4b. The model is just a config value, so anything Ollama can run will work.

The pipeline is deliberately boring:

Scanner: lists files and skips hidden files, partial downloads (.crdownload, .part) and anything modified in the last few minutes.
Reader: takes the first ~1000 characters of text-like files (txt, md, pdf, docx, csv). For binaries and images, the model only sees the name and extension.
Model call: asks Gemma for strict JSON with new_name and folder. The allowed categories are a fixed list, so the model can't invent 40 different folders. Bad JSON gets one retry, then the file is skipped and left alone.
Planner: builds the table and saves it to plan.json.
Mover: applies the plan, adds a number when a name collides, and writes undo_log.json.

sloth-sort plan <folder>    # dry run, nothing moves
sloth-sort apply            # apply the last plan after confirmation
sloth-sort undo             # put everything back

I used Antigravity as my coding agent and wrote a detailed spec first: safety rules, exact commands, and a list of things I did not want (no dashboard, no extra features).

What the small model got wrong: in my first run, setup_app_installer.exe was renamed to installer.exe. For a binary, the model only has the file name to go on, so a rename just throws information away. I changed the rule: binaries and images get a category folder but keep their original name. A small model is good at sorting, but it shouldn't rewrite names it can't verify.

To measure accuracy instead of eyeballing it, I built a test folder of 40 ugly files and wrote the correct category for each one before running anything.

Why Does Open Innovation Matter?

A file tidier sees everything: invoices, ID scans, personal notes, whatever lands in Downloads. I didn't want to upload any of that to a server I don't control just to rename a file.

An open-weight model running locally gave me things a closed API wouldn't:

Privacy by default. File contents never leave my machine.
It works offline. After the one-time model download, no network is involved.
No running cost. Sorting 500 files costs the same as sorting 5: no money at all.
The model is swappable. Moving from gemma3:1b to gemma3:4b was a one-line config change, so I could measure speed against quality on my own hardware.

The honest tradeoff is quality. The 1B model got confused by installers and receipts without explicit headers, dumping .dmg files and coffee receipts into Misc, while the 4B model correctly recognized them as Installers and Invoices. Both models struggled with informal household notes: a grocery list and an apple pie recipe went to Misc with the 1B model and to the formal Documents category with the 4B model. I didn't test a large cloud model, but I'd expect one to do better at telling casual notes from business documents, and at reading tabular CSV data to tell bank transactions from general reports.

Reply Desk: Review Replies for Small Businesses, Written Offline by Gemma 3 1B

Sai Sri Madhav K — Sat, 17 Oct 2026 18:04:14 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Reply Desk is a small local web app that writes replies to customer reviews. You paste a review, optionally pick a star rating, and get a ready-to-post reply in your own voice, which you can edit and copy.

The person who would pay for it is a small business owner: a café, a salon, a repair shop, a dental clinic. They get reviews on Google and elsewhere, and they know they should reply, but writing a calm, specific answer to an angry one-star review at the end of a long day is hard. Review management tools exist, but they charge monthly fees that a small shop doesn't want to pay.

What it does:

Detects whether the review is positive, neutral, or negative (you can override it)
Writes a reply in a tone you choose (friendly, professional, apologetic) at a length you choose (short or medium)
Uses a saved Business Profile: business name, owner name, sign-off, tone notes, and a "things to never say" list (for example, never promise refunds)
Keeps a searchable history of past reviews and replies
Runs fully offline with no accounts, no API keys and no tracking

Demo

It uses a simple two-pane layout, with the review on the left and the editable reply on the right. I deliberately made it look like ordinary software (flat, quiet, one accent color) because I wanted it to feel like a tool you'd use every day, not a flashy AI demo.

![landing page of reply desk]tps://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/rtp0rt2a23i3ifd3vbkb.png)

Code

madhav-1204 / Reply-Desk

Reply Desk

Paste a customer review. Get a ready-to-post reply in your voice. Runs on your own computer.

Reply Desk is a privacy-first, local review reply generator designed for small business owners—cafes, hair salons, auto repair shops, dental clinics, and local stores—who dread writing review replies or don't want to pay monthly SaaS fees.

Built from scratch for the DEV Hacktoberfest Open-Source AI Challenge Week 2 (Theme: Side Hustle), powered by open-source AI running completely on your local machine using Ollama and Gemma 3 1B.

Key Features

Split-Screen Utility Layout: Clean two-pane interface—customer review and controls on the left, live generated reply on the right.
Auto-Detected Sentiment: Automatically classifies review sentiment as Positive, Neutral, or Negative, with full manual override.
Star Rating Aware: Select 1 to 5 stars as context hints for tone and sentiment.
Tone & Length Customization: Choose between…

View on GitHub

To run it you need Node.js and Ollama:

ollama pull gemma3:1b
git clone https://github.com/madhav-1204/Reply-Desk.git
cd Reply-Desk
npm install
npm run dev

Then open http://localhost:3000.

How I Built It

Model: Gemma 3 1B (open weights) running locally through Ollama. The whole app talks only to localhost:11434.

Stack: Node.js and Express on the backend, plain HTML/CSS/JS on the frontend, and a local JSON file for the profile and history. Replies stream into the box as they are generated.

I picked the 1B model on purpose. It's about 800 MB and runs on an ordinary laptop, which is realistic for a small business owner. The downside is that a model this small is easy to confuse, so most of the work went into the pipeline around it. Each reply goes through three steps:

Sentiment classification. A very short few-shot prompt at low temperature that returns a single word: positive, neutral or negative. The star rating is used as a hint and as a fallback if the model's output is unclear.
Constrained reply generation. The prompt combines the business profile, tone, length and sentiment with a few matched examples. It also carries hard rules: only mention details that appear in the review, never promise refunds or discounts, never admit legal fault. Negative reviews follow a fixed structure of thanking the customer, apologizing, addressing the specific complaint, and inviting them to continue offline.
Post-processing. The code removes preambles like "Here is your reply:", strips quotes and markdown, enforces the sentence limit, and adds the owner's sign-off.

What I learned: with a small model, a good prompt and a clean post-processing step matter more than the raw model.

Why Does Open Innovation Matter?

Reviews are not as harmless as they look. They mention customer names, staff, bills and disputes. A closed API would mean sending all of that to someone else's server for every reply. With an open-weight model running locally, none of it leaves the machine.

It also changes the economics. Tools in this space charge small businesses a monthly fee, and API-based apps charge per request. With a local model, a reply costs nothing, so a one-person shop can use it as much as it likes with no subscription, no quota and no billing surprise. It works with the internet down too.

Finally, open weights let me control the behavior. I could tune the prompts and rules for exactly this task, and the model name is a single config value, so a shop with a better computer can swap in a larger Gemma by changing one line. A closed API gives you none of that.

Prize Categories

Best Use of Gemma: the entire app is built around Gemma 3 1B running locally through Ollama.

Sit Spot: a local journal for ten minutes outside

Sai Sri Madhav K — Sun, 11 Oct 2026 13:30:26 +0000

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

What I Built

Sit Spot is a small journal for short sit-outside sessions. You pick how long you'll be out (5, 10, 20 minutes, or your own number). The app gives you one short prompt and then gets out of the way: the next screen says "phone away" and has a single button, "I'm back".

When you return, you type rough notes. A few lines, typos and fragments are fine. A local model tidies them into a short journal entry. Your raw notes and the tidy version sit side by side, and you can edit either one or keep only the raw notes.

The screen is meant to be the shortest part of the experience, so the app measures it. Every entry shows how long you were outside and roughly how long you spent on screen. That comparison is the number I care about.

It's for anyone who wants a small, repeatable reason to go outside and pay attention, without an app competing for that attention. There are no accounts, no streaks and no notifications.

There's also a "What keeps showing up" button. It asks the model to look across recent entries for patterns and to cite the date of every entry it draws on.

Demo

The video shows one full session, from picking a length to a saved entry. it's in the repo

Code

madhav-1204 / Sit-Spot

Sit Spot

A local-first journal for short sit-outside sessions. An open-weight Gemma model running locally through Ollama gives you one brief prompt before you step outside, and tidies your rough notes when you return.

Built during Hacktoberfest Week 1 (Oct 5–11, 2026) for the "Touch Grass" challenge. The screen is designed to be the shortest part of the experience.

Setup in 4 Commands

git clone https://github.com/madhav-1204/Sit-Spot.git
cd sit-spot
pip install -r requirements.txt
python app.py

Then open your browser to http://127.0.0.1:5000.

(To populate sample entries for demonstration, run: python app.py --demo)

Local AI Model Configuration

Sit Spot uses an open-weight model running entirely on your local machine via Ollama. No cloud APIs, no tracking, and no internet access required at runtime.

Install Ollama from ollama.ai.
Pull the default Gemma model
```
ollama pull gemma3:1b
```
(Or use gemma3:4b / gemma2:2b by setting the environment variable SITSPOT_MODEL).
If…

View on GitHub

How I Built It

The app is Python, Flask, SQLite (standard library) and requests. The pages are server-rendered HTML with one CSS file. There's no JavaScript framework, no CDN and no web fonts. The only network calls go to localhost:11434.

The AI is Gemma 3 1B (gemma3:1b, about 806 MB) running locally through Ollama. The model name comes from an environment variable, so swapping models is a one-line change.

The model does three jobs, and each has its own prompt file in prompts/:

Session prompt: one instruction, 25 words at most, based on the time of day, the month and the last entry.
Tidy: 3 to 4 first-person sentences from the rough notes, plus one follow-up question for next time.
Look back: patterns across recent entries, with dates cited.

If Ollama isn't running, or a call takes longer than 60 seconds, the app saves the raw notes and uses prompts from a fallback file. It's still useful without the model.

What went wrong. My first run of the tidy step used five test entries. The 1B model made up sensory details that nobody had written (it added "felt cool beneath my fingertips" and "lilac flowers"). It also folded the follow-up question into the body paragraph. I fixed this by adding a one-shot example and explicit negative constraints to the prompt, and code that pulls the question out separately.

The second round was better but still wrong in a funny way. A note that said "Rain stopped about 10 minutes ago" came back as "I stopped the rain about ten minutes ago." I added a rule that natural events must never be attributed to the observer.

The results improved a lot but are not perfect. That's why the raw notes always appear next to the tidy version, with a line telling you to check one against the other. Every break and fix is in the dated log in NOTES.md.

I used Antigravity as the coding agent.

Taking It Outside

account:

where you sat, and for how many minutes
the exact prompt the app gave you
your raw notes, and what the tidy version kept or got wrong
the outside and screen times the app recorded
one honest thing you noticed, good or bad]]

Why Does Open Innovation Matter?

A journal is personal. It records where you sit, what you notice and when you go out, which adds up to a picture of someone's routine. With a local open-weight model, that data never leaves the laptop. I didn't have to choose between a useful tidy-up step and keeping my notes private.

Cost was the second thing. Rewriting a note costs nothing per call, so I could keep running the same entries through the model while I fixed the prompts, without watching a bill.

Control was the third. The model is one environment variable, and the prompts are plain text files. When the model wrote "I stopped the rain," the fix was an edit to a text file and a re-run.

It also needs no internet at all, so the whole thing works with Wi-Fi off.

The trade-off is real. A larger hosted model would almost certainly have made fewer of the mistakes in my log. I accepted weaker output in exchange for privacy, zero cost and no dependence on a connection, and for a personal journal I think that's the right choice. The raw-notes-first design is what makes it safe to accept.

Prize Categories

Best Use of Gemma: Gemma 3 1B, run locally through Ollama, is the only AI in the project. It writes the session prompts, tidies the notes and summarises patterns, with no cloud API involved.