DEV Community: Aditya Mishra

SlothChat

Aditya Mishra — Tue, 20 Oct 2026 12:17:14 +0000

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

What I Built

SlothChat is an automated, local AI agent designed to embrace absolute laziness. Instead of spending 20 minutes every morning scrolling through hundreds of chaotic, missed unread messages across various group chats (Slack, Discord, and WhatsApp), SlothChat handles the filtering for you.
Running silently in the background overnight, it aggregates message histories, extracts key context, eliminates noise (like memes or small talk), and generates a strict two-sentence morning digest featuring actionable highlights and direct mentions. It saves community managers, developers, and casual users from text fatigue, letting them catch up on hours of conversation in less than five seconds.

Demo

You can view the functional application and its interactive dashboard live here:
👉 Live Deployment: https://slothchat-digest.tech
(Note: The dashboard showcases an interactive timeline view of generated daily summaries alongside real-time pipeline status checks.)

Code

The complete codebase, configurations, and environment setups are fully open-source and hosted on GitHub:
👉 GitHub Repository: github.com
bash

Quickstart Installation

git clone https://github.com
cd slothchat-agent
npm install
ollama run gemma2
npm run dev
Use code with caution.

How I Built It

SlothChat is engineered entirely around a robust open-source AI and automation architecture:
• Core LLM: I utilized Gemma 2 (9B) running completely locally via Ollama. It handles all semantic parsing and text summarization without sending text data to external third-party services.
• Agent Framework: Built using the Mastra framework to orchestrate the internal tool layout, schedule the cron schedules, and route message payloads seamlessly to the local model.
• Durable Orchestration: The collection, formatting, and delivery pipelines are wrapped inside a Temporal workflow. This guarantees that if a local machine loses network connectivity or restarts overnight, the agent automatically retries the tool calls and resumes exactly where it left off without losing state.
• Data & Memory Layer: Message logs, conversational context vectors, and historical digests are managed using MongoDB Atlas via Atlas Vector Search to keep an optimized local window index.
• Telemetry: Instrumented using Sentry Agent Tracing to carefully monitor pipeline performance, pipeline exceptions, token counts, and execution latency.

Why Does Open Innovation Matter?

Open innovation is the absolute foundation of SlothChat. Building this on a closed-source API ecosystem would pose severe roadblocks:

Absolute Privacy: Group chats contain private conversations, proprietary code, and sensitive personal information. Passing thousands of daily chat logs to a closed API vendor raises major privacy concerns. Running Gemma locally ensures that every single byte of message history stays entirely on local storage.
Predictable Cost-Efficiency: Parsing thousands of messages every single night would quickly rack up massive token bills on paid closed APIs. Leveraging open-weight models means the system scales effortlessly, running continuously for zero operational API costs.
Local Offline Resiliency: Because the core compilation engine operates directly on-device, the parsing engine functions even without an active internet connection, providing true computing autonomy.

My Agent Session

To see how the agent reasons through raw chat data, filters out chatter, and maps messages to structural summaries, you can inspect the full execution logs here:
👉 DevRelay Agent Session Link: devrelay.ai

The Lazy Payoff

SlothChat turns grueling catch-up routines into an instant glance. During testing this week, the agent processed 412 missed unread messages across three active Discord servers overnight.
Instead of spending an average of 18 minutes wading through backlogged chatter, the agent delivered a clean, accurate 2-sentence summary right at 8:00 AM:
"The engineering team decided to delay the beta release until Thursday due to a caching bug found in the API layer. Action Required: @developer needs to review the updated PR #402 on GitHub before the afternoon standup."
Total time saved: ~17 minutes per day, scaling up to nearly 2 hours of focus time saved every single week.

Prize Categories

This project is entering the following specific partner categories:
• Best Use of Gemma: Utilizes the Gemma 2 open-weight model running locally via Ollama for private token processing.
• Best Use of Mastra: Uses Mastra to build, structure, and orchestrate the core agent workflows and tools.
• Best Use of Temporal: Wraps the background chat parsing ingestion inside durable workflows to survive failures and handle state retries gracefully.
• Best Use of MongoDB Atlas: Employs MongoDB Atlas as the primary data and vector memory layer for active message log indexing.
• Best Use of Sentry Agent Tracing: Implements detailed tracing to track latency performance and debug token operational overhead.
• Best Use of a .tech Domain: Deployed live on a custom .tech domain registered specifically for the challenge.

VoxCommerce: Multi-Modal AI for Resellers

Aditya Mishra — Tue, 13 Oct 2026 06:28:01 +0000

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

What I Built

I built VoxCommerce, a hands-free, voice-to-listing multi-modal platform built specifically for micro-retailers, Etsy crafters, and eBay flippers who struggle with manual data entry or suffer from physical or visual impairments.
Instead of spending 20 minutes typing out SEO keywords, sizing details, and formatting text for a single item, a seller simply snaps a few photos and speaks naturally about their product ("Hey, this is a hand-knitted vintage-style teal cardigan, super chunky wool, size medium, slight fraying on the left cuff..."). VoxCommerce instantly blends the audio narrative with the visual data to output highly optimized, marketplace-ready titles, descriptions, pricing suggestions, and search tags.

