DEV Community: Srujan Kaleru

LocalReceipts AI: Private Receipt-to-CSV Automation for Indian Freelancers

Srujan Kaleru — Mon, 19 Oct 2026 06:48:42 +0000

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

What I Built

LocalReceipts AI turns receipt images and PDF invoices into an editable expense register, with all receipt processing on the user's laptop.

It is designed for freelancers and small business owners in India who need to hand their Chartered Accountant something more useful than a folder of photographs.

The workflow is deliberately small: upload bills, extract their details with a local vision model, correct the results, and download an accounting CSV. There is also a JSON backup containing the edited records and original extraction for comparison.

The app supports:

Batch PNG, JPG, JPEG and PDF uploads, with document/page previews.
Vendor name, invoice date, expense category, vendor GSTIN, subtotal, tax amount, total and line-item summary.
Six expense categories: Software, Travel, Meals, Office Supplies, Utilities and Professional Services.
An editable table with expense and tax totals, review notes and a Reviewed checkbox.
CSV exports with readable accounting headers and JSON backups.
Friendly handling of unavailable Ollama servers, missing models, malformed responses and damaged or protected documents.

GSTIN stays a text identifier, separate from the numeric tax amount. Missing amounts stay blank: an unreadable tax figure should never silently become zero.

Who would pay for it? The customer hypothesis is an independent consultant, freelancer or small business that spends time retyping receipts but does not want to upload client or financial documents to a cloud service. A potential paid offering would be assisted installation, model configuration and support for their receipt workflow. That is a business hypothesis, not validated demand: I do not yet have a paying customer or external user study.

Demo

This is a local desktop utility. There is currently no public hosted app or video demo. The repository contains a runnable synthetic demonstration and setup instructions so readers can reproduce the workflow without providing private receipts.

Run the synthetic receipt demo · Installation and app walkthrough

After installing Python dependencies and downloading a vision model, configure Ollama in local-only mode and run the app. On Windows:

# In the Ollama terminal, after exiting any existing Ollama instance:
$env:OLLAMA_NO_CLOUD = "1"
$env:OLLAMA_HOST = "127.0.0.1:11434"
ollama serve

# In another terminal, from the cloned repository:
.\.venv\Scripts\python.exe -m streamlit run app.py

Select an installed vision model, upload a receipt, inspect the preview, extract it, edit the table and download the CSV. The app's default model name is llama3.2-vision; custom installed models are supported.

For a repeatable test, the demo script generates a fictional software-store receipt and sends it to local Ollama:

.\.venv\Scripts\python.exe scripts\smoke_local_model.py --model qwen3.5:4b

In the live local test, qwen3.5:4b returned:

Field	Extracted value
Vendor	SAMPLE SOFTWARE STORE
Invoice date	2026-10-19
Category	Software
GSTIN	null
Subtotal	INR 1,000.00
Tax	INR 180.00
Total	INR 1,180.00
Items	Software subscription

The script checks the expected tax and total. This is one synthetic test, not a claim of general receipt accuracy. The smaller installed moondream model returned valid JSON but incorrect amounts on this example. That failure is documented too: structured output does not make an answer financially correct.

Code

GitHub repository: LocalReceipts AI

srujankaleru2007 / locarecieptsAi

LocalReceipts AI

A modular, offline Streamlit desktop utility for Indian freelancers and small businesses. PNG/JPEG bills and multi-page PDF invoices become an editable INR expense register, with CSV and JSON downloads.

Install once (internet needed for packages and model weights)

Requires Python 3.10+ and a recent local Ollama installation. Model memory requirements vary substantially; choose one that fits your machine. The default llama3.2-vision can be slow without sufficient GPU memory. minicpm-v and llava are alternatives.

From this directory in PowerShell:

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements.txt
ollama pull llama3.2-vision

Set Ollama to local-only mode before processing private documents. Quit the Ollama tray application first, then start its server in a dedicated terminal:

$env:OLLAMA_NO_CLOUD = "1"
$env:OLLAMA_HOST = "127.0.0.1:11434"
ollama serve

Keep that terminal open. If Ollama reports the port is…

View on GitHub

The repository includes the application, modular extraction code, dependency files, a Windows launcher, tests, setup documentation and validation notes.

How I Built It

