DEV Community: Kumar Saurav

PhantomLog: Turning Offline Smart Home Data into Local Ghost Stories

Kumar Saurav — Sat, 31 Oct 2026 07:14:15 +0000

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

What I Built

I built PhantomLog, an offline, haunted storyteller that turns your mundane smart home data into personalized, creepy ghost stories about what happened in your house while you were asleep.

I leaned heavily into the "things that go bump in the night" interpretation of the theme. Most of us have motion sensors, smart thermostats, and door contacts that silently log data 24/7. PhantomLog pulls the 12:00 AM to 6:00 AM sensor logs from a local Home Assistant instance, analyzes the sequence of events (e.g., a temperature drop followed by a hallway motion trigger), and uses a local LLM to weave a terrifying micro-fiction about the "ghost" wandering your halls

Demo

Here is a sample output generated on my dashboard when I woke up this morning:

The 3:14 AM Visitor

The house was dead quiet when the living room temperature inexplicably dropped by 3 degrees at 2:45 AM. Whatever it was, it didn't stay there. At 3:14 AM, the hallway motion sensor detected movement—slow, methodical, pacing toward the kitchen. It lingered by the fridge for exactly four minutes before the backdoor contact sensor registered a microscopic vibration. You were fast asleep, but your house knows it wasn't alone.

How I Built It

PhantomLog is built entirely on open-source, local AI infrastructure to ensure zero latency and complete privacy.

The Brain: I used Llama-3.1-8B-Instruct as the core narrative engine, heavily prompted to adopt a suspenseful, Gothic horror
The Engine: Inference is handled locally using Ollama, running bare-metal on my home lab server.
The Harness: I used LangChain in Python to build the agent workflow. The script queries the Home Assistant SQLite database, filters out baseline noise, formats the raw timestamps and sensor names into a readable context window, and feeds it to the local model.

Why Does Open Innovation Matter?

Open innovation is the only reason this project can exist safely. Smart home data is arguably the most intimate digital footprint we have—it maps our sleep schedules, our floor plans, and when we are vulnerable.

Sending a nightly dump of my family's movement patterns and door lock statuses to a closed, cloud-based API just to generate a fun Halloween story would be a massive privacy violation. By using an open-weight model like Llama 3 running through Ollama, PhantomLog works entirely offline. The "ghost" stays on my local network, the data never touches a server I don't control, and it costs exactly zero dollars in API credits to run every single morning.

The Spirit of It

The moment this project truly landed for me was during a test run two nights ago. I woke up, checked the PhantomLog dashboard, and read a genuinely chilling story about "something pacing frantically at the bottom of the basement stairs at 4:12 AM."

I actually got goosebumps and went to check the basement—only to realize my cat's litter box is down there, and she had the 4 AM zoomies. It turned a completely invisible piece of data into a memorable, spooky morning ritual that perfectly captures the Halloween spirit.

I Built a tool to generate podcast of any place we visit.

Kumar Saurav — Sat, 10 Oct 2026 12:51:44 +0000

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

What I Built

My friend loves hiking near our town in Himachal Pradesh. He dislikes staring at a screen to identify local plants or birds. I built TrailTale to solve this problem. TrailTale is a web application that creates hyper-local audio podcasts. A user types a location into the browser. The application searches the internet for real-time data about local wildlife, geology, and native plants. It writes a short documentary script and converts that text into an audio file. My friend can put her device away and listen to facts about the ground beneath her feet.

Demo

trail-tales-lake.vercel.app

Code

Saurav10codes / TrailTales

Hyper-Local Ecosystem Podcast Generator

A stateless web app that generates personalized audio podcasts about local flora, fauna, and geology based on your location.

Architecture

/server - Node.js/Express backend with TypeScript
/client - Vite + React frontend with neo-brutalism UI

Setup

Prerequisites

Node.js 18+
API keys for: SerpApi, LLM provider (Groq/DigitalOcean)

Environment Variables

Copy the example env file:

cp server/.env.example server/.env

Fill in your API keys in server/.env:

SERPAPI_KEY - Get from serpapi.com
LLM_API_KEY - Your LLM provider API key
LLM_ENDPOINT - LLM API endpoint (defaults to Groq)

Installation

