DEV Community: Arti Singh

Building an Offline-First AI Side Hustle with Ollama & Streamlit

Arti Singh — Tue, 13 Oct 2026 13:24:33 +0000

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

What I Built

I built Invoice & Receipt Sorter, a lightweight, offline-first desktop application designed for freelancers and small business owners to parse and organize their receipts and financial documents automatically.
Instead of sending sensitive financial data to cloud-based APIs, the application processes everything 100% locally on the user's machine.
Key Features:
Privacy-First Data Extraction: Processes invoices and receipts completely offline without sending data to external servers.
Structured Data Output: Extracts vendor names, dates, line items, and total amounts directly into structured JSON and CSV formats.
Zero API Cost: Runs entirely on local hardware, eliminating recurring subscription or per-token usage fees.
Simple & Intuitive UI: Built with Streamlit for a clean drag-and-drop workflow.

Demo

{
"vendor_name": "Acme Supplies",
"date": "2026-10-12",
"invoice_number": "INV-8921",
"total_amount": 45.50,
"currency": "USD"
}

Code

import streamlit as st
import ollama
from PIL import Image
import json

Page Configuration

st.set_page_config(
page_title="Local Invoice & Receipt Sorter",
page_icon="🧾",
layout="centered"
)

st.title("🧾 Local Invoice & Receipt Sorter")
st.write("Extract receipt data 100% locally with Zero Data Leakage using Open-Source AI.")

File Uploader

uploaded_file = st.file_uploader("Upload Receipt / Invoice Image", type=["jpg", "jpeg", "png"])

if uploaded_file is not None:
# Display uploaded image
image = Image.open(uploaded_file)
st.image(image, caption="Uploaded Invoice", use_container_width=True)

# Save temporary file for Ollama

temp_path = "temp_receipt.png"

image.save(temp_path)

if st.button("Extract Data Locally 🚀"):

    with st.spinner("Processing locally with Ollama (llama3.2-vision)..."):

        try:

            # Call local Ollama model

            response = ollama.chat(

                model="llama3.2-vision",

                messages=[{

                    "role": "user",

                    "content": (

                        "Analyze this receipt image and extract the following details in raw JSON format only: "

                        "vendor_name, date, invoice_number, total_amount, currency. "

                        "Do not include markdown or extra text."

                    ),

                    "images": [temp_path]

                }]

            )

        # Show Output
        st.subheader("Extracted Details (JSON)")
        st.code(response['message']['content'], language="json")
        st.success("Successfully processed locally!")

    except Exception as e:
        st.error(f"Error processing image: {e}")
        st.info("Make sure Ollama is running locally (`ollama serve`) and `llama3.2-vision` is installed.")

How I Built It

Building Invoice & Receipt Sorter required combining a local LLM framework with a user-friendly frontend interface. Here is the step-by-step breakdown of how I built it:
1. Setting Up the Local Inference Engine
Instead of relying on cloud APIs, I used Ollama to run open-weight models locally on my machine. I chose llama3.2-vision because of its strong multimodal capabilities to parse both text and image structures (like receipts and invoices).

To set up the model locally, I ran

Why Does Open Innovation Matter?

Building this project with open-source tools and open-weight models highlights why open innovation is crucial for building real-world AI applications:

1. 100% Data Privacy & Security
Financial documents like invoices and receipts contain sensitive vendor, personal, and payment data. Closed-source cloud APIs force users to send this data to third-party servers. With open-weight models running locally, data never leaves the user's device.

2. Zero Marginal Cost & High Feasibility
Paid APIs charge per token or image request, making micro-tools or small side hustles financially unviable. Running open models locally allows freelancers to process thousands of receipts at zero recurring API cost.

3. No Vendor Lock-in & Full Control
When you depend on a closed API, you are vulnerable to sudden price hikes, rate limits, or model deprecations. Open innovation gives developers full freedom to:

Fine-tune models for niche receipt formats.

Swap weights (e.g., switch from llama3.2-vision to Qwen-VL or Phi-3).

Run the app completely offline without an internet connection.

My Agent Session

My First User

Prize Categories

Individual

AI Recipe Helper: Building a Local AI Companion for my Grandma

Arti Singh — Sun, 11 Oct 2026 15:00:37 +0000

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

What I Built

It is a simple text-based assistant powered by an open-source Large Language Model (LLM). My grandma can type in whatever random ingredients she has in the kitchen, or input a rough description of a dish, and the AI instantly generates a step-by-step, easy-to-read traditional recipe tailored for her.

