DEV Community: Abhinav Amrute

SlothSort

Abhinav Amrute — Fri, 23 Oct 2026 15:33:01 +0000

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

What I Built

SlothSort is a lazy person's file butler. It watches your Downloads folder (or any folder you point it at), reads what's actually inside each file, and then renames it with a sensible name, sorts it into the right folder, and archives anything stale, all by itself and all on your own machine.

No more Screenshot 2026-10-12 at 11.42.07 (3).png, final_FINAL_v2.pdf, or a Downloads folder with 900 mystery files. You drop things in, SlothSort files them away overnight, and in the morning you get a short digest of what it moved and why. If it isn't confident about a file, it leaves it alone and flags it, and every move can be undone with one command.

Anyone who has ever said "I'll clean this up later" gets to be a little lazier.

Demo

Video demo: [add your video link here]
Deployed link (if any): [add link here]

Code

[Add your GitHub repo link here. On DEV you can embed it directly with the {% embed https://github.com/your-username/slothsort %} tag.]

How I Built It

SlothSort is built around a local open-weight model served through Ollama, so the whole pipeline runs without a network connection.

Model: [your open-weight model, e.g. a small Qwen, Gemma or Llama variant] running locally via [Ollama / llama.cpp]. I picked a small model on purpose, since classifying and naming files doesn't need a giant one, and a small model keeps the laptop quiet and the battery happy (very sloth-appropriate).
Watcher: a lightweight Python script using watchdog that notices new files and queues them.
Content extraction: plain-text readers for PDFs, docs and text files, plus [a local vision model / OCR] for images and screenshots. Nothing is uploaded anywhere.
Decision step: the model gets the extracted text, the filename, and my folder rules, and returns a small JSON object: { "new_name": ..., "folder": ..., "confidence": ... }.
Safety rails: anything below a confidence threshold is skipped, nothing is ever deleted (only moved), and every action is written to a log so slothsort undo can reverse it.
Morning digest: one short summary of what was filed, generated by the same local model.

The folder rules live in a plain config file, so changing how SlothSort behaves means editing a few lines, not retraining anything.

Why Does Open Innovation Matter?

Sorting your files means the tool has to read your files: tax documents, invoices, medical reports, private screenshots. That is exactly the kind of data I don't want to send to a server I don't control.

Running an open-weight model locally made that possible:

Privacy by default: file contents never leave my machine, so there is nothing to trust a third party with.
Works offline: it runs on a plane, on bad Wi-Fi, or with the router unplugged.
Zero running cost: no per-file API charges, so I can let it process thousands of files without watching a bill.
Swappable and tunable: I can change models as better open ones appear, adjust prompts and rules, and even fine-tune on my own naming style, none of which a closed API would let me do on my terms.
No surprises: the model version I tested with is the model version I keep running. It can't change under me or disappear.

For a "set it up once and forget it" tool, that reliability matters as much as the privacy.

My Agent Session

[Optional: embed your DevRelay session here with the agent_session tag, or paste a link to it.]

The Lazy Payoff

Files processed so far: [number]
Time I used to spend tidying per week: [X minutes]
Time I spend now: [near zero, plus a 10-second glance at the morning digest]
Used by: [me / a friend / my team] this week

[Replace these with your real numbers, or delete this section if you'd rather not include it.]

ReceiptBox

Abhinav Amrute — Tue, 13 Oct 2026 11:52:57 +0000

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

What I Built

ReceiptBox is a local-first invoice and receipt sorter for freelancers.

Every freelancer knows the end-of-quarter scramble: a downloads folder full of IMG_4821.jpg, invoice (3).pdf and screenshots of payment confirmations, and an accountant waiting for a tidy spreadsheet. ReceiptBox fixes that.

You drop a folder of messy receipts and invoices onto it. It then:

Reads each file (photo, scan or PDF) with a local vision-language model
Extracts vendor, date, total, tax, currency and a likely expense category
Renames and files each document, e.g. 2026-09-14_Figma_USD-15.00_software.pdf
Exports a clean CSV that an accountant (or a tax tool) can open straight away
Flags anything it is unsure about for a quick human check, instead of guessing

Who would pay for it? Freelance designers, developers, writers and consultants who handle their own books, and the small bookkeepers who serve them. The pitch is a one-time license or a small monthly fee (think $5-10/month) for something that saves a few hours every quarter and never uploads client paperwork anywhere.

Demo

No hosted link: the whole point is that it runs on your own machine. Here is a typical run from the terminal:

$ receiptbox sort ./inbox --out ./sorted

Scanning 14 files...
 [ok]    IMG_4821.jpg        -> 2026-09-14_Figma_USD-15.00_software.jpg
 [ok]    invoice (3).pdf     -> 2026-09-02_Hetzner_EUR-4.51_hosting.pdf
 [ok]    scan0007.png        -> 2026-08-29_Uber_INR-342.00_travel.png
 [check] receipt_blurry.jpg  -> confidence 0.41, moved to ./sorted/_needs_review
 ...

Done: 13 sorted, 1 needs review
Wrote ./sorted/expenses_2026-Q3.csv

And the resulting CSV:

date,vendor,total,currency,tax,category,confidence,file
2026-09-14,Figma,15.00,USD,0.00,software,0.97,2026-09-14_Figma_USD-15.00_software.jpg
2026-09-02,Hetzner,4.51,EUR,0.72,hosting,0.95,2026-09-02_Hetzner_EUR-4.51_hosting.pdf
2026-08-29,Uber,342.00,INR,16.29,travel,0.93,2026-08-29_Uber_INR-342.00_travel.png

Code

I'm not linking a repo for this post, so here are the core pieces inline.

Schema for extraction (Pydantic):

from pydantic import BaseModel, Field
from datetime import date
from typing import Literal

Category = Literal[
    "software", "hosting", "travel", "meals", "equipment",
    "office", "marketing", "education", "other",
]

class Receipt(BaseModel):
    vendor: str
    date: date
    total: float
    currency: str = Field(min_length=3, max_length=3)  # ISO 4217
    tax: float = 0.0
    category: Category
    confidence: float = Field(ge=0, le=1)

Extraction with a local VLM through Ollama:

import ollama
from pathlib import Path

PROMPT = """You are an accounting assistant. Read this receipt or invoice
and return ONLY JSON matching the schema. If a field is unreadable, lower
your confidence instead of guessing."""

def extract(path: Path) -> Receipt:
    resp = ollama.chat(
        model="qwen2.5vl:7b",
        messages=[{
            "role": "user",
            "content": PROMPT,
            "images": [str(path)],
        }],
        format=Receipt.model_json_schema(),  # constrained JSON output
        options={"temperature": 0},
    )
    return Receipt.model_validate_json(resp["message"]["content"])

Sorting, renaming and the review lane:

import shutil, csv

THRESHOLD = 0.75

def process(path: Path, out: Path, rows: list[dict]):
    try:
        r = extract(path)
    except Exception:
        shutil.move(path, out / "_needs_review" / path.name)
        return
    if r.confidence < THRESHOLD:
        shutil.move(path, out / "_needs_review" / path.name)
        return
    new = f"{r.date}_{r.vendor.replace(' ', '')}_{r.currency}-{r.total:.2f}_{r.category}{path.suffix}"
    shutil.move(path, out / new)
    rows.append({**r.model_dump(), "file": new})

PDFs are rasterized page by page (first page for receipts, all pages for multi-page invoices) with pdf2image before being passed to the model.

How I Built It

Model: an open-weight vision-language model, Qwen2.5-VL 7B, served locally through Ollama. It reads photos, scans and screenshots directly, so there is no separate OCR step to tune.
Structured output: Ollama's JSON-schema constrained decoding plus Pydantic validation. The model cannot return a malformed record, and bad values get caught before they reach the CSV.
Confidence-gated workflow: the model reports a confidence score and anything below the threshold goes to a _needs_review folder. For money data, "I'm not sure" is a feature.
Plumbing: Python, pdf2image for PDFs, SQLite for a local index (so re-running never duplicates files), and a small Typer CLI. A drag-and-drop desktop wrapper is the next step for non-technical users.
Hardware: it runs on a laptop with 16 GB RAM. A quantized build keeps it usable without a dedicated GPU, just slower.

Why Does Open Innovation Matter?

Privacy is the product. Receipts and invoices reveal who your clients are, what you charge and how you live. Many freelancers are under NDAs, and a lot of them simply do not want their financial paperwork sitting on someone else's server. With an open-weight model, ReceiptBox works with the Wi-Fi off. That is a real selling point, and a closed API can't offer it.

The economics work. A closed vision API charges per image, which punishes exactly the heavy, bursty usage of tax season, and it makes a $5/month price point risky. Local inference costs the user electricity, so my marginal cost per customer is effectively zero and the business can stay small and sustainable.

No lock-in, and room to specialize. I can swap in a newer or smaller model as soon as one is better, pin a version so extraction doesn't silently change mid-quarter, and fine-tune on region-specific formats (GST invoices in India, VAT receipts in the EU, handwritten rickshaw slips) that general-purpose APIs handle unevenly. If a vendor changes pricing or deprecates a model, my product doesn't break.

Where closed would have been better: a frontier hosted model probably has higher raw accuracy on very bad photos. The review lane and confidence threshold are how I make up for that, and for this use case, "private and cheap with a human check on the hard 5%" beats "slightly more accurate but uploads everything."

Prize Categories

Pocket Naturalist

Abhinav Amrute — Thu, 08 Oct 2026 18:10:03 +0000

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

What I Built

Pocket Naturalist is an offline field guide that helps you learn the plants and trees around you without staring at a screen.

You snap one photo of a leaf, bark, or flower, then put the phone back in your pocket. A local vision-language model identifies the likely species, and a short spoken note plays in your earbuds: the name, one interesting fact, and a "look for this next" prompt, like the shape of the bark or the berries nearby. The screen is only used for the single photo, and everything else is audio.

It's for casual hikers, parents on weekend walks, and anyone who has wondered "what is that tree?" but didn't want to stop and search. It works with no signal, which is where most good trails are.

Demo

Coming soon. I'll add a short video of a real trail walk after my first field test.

Code

Coming soon. The repo will be open-source and linked here.

How I Built It

Model: a small open-weight vision-language model (such as a Gemma or Qwen-VL variant), quantized to run on a laptop or recent phone-class device.
Inference: fully local through llama.cpp / Ollama. No API calls and no network needed after the initial model download.
Text-to-speech: an open-source offline TTS engine (such as Piper) reads the result aloud.
Agent logic: a lightweight loop that takes the photo, produces a species guess with a confidence level, adds a short fact, and generates a "look for this next" prompt so the walk keeps going.
Safety rail: the app never says anything is safe to eat. If confidence is low, it says "I'm not sure, here are two possibilities" instead of guessing. Foraging is deliberately out of scope.

Why Does Open Innovation Matter?

It works where the trail has no signal. A closed API can't identify a plant from a ridgeline with zero bars. A local open-weight model can.
Your photos and location stay on your device. Nobody's walking habits get uploaded to a server they don't control.
It costs nothing per scan. With no API fees, you can scan 200 leaves on one walk.
It can be fine-tuned for a region. Because the weights are open, a local nature club could tune the model on regional flora and share it.
Models are swappable. As better small open models appear, upgrading means changing one line instead of rewriting around a new vendor.

My Agent Session

Coming soon. I'll save my build session with DevRelay and link it here.

Prize Categories

Open-weight models, local inference.

Submission hactoberfest

Abhinav Amrute — Sun, 04 Oct 2026 13:31:54 +0000

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