DEV Community: Om Gedam

ChatDigest: An Overnight Local Agent that Reads Group Chats While You Sleep

Om Gedam — Sun, 25 Oct 2026 06:46:59 +0000

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

What I Built

I built ChatDigest, an entirely local, privacy-first AI agent that reads exported WhatsApp group chats overnight and hands you a strict, two-line summary every morning.

It saves you from the exhausting task of scrolling through 100+ unread messages just to figure out what actually happened and what you need to do today. If you want to wake up, read exactly two sentences, and know if you need to reply to anyone, this app lets you be a little lazier.

Demo

Here is an example of what the agent generates and writes to my laptop's hard drive every morning at 7:00 AM:

=== Morning briefing (10 msgs, gemma3:4b) ===
Dinner time shifted to 7:30 PM for everyone.
Priya: Get the receipt, Arun: Provide deposit receipt now.

Code

itsomg134 / chat-digest

A local overnight group-chat summarizer powered by Gemma 3 and Ollama. Built for Hacktoberfest.

ChatDigest: Overnight Local Group-Chat Summarizer

ChatDigest is a fully local, privacy-first AI agent that reads your group chat exports while you sleep and hands you a strict, two-line summary every morning. No cloud APIs, no data leaks—just you, your laptop, and Google's Gemma running entirely offline.

Built for Hacktoberfest 2026.

Features

100% Offline & Private: Uses Ollama to run gemma3:4b locally. Your sensitive group chats never leave your machine.
Two-Pass Map-Reduce Pipeline:
1. Condense: Compresses large chat logs into terse bullet points (decisions, action items, deadlines).
2. Finalize: Enforces a strict JSON output to generate exactly two lines—what happened, and what you need to do.
Deduplication Database: Uses SQLite to ingest WhatsApp .txt or .jsonl exports, ensuring you never process the same message twice.
Zero-Dependency Scheduler: Includes a lightweight Python scheduler that stays resident and fires the briefing at your chosen time (e.g., 07:00).

Quick Start

1. Prerequisites

Python 3.10+
Ollama…

View on GitHub

How I Built It

ChatDigest is built in Python and relies entirely on open-source AI and local inference. The core of the project is Gemma (gemma3:4b), running locally via Ollama.

Here is the workflow:

Ingest: The script reads WhatsApp .txt exports from a local folder, parses the timestamps, and hashes them into a SQLite database so it never processes the same message twice.

Map-Reduce Pipeline: It grabs the last 12 hours of messages and uses Ollama to call Gemma. Pass 1 condenses the chunks into terse bullet points like action items, deadlines. Pass 2 feeds those bullets back to Gemma with a strict JSON prompt to generate the final two-line output.

Schedule: A lightweight Python script sleeps until 07:00 AM local time, fires the digest, saves it to a text file, and goes back to sleep.

Why Does Open Innovation Matter?

Open innovation was a hard requirement for this project, not just a preference.

Absolute Data Privacy: Group chats contain highly sensitive personal data, addresses, and proprietary work decisions. Sending this to a closed cloud API is a massive privacy violation. Because I am running Gemma locally, the data never leaves my laptop. It is 100% offline.
Zero Marginal Cost: Because inference runs locally on my machine, the cost is exactly $0.00. A closed API would charge me every single night to summarize hundreds of messages. Open weights let me run this automation infinitely without a monthly bill.
The Freedom to Swap: Because Ollama acts as a standardized local runtime, I could easily swap from gemma3:1b for speed to gemma3:4b for better reasoning by changing a single line in my config.yaml. You cannot do that on a closed, hosted API.
Offline Resilience: Sloths don't worry about internet outages. If my Wi-Fi goes down at 2:00 AM, ChatDigest doesn't care. The stack (Python + SQLite + Ollama + Gemma) is entirely self-contained

The Lazy Payoff

I set this up once. I never pay for it, I never worry about API rate limits, and I never have to scroll through hundreds of messages again. It is the ultimate "set it and forget it" automation. I wake up, read two lines, and get on with my day.

Prize Categories