The stack is Python, Streamlit, the Ollama Python SDK, Pandas, Pillow and PyMuPDF. Local open-weight vision models perform the extraction; there is no hosted model fallback.

The pipeline is:

Image / PDF
  → bounded in-memory decoding
  → local vision extraction
  → JSON parsing and field normalization
  → editable expense register
  → CSV / JSON download

For PDFs, PyMuPDF renders pages locally. Each page is sent individually to Ollama, followed by a local text reconciliation pass that produces one invoice record. The prompt explicitly warns against summing repeated totals and page carry-forwards. Multi-page results still require review against the originals.

The model receives a JSON schema and instructions to leave uncertain fields null. A fallback parser handles markdown fences or surrounding text. Separate validation normalizes amounts and dates and flags missing fields, suspicious GSTIN formatting and inconsistent totals.

A few details mattered more than the happy-path demo:

Privacy extends beyond the hostname. Requests are pinned to loopback, ignore proxy environment variables and do not follow redirects. Cloud-named and remote-backed models are rejected before images are sent. Model metadata is preserved because an SDK can otherwise discard fields identifying a remote-backed alias.
The server needs its own configuration. Ollama should be started with cloud features disabled. Setting an environment variable in the Streamlit terminal does not reconfigure an already-running Ollama server.
Edits must survive reruns. The editor applies changes to canonical session records so metrics and exports reflect corrections.
CSV is an execution surface. Text that could be interpreted as a spreadsheet formula is escaped in CSV exports.
One failure should not lose the batch. Successful receipts remain available when another file fails, and identical file contents are skipped.

The automated suite passed 35 tests covering parsing, financial normalization, PDFs, image conversion, local transport, model failures, multi-page request handling, exports and Streamlit state. Dependency compatibility checks also passed. These checks complement, rather than replace, OCR testing on representative documents.

Current limits are explicit: the app is single-user, records are held in session memory, backups need to be downloaded before ending a session, and accuracy depends on the model and scan quality. Its CSV is an expense register for accountant review—not a statutory GST return or a determination of input-tax-credit eligibility.

Why Does Open Innovation Matter?

Local inference makes the privacy promise practical. Once dependencies and model weights are installed, the workflow can run without an internet connection. Receipt images do not need to be sent to a hosted inference API.

There is no per-receipt hosted inference fee. Hardware, electricity, installation and support still cost money, but processing more bills does not inherently create another cloud API bill. That makes a small support-oriented business model worth exploring.

Models are replaceable. The contrast between the two locally tested models is a useful example: I can compare another model using the same synthetic test and choose based on observed results. I am not tied to one provider's endpoint or pricing.

The workflow can be inspected and adapted. The parsing, review and export logic is visible in the repository. Future work could target specific receipt layouts or accountant workflows, while checking model and dependency licensing before commercial distribution.

The next step is a local pilot with real users and representative receipts, measuring correction time and error patterns before making stronger accuracy or commercial claims.

AI disclosure: Codex assisted with implementation and testing and authored this submission text. The reported test results are from actual runs; no customer feedback or revenue is claimed.

WildXP — An Offline-First Mobile RPG Built to Reduce Screen Time with Local Open-Source AI

Srujan Kaleru — Fri, 09 Oct 2026 09:53:03 +0000

What I Built

Core Pitch: “I built an AI application whose primary goal is to make you stop using it.”

WildXP is an offline-first, open-source AI-powered real-world exploration RPG designed for mobile devices. Unlike modern screen-time products, feeds, or infinite chatbots, WildXP uses local artificial intelligence to prepare outdoor experiences, gamify real-world discoveries, and then get out of the way.

Who Is It For?

WildXP is built for anyone who wants a reason to step away from screens, explore their immediate surroundings, learn about local flora and fauna, and build a meaningful personal exploration history without broadcasting their private data or location to cloud servers.

Key Features

