DEV Community: Yogesh

Sloth Mode — AI That Does the Busywork While You Rest

Yogesh — Thu, 22 Oct 2026 20:02:41 +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 assistant designed to reward doing less. It takes care of repetitive digital chores in the background, so you can spend less time managing your digital life and more time living it.

Code

yogesh147 / sloth-mode

Sloth Mode uses an open-weight language model, served locally with Ollama, to power its summarization and organization features. A lightweight automation layer handles scheduled tasks and connects the model to useful workflows.

View on GitHub

How I Built It

Why Does Open Innovation Matter?

Your personal files shouldn't have to leave your computer just to get organized.

By running inference locally, Sloth Mode can keep private data on-device and continue working without an internet connection once the required models and dependencies are installed. Open models also make it possible to switch models, customize behavior, and build features without depending entirely on a proprietary API.

Local inference can eliminate per-request API fees, too, making repeated everyday automation more accessible.

Prize Categories

🟣 Best Use of Render - powers the deployed backend and API.

StockSense AI

Yogesh — Wed, 14 Oct 2026 18:47:36 +0000

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

What I Built

I built StockSense AI, an AI-powered inventory management assistant designed to help small business owners manage their stock more efficiently and make smarter purchasing decisions using AI.

Demo

Video Link: https://www.youtube.com/watch?v=RWNfzTgBHSM
Render Link: https://stocksense-c2t2.onrender.com/

Code

yogesh147 / stocksense

StockMind — AI Inventory Management & Bill of Materials for Small Business

StockSense — AI inventory assistant

StockSense is a strong choice for the Side Hustle challenge because it solves a real business problem: small shop owners lose money when they run out of popular products or keep buying stock that doesn't sell.

1. What the product does

Upload stock data

Import an Excel or CSV file containing product names, quantities, sales, and purchase prices.

Analyze inventory

Calculate stock coverage, sales velocity, slow-moving items, and potential stockouts.

Ask questions in plain language

“Which products should I reorder this week?” or “Which items haven't sold in 30 days?”

Get an actionable report

See recommended quantities, estimated purchasing costs, and items that need attention.

Step 1 — Create a virtual environment

bash python -m venv .venv Activate it:

Windows:

bash .venv\Scripts\activate macOS/Linux:

bash source .venv/bin/activate Step 2 — Install dependencies

bash pip install -r requirements.txt Step 3 — Start StockSense

bash streamlit run app.py

View on GitHub

How I Built It

I built StockSense AI, an AI-powered inventory management assistant for small businesses using Python and Streamlit.
I used Pandas to analyze inventory data, identify low-stock products, and detect slow-moving items from Excel and CSV files.
SQLite supports local data storage, while Ollama with an open-weight LLM enables natural-language inventory queries.
I implemented rule-based logic to estimate stockouts, suggest reorder quantities, and calculate purchasing costs.
The goal is to help shop owners reduce waste, avoid stock shortages, and make smarter inventory decisions.

Why Does Open Innovation Matter?

Open innovation matters because it encourages people to share ideas, collaborate, and use existing technologies to solve real-world problems. With StockSense AI, I used open-weight AI models and open-source tools to build an affordable inventory management solution for small businesses. It reduces development costs, encourages experimentation, and makes AI technology more accessible. Open innovation helps turn creative ideas into practical solutions that can grow and benefit more people.

Prize Categories

🟣 Best Use of Render - powers the deployed backend

Python Reliability Benchmark: Testing AI Models Beyond Correct Answers

Yogesh — Sat, 10 Oct 2026 11:16:04 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

I built a benchmark to evaluate how reliably large language models solve practical Python programming tasks. Rather than measuring only whether a model can generate code that looks correct, I focused on three dimensions: functional correctness, debugging ability, and instruction following.

The benchmark includes Python problems involving data manipulation, edge cases, bug fixing, and code generation under explicit constraints. Each task is evaluated against predefined expected outputs or test cases wherever possible.

I chose this capability because code that appears convincing can still fail in real applications. A useful coding assistant must handle unusual inputs, follow requirements precisely, and produce solutions that work—not just explanations that sound plausible.

Models Tested

All models were evaluated on the same task set and under consistent prompting and scoring conditions. I used automated test cases where possible to reduce subjective judgments and make the results reproducible.

Findings

The benchmark measured functional correctness, edge-case handling, debugging success, and instruction compliance.

Key results:

One important aspect of this evaluation was separating plausible-looking code from code that actually passes tests. This distinction helps reveal whether a model is dependable on practical programming tasks, particularly when inputs are unusual or requirements are restrictive.

The results also highlight opportunities for further investigation. I would next expand the benchmark with more adversarial edge cases, multi-step debugging tasks, and repeated runs to measure consistency. I would also compare performance with and without additional reasoning or tool access to understand which conditions improve reliability.

These findings should be interpreted within the scope of the benchmark's task set, model versions, and evaluation settings rather than as a universal ranking of coding ability.

My Benchmark

yogesh147 / python-reliability-benchmark

python -m venv venv venv\Scripts\activate pip install -r requirements.txt

View on GitHub