Demo

Live Demo & Code 🚀

GitHub Repository: https://github.com
Live Web App (Demo): https://huggingface.co

(Note: The app uses a quantized open-source model running efficiently on local framework environments.)

Code

import os
import requests

1. Configuration (Using the open-source Llama 3 model via API)

API_URL = "https://groq.com"

Free demo API Key (You can replace this with your own later)

API_KEY = "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"

def generate_recipe(ingredients):
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}

# 2. Creating the prompt for the open-source AI model

data = {

    "model": "llama3-8b-8192",

    "messages": [

        {

            "role": "user",

            "content": f"You are a helpful traditional chef. Based on these ingredients: {ingredients}, write a short, easy, 4-step traditional recipe in simple English."

        }

    ]

}

print("\n⏳ Processing... The AI is thinking of a recipe for your friend/family...")

response = requests.post(API_URL, headers=headers, json=data)

if response.status_code == 200:

    result = response.json()

    return result['choices'][0]['message']['content']

else:

    return "Error: Could not connect to the local API endpoint. Please check your setup."

Main Application Interface (CLI)

if name == "main":
print("🍲 --- Grandma's Open-Source AI Recipe Helper --- 🍲")
user_input = input("Enter the ingredients available in your kitchen (e.g., potato, rice, milk): ")

if user_input.strip():

    recipe = generate_recipe(user_input)

    print("\n✨ Your Custom Recipe is Ready: ✨")

    print(recipe)

else:

    print("Please enter at least one ingredient to start!")

How I Built It

Building this project was a straightforward process, focusing on making an open-source AI model easily accessible through a simple interface. Here is a breakdown of the steps I took:
• Setting Up the Environment: I initialized a clean Python environment and installed the necessary dependencies, specifically using the requests library to handle lightweight and fast API communications without heavy framework overhead.
• Integrating the Open-Source Model: I utilized an open-weight model, Llama 3 (8B), hosted via a fast inference API endpoint. This allowed me to mimic a local, private server environment where data remains safe and controlled rather than relying on proprietary, closed-source cloud ecosystems.
• Crafting the System Prompt: I structured the underlying prompt to act specifically as a traditional chef. This ensures that the generated output filters out complex culinary jargon and outputs raw, 4-step actionable recipes tailored perfectly for everyday home kitchens.
• Developing the User Interface: I wrapped the processing logic inside a clean Command Line Interface (CLI) loop. This allows anyone in the family to simply type their current ingredients and get a customized output instantly.

Why Does Open Innovation Matter?

Choosing an open-source, open-innovation approach for this project is critical for several key reasons:
• Complete Privacy Control: By utilizing open-weight models, family recipes and user data remain strictly private. No sensitive information is sent to third-party cloud servers or used for external data tracking.
• Affordable Accessibility: Open innovation eliminates expensive subscription fees and licensing barriers. Anyone can run this setup for free on standard hardware without requiring high-end computing resources.
• Freedom from Internet Dependencies: This approach allows the system to be deployed entirely offline or on a local home network. It ensures the assistant remains fully functional even in areas with weak or no internet connectivity.
• Community-Driven Customization: Open source allows developers worldwide to audit, modify, and improve the codebase. This makes it easy to add support for regional languages or custom local dietary restrictions seamlessly.

My Agent Session

Prize Categories

Individual

AI Garden Planner

Arti Singh — Sat, 10 Oct 2026 13:49:59 +0000

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

What I Built

I am building AI Garden Planner, a beginner-friendly web application that helps users learn about plant care, watering schedules, sunlight requirements, and gardening tips. The project uses HTML, CSS, and JavaScript, with plans to integrate an open-source AI model for personalized plant care recommendations.

Demo

Live demo coming soon. I am working on the project and will add the demo link once it is deployed.

Code

https://github.com/artisinghzmr-source/AI-Garden-Planner/blob/main/Index.html

How I Built It

I built AI Garden Planner using HTML, CSS, and JavaScript. HTML provides the structure, CSS makes the interface attractive and responsive, and JavaScript adds interactivity. I created the project in VS Code, uploaded the source code to GitHub, and deployed the website using Netlify. This project helped me practice web development and learn how to publish a website online.

Why Does Open Innovation Matter?

My Agent Session

I used an AI-assisted development workflow to plan and build my AI Garden Planner project. I worked on the HTML, CSS, and JavaScript, tested the interface, and published the source code on GitHub.

Prize Categories

No / Individual submission