DEV Community: Priyesh Dabre

🦥 Sloth Mode: A Local AI Assistant That Does the Boring Work for You

Priyesh Dabre — Sun, 25 Oct 2026 14:39:13 +0000

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

What I Built

Meet Sloth Mode — a local-first AI document assistant designed for people who want to spend less time dealing with information and more time doing things they actually enjoy.

We all have documents, meeting notes, and random text files that take time to read and organize. Sloth Mode helps reduce that effort by turning lengthy text documents into concise, useful summaries.

With Sloth Mode, you can:

📄 Select a text document from your local documents folder.
🧠 Generate an AI-powered summary with important points, decisions, and action items.
🖥️ Use a simple browser-based interface built with Streamlit.
⬇️ Download the generated summary for later use.
The goal is simple: let AI handle the repetitive reading so you don't have to.

Code

GitHub repository: [https://github.com/priyeshdabre07/sloth-mode]

The project is built with Python and is designed to be easy to run and modify.

Repository contents:

ui.py — Streamlit user interface.
app.py — command-line document summarizer.
documents/ — sample text documents for testing.

How I Built It

I built Sloth Mode using a small, local AI stack:

Python — application logic and document processing.
Streamlit — browser-based user interface.
Ollama — local model runtime and inference API.
Qwen 2.5 3B — the open-weight language model that generates summaries. The application reads text files from a local folder, sends their contents to the Ollama service running on my Mac, and displays the model's response in the browser.

The workflow is straightforward:

Choose a text document.
Send its contents to the locally running model.
Generate a concise summary with important points and action items.
Display and download the result.

Why Does Open Innovation Matter?

For Sloth Mode, open-weight AI makes local, private-by-design document assistance possible without depending on a proprietary cloud AI API.

Privacy and control: Documents can be processed on my own computer instead of being uploaded to an external AI provider.

Offline potential: Once the model and software dependencies are installed, the core inference workflow can run without an internet connection.

No per-request API fees: Local inference avoids usage-based charges from a hosted model API, although it still uses electricity and computer resources.

Freedom to experiment: I can change the model, modify prompts, adjust the summarization workflow, and extend the application without being locked into one proprietary AI endpoint.

LocalAI Invoice Copilot: A Private Invoice Clerk for Freelancers

Priyesh Dabre — Sun, 18 Oct 2026 15:49:14 +0000

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

What I Built
LocalAI Invoice Copilot turns text-based PDF invoices into structured records that freelancers and small businesses can review and export as CSV. It extracts details such as vendor, invoice number, date, tax, and total, then flags missing fields, possible duplicates, and totals that do not add up.

The people most likely to pay for it are freelancers and small teams who are tired of manually copying invoice details into spreadsheets, but don’t want to send financial documents to a hosted AI service.

It’s a prototype: records are kept in memory, and extracted values should be reviewed before use.

Demo
There’s no hosted demo yet. The app runs locally, which is also how the invoice text stays on your machine.

Install Ollama and download the model with ollama pull qwen2.5:3b.
Install the Python dependencies with pip install -r requirements.txt.
Start the app with python -m streamlit run app.py.
Load the synthetic demo invoice or upload a text-based PDF, review the extracted fields, and download the CSV.
Scanned PDFs are not supported in the app yet; they need OCR.

Code
Source code: [https://github.com/priyeshdabre07/localai-invoice-copilot]

The app uses pypdf to read PDF text, asks the local model for structured JSON, and provides an editable review table with basic validation before CSV export.

How I Built It
The app is built with Python and Streamlit. It sends invoice text to Qwen2.5 3B through Ollama’s local API, using a JSON schema and a prompt that tells the model to leave uncertain fields blank rather than invent values. pypdf extracts selectable text from PDFs, and pandas handles the review table and CSV export.

Why Does Open Innovation Matter?
Invoices contain financial and business information that freelancers may not want to send to a third-party AI service. With local inference, invoice text stays on the user’s machine instead of going to a hosted LLM API. After downloading the model, there’s no per-invoice API fee; the tradeoff is that inference uses the user’s own hardware.

Using an open-weight model also makes the extraction prompt and expected fields easy to inspect and adapt to different workflows.

Prize Categories
Entering the overall Side Hustle challenge. No partner category.

#devchallenge #hf26challenge

Building a tiny choose-your-own-adventure with vanilla JavaScript

Priyesh Dabre — Fri, 16 Oct 2026 06:44:55 +0000

I wanted to build a small adventure game that felt like stepping into a story: a moonlit forest, a few meaningful choices, and more than one way for the journey to end.

Mosslight is a browser game where you explore the woods, collect a few items, and search for the moon bell. Play it here. It’s built with plain HTML, CSS, and JavaScript—no framework, build step, or package dependencies.

Put the story in data

Each scene is an object with its own text and choices. A choice can move the story forward, add an item, or change the ending:

{
  title: "A river with no end",
  choices: [
    {
      label: "Offer a moonleaf to the water",
      requires: "moonleaf",
      consume: "moonleaf",
      next: "tower",
      flag: "river_blessing"
    },
    {
      label: "Cross on the slippery stones",
      next: "tower",
      health: -1
    }
  ]
}

Keeping the choices with the scene made the story easy to expand and helped keep the game logic out of the page markup.

Keep state small

The game tracks the current scene, warmth, pocket items, and a few story flags. When a player chooses something, the game updates that state and renders the next scene:

function choose(choice) {
  if (choice.item) state.inventory = addUnique(state.inventory, choice.item);
  if (choice.consume) {
    state.inventory = state.inventory.filter(
      (item) => item !== choice.consume
    );
  }
  if (choice.flag) state.flags = addUnique(state.flags, choice.flag);
  if (choice.health) {
    state.health = Math.max(0, state.health + choice.health);
  }

  state.steps += 1;

  if (state.health === 0) {
    state.ending = "lost";
  } else if (choice.ending) {
    state.ending = choice.ending;
  } else {
    state.scene = choice.next;
  }

  render();
}

Story text is rendered as text rather than injected HTML. After a choice, focus moves to the new scene heading so keyboard players can follow the transition.

Make the atmosphere part of the interface

The forest illustration is made from CSS shapes and gradients, so the game needs no image assets. The layout adapts for smaller screens, and the firefly animation respects reduced-motion preferences.

The result is a short game with different routes, item-dependent choices, and endings shaped by what you did along the way. I tested a complete route to the moon-bell ending, the out-of-warmth ending, and the restart flow in the browser.

There’s room to grow the story, but keeping the scene data and game state simple made it possible to get a playable version running quickly. Try Mosslight.

CrumbCraft AI: An Offline, Voice-First Agent for My Baker Friend Niki 🎂🤖

Priyesh Dabre — Sun, 04 Oct 2026 14:47:40 +0000

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

What I Built

I built CrumbCraft AI, a hands-free, voice-activated baking and cake decorating assistant designed specifically for my friend Niki.

Niki runs a boutique home bakery specializing in custom, multi-tiered cakes. Her process is creative and precise, but working in her basement prep kitchen presents unique real-world challenges:

Flour-Covered Hands: When she's piping Swiss Meringue buttercream or sculpting fondant, touching a tablet or phone to look up recipe scalings or substitution math washes 10+ minutes down the drain in hand-sanitizing.
Strict Allergen Safety: A math miscalculation when scaling a gluten-free or vegan recipe for a sensitive client can ruin an event—or pose real health risks.
Kitchen Dead Zones: Her basement prep kitchen has unreliable Wi-Fi. Cloud-only voice assistants fail right when she needs an immediate unit conversion mid-bake.

CrumbCraft AI solves this by running as a 100% offline, hands-free voice loop on her kitchen laptop. Niki simply speaks her question out loud, and CrumbCraft processes her speech, calculates exact recipe scalings, verifies allergen rules, and speaks the answer back—all with zero internet connection.

Demo
Here is a recording of CrumbCraft AI running locally with zero Wi-Fi connection, listening through the microphone and speaking answers back via native audio:
{https://drive.google.com/file/d/1QmiBeJ2JV8rOoBrSpMsIlhqiAUh3gDhj/view?usp=share_link}

Code
You can check out the open-source repository and build setup below:
{https://github.com/priyeshdabre07/crumbcraft-ai}

Core Tech Stack

Agent Framework: Mastra (@mastra/core)
Local LLM Engine: Ollama running Google's open-weight gemma4:e4b
Local Speech Recognition (STT): OpenAI Whisper (small.en via whisper-node / whisper.cpp)
Local Audio Recording & TTS: SoX (rec) & macOS Native Speech Engine (say)
Local Memory Store: Embedded JSON Recipe Database

How I Built It

CrumbCraft AI is designed around a fully local, privacy-first pipeline where open-source components handle every step of the voice agent loop:
+-----------------------------------------------------------------------+
| KITCHEN WORKSPACE |
| |
| 🎙️ Microphones Capture Speech ---> 🔊 Speakers Output Audio |
+----------------------------------+------------------------------------+
|
v
+-----------------------------------------------------------------------+
| CRUMBCRAFT LOCAL PIPELINE |
| |
| 1. Speech-to-Text: OpenAI Whisper (small.en running locally) |
| │ |
| v |
| 2. Agent Orchestration: Mastra Framework |
| ├── LLM Reasoning: Google Gemma 4 (gemma4:e4b via Ollama) |
| ├── Deterministic Tools: frostingScalerTool & allergenCheckerTool |
| └── Embedded Memory: local_recipes.json Database |
| │ |
| v |
| 3. Text-to-Speech: Native macOS 'say' Engine / Local Audio Synthesis |
+-----------------------------------------------------------------------+

1. Deterministic Baking Tools with Mastra:

We defined specialized tools within Mastra so the agent doesn't hallucinate baking math:
TypeScript

import { createTool } from '@mastra/core';
import { z } from 'zod';
import { searchLocalRecipes } from '../db/localDb';

export const frostingScalerTool = createTool({
  id: 'frosting-scaler',
  description: 'Calculates total frosting volume and key ingredient weights based on cake tier diameters.',
  inputSchema: z.object({
    tierSizesInInches: z.array(z.number()).describe('Array of tier diameters in inches, e.g. [6, 8, 10]'),
    frostingType: z.string().describe('Type of frosting, e.g., Swiss Meringue Buttercream'),
  }),
  outputSchema: z.object({
    totalCupsNeeded: z.number(),
    butterGrams: z.number(),
    sugarGrams: z.number(),
  }),
  execute: async ({ context }) => {
    const { tierSizesInInches } = context;
    const totalSurfaceArea = tierSizesInInches.reduce((acc, d) => acc + Math.PI * Math.pow(d / 2, 2), 0);
    const totalCupsNeeded = Math.round((totalSurfaceArea * 0.15) * 10) / 10;

 return {
   totalCupsNeeded,
   butterGrams: Math.round(totalCupsNeeded * 115),
   sugarGrams: Math.round(totalCupsNeeded * 120),
    };
  },
});

2. Local Open Weights with Gemma 4:

We targeted gemma4:e4b running locally via Ollama. It strikes the perfect balance for Apple Silicon (M4 with 16GB Unified Memory): delivering native function-calling capabilities, zero network latency, and low memory usage (~6.6 GB RAM) so the machine stays cool and responsive.

3. Local Voice Pipeline:

Input: Audio is captured directly from the microphone using sox and transcribed locally via Whisper (small.en).
Output: Speech responses are generated instantly through macOS's native TTS engine (say), eliminating cloud per-character API fees.

Why Does Open Innovation Matter?

Open-source AI was not just a convenience for this project—it was an absolute requirement:

Kitchen Reliability (Zero Internet Dependency): Niki's basement prep room is an internet dead zone. Cloud AI models (like ChatGPT or proprietary voice APIs) freeze or fail completely when connection drops. Open-weight models like Gemma 4 run 100% locally on device, guaranteeing that her voice assistant works every single time.
Data Privacy for Client Relationships: Niki stores client allergy histories, family dietary preferences, and proprietary recipe ratios. Keeping execution entirely local ensures zero client data or custom recipes are uploaded to external training servers.
Zero Operating Cost: Running open-source models via Ollama and local speech engines means CrumbCraft AI costs $0.00/month to run. An artisan baker shouldn't have to worry about token billing while mixing batter.
Custom Tooling Control: Proprietary black-box endpoints can hallucinate substitution advice. Open frameworks like Mastra allow us to inspect, trace, and strictly enforce deterministic rule checking for allergen safety.

Prize Categories
Best Use of Gemma: Used gemma4:e4b locally via Ollama as the core reasoning engine for unit conversions, allergen substitutions, and tool calls.
Best Use of Mastra: Built the entire agent workflow, tool execution layer, and structured response pipeline using the Mastra TypeScript framework.