Who Would Pay For It?

Independent side-hustlers and full-time vintage resellers who manage high volumes of unique inventory. For these sellers, time is literally money. They would gladly pay a subscription fee ($15–$25/month) for a tool that reduces their listing time from minutes to seconds, turning their physical inventory backlog into live storefront cash flow.

Demo

✨ Live App: https://voxcommerce.tech
📺 Video Walkthrough: [Link to your Loom/YouTube demonstration video showing the image upload, voice processing, and final generated marketplace text]

Code

The complete open-source codebase, including the frontend UI and the backend multi-modal inference pipeline, is hosted on GitHub:

How I Built It

VoxCommerce is engineered entirely around an open-source, multi-modal AI stack designed to minimize API dependencies and maintain extreme architectural agility.
• Architecture Flow: The user interacting with the React Frontend (hosted on Render via a .tech Domain) uploads an image and audio file. This media bundle hits our FastAPI Backend running inside a Dockerized container hosted on a DigitalOcean GPU Droplet. Audio Transcription is handled via the ElevenLabs API, and the text transcription along with the image is passed directly to an instance of Gemma Vision running locally via Ollama/vLLM for final e-commerce generation.
• The Brain (Open-Weight Model): I deployed Gemma (using the vision-capable weights) via an optimized local inference engine (Ollama/vLLM) running on the backend. It takes the structured transcription alongside the raw images to extract visual characteristics (color, condition, texture) that the user might have forgotten to mention in their audio clip.
• The Ears: I integrated ElevenLabs to handle the speech-to-text processing, flawlessly converting messy, conversational, multi-dialect audio into high-fidelity text streams for our context window.
• The Cloud Pipeline: The frontend React application is securely deployed on Render. The heavy-lifting backend pipeline runs inside a Dockerized container on a DigitalOcean GPU Droplet, ensuring sub-second inference token generation.

Why Does Open Innovation Matter?

Open innovation isn't just a design choice for VoxCommerce—it is the foundational reason the business model works.

Marginal Cost to Zero: Relying on commercial, closed-source multi-modal APIs forces a predictable, linear cost per API call. For a high-volume seller uploading 500 items a month with multiple high-res photos, commercial API bills eat up the software profit margins entirely. By running an open-weight model like Gemma on dedicated architecture, our cost-per-listing drops asymptotically to zero as usage scales.
Niche Fine-Tuning Capability: Closed-source models are tuned to general-purpose assistant tasks. Because Gemma is open, I can easily fine-tune the model parameters on historical, high-performing e-commerce metadata (such as top-converting eBay headers or fashion-specific taxonomy) to output far superior copy than a generic corporate API can generate out of the box.
No Vendor Lock-In: We aren't vulnerable to sudden pricing changes, tier limitations, or sudden deprecations from corporate platform providers. We own our intelligence engine.

My Agent Session

I used DevRelay to log and map out the orchestration sessions while debugging the asynchronous audio/video data matching pipeline. You can review the complete development process here:
[Link to your DevRelay Agent Session]

My First User

To validate the "Side Hustle" commercial viability, I put a beta version of VoxCommerce in front of Sarah, a local vintage clothing vendor who runs an online Depop and Etsy store.
• What she did: She tested it live with a batch of 5 vintage sweaters.
• What she said: "Usually, doing descriptions makes me want to pull my hair out because I hate typing on my phone while measuring garments. I just spoke out loud while measuring the sleeves, and the app spit out a listing that looked better than what I write."
• Did she pay? She offered to pay $20 on the spot to keep access to the beta link for the rest of October, proving direct commercial validation!

Prize Categories

I am proudly entering VoxCommerce into the following Hacktoberfest challenge prize categories:
• Best Use of Gemma: For utilizing Google's open-weight model to orchestrate multi-modal listing logic.
• Best Use of DigitalOcean: For hosting our core AI models and inference pipeline on a GPU Droplet.
• Best Use of Render: For hosting our user-facing front-end client.
• Best Use of ElevenLabs: For processing fluid, conversational marketplace audio narratives into accurate data text.
• Best Use of a .tech Domain: For putting our live app production build on voxcommerce.tech.

FrostFlow AI

Aditya Mishra — Sat, 10 Oct 2026 16:20:14 +0000

FrostFlow AI: Helping Developers Touch Grass and Plant Seeds

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

What I Built

FrostFlow AI is a hyper-local, privacy-first garden assistant designed to pull developers away from their monitors and get their hands into real soil.
Most gardening apps rely on generic, static ZIP code tables that don't account for actual weather shifts. FrostFlow AI bridges this gap. It instantly tracks your real-time local weather forecast and cross-references it with your regional frost timeline. Instead of giving you a massive, overwhelming PDF guide, it uses an open-weight AI model to generate a bite-sized, actionable "Touch Grass Checklist" tailored precisely to your weekend. It tells you exactly what to direct-sow, what to transplant, and what physical prep work your soil needs right now.