Best Use of Gemma, The entire summarization logic from the chunking condensing to the strict JSON formatting is powered entirely by the open weight gemma3:4b model running locally via Ollama.

ListLens Turn product photos into polished Etsy & eBay listings with open-weight AI

Om Gedam — Thu, 15 Oct 2026 23:41:55 +0000

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

What I Built

ListLens is an AI listing writer for Etsy and eBay sellers. Upload 1–8 product photos, and it writes a full listing — title, description, tags, and category — optimized for the platform you're selling on.

Who pays for it: Casual sellers and side-hustlers who list 5–50 items a month. Writing good listings is tedious: keyword research, tag limits, platform-specific tone, honest condition descriptions. Most sellers either skip it (and lose visibility) or spend 15–20 minutes per listing. ListLens cuts that to ~15 seconds.

The problem it solves: Etsy lives or dies on SEO. eBay lives or dies on title keywords. But writing either well is a skill most makers and resellers don't have time to build. ListLens handles the boring part so they can focus on sourcing and photographing.

Demo

vercel.com

Code

itsomg134 / ListLens

🔍 ListLens

Turn a few product photos into polished Etsy & eBay listings in seconds.

Live Demo · Report Bug · Request Feature

📸 What is ListLens?

ListLens is an AI listing writer for Etsy and eBay sellers. Upload 1–8 product photos, and it generates a complete, platform-optimized listing — title, description, tags, and category — in about 15 seconds.

Writing good listings is tedious. Etsy lives or dies on SEO tags. eBay lives or dies on title keywords. Most makers and resellers either skip it (and lose visibility) or spend 15–20 minutes per item. ListLens handles the boring part so you can focus on sourcing and photographing.

✨ Features

📷 Multi-photo upload — drag-and-drop up to 8 images, auto-resized to 1024px to cut token cost
🎯 Platform-aware — tuned for Etsy, eBay, Shopify, and Depop
🎨 Tone selection — Friendly, Minimal, Vintage, or Luxury
🧠 Two-stage AI pipeline —…

View on GitHub

How I Built It

Stack: Next.js 15 (App Router), Tailwind CSS, deployed on Vercel.

The AI — fully open-weight:

I deliberately chose open-weight models over closed APIs because listing copy is a commodity task. It doesn't need frontier reasoning — it needs to be fast, cheap, and consistent. Running on open weights means I can:

Host the whole thing on Groq's free tier while I validate product-market fit

Swap models without rewriting the app (I prototyped on GPT-4o, then dropped in Llama 3.2 Vision in ~30 minutes of refactoring)

Let users self-host later if they want — the app is a thin wrapper around a prompt

The pipeline:

Vision pass — llama-3.2-90b-vision-preview receives up to 8 images and returns JSON attributes. The prompt is strictly constrained: "Only describe what is CLEARLY VISIBLE. Never invent brands, materials, or origins." This matters — vision models hallucinate details that get sellers in trouble with platform authenticity rules.

Copy pass — llama-3.3-70b-versatile takes those attributes plus platform + tone and returns a structured listing (title, description, tags array, category, SEO description). Response format is forced to JSON so the frontend can render individual fields cleanly.

Client-side image resize — every upload is downscaled to max 1024px via canvas before hitting the API. This cuts vision tokens by ~70% and keeps requests under 2 seconds.

Why two model calls instead of one: Separating "read the photo" from "write the copy" lets me tune each independently. When I noticed the vision model inventing leather textures, I tightened only that prompt — the writer prompt stayed stable. It's also cheaper: the vision call is the expensive one, and it never regenerates.

Frontend: Next.js with a two-column layout (controls left, output right), drag-and-drop upload, pill-style platform/tone selectors, loading skeletons, and per-field copy buttons. Full dark mode. Everything Tailwind, no component library.

Why Does Open Innovation Matter?

Two reasons, one practical and one philosophical.

Practical: Listing writers are a long-tail product. The market isn't 100,000 sellers — it's millions of tiny sellers who'd pay $5–10/month. At those margins, per-token API costs kill you. Open-weight models on Groq or Together let me offer a free tier and still have room to charge. A closed-API-only version of this product can't exist profitably at the bottom of the market.