The benchmark, evaluation procedure, and results are available at the link above so that others can inspect the methodology, reproduce the comparison, and extend the task set.

Touch Grass - AI outdoor companion

Yogesh — Tue, 06 Oct 2026 18:54:40 +0000

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

What I Built

I built the Touch Grass backend as a Python-based API that connects the frontend with the application's core services and data.

Touch Grass uses Gemma to create short outdoor activities based on the time you have. It gives you a simple quest, works offline with demo data, and encourages you to put your phone away and go outside. 🌱

Example: 30 minutes → walk → find a flower → sit quietly → find something blue → return.

### Key Features

Built a structured backend API using Python.
Added API endpoints for frontend communication.
Implemented request validation and response handling.
Integrated database operations for application data.
Added business logic and service-layer processing.
Configured environment variables for secure application settings.
Set up a virtual environment and dependency management.
Added development and deployment workflows.
Designed the backend to be modular and easy to maintain.

Demo

Video Link: https://www.youtube.com/watch?v=n_HMCvODRos

Render Link: https://touch-grass-n2zk.onrender.com/

Code

yogesh147 / touch-grass

Touch Grass is an open-weight AI outdoor companion that turns 15–60 minutes of free time into a tiny real-world adventure.

Tell it how much time you have and start from where you are. Gemma creates a personalized micro-quest. Once the quest starts, the app gets out of the way: the plan is cached offline, the screen becomes minimal, and optional on-device Gemma vision can turn things you discover into the next challenge.

The AI doesn't want your attention. It wants you to stop using your phone.

uvicorn main:app --reload

View on GitHub

How I Built It

I built the Touch Grass backend with a modular architecture focused on clean API communication, validation, business logic, and data management.

Development Process

Project Setup
- Created a Python backend project.
- Set up a virtual environment for isolated dependencies.
- Added dependency management using requirements.txt.
Backend Development
- Built REST API endpoints to communicate with the frontend.
- Organized the application into reusable modules and services.
- Implemented request and response handling.
Data & Business Logic
- Added validation to ensure reliable API requests.
- Implemented the application's core business logic.
- Connected the backend with database and external services where required.
Configuration
- Used environment variables for configuration and sensitive information.
- Separated development configuration from application code.
Testing & Debugging
- Tested API endpoints during development.
- Identified and fixed dependency and runtime issues.
- Verified the backend workflow from request to response.
Running the Project
- Created a reproducible local development setup.
- Used a virtual environment and dependency installation process.
- Configured the backend to run locally for development and testing.

Why Does Open Innovation Matter?

Open innovation matters because great ideas become more powerful when people, communities, and organizations can build on each other’s work instead of starting from scratch.

For a project like Touch Grass, open innovation enables us to:

Build faster: Open-source models like Gemma, frameworks, and tools provide a strong foundation.

Make AI accessible: Developers can experiment with powerful AI without depending entirely on closed platforms.

Encourage collaboration: Others can inspect, improve, remix, and contribute to the project.

Create more trustworthy technology: Open implementations make it easier to understand how a system works and identify problems.

Solve real-world problems: Innovation isn't just about better AI—it is about applying technology to meaningful challenges.

Keep control with users: With local and offline AI, people can use technology without constantly sending their data to a remote service.

For Touch Grass, this philosophy is especially important: open AI helps us build technology whose goal isn't to keep people online, but to help them leave the screen behind and experience the real world.

Open innovation turns technology from something we simply consume into something we can collectively build, improve, and use for good.

Prize Categories

🟣 Best Use of Render - powers the deployed backend and API.

🟢 Best Use of Gemma - powers memory extraction, reasoning, Friend Mode and grounded responses.

MemoryMate — Turning Friend Conversations Into Memories

Yogesh — Sun, 04 Oct 2026 10:05:23 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

MemoryMate is an AI-powered personal memory assistant that helps you remember important things from your conversations, notes, screenshots, PDFs, transcripts, and plans.

Instead of scrolling through hundreds of messages, you can simply ask:

💬 “What were the startup ideas Rahul and I discussed?”

💬 “When did I say my interview was?”

💬 “What movie did my friend recommend?”

💬 “What does Rahul like?”

MemoryMate searches your personal memories, finds the relevant context, and gives you an answer with the original source so you can verify where the information came from.

✨ Friend Mode

The most interesting part is Friend Mode.

MemoryMate can build a lightweight memory profile for each friend:

Rahul
❤️ Football · Gaming
🚀 College Startup
🎧 Looking for headphones
🎂 Birthday · May 18

And this enables one of my favorite features:

💡 “You mentioned this before…”

Imagine saying:

“I need a birthday gift for Rahul.”

MemoryMate can look through previous conversations and respond:

You mentioned this before: Rahul has been looking for headphones and has recently been talking about gaming. He also likes football.

Instead of just answering questions, MemoryMate helps you remember the people you care about.

Demo

🚀 Render Link: https://memorymate-lr5k.onrender.com/

Code

💻 GitHub: https://github.com/yogesh147/memorymate

Partner Technologies

Github
Render

Hackathon Experience