# Install server dependencies
cd server && npm install

# Install client dependencies  
cd ../client && npm install

Running the App

Terminal 1 (Server):

cd server && npm run dev

Terminal 2 (Client):

cd client && npm run dev

The app will be available at:

Frontend: http://localhost:5173
Backend: http://localhost:3000

How It Works

User enters a location
Server searches for local ecosystem…

View on GitHub

How I Built It

I built a stateless architecture using Node.js and React. The frontend uses a bold yellow design. The backend relies on an open-source pipeline.

SerpApi runs three concurrent web searches for wildlife, geology, and plant data.
The backend sends this data to the Groq API running the open-weight Llama 3.3 70B model.
The model writes a 300-word conversational script about the specific location.
The system passes the text to Transformers.js.
Transformers.js runs the Xenova/speecht5_tts model locally on the server to generate a WAV audio file.

The system returns the audio buffer to the frontend audio player. The process takes roughly 20 seconds.

Why Does Open Innovation Matter?

Open models made this project possible and affordable. The system generates high-quality text using Llama 3.3 without expensive proprietary fees. Transformers.js runs the text-to-speech conversion locally on the server. A closed text-to-speech API charges per character. The open-source model allows TrailTale to generate infinite audio for free. Developers can host this application anywhere and run the models directly on their own hardware. This keeps user location data private and reduces reliance on paid services.

Prize Categories

Best Use of SerpApi

I built a platform for my grandma (and others) so that they can upload their voice notes for a recipe and get a structured recipe

Kumar Saurav — Sun, 04 Oct 2026 19:33:57 +0000

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

What I Built

I built the Grandma Recipes web application to organize my family history. This software converts spoken voice recordings into structured Markdown documents. I designed this project specifically for my mother. She wants to record and preserve her old family recipes. She speaks the instructions directly into her phone. The application processes the audio and creates a clean text file. My mother no longer loses her scattered audio notes.

Demo

You can view the live application through the provided link. The visual interface uses a neo-brutalism design style. It features bold borders and bright yellow accents.
Link

Code

Saurav10codes / grandma-recipes

Made for HacktoberFest Challenge 1

Grandma Recipes 🍲

Speak a recipe → get it transcribed and formatted as Markdown. Runs 100% locally.

Stack

Whisper tiny (faster-whisper, CPU int8) — auto-downloads on first run (~75 MB)
Ollama locally for full offline mode
FastAPI backend
React + Vite frontend (neo-brutalism UI)

Prerequisites

Python 3.9+
Node.js 18+
FFmpeg: sudo apt install ffmpeg

For local mode (no API calls):

Ollama installed and running (ollama serve)

Run Locally

Backend

# Make sure Ollama is running: ollama serve

cd  backend

pip  install  -r  requirements.txt

uvicorn  main:app  --reload

Frontend

cd  frontend

npm  install

npm  run  dev

Open http://localhost:5173

Features

🎙 Live recording — click Record, speak, click Stop
📁 File upload — drag & drop or select audio files
📝 Auto-formatting — converts speech to structured Markdown recipes
🎨 Neo-brutalism UI — bold, minimalist design
🚀 100% local (optional) — no data leaves your machine

How it works

Record…

View on GitHub

How I Built It

The frontend architecture uses React and Vite. The backend relies on FastAPI written in Python. I chose the Whisper tiny model for audio transcription. This specific model runs locally on the server CPU. The application converts the browser audio files using ffmpeg. A large language model formats the resulting text into a recipe. I created two different modes for the backend system. One mode connects to the Groq API on a free tier. The alternative mode runs the Ollama software locally. This local mode powers the qwen2.5:1.5b open-weight model.

Why Does Open Innovation Matter?

Open innovation directly protects user privacy. Voice recordings represent deeply personal family data. A closed API sends this sensitive information to unknown corporate servers. My application transcribes the audio locally using open-weight models. Users keep total control of their private family memories. Open models perform exceptionally well on cheap hardware. The Whisper tiny model requires very little system memory. This tiny footprint makes the tool entirely free to host.

Prize Categories

I am entering the Best Use of Render prize category. I deployed the entire application using Render free tiers. The React frontend runs smoothly on a static site. The FastAPI backend operates inside a Docker web service.