DEV Community: Jitin Kumar

Sloth-Sorter: An Offline, CPU-Only File Organiser Powered by Local SLMs

Jitin Kumar — Sun, 25 Oct 2026 17:01:09 +0000

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

What I Built

sloth-sorter is a zero-dependency, offline daemon that automatically categorises and renames chaotic files in your Downloads directory using local Small Language Models (SLMs). Instead of letting files pile up as scan_0031 (2).pdf or final_v2_edited.docx, it inspects the file content and moves it into a structured Sorted/<category>/ directory with a deterministic, semantic filename like 2026-10-19-acme-invoice-42.pdf.

It is designed for developers who want an automated filesystem without sending personal documents to external APIs or burning GPU cycles. Because automated file operations carry inherent risk, the architecture prioritises safety:

Dry Run by Default: Previews the entire execution plan and proposed diffs before touching the filesystem.
Transactional Und o Log: Tracks every batch operation in SQLite, allowing instant, single-command rollbacks to restore original paths and filenames.
Declarative Config Rules: Uses plain-English routing rules in a local configuration file so you can adjust categorisation logic without modifying the source code.

Demo

Code

Jitin2102 / HactoberFest-Challenges-Week-3

hactoberfest week 3 challenge

HactoberFest-Challenges-Week-3

🦥 sloth-sorter

A lazy, fully local file tidier. A small open-weight model (via Ollama) reads each new file in your Downloads folder, picks a category, gives it a sensible name, and files it away. Nothing leaves your machine. Every move is logged so you can undo it.

Setup (CPU-only is fine)

# 1. Install Ollama (https://ollama.com), then:
ollama pull qwen2.5:3b          # ~2 GB, runs on CPU. Try qwen2.5:1.5b if it's slow.
# 2. Optional, for PDF text:
pip install pypdf
# 3. Edit config.toml (folders, categories, plain-English rules)

Needs Python 3.11+. No other dependencies.

Use

python sloth_sorter.py plan              # dry run (default), moves nothing
python sloth_sorter.py apply             # do it
python sloth_sorter.py undo              # reverse the last batch
python sloth_sorter.py watch --interval 600   # tidy every 10 minutes
python sloth_sorter.py bench --models qwen2.5:1.5b,qwen2.5:3b,llama3.2:3b

How it stays safe

Dry run is the default; apply is explicit.
Skips hidden files, partial…

View on GitHub

How I Built It

The core constraint was building a tool that runs reliably on a standard CPU-only laptop without bloating the Python environment.

Inference Engine: Runs ``locally via Ollama. At 3 billion parameters, it hits the sweet spot between CPU token generation speed and instruction-following accuracy for structured output.
Zero-Dependency Core: Built strictly on the Python standard library (urllib.request, sqlite3, pathlib, `), communicating directly with Ollama's local REST API (http://localhost:11434/api/generate`{% endraw %}). Optional PDF text extraction is supported if {% raw %}pypdf is present in the environment.
Execution Pipeline:
1. Ingestion & Filtering: Scans the target directory while ignoring hidden dot-files, active browser .crdownload/.part buffers, and files with open write locks.
Context Extraction: Reads file metadata and extracts a bounded text header from plaintext, source code, .docx (via standard zipfile XML parsing), and PDFs.
Constrained Inference: Prompts the local model to return a strict JSON payload.
Validation & Sanitisation: Verifies the output against an allowed category whitelist, strips illegal filesystem characters, and resolves naming collisions automatically (-2, -3).
1. Atomic Move & Logging: Executes the file transfer and commits the transaction ID, source path, and destination path to a local SQLite database.
Deterministic Guardrails: If the LLM hallucinates an invalid schema or Ollama times out, the pipeline degrades gracefully to a deterministic extension-based fallback router so a bad inference never crashes the batch run.
Built-in Benchmarking (bench): Includes a benchmarking CLI command that runs a test suite of files across multiple local models (qwen2.5:1.5b, qwen2.5:3b, llama3.2:3b) to measure latency per file and category agreement on your specific hardware.

Why Does Open Innovation Matter?

