DEV Community: Abhishek Kumar

A Little Thing Worth Keeping: A Local Gemma Memory Lantern

Abhishek Kumar — Fri, 30 Oct 2026 19:07:28 +0000

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

What I Built

Some memories arrive as a story. Others are just a steel dabba on a counter, peanuts toasted separately, or curry leaves from a balcony pot.

Memory Lantern is a private keepsake book for saving those small details. Pick one or more notes and it asks Gemma to shape them into a short remembrance, with the source notes shown alongside the result. You can edit or delete the originals, copy the draft, or save it as a printable HTML keepsake.

I read “Ghost in the Machine” as a question about what we choose to keep. The ghost here is not a simulated person speaking from beyond; it is the detail someone wrote down and decided to carry forward.

Demo

The repository includes a sample note so you can see the flow without entering a real family story:

Open the keepsake box and select The Sunday lemon rice.
Choose Light the lantern.
Review the remembrance and the source note it came from.
Save it as an HTML keepsake.

I ran the generation locally with Gemma 4. The sample result was:

Lemon rice was made on Sundays when cousins visited. Peanuts were toasted separately to maintain crunch. A steel dabba was on the counter, and curry leaves were used from a balcony pot.

Sources: [1]

To try it on your machine, install Ollama, pull Gemma, and run the app:

ollama pull gemma4:latest
python app.py

Then open http://127.0.0.1:8000. If Ollama is not already running as a service, start ollama serve in a second terminal. The app itself needs no Python packages.

Code

Source: github.com/Abhishek764/memory-lantern

How I Built It

Memory Lantern is a small Python server and a plain HTML, CSS, and JavaScript interface. It stores notes as readable JSON in data/memories.json, which is ignored by Git so personal notes don't get committed accidentally.

When you light the lantern, the server sends only the selected notes to Ollama at 127.0.0.1:11434. Gemma 4 is the writing engine; it is not a decorative add-on. The prompt asks it to stick to concrete details, avoid inventing emotions or biography, and return the note numbers it used. The interface keeps those originals visible so the generated text can be checked against them.

flowchart LR
  A[Your saved notes] --> B[Local Python app]
  B -->|selected notes on localhost| C[Ollama]
  C --> D[Gemma 4]
  D -->|draft + source numbers| B
  B --> E[Review, copy, or export]
  B --> F[(memories.json on this device)]

The server binds to 127.0.0.1. The interface uses system fonts and makes no external requests. If Gemma isn't available, the keepsake box still works; generation shows a clear local setup message instead of sending anything to a cloud fallback.

Why Does Open Innovation Matter?

These notes can be intimate. I wanted the privacy boundary to be visible in the architecture, not just promised in a privacy policy.

With an open-weight model running through Ollama, the story stays on the machine where it was written. After Gemma is installed, generation can run without an internet connection. There is no hosted AI account, no per-story API charge, and no dependency on one provider keeping a service online. The model, server, prompt, and storage format are all inspectable and replaceable.

A closed API could make the first version faster to wire up, but it would require sending family stories to a service I don't control. Here, the open approach makes local processing practical and gives the person keeping the memory the final say over the data.

Gemma can still get details wrong. This is a writing aid, not an authority: the original notes stay untouched, the output names its sources, and the person using it should review every draft before sharing.

The Spirit of It

The sample is fictional, so I won't pretend it brought back someone's real family memory. Its little test is smaller: can the tool keep “toast the peanuts separately” from dissolving into a generic recipe summary? In the local run, it did.

I hope the real moment comes when someone writes down an ordinary detail today, then finds it still there years from now.

Prize Categories

I'm entering Best Use of Gemma. Gemma 4 runs the core remembrance generation locally through Ollama.

A Little Thing Worth Keeping: A Local Gemma Memory Lantern

Abhishek Kumar — Fri, 30 Oct 2026 18:32:48 +0000

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

What I Built

Some memories arrive as a story. Others are just a steel dabba on a counter, peanuts toasted separately, or curry leaves from a balcony pot.

Demo

The repository includes a sample note so you can see the flow without entering a real family story:

Open the keepsake box and select The Sunday lemon rice.
Choose Light the lantern.
Review the remembrance and the source note it came from.
Save it as an HTML keepsake.

I ran the generation locally with Gemma 4. The sample result was:

Lemon rice was made on Sundays when cousins visited. Peanuts were toasted separately to maintain crunch. A steel dabba was on the counter, and curry leaves were used from a balcony pot.

