DEV Community: Kaushani Koner

ssorg.dev: I Built a Local AI Librarian for All Those Screenshots I Keep Forgetting About 🦥

Kaushani Koner — Sat, 24 Oct 2026 15:25:46 +0000

What I Built

We all have that one folder: hundreds of screenshots, useful information buried somewhere, and absolutely no idea where to find a particular image when we need it.

A screenshot of a coding error. A tutorial I wanted to try. An important reference. A piece of information I saved because I thought, “I'll need this later.”

And then I never find it again.

That's why I built ssorg.dev — a local-first, AI-powered screenshot organizer that helps turn a messy screenshot collection into a searchable personal knowledge library.

Instead of manually opening images one by one, ssorg.dev helps you find the information inside them.

Here's what it can do:

Extract text with OCR: Reads text from screenshots using Tesseract.
Organize with local AI: Uses Gemma 3 4B through Ollama to help generate summaries and structured metadata.
Build a searchable library: Stores screenshot records and metadata in SQLite for future searches.
Find screenshots by keywords: Search extracted text and browse matching results.
Ask ssorg: Ask questions about matching screenshots and receive answers grounded in retrieved records, with source references.
Detect exact duplicates: Uses SHA-256 hashing to identify identical image files.

The goal isn't to add more work to my workflow. It's to make the information I've already saved easier to find.

🎥 Demo

Watch the ssorg.dev demo video:

▶️ Watch the ssorg.dev Demo

The video demonstrates the project in action, including its screenshot organization and search workflow.

Code

GitHub Repository: https://github.com/kaushanikoner20-hub/ssorg.dev

The project is open source and licensed under the MIT License.

How I Built It

I wanted to build something practical using open-source AI while keeping my screenshots and their contents on my own machine.

My stack includes:

Python — application logic
Streamlit — user interface
Tesseract OCR and pytesseract — text extraction from screenshots
Gemma 3 4B — local AI-assisted classification, summaries, and metadata generation
Ollama — running the model locally
SQLite — persistent storage for screenshot records and metadata
Pillow — image handling
SHA-256 — exact duplicate detection

The workflow is straightforward:

Upload screenshots.
Extract their text using OCR.
Use the local Gemma model to help interpret and organize the extracted information.
Save the results in a local SQLite database and screenshot library.
Search the collection or ask a question about relevant screenshots.

For question answering, ssorg.dev retrieves matching records and uses their content as evidence. It also validates source references so answers can be connected to the records they came from.

I designed the project around local processing rather than a cloud AI API. This makes privacy a core design choice, not an afterthought.

Building it also meant thinking beyond the happy path: handling processing errors, validating uploads, confirming deletions, detecting duplicates, and avoiding unsupported answers when relevant evidence cannot be found.

Why Does Open Innovation Matter?

Open innovation matters because useful AI tools shouldn't have to depend on expensive services, closed platforms, or sending personal information to external providers.

With ssorg.dev, I wanted to explore how an open-weight model like Gemma can support a small but meaningful everyday workflow.

Screenshots can contain code, personal notes, account details, study materials, and other sensitive information. Keeping the AI workflow local gives users more control over where that information is processed.

The project also brings together accessible technologies that developers can inspect, learn from, and extend.

For me, open-source AI is not only about making a model available. It's about giving people the ability to build useful tools around it and adapt those tools to their own needs.

The Lazy Payoff 🦥

The idea behind Slow and Steady fits this project perfectly.

I don't want to spend time naming every screenshot, sorting every image into folders, or scrolling endlessly to rediscover something I saved weeks ago.

I'd rather let the computer handle the repetitive parts and spend my time doing something more useful.

ssorg.dev is my attempt to make that possible: extract the text, organize the information, and make it searchable when I need it.

I haven't quantified time saved in a formal benchmark, so I won't claim a specific productivity improvement. The benefit I'm aiming for is simple: less manual searching and a better chance of finding information I've already captured.

It's a small tool for a familiar problem, built with local AI and open-source technology.

Prize Categories

Best Use of Gemma

ssorg.dev uses Gemma 3 4B through Ollama for local AI-assisted screenshot organization and metadata generation. This is the category that best matches the project's actual implementation.

Closing Thoughts

This project started with a simple question:

What if saving a screenshot meant I could actually find it again?

Building ssorg.dev has been an opportunity to explore local AI, OCR, retrieval-grounded question answering, and privacy-conscious application design in one practical project.

I'd love to hear from you:

How do you manage the screenshots, notes, and bits of information you keep saving for later? Would you use a local AI librarian for them?

If you're interested, check out the demo and explore the code on GitHub. Contributions, feedback, and ideas are welcome!

BillBuddy AI: Private Expense Tracking for Freelancers, Powered by Gemma and Ollama

Kaushani Koner — Sun, 18 Oct 2026 15:56:03 +0000

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

Every freelancer knows the pile: photos of receipts, PDF invoices, and a spreadsheet that never gets updated until tax time. I built BillBuddy AI to turn that pile into organized expenses, without uploading a single receipt to someone else's server.

What I Built

BillBuddy AI is a receipt and invoice organizer that runs entirely on your own computer.

You drop in a receipt (JPG, PNG, or PDF).
OCR reads the text.
An open-weight model, Gemma, suggests the vendor, date, and total.
You check and correct the fields, then save them.
The app keeps a searchable expense list with totals per currency, a category breakdown, and a CSV export.

Who would pay, and why. Freelancers and small shop owners spend hours each month typing receipts into spreadsheets. Many of them are also uneasy about sending financial documents to a cloud AI service, because those documents hold client names, addresses, and purchase history. A tool that does the typing locally removes both problems. The side hustle angle I'm exploring is offering receipt and expense organizing to small local businesses: use BillBuddy to cut the data entry, and charge per batch or per month.

I want to be upfront: this is a working prototype. Nobody has paid for it yet, and I haven't tested whether people would.

Demo

BillBuddy runs on your own computer (that is the whole point), so there is no hosted link. Here is a 2-minute walkthrough of the full flow, from reading a receipt to saving, searching, and deleting expenses:

▶ Watch the 2-minute demo

[Drag your screenshots into the DEV editor here: the receipt-style OCR text panel, the AI-suggested fields with a warning visible, and the saved expenses with totals in two currencies. Fake receipts only.]

Code

kaushanikoner20-hub / BillBuddyAI

BillBuddy AI

An open-source, local-first receipt and invoice organizer for freelancers and small businesses Read a receipt with OCR, let an open-weight AI model (Gemma, running on your own computer through Ollama) suggest the expense details, correct them, and save them to a local SQLite database.

Screenshots

Demo

Watch the 2-minute demo

Features

Upload JPG, JPEG, PNG, or PDF receipts (10 MB limit, first 5 PDF pages are read)
Read the text with Tesseract OCR, including scanned PDFs
Gemma suggests the vendor, date, and total. The currency is detected from the receipt text itself.
Warnings when a suggested value does not appear in the receipt text
Review and correct every field, or fill in the form manually
Save expenses (vendor, date, total, currency, category, description) in SQLite
Search by vendor or description, filter by category and date, edit, and delete with confirmation
Dashboard: number of receipts, totals per currency…

View on GitHub

The repository has Windows setup instructions, a .env.example, automated tests, a GitHub Actions workflow, and an MIT license.

How I Built It

Receipt (JPG / PNG / PDF)
   -> Tesseract OCR (PDF pages rendered with PyMuPDF first)
   -> Gemma through Ollama, running locally, suggests fields
   -> validation and warnings
   -> you review and correct
   -> saved in SQLite (reviewed fields only)

Open-weight model: Gemma 3 (gemma3:4b) served locally by Ollama. The backend calls Ollama's local API with temperature 0 and JSON output.
OCR: Tesseract with Pillow. Scanned PDFs work too, because each page is rendered to an image first.
Backend: Python and FastAPI. Storage: SQLite, with only the fields you reviewed, not the receipt file or the full OCR text.
Frontend: React and Vite.

I built it in stages with help from an AI coding assistant, testing each stage on my own machine before moving on.

The lesson: a small model fills in blanks

The part that taught me the most was the currency field. I tested an Indian bill, and the app labeled the amount in USD. Nothing on the bill said dollars. The 4B model simply guessed, because a blank is uncomfortable for a language model. Tesseract's default settings can also misread the ₹ sign, so the model often never saw it.

So I stopped asking the model about currency. BillBuddy now detects it from the receipt text itself: a currency code, ₹, Rs, or Indian tax terms like GSTIN and CGST. When the text doesn't say, the field stays empty. A plain $ isn't enough either, because it doesn't tell you the country. An empty field you fill in yourself is better than a confident wrong one.

That one bug shaped how the whole app treats the model:

Never trust the output. Dates must be real dates, amounts must be non-negative numbers, and anything else becomes empty.
Warn when the numbers don't appear in the receipt. If the model suggests a total that isn't in the OCR text, the app says so.
Treat receipt text as untrusted. A receipt can contain instructions meant to steer the model, so the prompt tells it to ignore them, and the answer is validated anyway.
Never mix currencies. Totals are grouped by currency, so rupees and dollars are never added together.
Export safely. CSV cells that start like a spreadsheet formula are neutralized.

Because everything is local, testing was easy too: the tests replace the model with a stand-in, so the suite runs without Ollama, and a GitHub Actions workflow runs the tests and the frontend build on every push.

Limits

The AI can be wrong, so a person reviews every field before saving. I haven't measured extraction accuracy on real receipts, so I won't claim a number. There is no login or database encryption, so it is meant for one local user, and I developed and tested it on Windows.

Why Does Open Innovation Matter?

A receipt is exactly the kind of document you don't want to hand to a third party: it has names, addresses, and what you bought and where. With an open-weight model running locally, the receipt text never leaves the computer. A closed cloud API can promise to be careful with it, but it still has to receive it.

Open also changed the economics. There are no API keys and no per-receipt fee, so it costs nothing extra whether a shop processes ten receipts or ten thousand. For a business that might run this every day, that is the difference between a tool that works and one that eats the margin. After the one-time downloads, the pipeline doesn't need the internet.

And the model is one setting. If a larger Gemma, or a different model, reads receipts better, I change a single line instead of rewriting the app or being locked into someone's pricing.

I'll be honest about the trade-off: a 4B model on a laptop is less accurate than a large hosted model, and that is why the review step and the validation exist. For this use case, I think a reviewed, private, free-to-run answer beats a faster one that needs your documents uploaded.

Prize Categories

Best Use of Gemma: BillBuddy runs Gemma 3 (4B) locally through Ollama to read OCR text and suggest expense fields, with validation and warnings built around its answers.

TrailBuddy: The AI That Disappears—Powered by Gemma, Built to Get You Outside

Kaushani Koner — Fri, 09 Oct 2026 19:21:39 +0000

TrailBuddy: The AI That Disappears

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

What I Built

TrailBuddy turns a few choices—your mood, available time, activity, and preferred difficulty—into a personalized outdoor adventure.

It isn’t meant to be an AI companion you keep checking while you’re outside. Gemma designs a short sequence of sensory missions: listen for a sound you usually miss, notice a pattern, or explore your surroundings with curiosity. TrailBuddy then asks whether you’re going out, shows a closing scene where a bird takes off, and invites you to put your phone away.

The idea behind it is simple:

“What if the best thing an AI could do for you was make you stop looking at it?”

After generating and preparing an adventure, you can continue through its missions offline. Progress and an optional reflection are saved in your browser. Generating a new adventure still requires the configured backend and Ollama/Gemma to be available.

Demo

Watch the TrailBuddy screen recording

Code

TrailBuddy on GitHub

How I Built It

TrailBuddy uses Gemma 3 (gemma3:4b) through Ollama for local adventure generation. The React and Vite frontend sends the selected preferences to a Node.js and Express backend, which requests a structured adventure from the model and validates the response before showing it.

The frontend presents the generated missions one at a time in Phone Away Mode. The closing scene uses Three.js, and the production app includes a service worker that caches the application shell and assets for a prepared offline adventure. Local progress and reflections are stored in browser storage.

Why Does Open Innovation Matter?

The open-weight Gemma model and local Ollama setup let me build around a model I can run and experiment with on my own machine. I could shape the prompt for a specific purpose—an outdoor experience designer—and validate the result as structured missions instead of building another general-purpose chat interface.

Local inference also means the default setup doesn’t need a cloud LLM API to generate an adventure. The offline flow goes further: once an adventure is prepared, the user can leave the AI and backend behind and continue with the saved missions. That distinction matters: a new adventure still needs the configured model and backend.

My Agent Session

TrailBuddy Hacktoberfest Submission

You

Curate and save an Agent Session for my TrailBuddy Hacktoberfest submission. Remove secrets, credentials, and private machine paths. Save the session only—don’t create or publish my DEV article. Return the session ID or slug and the exact {% agent_session ... %} tag.

Agent

Saved this curated Agent Session for the TrailBuddy Hacktoberfest submission. No secrets, credentials, or private machine paths are included.

Prize Categories

Best Use of Gemma

devchallenge #hf26challenge

New to community!

Kaushani Koner — Fri, 02 Oct 2026 19:30:03 +0000

hello everyone