Strict Data Privacy: A folder is a goldmine of sensitive data—bank statements, tax forms, IDs, and private keys. Running open-weight models locally guarantees zero data exfiltration; not a single byte leaves.
Zero Marginal Cost: Cloud LLM APIs charge per token, which makes background system utilities economically impractical. Local inference turns file organisation into a free, background OS primitive that works completely offline.
Model Agnostic & Swappable: Relying on open weights prevents vendor lock-in. Using the bench command, I was able to empirically test different parameter sizes and quantisation levels (qwen2.5 vs. llama3.2) and select the exact model that matched my CPU's thermal and latency constraints.
Auditable & Hackable: Open-source tooling paired with local models means you control both the system prompt and the routing engine. Adding a custom rule like "Route receipts into /finance and prefix with the vendor name" takes one line of config rather than waiting on a SaaS feature request.

The Lazy Payoff

Rather than racing for sub-second cloud latency, 'sloth-sorter' embraces the "slow and steady" philosophy: it quietly processes files in the background on CPU threads while I focus on actual work.

In a test run across a cluttered directory of ** mixed files** (PDFs, code snippets, archives, and docs), it categorised and renamed the entire batch in ~3.5 minutes on CPU—saving ~20 minutes of manual inspection and renaming. When one ambiguous document was misclassified during testing, a single undo command cleanly reverted the batch, and a one-line tweak to the plain-English rules fixed the behaviour permanently.

LocalBiz AI: A Local AI Marketing Assistant for Small Businesses 🌱

Jitin Kumar — Sat, 17 Oct 2026 11:49:28 +0000

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

What I Built

Small businesses often struggle to create consistent marketing content because hiring a copywriter or subscribing to multiple AI tools can be expensive.

LocalBiz AI is a marketing content assistant designed to help small business owners generate promotional content tailored to their business, audience, platform, and preferred tone.

Users can generate:

📱 Social media posts and promotional captions
🛍️ Product descriptions
📧 Promotional emails
💬 Marketing messages for customer outreach

The application uses a local language model to generate content and provides a template-based fallback when the model is unavailable.

The goal is simple: help small businesses save time on routine marketing tasks while keeping AI tools accessible.

Who could benefit? Local cafés, clothing stores, fitness centres, bakeries, freelancers, and other small businesses that need regular promotional content.

Demo

Run it locally: Follow the installation instructions in the GitHub README.

Application URL: http://127.0.0.1:8000

The application runs on your local machine after setup. A publicly deployed demo is not currently available.

Code

🚀 GitHub Repository: Jitin2102/LocalBiz-AI

The repository contains the application source code, frontend, FastAPI backend, setup scripts, and testing files.

Contributions and suggestions are welcome!

How I Built It

I built LocalBiz AI using Python, FastAPI, HTML, CSS, and JavaScript, with SQLite for storing generation history.

The most important part is its integration with Ollama and Gemma 3 1B, an open-weight language model that can run locally.

The technology stack

Python: Application logic and backend development.
FastAPI: REST API and request handling.
Gemma 3 1B: Local language model for marketing content generation.
Ollama: Local model execution and inference.
SQLite: Storage for generated content history.
HTML, CSS, and JavaScript: Responsive user interface.
Pytest: Automated testing.

How it works

The user enters their business name, business type, target audience, platform, content type, tone, and key details.
The frontend sends the information to the FastAPI backend.
The backend uses the local Gemma model through Ollama to generate marketing content.
If the model is unavailable, the application can fall back to template-based generation.
Generated content can be stored in the local SQLite history.

This architecture keeps the application lightweight and provides an alternative to depending entirely on a hosted AI API.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with an AI-powered business tool without building a language model from scratch or relying entirely on a proprietary AI service.

Using an open-weight model with local inference offers several advantages:

1. Greater accessibility

Developers and small businesses can experiment with AI tools without requiring a paid, hosted language-model API for every generation.

2. More control over data

With local inference, prompts can be processed on the user's own machine rather than sent to a third-party model API. This depends on the application configuration and any other external services used.

3. Freedom to experiment

Open-weight models allow developers to test different models, modify prompts, and explore alternative implementations.

4. A foundation for collaboration

The project can be extended with new content templates, additional languages, improved prompting strategies, and support for other compatible models.

