DEV Community: MANAV mishra

SlothSort AI: Let Gemma Clean Your Messy Files So You Don't Have To

MANAV mishra — Sun, 25 Oct 2026 15:41:28 +0000

SlothSort AI: Let Gemma Clean Your Messy Files So You Don't Have To

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

What I Built

SlothSort AI is a local-first AI file organizer that turns the repetitive job of cleaning up a messy folder into a simple review-and-apply workflow.

Instead of manually sorting files one by one, SlothSort lets local Gemma generate an organization plan that the user can review before anything changes.

The workflow is:

Select a folder.
Scan the visible files.
Let local Gemma generate an organization plan.
Review the proposed changes.
Apply the organization only after confirmation.

SlothSort does not read file contents. It uses metadata such as filenames, extensions, file sizes, and modification times to create the organization plan.

Demo

Watch the full SlothSort AI demo

The demo shows the complete workflow from creating a fake folder and scanning its files to generating, reviewing, and applying the AI organization plan.

Code

View the SlothSort AI source code on GitHub

How I Built It

SlothSort AI is built with:

Python
FastAPI
Pydantic
Vanilla HTML, CSS, and JavaScript
Ollama
Gemma 4 E4B

The architecture is intentionally lightweight:

User
  ↓
SlothSort UI
  ↓
FastAPI
  ↓
Ollama
  ↓
Gemma 4 E4B
  ↓
Structured JSON plan
  ↓
Pydantic validation
  ↓
Review
  ↓
User confirmation
  ↓
Filesystem changes

The backend scans the selected folder and collects metadata from visible files. That metadata is sent to Gemma through Ollama running locally.

Gemma returns a structured organization plan, which is validated with Pydantic before being presented to the user.

Nothing is changed during scanning or planning. Files are only moved after the user reviews the proposed changes and explicitly confirms the operation.

The backend also rechecks the scan before applying changes, keeps destinations inside the selected root folder, avoids intentional overwrites, and never deletes files.

Why Does Open Innovation Matter?

SlothSort uses Gemma locally through Ollama instead of depending on a proprietary hosted AI API.

This means the application can perform its AI planning locally without requiring a cloud AI account or API key. File contents are never read, and only file metadata required for organization is provided to the local model.

Open-weight models make this kind of local-first application possible while giving developers and users more control over the AI component and where their data is processed.

The Lazy Payoff

Organizing a messy folder is exactly the kind of repetitive task that is easy to keep postponing.

SlothSort turns:

Look at file → Decide → Rename → Move → Repeat

into:

Select folder → Scan → Review AI plan → Confirm

The goal is simple: let local AI handle the repetitive first pass while keeping the user in control of the final changes.

Safety

File contents are never opened or sent to the model.
Only file metadata is used for AI planning.
Scanning does not modify files.
AI-generated plans are validated before they can be applied.
Applying changes requires explicit user confirmation.
The backend rechecks files before applying a plan.
Destination paths must remain inside the selected root folder.
Existing destination names receive a numbered suffix.
Files are never intentionally deleted.

Prize Categories

Overall
Best Use of Gemma

AI Disclosure

AI coding tools were used during implementation, debugging, and refinement of the project.

The project concept, product direction, feature decisions, testing, final review, and submission were human-led.

Team

Solo submission.

QuoteCraft AI is a local-first AI quote generator for freelancers and small service businesses.

MANAV mishra — Sun, 18 Oct 2026 16:45:29 +0000

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

What I Built

QuoteCraft AI is a local-first AI quote generator for freelancers and small service businesses.

Freelancers often receive client requests as messy paragraphs, chat messages, or loosely defined requirements. Turning those requests into a professional quote takes repetitive work: defining the scope, listing deliverables, estimating a timeline, writing pricing notes, specifying exclusions, and preparing a response for the client.

QuoteCraft turns that process into a single workflow.

A freelancer enters:

Their name
The service they provide
The client's request
The available budget
The expected deadline

QuoteCraft then uses Gemma 4 E4B running locally through Ollama to generate a structured quote containing:

Project title and summary
Scope
Deliverables
Timeline
Pricing note
Exclusions
Payment terms
Client-ready message

The target user is a freelancer or small service business that wants to spend less time preparing repetitive quotes.

A freelancer could plausibly pay for this because it removes a small but recurring administrative task from their workflow.

Demo

Watch the QuoteCraft AI demo

The demo shows the complete workflow: entering a realistic restaurant website request, generating a quote with local Gemma inference, and reviewing the resulting scope, deliverables, timeline, pricing, exclusions, payment terms, and client-ready message.

Code

View the QuoteCraft AI source code on GitHub

The project is released under the MIT License.

How I Built It

QuoteCraft is deliberately lightweight.

The frontend is a simple web interface, while a Python FastAPI backend handles the request and communicates with Ollama.

The core flow is:

User
  ↓
QuoteCraft frontend
  ↓
FastAPI
  ↓
Ollama
  ↓
Gemma 4 E4B
  ↓
Structured JSON
  ↓
Pydantic validation
  ↓
QuoteCraft UI

The main technologies are:

Python
FastAPI
Pydantic
Vanilla HTML/CSS/JavaScript
Ollama
Google Gemma 4 E4B

Gemma is not an optional add-on. It is the component that turns the client's unstructured requirements into the structured quote that powers the application.

The application also normalizes model output before Pydantic validation so that common variations in structured LLM responses do not unnecessarily break the quote-generation workflow.

Why Does Open Innovation Matter?

The biggest reason I built QuoteCraft around a local open-weight model is privacy and cost.

Freelancers can receive sensitive information in client requests: project requirements, business plans, pricing information, internal processes, or other details they may not want to send to an external AI provider.

With QuoteCraft, the core generation can happen directly on the freelancer's machine.

Gemma 4 E4B runs locally through Ollama, meaning the application does not require a proprietary hosted AI API for its core generation workflow.

That provides three important advantages.

Privacy: client requirements can remain on the freelancer's computer.

Cost: there is no per-request hosted model API charge for the local generation path.

Control: the model and inference stack can be inspected, modified, replaced, or extended by the developer.

This is where open innovation worked better for this particular product. The goal isn't simply to make another interface around an AI API. It is to make a small business tool that can run with the model itself under the user's control.

Prize Categories

Best Use of Gemma

QuoteCraft AI uses Google's open-weight Gemma 4 E4B as the core generative model, running locally through Ollama.

Gemma transforms unstructured client requirements into structured quote information including scope, deliverables, timeline, pricing notes, exclusions, payment terms, and a client-ready message.

Because Gemma runs locally, QuoteCraft can generate the core quote without sending the client's project description to a third-party hosted AI API.

Gemma is therefore not simply an added feature — it is the core AI component responsible for the product's main workflow.

TrailQuest AI: An AI That Gives You a Reason to Put Your Phone Away 🌿

MANAV mishra — Sun, 11 Oct 2026 14:24:37 +0000

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

What I Built

I built TrailQuest AI, an open-source AI outdoor companion that turns ordinary outdoor time into personalized real-world quests.

The idea is simple: instead of using AI to keep people on a screen, use AI to help them get away from the screen.

A user can provide:

How much time they have
An outdoor activity such as walking, photography, exploration or nature observation
Difficulty
Approximate location/context
Personal interests
Accessibility or physical constraints

TrailQuest then generates a structured outdoor quest around those requirements.

For example, a user could say:

“I have 45 minutes, want something relaxing near a park, like old trees, street photography and listening to birds, and prefer step-free routes.”

The application turns that into a personalized quest with objectives, preparation, completion criteria and safety notes.

The main Touch Grass feature: Away Mode

Once the quest starts, TrailQuest deliberately gets out of the way.

Away Mode shows only one objective at a time instead of keeping the entire quest on screen.

The intended flow is:

Plan → Go outside → Put your phone away → Complete the quest → Come back → Reflect

The user reads an objective, puts the phone away, completes it in the real world, and returns when they need the next step.

TrailQuest is designed for people who want a small, personalized reason to go outside without turning the outdoor activity itself into another screen-based experience.

Demo

Watch the TrailQuest AI Demo

The demo shows the complete flow:

Creating a personalized quest
Generating the quest with Gemma
Reviewing the generated quest
Starting Away Mode
Progressing through the individual objectives
Completing the quest
Returning to the reflection screen

Code

GitHub Repository

The repository contains the complete source code, tests, README, setup instructions and project documentation.

How I Built It

TrailQuest uses Gemma 4 E4B, an open-weight model, running locally through Ollama.

The application is structured around a React frontend and a Python/FastAPI backend:

React + Vite
      ↓
   FastAPI
      ↓
 QuestService
      ↓
   AIProvider
    ↙     ↘
Ollama   OpenAI-compatible
    ↓
  Gemma 4 E4B
      ↓
Structured Quest JSON
      ↓
Pydantic Validation
      ↓
Safety / Constraint Checks
      ↓
React
      ↓
Away Mode

The frontend is built with React and Vite.

The backend uses Python, FastAPI and Pydantic.

The AI layer uses Gemma 4 E4B through Ollama, allowing the model to run locally.

The generated model response is not displayed directly. It is parsed into structured quest data and validated before reaching the user.

The application also performs additional checks for things such as duration, difficulty, activity, location/context, accessibility requirements and safety-related content.

I also separated the AI provider behind an AIProvider interface. This allows the project to use Ollama locally while also supporting an OpenAI-compatible provider such as LM Studio.

Testing

Before submitting, I verified both the automated tests and the real browser flow.

75 backend tests passing
5 frontend tests passing
Production frontend build passing
FastAPI startup verified
Real browser → FastAPI → Ollama → Gemma → validation → React flow tested
Away Mode tested through the complete quest
Objective progression tested
Reload persistence tested
Abandon/end-early flow tested
Quest completion and reflection tested

I also manually generated a real quest using Gemma from the browser and took it through the complete Away Mode experience.

Why Does Open Innovation Matter?

Open innovation is important to TrailQuest because the core AI experience does not need to depend on a proprietary hosted API.

With Gemma running locally through Ollama, users can run the AI on their own hardware and experiment with the model and inference stack themselves.

This makes it possible to:

Run AI locally
Experiment with different open-weight models
Change the inference runtime
Modify the prompts and generation pipeline
Inspect and modify the application
Avoid making a proprietary AI provider a mandatory dependency

It also gives the application a useful separation of responsibilities.

The model generates the language and ideas for the quest, while the application remains responsible for structure, validation, constraints, persistence and safety checks.

For an application involving personal preferences, accessibility requirements and outdoor context, having the option to keep the AI generation local is particularly useful.

Prize Categories

Best Use of Gemma

TrailQuest uses Gemma 4 E4B as the core generative model for creating personalized outdoor quests, with local inference through Ollama.

I Built a Local AI Study Organizer for My Friend's Messy PDF Library

MANAV mishra — Sun, 04 Oct 2026 16:25:20 +0000

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

What I Built

A friend of mine has a large collection of study PDFs spread across different folders. The problem wasn't a lack of study material. The problem was finding the right material quickly and knowing what each document actually contained.

So I built StudyShelf AI, a local-first study organizer that uses an open-weight AI model to turn a messy collection of study PDFs into an organized, searchable study shelf.

The idea is simple:

Instead of manually opening dozens of PDFs to figure out what they contain, upload them to StudyShelf AI and let local AI organize them.

For each document, the application generates:

Subject/category
Relevant tags
Priority
Short summary

The result is a much easier way to understand and search through a large study library.

Demo

Video demo:

Watch the StudyShelf AI demo

The demo shows the complete workflow:

Running the Qwen model locally through LM Studio
Opening the StudyShelf AI application
Uploading a study PDF
Extracting the PDF text locally
Sending the extracted text to the local AI model
Generating the category, tags, priority and summary
Adding the document to the searchable study shelf

Code

GitHub repository:

MANAV-MISHRA-BYTES/StudyShelf-AI
(https://github.com/MANAV-MISHRA-BYTES/StudyShelf-AI)

The complete source code, requirements, setup instructions and project documentation are available in the repository.

How I Built It

StudyShelf AI is built with Python and Streamlit.

The core pipeline is:

Study PDF
   ↓
PyMuPDF
   ↓
Local text extraction
   ↓
LM Studio
   ↓
Qwen3.8 9B
   ↓
Category + Tags + Priority + Summary
   ↓
Searchable Study Shelf
   ↓
CSV Export

Tech Stack

Python
Streamlit
PyMuPDF
Pandas
Requests
LM Studio
Qwen3.8 9B Q5_K_M

PyMuPDF handles local text extraction from PDF files.

Streamlit provides the user interface.

Requests communicates with the local LM Studio API.

Pandas is used to organize and export the generated document index.

LM Studio runs the open-weight model locally and provides the local API used by the application.

For this project, I used Qwen3.8 9B Q5_K_M through LM Studio.

Why Does Open Innovation Matter?

Open-weight AI was important to this project because the application deals with study documents that may contain private notes, assignments, personal annotations and other information that a student may not want to upload to a third-party AI service.

With StudyShelf AI, the core document organization workflow can remain on the user's computer:

Study PDF
   ↓
Local text extraction
   ↓
Local LM Studio server
   ↓
Open-weight Qwen model
   ↓
Document organization

There is no requirement for a cloud AI API for the core organization task.

This gives the user more control over their study material and avoids sending the documents to an external AI service just to categorize and summarize them.

It also means the model can be changed or upgraded without rebuilding the entire application around a proprietary API.

For this project, open AI was not just a requirement of the challenge. Local inference directly supported the privacy goal of the application.

What I Learned

One of the biggest lessons from this project was that a useful AI application does not necessarily need to be huge.

I initially considered building a much larger study assistant with RAG, a database, authentication, question answering and several other features.

But that would have added complexity without solving the immediate problem better.

Instead, I focused on one useful workflow:

Take a messy collection of study PDFs and make it understandable.

That kept the application small enough to build during the challenge while keeping the AI component central to the solution.

Current Limitations

StudyShelf AI is currently an MVP, so there are several things it does not do yet:

Scanned or image-only PDFs are not currently OCR'd.
It does not yet provide full RAG-based question answering.
The organized library is not currently persisted in a database.
The application expects a local LM Studio-compatible server.
Search currently operates on generated document metadata rather than performing semantic search across the full document contents.

These limitations also provide a clear path for future versions.

What's Next?

Some improvements I would like to add in future versions are:

OCR support for scanned documents
Persistent document libraries
Semantic search
RAG-based question answering
Flashcard generation
Quiz generation
Automatic revision scheduling
Duplicate document detection
Better document previews
Support for additional local open-weight models

Hacktoberfest

StudyShelf AI was built for the Hacktoberfest Weekend Challenge: Build for a Friend.

The project addresses a real study-organization problem for a friend while using an open-weight AI model and local inference at the core of the solution.

The challenge encouraged building something useful for a real person rather than simply building a large project for the sake of complexity.

I therefore focused on one small but practical problem: making a large collection of study material easier to understand and navigate.

Prize Categories

No partner category is being claimed for this submission.

My Agent Session

No agent session is being submitted.

Thanks for checking out StudyShelf AI.