I participated in DevChallenge, WeekendChallenge, and HF26Challenge, and each experience gave me a great opportunity to build, experiment, and learn in a fast-paced environment. I enjoyed turning ideas into working projects while working within tight deadlines and thinking creatively about real-world problems.

The most memorable part was the energy and collaboration throughout the challenges. I got to connect with other builders, exchange ideas, learn from different approaches, and push myself beyond what I would normally build. These experiences helped me improve both my technical skills and my ability to work effectively under pressure. Most importantly, they made me more confident and excited about building and experimenting with new ideas.

MemoryMate — Turning Friend Conversations Into Memories

Yogesh — Sun, 04 Oct 2026 10:05:02 +0000

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

🧠 MemoryMate — An AI built to help a friend remember the little things.

Friends talk about hundreds of things — ideas, plans, birthdays, recommendations, and random conversations.

But sometimes we forget the details that matter:

“What did I say I wanted?”
“When did we talk about that?”
“What was that idea we discussed?”

I built MemoryMate to help a friend find those memories again — without searching through hundreds of messages.

What I Built

MemoryMate is an AI-powered personal memory assistant that helps you remember important things from your conversations, notes, screenshots, PDFs, transcripts, and plans.

Instead of scrolling through hundreds of messages, you can simply ask:

💬 “What were the startup ideas Rahul and I discussed?”

💬 “When did I say my interview was?”

💬 “What movie did my friend recommend?”

💬 “What does Rahul like?”

MemoryMate searches your personal memories, finds the relevant context, and gives you an answer with the original source so you can verify where the information came from.

✨ Friend Mode

The most interesting part is Friend Mode.

MemoryMate can build a lightweight memory profile for each friend:

Rahul
❤️ Football · Gaming
🚀 College Startup
🎧 Looking for headphones
🎂 Birthday · May 18

And this enables one of my favorite features:

💡 “You mentioned this before…”

Imagine saying:

“I need a birthday gift for Rahul.”

MemoryMate can look through previous conversations and respond:

You mentioned this before: Rahul has been looking for headphones and has recently been talking about gaming. He also likes football.

Instead of just answering questions, MemoryMate helps you remember the people you care about.

Demo

🚀 Render Link: https://memorymate-lr5k.onrender.com/

Code

💻 GitHub: https://github.com/yogesh147/memorymate

The repository contains the frontend, backend, AI pipeline, memory retrieval system, and supporting infrastructure used to build MemoryMate.

How I Built It

MemoryMate is built around open-weight AI, semantic search, structured memory, and retrieval-augmented generation (RAG).

      📄 Conversations
      📝 Notes
      🖼️ Screenshots
      📑 PDFs
      🎙️ Transcripts
             │
    Ingestion Pipeline
             │
  Extract • Chunk • Structure
             │
    Memory Extraction
             │
 People • Dates •  Facts • Preferences
             │
         Tiger Data
  PostgreSQL + Vector Search
             |
       Hybrid Retrieval
             │
           Gemma
             │
    Answer + Source Context

🧠 Gemma — The Intelligence

Use Gemma as the open-weight language model powering the AI layer.

Gemma is used for:

Extracting useful memories from conversations

Identifying people, dates, preferences, and events

Understanding natural-language questions

Reasoning over retrieved memories

Generating grounded responses

Building Friend Mode profiles

Rather than treating the LLM as a simple chatbot, Use as part of a memory pipeline where retrieved information provides the context for each answer.

🗄️ Tiger Data — The Memory

MemoryMate uses Tiger Data as the database and vector-search layer.

A memory contains both semantic and structured information:

Memory
├── Content
├── Embedding
├── Person
├── Timestamp
├── Conversation
├── Source
├── Confidence
└── Metadata

This allows the application to combine:

Semantic search
“What did Rahul say about his startup?”

with:

Structured search
“Find things Rahul said about his startup in August.”

That combination makes personal-memory retrieval much more useful than relying on vector similarity alone.

🚀 Render — The Application

Use Render to deploy the MemoryMate backend and expose the application through a production API.

The backend is built with FastAPI, while the frontend is built with React.

This gives me a simple architecture:

React
↓
FastAPI
↓
Memory / Retrieval Layer
↓
Tiger Data + Gemma

🔐 Privacy & Local AI

Personal memories are sensitive.

That's why I designed MemoryMate around open-weight models and local inference.

The architecture can be adapted to run AI inference locally, giving users more control over where their memories and personal information are processed.

The goal isn't just to make AI remember more.

It's to explore how AI can remember more responsibly.

Why Does Open Innovation Matter?

Open innovation allowed me to combine open-weight AI, vector search, local inference, and open-source tools into a privacy-focused personal AI.

For a product handling personal memories, this control matters.
Instead of relying entirely on a closed API, developers can customize how memories are extracted, stored, searched, and processed.

MemoryMate shows how open AI can become more than a chatbot — it can become a personal memory layer.

Prize Categories

I'm entering MemoryMate for:

🟣 Best Use of Render - powers the deployed MemoryMate backend and API.

🟢 Best Use of Gemma - powers memory extraction, reasoning, Friend Mode and grounded responses.