DEV Community: Mayank Bisht

LazyDigest: Let AI Read the Long Stuff for You

Mayank Bisht — Fri, 23 Oct 2026 16:28:53 +0000

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

What I Built

Ever opened a long document, a pile of notes, or a lengthy block of text and thought, “I'll read this later”?

That's exactly the problem LazyDigest is designed to solve.

LazyDigest is a local-first AI summarizer that turns lengthy text into something you can understand at a glance. Instead of manually going through every paragraph, you can paste text or upload a .txt or .md file and get:

Short summary: Understand the main idea without reading everything.

Key points: Find the most important information quickly.

Action items: Identify tasks and next steps mentioned in the text.

Important dates: Surface dates and deadlines when they appear in the content.

It also handles longer inputs by splitting the text into smaller chunks, summarizing them, and combining the results into a final digest.

I built it for students, developers, and anyone who deals with too much text and too little time.

The idea is simple: spend less time extracting information and more time actually using it.

Code

GitHub repository: LazyDigest

How I Built It

LazyDigest uses Gemma, an open-weight AI model, running locally through llama.cpp's OpenAI-compatible server interface.

The application is built with:

Python and FastAPI for the backend and API endpoints.

HTML, CSS, and JavaScript for the user interface.

HTTPX to communicate with the local model server.

Gemma to generate summaries, key points, action items, and dates.

Chunk-based summarization to handle longer text without sending the entire input in one request.

The workflow is straightforward:

The user pastes text or uploads a supported text file.

The backend validates the input.

Short inputs are sent for summarization, while longer inputs are processed in chunks.

The model generates structured results.

The interface presents the digest in a readable format.

I kept the initial version focused on doing one thing well instead of adding unnecessary infrastructure. There is no database storing uploaded documents, and the application does not need a separate hosted AI API.

The project is intentionally small enough for someone to understand, run, and build upon.

Why Does Open Innovation Matter?

For a tool that processes personal notes, study material, work documents, or private text, where the data goes matters just as much as the result.

Using an open-weight model locally gives users more control over their data and how AI is run.

With LazyDigest, the text can be processed on the user's own machine instead of being sent to a third-party AI service. Once the model and dependencies are installed, summarization can work without an internet connection, provided the local inference server is running.

Open models also give developers the freedom to experiment with different models, adjust prompts, inspect the surrounding implementation, and extend the project without being locked into one hosted API.

That flexibility is what makes this approach exciting to me. AI should not always require sending your data elsewhere or paying for every request.

Sometimes, the best AI tool is one you can run yourself.

The Lazy Payoff

Imagine receiving a long set of notes before an exam, opening a lengthy project document, or reviewing a large collection of text.

Instead of starting by reading every line, you can start with the summary, scan the key points, and check the action items and dates. You can then return to the original text when you need more detail.

I haven't measured the actual time saved yet, so I won't claim a specific percentage. The goal is to reduce the effort required to understand lengthy text and identify what deserves attention.

The next steps I'd like to explore include PDF support, scheduled folder digests, and optional voice input or speech output.

For now, LazyDigest is a small step toward making everyday information overload a little less overwhelming.

Prize Categories

Best use of Gemma

ShopSaathi: Bringing Local AI to Small Shops with Gemma | Hacktoberfest Side Hustle

Mayank Bisht — Sun, 18 Oct 2026 11:23:33 +0000

ShopSaathi: A Local AI Sales and Inventory Assistant for Small Shopkeepers

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

What I Built

ShopSaathi is a local AI-powered sales and inventory assistant designed for small shopkeepers.

Many small shop owners track their daily sales and remaining stock manually, using notebooks or memory. This can make it difficult to calculate daily revenue, monitor inventory, identify products running low, and understand how the business performed at the end of the day.

ShopSaathi aims to make this process simpler.

With ShopSaathi, a shopkeeper can:

Add products with their prices, opening stock, and optional cost prices.
Record sales using simple, natural-language text, such as “Sold 3 packets of biscuits and 2 bottles of juice.”
Review AI-extracted sales entries before confirming them.
Track remaining stock as confirmed sales are recorded.
View daily revenue, units sold, estimated gross profit, and low-stock products.
Generate an easy-to-understand, AI-written end-of-day summary.

The goal is to give small shopkeepers a simple way to understand their business without needing complicated accounting or inventory software.

Who is it for? Small retail shops and independent shopkeepers who want a lightweight way to track sales and inventory.

Demo

ShopSaathi currently runs locally on a computer.

To try it, clone or download the repository, start the local Gemma model server, install the Python dependencies, and launch the FastAPI application. The web interface is served directly by the backend.

Repository: ShopSaathi on GitHub
Local demo: http://127.0.0.1:8000

Code

The project is built with a small, straightforward codebase:

FastAPI: Backend and API endpoints.
SQLite: Local storage for products and sales.
Gemma: Natural-language sales extraction and daily-summary generation.
HTML, CSS, and JavaScript: Lightweight web interface.

The project is designed to be approachable for contributors and easy to run locally.

How I Built It

I wanted to build something practical for people who run small businesses, rather than another AI chatbot that only answers questions.

I chose Gemma as the core AI model and designed ShopSaathi to run locally using a Gemma-compatible inference server.

The workflow is simple:

Product setup: The shopkeeper adds products, prices, and stock quantities.
Sales entry: The shopkeeper types a natural-language description of the items sold.
AI extraction: Gemma converts the description into structured product and quantity entries based on the available catalogue.
Human confirmation: The shopkeeper reviews the proposed entries before confirming them.
Inventory update: Python handles the actual stock and sales calculations after confirmation.
Daily summary: The application calculates the day's figures and lets Gemma explain them in plain language.

One important design decision was to keep arithmetic and inventory updates in application code instead of trusting the language model to calculate business figures. This helps keep recorded totals and stock changes grounded in the database.

The current MVP is text-first. Voice input is a planned next step, not a feature I am claiming is already implemented.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with useful AI tools without building everything around a paid, closed API.

Using an open-weight model such as Gemma gives this project a path toward local inference, more control over how data is processed, and the ability to experiment without sending every sales entry to an external AI service.

For a small shopkeeper, privacy and running costs matter. Sales records and inventory information can be sensitive, and an internet-dependent workflow may not always be convenient.

Local inference does not automatically solve every privacy or deployment concern, but it gives ShopSaathi a foundation for exploring a more private, accessible, and affordable approach.

Open-source tools also make the project easier for other developers to inspect, improve, and adapt to different types of shops.

Future Plans

The next major improvement is to make ShopSaathi voice-first.

Many shopkeepers may find speaking easier than typing every sale, especially while serving customers. In a future version, I want a shopkeeper to say something like, “Sell five packets of biscuits,” have the system identify the product and quantity, and then confirm the transaction.

The planned voice workflow is:

Speech-to-text for capturing spoken sales.
Gemma for interpreting the spoken text against the product catalogue.
A confirmation step before changing stock.
Optional spoken feedback for sales confirmation and end-of-day summaries.

I also want to test ShopSaathi with a real shopkeeper, gather feedback, and improve the workflow based on how they actually record sales.

Prize Categories

Best Use of Gemma

Closing Thoughts

ShopSaathi is an early MVP, but the idea behind it is simple: useful AI should help people with everyday work, not make that work more complicated.

I built this project to explore how open-weight AI can make sales tracking and inventory management more accessible to small shopkeepers. My next goal is to make it voice-first and put it in the hands of a real user.

Feedback, ideas, and contributions are welcome!

Touch Grass 🌱 — An AI That Gets You Offline

Mayank Bisht — Sat, 10 Oct 2026 21:24:24 +0000

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

What I Built

Touch Grass is an AI-powered offline activity companion designed to help students and anyone who spends too much time in front of a screen reconnect with the real world.

Instead of simply telling users to reduce their screen time, it gives them something meaningful to do offline.

Users can choose their interests—such as reading, drawing, walking, gardening, sports, or cooking—and select how much time they want to spend offline. The AI then generates a personalized challenge with clear instructions and a specific goal. Users can also choose Surprise Me to discover a random activity.

Once a challenge begins, the app provides a timer to help users stay focused on the activity. Afterward, they submit activity-specific evidence, such as summarizing something they learned from reading or describing what they observed during a walk. The AI evaluates their submission and provides feedback and a score.

The goal isn't just to spend less time on a screen. It's to make the time away from it more meaningful.

Demo

Code

https://github.com/Mayank-0-0/Touch-grass.git

How I Built It

I built Touch Grass using a local-first architecture inspired by my previous AI project, Day Planner.

The tech stack includes:

Frontend: React + Vite

Backend: Python + FastAPI

Database: SQLite with SQLAlchemy

AI Model: Google's Gemma 4 E2B, using a local GGUF model

Inference: llama.cpp

The React frontend communicates with the FastAPI backend through REST endpoints. The backend sends prompts to the locally running Gemma model, validates its structured responses, and stores challenge and activity history in SQLite.

AI is central to the experience: it personalizes challenges based on users' interests and available time, generates activity-specific instructions, and evaluates the evidence submitted afterward.

Rather than requiring users to upload a photo for every activity, the app supports different forms of evidence depending on the challenge. This makes activities more flexible and keeps the focus on the experience itself.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with AI in a way that is accessible, transparent, and under my control.

