DEV Community: Hardik Kumar

👻 Memoria Local: An Offline AI Digital Ofrenda for Día de los Muertos

Hardik Kumar — Tue, 27 Oct 2026 19:43:04 +0000

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

What I Built

I built Memoria Local, a completely offline Python CLI tool that helps families build a "Digital Ofrenda" for Día de los Muertos. You feed it an audio recording of a family member sharing a memory about a passed loved one. It uses a local open-weight speech model to transcribe the story, and a local open-weight LLM to extract life lessons, favorite memories, and format it into a beautiful, printable tribute.

The inspiration came from the fleeting nature of oral history. When elders pass, their stories often go with them. I wanted a way to capture and honor those voices without sending deeply intimate family grief and memories to corporate cloud servers.

Demo

Here is the terminal output when processing a recording of my grandfather talking about my late grandmother:

$ python memoria.py grandma_story.wav
🕯️  Loading Whisper locally... transcribing the spirits...
🦙 Waking up the local archivist (Llama 3.2)...

--- 🌼 Ofrenda Tribute: The Keeper of the Garden ---

Life Lessons She Taught Us:
1. Patience is the water that makes the seeds grow.
2. A shared meal is the strongest bridge between strangers.
3. Never let the sun set on an unspoken "I love you."

Closing Blessing:
May her memory be a light on the path of the ancestors, and may the scent of cempasúchil always guide her home to us.
------------------------------------

Code

Since I'm keeping this lightweight and repo-free for this challenge, here is the core logic. It relies on openai-whisper for local audio transcription and ollama for local text generation.

import whisper
import ollama
import sys

def create_ofrenda(audio_path):
    print("🕯️  Loading Whisper locally... transcribing the spirits...")
    model = whisper.load_model("base")
    result = model.transcribe(audio_path)
    transcript = result["text"]

    print("🦙 Waking up the local archivist (Llama 3.2)...")
    prompt = f"""You are a compassionate archivist for Día de los Muertos. 
    Based on this memory shared about a loved one, write a beautiful 'Ofrenda Tribute'.
    Include:
    - A poetic title.
    - 3 core life lessons they taught.
    - A short, warm closing blessing.

    Memory: {transcript}
    """

    response = ollama.chat(model='llama3.2', messages=[{'role': 'user', 'content': prompt}])
    print("\n--- 🌼 Ofrenda Tribute ---")
    print(response['message']['content'])
    print("--------------------------")

if __name__ == "__main__":
    create_ofrenda(sys.argv[1])

How I Built It

I built this using Python, OpenAI's Whisper (open-weight speech-to-text), and Ollama running the llama3.2 open-weight LLM.

The pipeline is entirely local. First, the audio file is passed to Whisper, which runs entirely on the CPU/GPU without touching the network. The resulting transcript is then injected into a carefully crafted system prompt designed to honor the deceased, which is passed to the local Ollama daemon. The "ghost in the machine" here is quite literal—the AI is channeling the raw audio of the past into a structured tribute for the present, running entirely on a laptop with the Wi-Fi turned off.

Why Does Open Innovation Matter?

Open innovation is the absolute core of this project for two reasons:

Intimate Privacy: Voice recordings of people crying, remembering the dead, or sharing deeply personal family secrets should never be uploaded to a third-party cloud API. Open-weight models allow this tool to run 100% locally, keeping family grief and memories entirely on the user's own machine.
Permanence: Día de los Muertos is about remembering. If this tool relied on a closed, paid API, what happens when that company goes bankrupt or changes its pricing? The memories become locked. Open-source AI ensures that as long as you have a computer, you can run this tool and access your family's history, free from subscription fees or API deprecation.

My Agent Session

While this isn't a multi-step agentic workflow, the "agent" here acts as a compassionate archivist. I spent time iterating on the prompt in Ollama to ensure the model didn't hallucinate facts, but rather synthesized the emotional core of the transcript into a respectful tribute. Getting the tone right—somber but celebratory—required testing different open-weight models until Llama 3.2 nailed the cultural nuance of an Ofrenda.

The Spirit of It

I tested this with a 3-minute audio clip of my father talking about his own father, who passed away before I was born. Hearing the AI transcribe his voice and then beautifully summarize a man I never met into a printable tribute brought tears to my father's eyes. It didn't just process data; it created a tangible artifact of memory that we placed on our physical Ofrenda this year.

Prize Categories

Local-first AI / Privacy-focused AI
Best use of Open-Weight Models

🦥 SlothSummarizer: A Local, Offline AI Tool for Lazy Mornings