Sources: [1]

To try it on your machine, install Ollama, pull Gemma, and run the app:

ollama pull gemma4:latest
python app.py

Then open http://127.0.0.1:8000. If Ollama is not already running as a service, start ollama serve in a second terminal. The app itself needs no Python packages.

Code

Source: github.com/Abhishek764/memory-lantern

How I Built It

flowchart LR
  A[Your saved notes] --> B[Local Python app]
  B -->|selected notes on localhost| C[Ollama]
  C --> D[Gemma 4]
  D -->|draft + source numbers| B
  B --> E[Review, copy, or export]
  B --> F[(memories.json on this device)]

Why Does Open Innovation Matter?

These notes can be intimate. I wanted the privacy boundary to be visible in the architecture, not just promised in a privacy policy.

The Spirit of It

I hope the real moment comes when someone writes down an ordinary detail today, then finds it still there years from now.

Prize Categories

I'm entering Best Use of Gemma. Gemma 4 runs the core remembrance generation locally through Ollama.

BOOH: The 3 AM App I Wish Every New Parent Had

Abhishek Kumar — Sun, 04 Oct 2026 20:13:55 +0000

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

What I Built

There is a special kind of tiredness that only exists at 3 AM.

You're awake.
The baby just fell asleep.
You finally put your phone down.

And then the question appears:

“How long do I have before the next wake-up?”

I built BOOH around that question.

BOOH is a privacy-conscious nighttime dashboard designed for a new parent who doesn't need another complicated parenting app. They need one simple answer:

“How much sleep time do I probably have?”

Instead of showing endless charts and statistics, BOOH looks at the baby's previous sleep, feeding, and wake patterns and estimates:

expected sleep duration
probability of waking within the next 60 minutes
the usual sleep duration from the recent baseline
a short, calm explanation of the prediction
an optional voice version for those moments when even reading feels like too much work

The idea came from thinking about a friend who was going through the exhausting reality of caring for a newborn.

I didn't want to build another generic AI chatbot.

I wanted to build something that could be useful when someone is too tired to use an app.

That's BOOH.

Demo

🚧 Live Demo: Coming soon

🎥 Video Demo: Coming soon

The final demo will show the complete journey:

Login
  ↓
Choose Baby
  ↓
Import Sleep History
  ↓
Analyze Pattern
  ↓
Get Prediction
  ↓
See "How Long Do I Have?"
  ↓
Listen to the Summary

Code

The project is open source because I want people to be able to understand exactly how the prediction is being made and what happens to their data.

GitHub: BOOH Repository

The project is being built with a strong separation between:

User Data
     ↓
Feature Engineering
     ↓
Prediction Model
     ↓
Prediction
     ↓
AI Summary

The language model is deliberately not responsible for making the numerical prediction.

That distinction matters.

How I Built It

The interesting part of BOOH isn't simply that it uses AI.

It's how the AI is used.

The architecture combines several open-source technologies:

🧠 TabPFN — Prediction

BOOH uses TabPFN for the numerical prediction layer.

The model works with structured features extracted from the baby's history, such as:

recent sleep duration
time since the last feed
recent wake intervals
rolling sleep totals
time of day
day/night patterns
recent event counts

Alongside TabPFN, BOOH keeps a simple last-7-day baseline.

This gives us something important:

AI prediction vs. a simple baseline.

I don't want the app to say:

“AI says 47 minutes.”

and expect everyone to trust it.

I want to know whether the model is actually doing better than something simple.

So BOOH evaluates the prediction using metrics such as MAE and Brier score on held-out recent data.

🤖 Gemma — Explanation, Not Prediction

The language model has a very specific job.

It doesn't decide when the baby will wake up.

It receives structured prediction results and turns them into a short, human-friendly explanation.

For example:

“You may have around 45 minutes before the next wake-up. The recent pattern suggests a moderate chance of waking within the next hour.”

The model is restricted to short summaries.

It doesn't receive the entire baby history unnecessarily.

It isn't allowed to diagnose medical conditions, recommend medication, or invent information.

If the model fails, BOOH falls back to a deterministic summary.

🔊 ElevenLabs — When Reading Is Too Much

At 3 AM, even reading a screen can feel like work.

So BOOH can turn the summary into a short audio message.

The voice layer is optional and can be disabled completely for offline development.

The frontend never receives the ElevenLabs API key.

