DEV Community: Atharva Babhane

InboxSloth AI: Let AI Handle the Message Overload

Atharva Babhane — Fri, 23 Oct 2026 14:40:01 +0000

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

What I Built

Ever opened a college WhatsApp group and found hundreds of messages, only to discover that the important assignment deadline was hidden somewhere in the middle? 😅

That's the problem I wanted to solve with InboxSloth AI — Smart Message Summarizer.

InboxSloth AI is an AI-powered application designed to turn long message conversations into short, useful briefings. Instead of reading every message manually, users can get a summary of important updates, actionable tasks, deadlines, and potential warnings.

🦥 What can it do?

📝 Summarize conversations: Turn lengthy discussions into concise summaries.
✅ Extract action items: Identify assignments, tasks, and follow-ups.
📅 Find deadlines: Detect dates and times mentioned in messages.
🚨 Highlight important updates: Help users prioritize urgent announcements.
🔁 Reduce repetition: Identify duplicate messages and repeated information.
🌐 Handle mixed-language messages: Aim to support English, Marathi, and Marathi-English conversations.
🔒 Run AI locally: Use an open-weight model through Ollama instead of depending entirely on a hosted AI API.

The goal is simple: spend less time scrolling through messages and more time getting things done.

My main target users are students, project teams, and anyone overwhelmed by busy group conversations.

Demo

GitHub Repository: InboxSloth AI

The project uses Ollama to run the Gemma 3 1B model locally.

To try the model:

ollama pull gemma3:1b
ollama run gemma3:1b

The web application can be run locally after installing its Python dependencies and configuring the project.

Note: A public video or deployed demo link will be added when available.

Code