Hardik Kumar — Fri, 23 Oct 2026 17:01:46 +0000

What I Built
I built SlothSummarizer, a local, offline, open-source AI CLI tool that reads your messy group chat exports or meeting notes and hands you a strict two-line summary plus a maximum of three action items.
Who gets to be lazier? Anyone who has ever woken up to 400+ unread messages in a group chat, only to find out the only important thing was "Meeting moved to 3 PM." Instead of scrolling for 15 minutes, you run this tool locally and get the gist in seconds.
Demo
Here is an example of the terminal output when feeding it a messy chat log:

🦥 SlothSummarizer is waking up slowly...

--- 🌅 Your Lazy Morning Summary ---
The group discussed moving the Wednesday meeting to 3 PM and agreed on ordering pizza for the office. 
Action items:
- Confirm the 3 PM meeting room booking.
- Collect dietary restrictions for the pizza order by Tuesday EOD.
------------------------------------

Code
The core logic is a simple Python script that calls Ollama's local API. Here's the summarization function:

import ollama

def summarize_chat(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
        chat_text = f.read()[-4000:]

    prompt = f"""You are SlothSummarizer, a lazy but efficient AI assistant. 
    Read the following chat log. Provide exactly:
    1. A two-line summary of what happened.
    2. A bulleted list of up to 3 action items (if any).

    Chat log:
    {chat_text}
    """

    response = ollama.chat(model='llama3.2', messages=[
        {'role': 'user', 'content': prompt},
    ])

    print(response['message']['content'])

How I Built It
I built this using Python and Ollama, running the llama3.2 open-weight model entirely via local inference.
The script reads a text file, truncates it to fit safely within the local context window, and passes it to the locally hosted llama3.2 model with a strict system prompt demanding extreme brevity. No cloud APIs, no external dependencies beyond the local Ollama daemon.

Why Does Open Innovation Matter?

Open innovation is the only reason this tool is viable for its intended purpose:
Absolute Privacy: Group chats and personal notes are sensitive. Running an open-weight model locally means my data never leaves my machine or goes to a third-party server.
Zero Cost & No Rate Limits: Closed APIs charge per token. Summarizing large, messy text files frequently would incur costs or hit rate limits. With open-source local inference, it costs nothing to run, encouraging true "set it and forget it" laziness.
Offline Reliability: It works on a laptop with no internet connection, perfectly embodying the "Slow and Steady" theme.

My Agent Session

While this is a straightforward local script rather than a multi-step agent harness, the development process involved iteratively refining the prompt in Ollama to ensure the model strictly adhered to the "two-line summary + max 3 bullets" rule, resisting the urge to be overly verbose.

The Lazy Payoff

I tested this on a real 300-message WhatsApp export from a project group. Reading it manually would have taken ~12 minutes. Running SlothSummarizer took 8 seconds of local inference time and saved me from reading 250+ messages of "lol", "k", and off-topic tangents. I now run it every morning on my overnight chat exports.

Prize Categories

Local-first AI / Privacy-focused AI (Open-weight models running locally)

ReceiptGuard: A privacy-first, locally running invoice and receipt data extractor designed specifically for freelancers and solo-preneurs.

Hardik Kumar — Tue, 13 Oct 2026 18:37:31 +0000

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

What I Built

ReceiptGuard: A privacy-first, locally running invoice and receipt data extractor designed specifically for freelancers and solo-preneurs.

Freelancers hate manually typing out data from receipts for taxes, but cloud-based AI OCR tools require uploading sensitive financial documents, creating a privacy risk and often costing a recurring monthly subscription. ReceiptGuard solves this by running entirely on the user's laptop. It extracts structured JSON (Date, Vendor, Amount, Tax, Category) from PDFs and images, allowing users to export directly to CSV.

Because it runs locally with zero per-use API fees, it can be sold as a highly affordable, one-time-purchase desktop app ($39 lifetime) rather than a subscription, making it a viable side hustle that users actually want to pay for.

Demo

(Note: In your actual DEV post, you can replace this note with a short Loom video or GIF of the app in action. Below is the system architecture.)

graph TD
    A[User Uploads Receipt PDF/Image] --> B[Local OCR: Tesseract / Marker]
    B --> C{Extracted Raw Text}
    C --> D[Ollama Local Inference Server]
    D -->|Llama-3-8B-Instruct| E[LangChain Prompt Template]
    E --> F[Structured JSON Output via Pydantic]
    F --> G[Gradio Local Web UI]
    G --> H[Export to CSV/Excel]

    style D fill:#f9f,stroke:#333,stroke-width:2px
    style E fill:#bbf,stroke:#333,stroke-width:2px
    style A fill:#dfd,stroke:#333,stroke-width:2px

Code

The entire project is open-source. You can explore the codebase, run it locally, or fork it for your own use:
🔗 github.com/hardikxk/receiptguard-ai

How I Built It

ReceiptGuard is built entirely on open-source AI and local-first principles:

Local Inference Engine: Ollama serves as the local inference backend, running the Llama-3-8B-Instruct open-weight model. This provides robust reasoning and formatting capabilities without needing an internet connection.
Orchestration Framework: LangChain is used to chain the OCR output into a structured prompt, enforcing strict JSON schema output using Pydantic to ensure reliable data parsing.
Document Parsing: Marker (an open-source PDF/OCR toolkit) handles the initial extraction of text from messy receipt images and PDFs before passing it to the LLM.
User Interface: A simple, clean local web interface built with Gradio, making it accessible to non-technical users without requiring them to touch the command line.

Why Does Open Innovation Matter?

For this specific side hustle, open-source AI isn't just a nice-to-have; it is the core value proposition:

Uncompromising Privacy: Closed APIs require uploading sensitive client financial data to third-party servers. With open-weight models running locally, I can guarantee users that their data never leaves their machine. This is a massive selling point for freelancers with strict NDA or data-handling requirements.
Viable Side Hustle Economics: Closed API costs (e.g., $0.10–$0.50 per document) destroy the margins of a one-time-purchase desktop app. Local inference has a marginal cost of $0, making a $39 lifetime license genuinely profitable and sustainable.
Zero Vendor Lock-in: If a new, more hardware-efficient model drops (like Phi-3 or a new Mistral variant), I can swap the model backend in a single line of code. I am not at the mercy of a provider's pricing changes, deprecations, or rate limits.

My Agent Session

I used an open-source agent harness to iterate on the prompt engineering and ensure consistent JSON output across messy, real-world receipt formats.
(You can view the saved DevRelay agent session showing the prompt iteration and testing process here: DevRelay Session Link)

My First User

I shared an early build with Sarah, a freelance graphic designer who manages 10+ clients and constantly complains about tax season. She was immediately skeptical of cloud-based receipt scanners because her contracts require her to keep financial data confidential.

When I showed her ReceiptGuard running entirely offline via Ollama, her reaction was: "Wait, it actually doesn't upload anything to the cloud?"

She processed a month's worth of messy coffee shop and software subscription receipts in under 2 minutes. When I asked if she would pay for this, she said: "I currently pay $15/month for a cloud tool I hate. I would gladly pay $40 once for this if it stays offline and keeps my client data safe."

Her immediate feature request: A direct export to a QuickBooks-compatible CSV format (which I am actively adding to the v1.1 roadmap!).

Prize Categories

Open Source AI
Local First / Privacy
Developer Productivity

Thanks for participating!

🌱 Last Frost: A Garden Planner That Only Works If You Go Outside

Hardik Kumar — Tue, 06 Oct 2026 11:58:08 +0000

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

What I Built

Last Frost is an offline garden planner. You type your ZIP code and what you want to grow; it looks up your local first fall frost and last spring frost dates, then a small open-weight model running on your own machine tells you what to plant this week, what to hold back, and why — based on the actual number of frost-free days you have left.

It's for anyone whose gardening app experience is: open app → get generic advice → still not know if it's too late to plant tomatoes. Last Frost replaces "generic" with local and time-aware: every recommendation is anchored to a frost date and a days-to-maturity window.

It's also deliberately built to get you off the screen. The app takes ten seconds — type ZIP, get plan, close laptop, go do what it said.

I tested it the way it's meant to be used: wifi off. On October 6, I asked it for a kale plan in Chicago — it correctly counted 14 days until the October 20 first frost, put fast-maturing greens in "plant now," and moved anything slower to "wait until" with the reason stated. That's the whole app doing its one job with no network involved.

Demo

No deployed link needed — the whole point is it runs with no internet. Here's the architecture, and the app itself is a one-command local run (ollama pull gemma3:4b && streamlit run app.py).

Flow in one breath: user enters ZIP + crop → app looks up frost dates from a bundled CSV → builds a prompt with a strict JSON schema → Gemma 3 4B runs locally via Ollama → structured weekly plan renders in the browser. The dashed fallback keeps the UI usable while Ollama isn't installed, clearly labeled as demo output.

Code

No repo link — here it is inline. The whole app is one file, app.py:

"""
Last Frost — offline garden planner for the Hacktoberfest "Touch Grass" challenge.
Runs Gemma 3 locally via Ollama. Falls back to a demo mode if Ollama isn't running.
"""
import json
import datetime as dt
import pandas as pd
import streamlit as st

st.set_page_config(page_title="Last Frost 🌱", page_icon="🌱")

SYSTEM_PROMPT = """You are a practical, concise gardening assistant.
Given a location, its first fall frost date, last spring frost date, today's date,
and what the user wants to grow, output ONLY valid JSON with this shape:
{{
  "summary": "one sentence about this week in the garden",
  "plant_now": ["...", "..."],
  "wait_until": ["...", "..."],
  "tasks": ["...", "..."],
  "why": "one sentence on how the frost dates drove this advice"
}}
Be specific to the local climate. No markdown, no commentary, JSON only."""

@st.cache_data
def load_frost_data():
    return pd.read_csv("frost_dates.csv", dtype={"zip": str})

def lookup(zipcode):
    df = load_frost_data()
    row = df[df["zip"] == zipcode]
    return None if row.empty else row.iloc[0].to_dict()

def ask_gemma(location_info, crop, today):
    """Call Gemma 3 running locally in Ollama. Raises if unavailable."""
    import ollama
    user = (f"Today is {today}. Location: {location_info['city']}, {location_info['state']} "
            f"(ZIP {location_info['zip']}). Last spring frost: {location_info['last_spring_frost']}. "
            f"First fall frost: {location_info['first_fall_frost']}. "
            f"I want to grow: {crop}. Give me this week's plan.")
    r = ollama.chat(model="gemma3:4b", format="json",
                    messages=[{"role": "system", "content": SYSTEM_PROMPT},
                              {"role": "user", "content": user}])
    return json.loads(r["message"]["content"])

def demo_plan(location_info, crop, today):
    """Offline fallback so the app always runs. Clearly labeled in the UI."""
    fall = dt.date.fromisoformat(location_info["first_fall_frost"])
    spring = dt.date.fromisoformat(location_info["last_spring_frost"])
    t = dt.date.fromisoformat(today)
    if spring &lt;= t &lt;= fall:
        growing = True
    elif t &gt; fall:
        growing = False
    else:
        growing = (fall - t).days &lt; 120  # near fall, short window
    if growing:
        days_left = (fall - t).days
        return {
            "summary": f"Growing season is ON in {location_info['city']} — about {days_left} days until first frost.",
            "plant_now": [f"Fast-maturing {crop} (under {days_left} days to harvest)", "Succession sow greens every 2 weeks"],
            "wait_until": ["Long-season crops that won't mature before frost" if days_left &lt; 90 else "Nothing — full season available"],
            "tasks": ["Mulch to hold moisture", "Scout for pests in the cool mornings"],
            "why": "Demo mode: advice driven by the first fall frost date.",
        }
    return {
        "summary": f"Too cold to plant in {location_info['city']} right now.",
        "plant_now": ["Nothing outdoors", "Start seeds indoors 6-8 weeks before last frost"],
        "wait_until": [f"Transplant {crop} outdoors after {location_info['last_spring_frost']}"],
        "tasks": ["Plan beds", "Order seeds", "Compost leaves"],
        "why": "Demo mode: advice driven by the last spring frost date.",
    }

# ---------------- UI ----------------
st.title("🌱 Last Frost")
st.caption("Offline garden planner · open-weight Gemma 3, running locally · Hacktoberfest 2026")

zipcode = st.text_input("ZIP code", value="10001", max_chars=5)
crop = st.text_input("What do you want to grow?", value="kale and tomatoes")
today = st.date_input("Today's date", value=dt.date.today()).isoformat()

if st.button("What's my plan this week?", type="primary"):
    loc = lookup(zipcode)
    if not loc:
        st.error("ZIP not in the sample dataset — add it to frost_dates.csv.")
        st.stop()
    try:
        plan = ask_gemma(loc, crop, today)
        mode = "gemma"
    except Exception:
        plan = demo_plan(loc, crop, today)
        mode = "demo"
    if mode == "demo":
        st.warning("Ollama/Gemma not detected — showing DEMO plan. Run `ollama pull gemma3:4b` for real AI output.")
    st.success(plan["summary"])
    c1, c2 = st.columns(2)
    with c1:
        st.subheader("🌿 Plant now")
        for x in plan["plant_now"]: st.write("•", x)
    with c2:
        st.subheader("⏳ Wait until")
        for x in plan["wait_until"]: st.write("•", x)
    st.subheader("🛠 This week's tasks")
    for x in plan["tasks"]: st.write("•", x)
    st.info("Why: " + plan["why"])

frost_dates.csv holds frost dates per ZIP (10 sample US cities); requirements.txt is three lines (streamlit, pandas, ollama). Clone-by-copy works — that's the point of a 120-line app.

How I Built It

The open piece that makes this project work is Gemma 3, Google's open-weight model, running locally via Ollama — no API calls, no cloud, no account.

Prompt development in Google AI Studio. I started on Gemma 3 27B with a strict spec: a system prompt defining the JSON schema, six behavioral rules (e.g., "if days-to-first-frost < 60, only fast-maturing crops go in plant_now"), and four few-shot examples covering mid-season, pre-spring, post-frost, and long-season edge cases. I iterated against a 6-case test checklist — the make-or-break case being "pumpkins with 56 frost-free days left," where a correct model moves pumpkins to wait_until and admits in why that it can't mature in time.
Local inference with Ollama. Same prompt, smaller model: ollama pull gemma3:4b. The 4B runs comfortably on a laptop, stays fully offline, and returns structured JSON via Ollama's format="json" mode — the UI never parses prose.
The glue is ~12 lines of Python. A CSV lookup for frost dates, a date comparison, one ollama.chat() call. Streamlit renders the plan: summary, plant now, wait until, weekly tasks, and the "why" sentence citing the frost dates the model actually used.

Why Does Open Innovation Matter?

I could have built this in an afternoon on a closed API. It would have worked worse in every way that matters for this project:

It runs where gardening happens — with zero signal. Gardens and allotments have terrible wifi. Last Frost doesn't degrade offline; offline is its default state. A closed API can't do that without a phone plan.
It costs $0 to run, forever. No tokens, no meter, no rate limits. Ask it for a plan every week for a decade; the marginal cost is a few watt-hours.
Your data never leaves the device. Location and garden plans are processed locally — there's no server holding a map of who's growing what where.
The model is swappable infrastructure, not a dependency. One Ollama command swaps gemma3:4b ↔ gemma3:12b ↔ any future open model. If a Gemma version is ever deprecated, the project doesn't break — the weights are mine.

Open weights didn't just make this project cheaper. They made it possible in the environment it's designed for.

My Agent Session

I built Last Frost with an AI coding assistant (Kimi) acting as my pair programmer, and I want to show the process rather than just the result — this challenge is about open-source AI, and the session below is open-source AI doing real work.

The session, condensed:

Scoping. I dumped the challenge prompt and prize categories into the chat and asked for the easiest qualifying project. The assistant proposed Last Frost (garden planner, ZIP → frost dates → local LLM) with a difficulty comparison against the alternatives (bird-call ID, vision trail narrator) — which is why the build is text-only instead of an audio pipeline I couldn't finish in 4 days.
Spec engineering. I asked for "the entire spec to one-shot the model in Google AI Studio." What came back became my actual development artifact: a system prompt with 6 behavioral rules (the load-bearing one: "if days-to-first-frost < 60, only fast-maturing crops go in plant_now"), 4 few-shot examples covering mid-season / pre-spring / post-frost / long-season cases, and a 6-case test checklist.
The test that mattered. Case #5 — pumpkins with 56 frost-free days left. A model that says "plant pumpkins!" fails the whole point of the app. That's the case I iterated against in AI Studio until Gemma correctly moved pumpkins to wait_until and admitted in why that they can't mature in time. The assistant's framing ("if Gemma gets that right, your prompt is done") was my done-ness criterion.
Code generation with verification. The assistant generated the full app (Streamlit + Ollama + CSV lookup + demo fallback), then ran the core logic itself before handing it over — frost lookup for NYC and Chicago returned correct days-to-frost, unknown ZIPs were rejected. I ran the same checks locally.
The fallback decision. Demo mode when Ollama isn't running was the assistant's suggestion, not mine — and it's the difference between "broken on first run" and "testable UI on day one."

What I'd do differently: I should have saved the raw AI Studio chat (Gemma 27B iterations) as I went. The structured session above is reconstructed from notes; the real artifact would be better. Lesson for week 2: DevRelay from minute one.

Prize Categories

Best Use of Gemma — Gemma 3 (open weights) is the core of the project: developed on 27B in Google AI Studio, served locally via Ollama for offline use.