Open innovation is not just about making software free. It is about making experimentation, adaptation, and collaboration more accessible.

My Agent Session

This project currently focuses on the application and its local AI integration. I do not have a shareable agent-session recording to include.

Prize Categories

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

Additional partner categories can be added if the project meets their specific requirements.

What's Next?

LocalBiz AI is a starting point, not a finished commercial product.

Future improvements could include multilingual content generation, reusable brand profiles, downloadable marketing copy, support for additional local models, and content-quality evaluation.

My next goal is to improve the generated content, test the application with real small-business owners, and use their feedback to guide development.

Building practical AI tools is about more than getting a model to generate text. It is about making the output useful for real people.

Built with Python, FastAPI, Ollama, and Gemma 3 1B. 🚀

EcoQuest AI: Touch Less Screen, Explore More Earth 🌿 | Building with Gemma for Hacktoberfest 2026

Jitin Kumar — Fri, 09 Oct 2026 09:15:11 +0000

🌿 EcoQuest AI: Touch Less Screen. Explore More Earth.

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

What I Built

EcoQuest AI is an open-source, AI-powered outdoor exploration app designed to help people spend less time scrolling and more time experiencing the world around them.

Instead of using AI to keep people glued to their screens, EcoQuest uses it to encourage real-world exploration through small, achievable outdoor missions.

With EcoQuest AI, users can:

🌱 Discover Nature Quests: Explore outdoor activities such as identifying plants, observing birds, mapping natural sounds, and cleaning up litter.
📓 Maintain a Field Journal: Record outdoor observations and document experiences.
🏆 Track Progress: Earn points by completing missions and monitor exploration progress.
🤖 Explore with AI: Use a locally running Gemma model to generate personalized missions and ask questions about nature.
🌍 Make a Difference: Build awareness of the environment through simple, actionable outdoor activities.

EcoQuest AI is designed for students, nature enthusiasts, and anyone who wants to build healthier digital habits while reconnecting with the natural world.

The core idea is simple: AI should encourage us to experience more of the real world, not just spend more time online.

Demo

The application currently runs locally using Streamlit.

To try it, follow the setup instructions in the repository README.

A deployed demo or video walkthrough will be added when available.

Code

GitHub Repository: https://github.com/Jitin2102/HactoberFest-Challenges-Week-1

The project includes the Streamlit application, outdoor quest system, field journal, progress tracking, and optional local Gemma integration.

How I Built It

EcoQuest AI combines a lightweight Python application with open-weight AI.

Technology stack:

**Python—Application logic
**Streamlit—Interactive web interface
**Gemma—Locally running AI model for mission generation and nature-related questions
**Ollama—Local model inference
python-dotenv — Environment-based configuration

The application provides ready-made outdoor missions without requiring an AI model. For AI-powered features, users can run Gemma locally through Ollama.

This approach keeps the basic experience accessible while making AI features available without depending entirely on a hosted, proprietary API.

Why Does Open Innovation Matter?

AI should not be limited to centralized platforms or expensive API subscriptions.

Open-weight models make it possible for developers to experiment, build locally running applications, and adapt AI-powered experiences to specific needs.

For EcoQuest AI, local Gemma inference provides an opportunity to explore AI-assisted nature activities without making a proprietary cloud API the foundation of the application.

Open innovation also makes experimentation more accessible to students and independent developers. Developers can inspect their implementation, learn from existing tools, contribute improvements, and build on shared technology.

Most importantly, open AI gives us the freedom to explore different ways of using technology—including ways that encourage people to step away from it.

My Agent Session

I don't have a published agent session to share yet.

Prize Categories

Gemma: Local AI integration using an open-weight Gemma model.

What's Next?

EcoQuest AI is an early MVP, and there is plenty of room to grow.

Future improvements could include:

Persistent user profiles and mission history
Nature identification from uploaded photographs
Voice-based outdoor guidance
Location-aware missions
Offline-first mobile support
Community challenges and collaborative environmental activities

I'd love to see contributors help turn this initial concept into a practical tool for reconnecting people with nature.

Less scrolling. More exploring. More Earth. 🌿