📊 Huckleberry Import

BOOH can import existing baby-tracking data through a CSV workflow.

Instead of scraping or depending on a private service, the importer converts the exported data into BOOH's own normalized event format.

That means the system can work with:

Sleep
Feed
Wake

rather than tying the prediction engine directly to one application's internal format.

🐳 Production Architecture

The application is designed as a real full-stack system rather than a notebook demo.

Next.js
   ↓
FastAPI
   ↓
PostgreSQL
   ↓
Feature Engineering
   ↓
TabPFN
   ↓
Prediction
   ↓
Gemma
   ↓
ElevenLabs

Authentication uses Google OAuth.

The application is containerized with Docker and designed for deployment on Render.

Privacy Was a Design Requirement

Baby data is sensitive.

So one of my rules while building BOOH was:

Just because AI can see something doesn't mean AI should see it.

The numerical prediction operates on structured features.

Gemma does not need the baby's entire sleep history.

The system also enforces ownership checks so one authenticated user cannot access another user's baby data.

Secrets such as:

OAuth credentials
database credentials
AI API keys
TTS credentials

are never supposed to be committed to Git.

Security checks are part of the development workflow rather than something I want to remember at the end.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

I could have built BOOH as:

Baby data
   ↓
Send everything to a closed AI API
   ↓
"AI prediction"

That would have been much easier.

But it would also make it harder to understand what is happening to the data and harder to experiment with the actual prediction system.

Open innovation gives me the ability to separate the problem into pieces.

I can choose:

TabPFN for structured prediction.

Gemma for language generation.

FastAPI for the backend.

PostgreSQL for persistence.

Next.js for the interface.

And potentially replace any individual component later.

That is powerful.

If a better open model appears tomorrow, I don't have to rebuild BOOH from scratch.

I can swap the model.

If I want to run inference locally, I can.

If I want researchers or developers to inspect the feature engineering, they can.

If I discover that the model isn't better than the baseline, I can show that too.

That's what I like about open innovation:

the system becomes something people can inspect, question, improve, and replace.

For a project dealing with something as personal as a baby's routine, that transparency matters even more.

My Agent Session

BOOH is also an experiment in AI-assisted software engineering.

I'm building the project using multiple coding agents with an orchestration and loop-engineering workflow.

Instead of asking one AI agent:

“Build the entire application.”

I'm breaking the project into independent engineering tasks.

For example:

                    BOOH Orchestrator
                           │
        ┌──────────────────┼──────────────────┐
        ↓                  ↓                  ↓
     Backend            Frontend             ML
        ↓                  ↓                  ↓
      Data                LLM              DevOps
        └──────────────────┬──────────────────┘
                           ↓
                       Integration
                           ↓
                        Security
                           ↓
                           QA

Each agent has a defined responsibility.

The development loop is:

PLAN
 ↓
IMPLEMENT
 ↓
TEST
 ↓
SECURITY REVIEW
 ↓
REVIEW DIFF
 ↓
UPDATE CONTEXT
 ↓
COMMIT
 ↓
INTEGRATE

I also keep a persistent CONTEXT.md so that when I return to the project in a new AI session, the next agent doesn't have to rediscover the entire project.

Every logical task gets its own Git commit.

That makes the AI-assisted development process much easier to inspect and recover.

The Part I'm Most Proud Of

BOOH isn't trying to predict everything about a baby.

It's trying to answer one small question at an incredibly difficult moment.

You don't need a giant dashboard at 3:00 AM.

You don't need 15 graphs.

You don't need an AI that talks for five minutes.

You need:

“You probably have about 45 minutes.”

And maybe, if you're lucky:

45 minutes of sleep.

That's BOOH.

Prize Categories

I'm entering BOOH for the partner categories that fit the technologies used in the project.

Open-source AI / open innovation
AI / agentic development
Developer tooling / open-source software
[Add applicable partner category here]

What's Next?

The current goal is to take BOOH from a hackathon prototype into something that could actually be useful.

Next steps include:

improving prediction quality
collecting better evaluation data
expanding manual event logging
improving the nighttime UX
local/offline inference options
better model comparison
stronger privacy controls
production deployment
making the project easier for contributors to understand

Because ultimately, I don't want BOOH to be something I built once for a weekend.

I want it to become something that another tired parent can open at 3 AM and immediately understand.

“Okay. I probably have 45 minutes.”

Now go get some sleep. 🌙