Philosophical: The prompts are the product. If listing copy is generated by a closed model, and the prompts are the only differentiator, then every competitor is one good reverse-engineering away from cloning me. With open weights, I can fine-tune on my own seller data, run on my own hardware, and eventually let sellers self-host with their own listings baked in. That's a moat a closed API can't give me.

The challenge framing asked why open innovation matters "for what you built" — the honest answer is that open weights are what make a tiny-margin side-hustle tool economically viable at all.

My Agent Session

Groq

LifeLink 360: A Patient Practice Partner for a Friend Learning a New Language

Om Gedam — Mon, 05 Oct 2026 17:42:17 +0000

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

What I Built

LifeLink 360 is an assistive communication web app designed for patients with severe motor impairments (such as ALS, locked-in syndrome, or post-stroke recovery).

I built this for my friend [Friend's Name], who is a patient care partner. We realized that patients who cannot speak or move their hands often struggle to communicate basic needs like "I need water," "I am in pain," or "Yes/No." Traditional eye-tracking hardware is expensive, bulky, and inaccessible to many families.

LifeLink 360 solves this by turning any standard laptop or tablet webcam into a powerful communication device. Using 16 specific eye-blink patterns (single, double, triple, long blink), the patient can trigger pre-set phrases. The app then uses AI to generate a compassionate, contextual response and speaks it out loud using the Web Speech API.

It gives the patient a voice, and it gives the caregiver peace of mind.

Demo

lifelink-eight-indol.vercel.app

Code

itsomg134 / LifeLink-360

LifeLink-360

View on GitHub

How I Built It

This project was built using a modern, open-source AI stack combined with cloud infrastructure:

Computer Vision (Frontend): I used MediaPipe Face Mesh (an open-source framework from Google) running directly in the browser. It tracks 468 facial landmarks in real-time. I calculated the Eye Aspect Ratio (EAR) to determine if the eye is open or closed, and used timing logic to distinguish between short blinks, long blinks, and gaze direction.

AI Agent (Backboard.io): I integrated the Backboard.io API as the "brain" of the application. When a patient blinks a pattern (e.g., 3 blinks = "Yes, please"), the frontend sends this to Backboard. The LLM (GPT-4o) processes the request using a specialized System Prompt designed for empathy and brevity, and returns a natural language response.

Backend & Hosting (DigitalOcean): I built a lightweight Node.js/Express backend to securely handle API keys and serve the static frontend. I deployed the entire application on the DigitalOcean App Platform, which provides automatic HTTPS, global CDN distribution, and seamless scaling. The backend is currently running on a basic Droplet, but the architecture is ready to scale to a DigitalOcean GPU Droplet to run open-weight models (like Llama 3) locally for 100% private, HIPAA-compliant inference.

Audio Output: The app uses the browser's native SpeechSynthesis API to read the AI's response out loud, ensuring the patient and caregiver can both hear the communication.

Why Does Open Innovation Matter?

Open innovation is the only reason this project exists.

Accessibility: Closed, proprietary eye-tracking hardware can cost thousands of dollars. By using MediaPipe (open-source) and standard webcams, I made this tool accessible to anyone with a laptop.

Customization: Because we used open frameworks, a caregiver can easily tweak the BLINK_THRESHOLD in the code to match the specific eye shape and fatigue level of their patient. You cannot do that with a black-box medical device.

Privacy & Local Inference: The future of this project involves deploying open-weight models on a DigitalOcean GPU Droplet. This means patient data never has to leave the home. Open innovation allows us to build medical tools that are both intelligent and private.

My Agent Session

I built this primarily using Backboard.io's API

Prize Categories

We are entering the following partner categories:

Best Use of DigitalOcean: For hosting the Node.js backend on App Platform and preparing the architecture for GPU Droplet inference to run open-weight models privately.

Best Use of Backboard.io: For using their API to handle the contextual, patient language tutor layer that powers the conversation.

Team Submissions:

This project was built by:

@omgedam123098
@niradari0614

hi D

Om Gedam — Sun, 04 Oct 2026 10:00:49 +0000