Anime-Inspired RPG Quest Window: Receives daily micro-quests (e.g., "Eastbound Hunter: Take a 20-minute walk east and discover 2 unique plants"). Quests dynamically target underexplored bearings relative to your home area.
“What The Hell Is That?” (Local VLM Scanner): Point your phone camera at an interesting bird, tree, insect, plant, or object. Local vision AI identifies the subject, assesses honest uncertainty (strong_match, possible_match, or not_sure), provides visual clues, and sets a tiny observation challenge.
Deterministic Real-World RPG Stats: Earn XP, increase your Explorer Level, track verified outdoor time, monitor screen-off/phone-free minutes, and view directional exploration coverage. All stats are strictly grounded in true execution data—never faked or hallucinated by LLMs.
End-Day Audio Narrator: At sunset, a local language model aggregates your verified MongoDB daily activity into a short narrative story, which is spoken aloud using local Text-to-Speech (TTS).
Private Exploration Journal: Keeps a permanent offline record of all discovered species, places visited, and earned achievements.

Demo

Live Repository & Architecture: [https://github.com/srujankaleru2007/WildXP.git]
Visual Preview:

[https://drive.google.com/file/d/1eXNSCBKwYQfots2dL7NBNqrnik2bF9bL/view?usp=sharing]

Anime Quest Window: Mobile-optimized dark HUD with directional exploration compass.

VLM Scanner: Real-time camera viewfinder with instant offline classification and XP reward toast.

Audio Summary: Interactive audio player for your daily spoken exploration story.

Code

srujankaleru2007 / WildXP

Prize Categories

Overall Winner / Main Category: Touch Grass (Hacktoberfest Week 1)
Best Use of Gemma: Used gemma3:1b locally via Ollama to synthesize daily outdoor stats into narrative recap scripts for speech output.
Best Use of MongoDB Atlas: Used MongoDB as the primary offline-first database store to log player discoveries, track screen-off and GPS distance metrics, maintain directional geohash exploration statistics, and serve ground-truth data to the local AI narrator.

The Chaos Translator — Turning Scattered Information into Actionable Intelligence

Srujan Kaleru — Mon, 05 Oct 2026 05:26:51 +0000

What I Built

The Chaos Translator is an AI-powered platform that transforms scattered information from conversations and documents into structured, actionable intelligence.

It can process WhatsApp chat exports, PDFs, DOCX, PPTX, images, and audio recordings, bringing related information together instead of treating every file as an isolated source.

It extracts and connects:

People and participants
Tasks, owners, and deadlines
Important decisions and events
Dependencies and unanswered questions
Contradictions across different sources
Evidence-backed action plans

Its key differentiator is cross-source intelligence. For example, if a WhatsApp conversation mentions one deadline while an uploaded document mentions another, The Chaos Translator identifies the conflict and presents the supporting evidence instead of silently choosing one.

Users can also investigate their uploaded information through conversational AI and trace answers back to their original sources.

The Problem

I built this for my friends, particularly those who regularly collaborate on projects, hackathons, college activities, and group work.

Important information often gets scattered across WhatsApp groups, documents, screenshots, and voice notes. Deadlines get buried in conversations, responsibilities become unclear, and decisions are difficult to track.

Finding out what was decided, who is responsible, and what needs to happen next can become a task of its own.

The Chaos Translator aims to eliminate this information chaos by connecting scattered details and turning them into one actionable picture.

Demo

Demo Video Link: https://drive.google.com/drive/folders/1Jl-xs_hhN7MYlpdhMsU3VPUOVefHQQ-r?usp=sharing

Source Code

GitHub Repository: https://github.com/srujankaleru2007/Chaos_Translator.git

How I Built It

The project uses a full-stack architecture:

Frontend: Next.js, React, TypeScript, and Tailwind CSS.
Backend: Python and FastAPI.
Database: MongoDB Atlas for persistent storage.
AI and Reasoning: Qwen 3.5 4B for lightweight extraction and GPT-OSS-20B through Groq for complex reasoning and cross-source analysis.
Document Processing: Docling for document extraction.
OCR: PyTesseract integration for image text extraction.
Audio Processing: Faster-Whisper integration for speech transcription.

The system follows a source-first architecture: extracted information retains its original source and evidence references, allowing the intelligence layer to connect findings without losing their provenance.

Why Open Innovation Matters

The project brings together open-source models, document-processing tools, and developer platforms to solve a practical problem.

Rather than relying on a single closed system, it combines specialised tools and models into a modular architecture. This makes the platform easier to extend, inspect, and adapt.

Categories
GitHub Copilot
ElevenLabs
MongoDB