Demo

You can try the live application here: [Deployed Link Here]
Watch the quick 1-minute video walk-through showing how a shifting weather forecast changes your weekend outdoor tasks: [Video/GIF Link Here]

Code

The entire project is completely open-source. Check out the repository, run it locally, or contribute:

How I Built It

I wanted this app to be fast, free to run, and entirely independent of restrictive cloud AI ecosystems.

The AI Core: I chose Llama 3.1 8B running locally via Ollama. It is lightweight enough to run smoothly on a standard laptop, eliminating the need for expensive API tokens.
The Data Pipeline: I used the Open-Meteo API to fetch real-time 7-day weather forecasts and historical frost trends based on latitude and longitude without requiring any API keys.
The Orchestration: Built with Node.js/Python, the app injects live meteorological data into a structured system prompt.

Instead of treating the LLM like a generic chatbot, it acts as a precise data translator. The system feeds the current date, the days remaining until the first local frost, and the upcoming weekly temperature lows directly to Llama 3.1. The model then dynamically calculates biological safety windows for plants and structures them into clean JSON to render your custom weekend dashboard.

// A look at the dynamic prompt matrix feeding our open modelconst systemPrompt = `
You are an expert local agronomist. Today's date is ${currentDate}.
The user's estimated first autumn frost date is ${frostDate} (${daysToFrost} days away).
The upcoming 7-day forecast shows a low of ${lowTemp}°C and a high of ${highTemp}°C.

Determine exactly what seeds should be sown indoors, transplanted, or direct-seeded outdoors THIS WEEK.
Provide 3 immediate, physical outdoor tasks for this weekend to get the user away from their screen.
`;

Why Does Open Innovation Matter?

Open innovation completely changes how we build tools for the physical world.
If I had built FrostFlow AI using a closed, proprietary API, the application would instantly be tethered to a corporate life support system. The moment token prices shift or an API endpoint changes, a free community tool becomes unsustainable.
By combining open-weight models like Llama 3.1 with open-data initiatives like Open-Meteo, we can build tools that belong truly to the public. Community gardens, urban homesteaders, and schools can run this application entirely offline on a Raspberry Pi or an old laptop. Open innovation ensures that technology remains accessible, private, and deeply connected to local communities—democratizing precision agriculture for the dirt under our actual fingernails.

My Agent Session

You can view the full development, prompt tuning, and architectural building process in my recorded session here: [DevRelay Session Link]

Prize Categories

I am entering FrostFlow AI into the following categories:

Grand Prize Winner
Best Use of Local Inference (Ollama Track)

Reading Between the Lines: An Accessible Auditory Document Explainer for My Parents Built via Gemma and ElevenLabs

Aditya Mishra — Mon, 05 Oct 2026 06:56:42 +0000

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

What I Built

I designed a localized auditory accessibility bridge tailored specifically for my aging parents. As critical banking statements, medical updates, and official household notices increasingly transition to dense digital document portals, my parents face heavy eye strain and cognitive fatigue trying to decipher microscopic font styles and legal jargon.

This project strips away structural formatting clutter, aggregates dense notification data, and uses a local pipeline to transform complex bureaucratic letters into comforting, beautifully paced vocal explanations that they can listen to hands-free.

Demo

The prototype operates via a streamlined text-to-vocal compilation layout. Written notification blocks are cleanly processed through generative formatting scripts, turning intimidating terms into a smooth audio track. The final clear speech track was rendered as an MP3 file and delivered straight to my family's communication channels.

Code

The modular architecture utilizes a text preprocessing wrapper that structures raw document lines before transmitting them to a dedicated vocal rendering endpoint:

import os

def format_document_for_parents(raw_bureaucratic_text):
    """
    Simulating a local Gemma-7b step that simplifies dense terms 
    into conversational, clear sentences before vocal synthesis.
    """
    conversational_summary = f"Hey Mom and Dad, here is a clear breakdown of your update: {raw_bureaucratic_text}"
    return conversational_summary

How I Built It

The foundational logic maps clean textual data via localized preprocessing rules designed around open innovation concepts, which then routes the clean text blocks directly to the ElevenLabs Text-to-Speech API workspace.

By utilizing advanced narrative models, the system completely bypasses the cold, choppy, and robotic cadence of traditional computer accessibility readers. It meticulously controls structural pacing and pauses around dense punctuation markers, creating a natural voice track that sounds exactly like an expert family friend explaining a notice over the kitchen table.

Why Does Open Innovation Matter?

When handling sensitive personal data—such as parental financial updates, insurance modifications, or medical notices—absolute information privacy is non-negotiable.

Relying on open-weight local infrastructure (like Gemma) means that the processing of intimate household documents can happen entirely on a laptop with zero internet, preventing private family details from being sent to external databases. This architecture ensures our family records are never harvested for advertising profiles, locked behind commercial paywalls, or fed into closed corporate algorithms.

Prize Categories

Best Use of ElevenLabs