Using an open-weight model with local inference means Touch Grass can generate challenges and evaluate submissions without depending on a paid, cloud-hosted AI API. It also gives me greater control over prompts, model behavior, and how user data is processed.

For a project that encourages people to disconnect from their screens, keeping the AI lightweight and local feels especially appropriate. The AI should help users get outside and engage with the world—not require another always-connected service.

Open tools also make it easier for other developers to inspect the implementation, improve the experience, and build on the idea.

Prize Categories

Best Use of Gemma

Organize Me - Turning Student Chaos into a Plan with Gemma

Mayank Bisht — Sun, 04 Oct 2026 13:29:22 +0000

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

What I Built

I built Organize Me, a local AI-powered day planner for myself and my engineering friend circle.

As engineering students, it can be difficult to keep track of everything happening at once — assignments, projects, exams, coding practice, college work, and deadlines. It's easy to know what needs to be done but much harder to organize everything into a manageable plan.

Organize Me lets us describe what we need to accomplish in natural language, and the AI turns it into a structured list of tasks with descriptions, estimated durations, and deadlines.

For example, instead of manually creating several tasks for an upcoming exam, we can simply say:

"I have a science exam in two days and need to prepare for it."

The AI breaks that into actionable tasks that can then be tracked through the application.

Users can also:

Mark tasks as complete or incomplete
Delete tasks
View all their planned tasks
Keep their tasks saved between sessions

The main goal was to build something that my friends and I could actually use during college, rather than just building another demo application. --

Demo

Code

The complete source code is available on GitHub:

Mayank-0-0 / Organize-Me-

Day Planner

A simple productivity app for turning a natural-language description of your day into actionable tasks. Review tasks, track their duration and deadline, run a focus timer, and mark work complete as you go.

Features

AI Planner: Send a planning prompt to the backend and add the generated tasks to your list.
My Tasks: Fetch, review, complete, and delete tasks.
Task details: See descriptions, durations, and deadlines.
Focus timer: Start, pause, and reset a countdown for tasks that have a duration.
Responsive interface: Use the planner on desktop or smaller screens.

Project structure

.
├── backend/     # FastAPI API, SQLite database, and AI service integration
└── frontend/    # React 19 app built with Vite

Requirements

Python 3.10 or later
Node.js and npm
A local LLM server available at http://127.0.0.1:8081 with a /completion endpoint that accepts the llama.cpp completion request format and returns generated text in a content field

The…

View on GitHub

How I Built It

I built Organize Me using a React frontend, FastAPI backend, SQLite database, and Gemma running locally through llama.cpp.
The basic architecture is:

React → FastAPI → SQLite + Local Gemma

The React frontend provides the planner and task-management interface.

The FastAPI backend handles API requests, task management, database operations, and communication with the AI model.

SQLite is used to persist the tasks.

For the AI functionality, I used Gemma, running locally through llama.cpp. When a user describes what they need to accomplish, the backend sends the request to Gemma with instructions to return structured JSON containing the tasks, descriptions, estimated durations, and deadlines.

The backend then processes that response and stores the generated tasks in SQLite.

One of the important parts of the project was making the AI output predictable enough for the application to consume. Instead of simply displaying the model's response as text, I instructed Gemma to return a specific JSON structure that the backend could process.

Why Does Open Innovation Matter?

Open innovation made it possible for me to build the core AI functionality without depending on a paid external AI API.

Because Gemma is an open-weight model and can run locally through llama.cpp, the application can process planning information locally instead of sending it to a third-party AI service.

This gives the project several advantages:

Privacy — personal tasks and plans don't need to be sent to an external AI API.
Control — I can control the model, prompts, and output format.
No per-request API cost — the AI runs locally once the model is downloaded.
Experimentation — I can modify and experiment with the AI integration without being tied to a specific hosted API.

For a personal productivity application, having an AI assistant that can run locally makes open-weight models a particularly interesting option.

Prize Categories

Best Use of Gemma — Gemma is used as the core AI model that converts natural-language planning requests into structured tasks.

What I Learned

Building Organize Me taught me much more than just integrating an AI model.

I learned how to connect a React frontend with a FastAPI backend and build a complete flow from a user's natural-language request to AI-generated structured data stored in a database.

I also learned how to run an open-weight model locally using llama.cpp, communicate with it through an HTTP API, and design prompts that make the model return predictable JSON that my application can actually use.

On the backend side, I got more practical experience with FastAPI, SQLAlchemy, SQLite, CORS, API endpoints, and handling the gap between an AI model's output and the structured data expected by an application.

Most importantly, I learned that building an AI application isn't just about calling a model. The real challenge is connecting the model reliably with the rest of the software system and designing the application around it

Starting a new Journey !!

Mayank Bisht — Fri, 02 Oct 2026 15:02:24 +0000

Excited to start a new journey. Glad to be the part of DEV