🔗 Source code: [(https://github.com/MrAtharvaB/InboxSloth-AI)]

The project is built with an open-source-friendly stack:

Python for application logic
Flask for the backend
Ollama for local model inference
Gemma 3 1B for AI-powered text processing
HTML, CSS, and JavaScript for the web interface

The repository contains the project code and setup instructions as development progresses.

How I Built It

I chose a local AI approach because I wanted to explore how a small language model could solve an everyday productivity problem without requiring a paid inference API for every request.

1. Local AI with Gemma

I use Gemma 3 1B through Ollama as the intended language model for summarizing conversations and extracting useful information.

The model can be instructed to identify key announcements, tasks, deadlines, and uncertain information from message text.

2. Python and Flask

Flask provides the foundation for connecting the user interface with the AI processing pipeline.

The intended workflow is:

The user provides a conversation or message dump.
The application prepares the text for processing.
The local model generates a summary and extracts relevant information.
The application organizes the results into a readable format.

3. A focus on useful output

A summary alone isn't always enough. Knowing that an assignment is due on Friday is more useful than simply knowing that an assignment was discussed.

That's why InboxSloth AI focuses on action items and deadlines alongside the summary.

An important design goal is to avoid inventing dates or treating conflicting announcements as confirmed facts.

4. Learning through experimentation

Building this project has also helped me explore local model setup, prompt design, Python application development, and the practical challenges of making AI outputs useful.

Rather than building another generic chatbot, I wanted to experiment with AI as a tool that reduces repetitive work.

Why Does Open Innovation Matter?

Open innovation makes projects like InboxSloth AI possible for individual developers and students.

Using an open-weight model through Ollama gives me an opportunity to experiment with local inference, understand how the model fits into an application, and explore AI development without making a hosted API the foundation of every interaction.

It also creates opportunities to learn from the broader developer community.

For a student developer, this matters because experimentation should not stop simply because an API has usage limits or an application needs a different deployment strategy.

Open tools make it easier to learn, adapt, test ideas, and build projects that others can inspect and improve.

Local inference can also reduce the need to transmit conversation text to an external model provider, although privacy still depends on how the complete application handles its data.

For me, open innovation is about making AI development more accessible and giving developers the freedom to understand and improve the tools they use.

My Agent Session

I am developing InboxSloth AI as an experiment in practical local AI.

A DevRelay agent session can be added here if I capture and publish one for this project.

The Lazy Payoff 🦥

Imagine spending 10 minutes scrolling through a group chat just to find three important announcements.

InboxSloth AI aims to turn that process into a quick review of a concise summary and a task list.

The potential payoff is less repetitive reading, fewer missed announcements, and a clearer view of what needs attention.

I am treating this as a productivity goal to validate through testing, rather than claiming a measured time saving before collecting real usage data.

Prize Categories

I am submitting InboxSloth AI to the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

I will add any applicable partner prize categories after verifying the official challenge requirements.

Final Thoughts

InboxSloth AI started with a simple idea: important information shouldn't get lost in a sea of messages.

This project is my opportunity to explore local AI, open-weight models, and practical productivity tools while continuing to improve my development skills.

If you have ideas for improving message summarization, multilingual support, or local AI workflows, I'd love to hear your suggestions!

⭐ Check out the project: InboxSloth-AI on GitHub

Less scrolling. More doing. 🦥

devchallenge # hf26challenge

BillBuddy AI: Your Local AI-Powered Receipt & Invoice Extractor

Atharva Babhane — Wed, 14 Oct 2026 15:01:50 +0000

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

Built for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

BillBuddy AI is an AI-powered receipt and invoice extractor that helps small shop owners, freelancers, and individuals simplify expense tracking.

Managing receipts manually can be time-consuming. Important information such as the vendor name, purchase date, total amount, and line items often gets lost in piles of paper receipts or scattered images.

BillBuddy AI turns receipt images into structured financial information using OCR and local AI.

✨ Key Features

📸 Receipt Image Upload: Upload receipt and invoice images for processing.
🔎 OCR-Based Text Extraction: Uses Tesseract OCR to read text from receipt images.
🧠 Local AI Extraction: Uses the open-weight Gemma 3 1B model through Ollama to help structure extracted information.
🧾 Financial Data Extraction: Extracts details such as vendor name, date, total amount, and available line items.
📊 Expense Dashboard: View extracted information and recent receipt history.
📁 CSV Export: Export expense data for further analysis in spreadsheet applications.
🔒 Local Processing: Run the application and AI model locally, reducing reliance on external AI APIs.

🎯 Who Is It For?

BillBuddy AI is designed for small business owners, local shopkeepers, freelancers, and individuals who want a simpler way to digitize receipts and organize expenses.

It could be useful for anyone who wants to reduce manual data entry and make receipt management easier.

Demo

Local demo: The application runs locally at http://127.0.0.1:5000.

I tested BillBuddy AI with a DMart receipt image. The application extracted the receipt information and identified the grand total as ₹393.55.

The project currently runs locally, so a public deployment or video demo is not available yet.

📹 Demo video: [https://youtu.be/W7rZG9yW3xQ]

Code

💻 GitHub Repository: [https://github.com/MrAtharvaB/BillBuddy-AI]

The project is built with Python and Flask, with a frontend using HTML, CSS, and JavaScript.

The repository includes the application code, templates, styling, and configuration needed to run the project locally.

How I Built It

I built BillBuddy AI using a combination of traditional OCR, open-weight AI, and web technologies.

🛠️ Tech Stack

Python — Core application logic and data processing.
Flask — Backend web framework and application routes.
HTML, CSS, JavaScript — Dashboard and interactive user interface.
Tesseract OCR — Extracts text from receipt images.
Gemma 3 1B — Open-weight language model used for structured information extraction.
Ollama — Runs the AI model locally.
CSV — Exports extracted expense information.

⚙️ How It Works

Upload: The user uploads a receipt or invoice image.
Preprocess: The application prepares the image to improve OCR readability.
Extract text: Tesseract OCR reads the text from the receipt.
Process with AI: The extracted text is passed to Gemma 3 1B through Ollama to identify relevant financial fields.
Fallback: If AI extraction is unavailable or unsuccessful, the application uses a fallback extraction method.
Display: The dashboard presents the extracted details and receipt history.
Export: Users can export their expense records to CSV.

🧪 A Real-World Test

During testing, I used a DMart receipt containing a subtotal of ₹374.80 and a grand total of ₹393.55.

This test helped me focus on an important challenge in receipt extraction: distinguishing the subtotal from the final payable amount. A reliable receipt extractor must prioritize explicit labels such as Grand Total or Amount Payable rather than simply selecting the first monetary value it finds.

Why Does Open Innovation Matter?

Open innovation made it possible for me to build an AI-powered application without depending entirely on a proprietary, paid AI API.

Using Gemma 3 1B with Ollama allowed me to experiment with local inference, test the application on my own machine, and integrate an open-weight model into a practical project.

Open-source tools also made it possible to combine different technologies for different tasks:

Tesseract handles OCR.
Python and Flask connect the components.
Gemma helps interpret the extracted text.
Ollama makes local model execution accessible.
The web frontend turns the workflow into a usable application.

For small businesses and individual developers, this approach can lower experimentation costs and provide greater control over data processing.

Open innovation is not just about accessing source code or model weights. It is about having the freedom to learn, modify, experiment, and build solutions around real-world problems.

My Agent Session

This project was developed through iterative coding, testing, and debugging.

I worked on OCR extraction, local model integration, fallback handling, and the dashboard interface.

Agent session: Not available yet.

Prize Categories

Challenge: Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

Project focus: Open-weight AI, local inference, and practical AI applications.

Add the official partner prize categories here if your project meets their published eligibility requirements.

What's Next?

Some improvements I would like to explore include:

Better extraction accuracy across different receipt formats.
Improved handling of taxes, discounts, subtotals, and grand totals.
Support for more document formats and languages.
Expense categorization and monthly analytics.
A deployable version for easier access by other users.

Building BillBuddy AI has been a hands-on way to explore how open-weight AI can solve everyday problems.

Thanks for checking out my project! 🚀

Hacktoberfest #OpenSource #AI #Gemma #Ollama #Python #Flask #BuildInPublic

🌱 WalkQuest AI: Turn a Walk Into an AI-Powered Adventure

Atharva Babhane — Thu, 08 Oct 2026 15:25:37 +0000

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

What I Built

I built WalkQuest AI, a local AI-powered outdoor adventure generator.

The idea is simple: instead of using AI to keep people on their screens, WalkQuest AI uses AI to encourage people to put the screen down and go outside.

Users enter:

📍 Their walking location
⏱️ Available time
🥾 Difficulty

WalkQuest AI then generates a short outdoor quest with:

🎯 4 walking missions
🦺 A safety tip
🌱 Touch Grass Score
📵 A screen-free quest rule

Users can check off each mission and complete their quest to earn 100 XP.

It is designed for students, developers, and anyone who wants a simple reason to go outside and explore their surroundings.

Demo

Watch WalkQuest AI Demo

1. Generate a Walking Quest

2. AI-Generated Outdoor Quest

3. Quest Completed

Here is the WalkQuest AI demo flow:

1. Generate a Quest

The user selects a location, duration, and difficulty.

2. AI Generates the Adventure

Gemma creates four outdoor missions, a safety tip, and a Touch Grass Score.

3. Complete the Quest

Users check off all four missions.

4. Quest Completed

After completing all missions:

🌱 Quest Completed!

🏆 Touch Grass Achievement

⭐ 100 XP

The complete source code is available on GitHub:

MrAtharvaB / WalkQuest-AI

🌱 WalkQuest AI

Turn a walk into an adventure.

WalkQuest AI is a simple AI-powered app that generates fun outdoor walking quests based on location, duration and difficulty.

✨ Features

🌱 AI-generated walking quests
📍 Location selection
⏱️ Duration selection
🥾 Difficulty selection
🎯 4 walking missions
🦺 Safety tips
🌱 Touch Grass Score
🏆 Mission completion tracker
💯 100 XP achievement

🛠️ Tech Stack

Python
Streamlit
Ollama
Gemma 3 1B

📂 Project Structure

WalkQuest-AI/
├── app.py
├── prompts.py
├── requirements.txt
└── README.md

View on GitHub

The project is open source and can be run locally with Python, Streamlit, Ollama, and Gemma 3 1B.

How I Built It

WalkQuest AI is built with:

Python
Streamlit
Ollama
Gemma 3 1B

The architecture is:

User Input
↓
Streamlit
↓
Ollama
↓
Gemma 3 1B
↓
Generated Outdoor Quest
↓
Quest Completion

I used Gemma 3 1B locally through Ollama as the AI engine.

The AI is responsible for generating the walking quests based on the user's location, available time, and difficulty.

The application also includes rules in the prompt to keep quests short, safe, realistic, and focused on outdoor activities.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with AI in a way that is more accessible and controllable for developers.

For WalkQuest AI, running Gemma locally through Ollama allowed me to build around an AI model without making a paid cloud API the core dependency of the application.

It also gave me the freedom to design the AI experience specifically around the project's goal: encouraging people to spend less time on screens and more time outdoors.

This project showed me that AI does not always have to keep people online.

It can also be used to encourage people to step away from the screen.

My Agent Session

Not used for this project.

Prize Categories

Best Use of Gemma

I am entering the Best Use of Gemma category.

WalkQuest AI uses Gemma 3 1B locally through Ollama to generate personalized outdoor quests.

Final Thought

AI can be more than a tool for spending more time online.

Sometimes, the best AI experience is one that tells you:

📵 Put the phone down.

🌱 Go outside.

🚶 Touch Grass.

#devchallenge #hf26challenge

StudyMate AI — Your Personal AI Study Companion 📚🤖

Atharva Babhane — Sat, 03 Oct 2026 16:24:13 +0000

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

📚 StudyMate AI — Your Personal AI Study Companion

What I Built

StudyMate AI is an AI-powered study companion designed to help engineering students understand, revise, and interact with their study material more effectively.

I built this project for a fellow student who often struggles with lengthy notes, difficult technical concepts, and the time-consuming process of finding specific information inside PDFs.

Instead of repeatedly searching through notes, the student can simply upload a PDF, ask a question, and interact with an AI study companion.

✨ Key Features

📄 PDF Study Notes Upload — Upload engineering notes directly into the application.
🔍 PDF Text Extraction — Extracts useful content from study material using PyPDF.
🤖 Gemma-Powered AI — Uses Gemma to generate clear and student-friendly explanations.
💬 Interactive AI Chat — Ask questions naturally and receive structured responses.
📚 Notes-Based Answers — The AI can use the uploaded study material as context when answering questions.
🧠 Student-Focused Explanations — Concepts are explained in simple language with examples where useful.
🔗 Backboard Integration — Uploaded study documents are also indexed through Backboard.

The goal was simple: turn static study notes into an interactive learning experience.

Demo

📸 Project Screenshots

Here are screenshots of StudyMate AI in action:

The demo showcases the complete StudyMate AI workflow:

Upload PDF → Process Study Material → Ask a Question → Get an AI-Powered Explanation

The demonstration also shows how StudyMate AI uses the uploaded notes to answer questions relevant to the student's study material.

Code

💻 GitHub Repository:

Code

The repository contains the complete source code, project structure, setup instructions, environment configuration, and implementation details.

The project is built with a focus on keeping the architecture simple, understandable, and easy for other developers to explore and extend.

How I Built It

StudyMate AI is built around Gemma, an open-weight AI model, with document processing and AI-assisted study workflows integrated into a lightweight web application.

🏗️ Architecture

             ┌─────────────────────┐
             │      Student        │
             │                     │
             │  Upload PDF / Ask   │
             │      Question       │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │     Flask App       │
             │    Web Backend      │
             └──────────┬──────────┘
                        │
          ┌─────────────┴─────────────┐
          ▼                           ▼
  ┌───────────────┐           ┌─────────────────┐
  │     PyPDF     │           │   Backboard     │
  │ PDF Extraction│           │Document Indexing│
  └───────┬───────┘           └─────────────────┘
          │
          ▼
  ┌─────────────────┐
  │  Study Context  │
  │ Extracted Notes │
  └────────┬────────┘
           │
           ▼
  ┌─────────────────┐
  │      Gemma      │
  │  AI Generation  │
  └────────┬────────┘
           │
           ▼
  ┌─────────────────┐
  │   StudyMate AI  │
  │     Answer      │
  └─────────────────┘

Why Does Open Innovation Matter?

Open innovation matters because it gives developers the freedom to experiment, learn, and build AI-powered solutions around open technologies.

For StudyMate AI, using Gemma as an open-weight AI model allowed me to build an AI study experience around an open model rather than treating AI as a completely closed black box.

This is especially valuable for students and independent developers. Open technologies make it possible to explore how AI can be integrated with real-world problems, experiment with different approaches, and build solutions tailored to specific communities.

For this project, the problem was simple: students have plenty of study material, but finding and understanding the right information can take a lot of time.

By combining Gemma with open-source tools such as PyPDF and a lightweight Flask application, I was able to turn static study notes into an interactive learning experience.

Open innovation makes it possible to learn by building, experiment openly, and create technology around real human needs.

Prize Categories

🏆 Best Use of Gemma

StudyMate AI uses Gemma as the core AI model powering its conversational study experience and generating clear, student-friendly explanations using the student's study material.

🏆 Best Use of Backboard

StudyMate AI integrates Backboard for uploading and indexing study documents as part of the project's document-based study workflow.

What's Next?

I plan to extend StudyMate AI with features such as:

📝 Automatic quiz generation
❓ Practice question generation
🎯 Topic-wise revision
🧠 Smarter document retrieval
📊 Personalized study progress
📚 Support for multiple subjects and documents

The current version focuses on one core goal: making a student's existing study material easier to understand and interact with.

devchallenge #weekendchallenge #hf26challenge