SlothSortAI: A Local AI File Organizer That Does the Work for You

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

What I Built

I built SlothSortAI 🦥, an open-source, local-first AI file organizer designed to explore how AI can make everyday file management easier.

We all accumulate documents, PDFs, screenshots, and other files until finding the right one becomes a task of its own. SlothSortAI explores how AI-assisted analysis can help reduce this repetitive work.

The application combines Python-based file scanning, a Streamlit interface, and a locally running language model through Ollama.

Key features

• Folder scanning: Scans a selected folder to discover files.
• Local AI analysis: Integrates the open-weight qwen2.5:3b model through Ollama.
• Simple interface: Provides an interactive Streamlit UI.
• Safety-focused design: Includes a dedicated module for file-handling safeguards.
• Open-source code: Lets developers inspect, run, and extend the project.

My goal was to build a practical starting point for AI-assisted file management rather than another complicated AI demo.

Demo

Project repository: https://github.com/Neeraja-Pyla/SlothSortAI

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/wanf40smvse914khd5km.png]

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/a1hl0aeb5sexhx5mc5mf.png]

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/d88fr12uqg6tk0vud514.png]

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/3jnkwmmlx24nahzhk6qv.png]

The application currently runs locally and requires Python, Streamlit, Ollama, and the configured model. I have not deployed a public hosted demo.

Code

GitHub: https://github.com/Neeraja-Pyla/SlothSortAI

The repository contains the Python application, file scanner, database module, AI integration, safety logic, dependency list, and automated tests.

To try it locally:

git clone https://github.com/Neeraja-Pyla/SlothSortAI.git
cd SlothSortAI
python -m venv .venv

On Windows PowerShell, activate the environment:

.\.venv\Scripts\Activate.ps1

Install dependencies and download the model:

pip install -r requirements.txt
ollama pull qwen2.5:3b

Start the application:

streamlit run app.py

Ensure Ollama is installed and available before running the application. Refer to the repository README for any additional setup details.

How I Built It

I built SlothSortAI using Python, Streamlit, Ollama, and the open-weight qwen2.5:3b language model.

The application combines traditional programming for file scanning and application logic with local AI inference for AI-assisted analysis.

Here's the technology stack:

• Python: Core logic and file handling.
• Streamlit: User interface.
• Ollama: Runs the language model locally.
• Qwen 2.5 3B: Open-weight model used for AI integration.
• Pytest: Automated testing.
• GitHub: Source control and open-source distribution.

One important part of the process was keeping the application modular, with separate files for scanning, AI integration, database functionality, and safety-related logic.

I also ran the automated test suite, which passed all six existing tests.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with AI beyond a hosted API.

By using an open-weight model through Ollama, I could explore local inference and build an application without requiring a paid hosted model API for its AI inference.

This matters for a file-management tool because users may prefer to keep their workflows on their own machines. Local inference gives users more control over where model processing takes place, although privacy still depends on the complete application and how files are handled.

Open-source development also makes the implementation accessible to other developers. They can inspect the code, learn from the architecture, reproduce the setup, identify weaknesses, and contribute improvements.

For me, the biggest lesson is that open-weight AI makes experimentation more accessible. A developer can start with a small model, connect it to a practical application, and gradually improve the result.