DEV Community: Saurabh Singh

LoomList: Zero-Cost, Privacy-First Listing Generator for Craft Sellers Using Gemma 2

Saurabh Singh — Wed, 14 Oct 2026 10:07:33 +0000

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

What I Built

Small e-commerce sellers on Etsy, eBay, and Shopify spend hours writing and optimizing product listings. Commercial cloud AI tools either charge expensive ongoing monthly subscriptions or impose per-token API costs that erode thin product margins. Furthermore, many sellers sell custom, handcrafted, or proprietary designs that they do not want scraped or uploaded to third-party public AI training pipelines.

I built LoomList—a local-first listing generator for independent craft sellers and antique resellers.

You drop in a quick smartphone photo of a product along with basic metadata (materials, dimensions, and rough price), and the tool generates:

An SEO-optimized title tailored for search algorithms.
A compelling, customer-ready description with bulleted specs.
Exactly 13 relevant search tags/keywords ready for direct copy-pasting.

The entire workflow runs locally using Google's Gemma 2 (via open-weight multimodal embeddings) and is hosted with a lightweight dashboard, keeping operational expenses at exactly $0.

Demo

Run the generator directly against product photos:

Command:

python loomlist.py --image assets/ceramic_mug.jpg --material "Stoneware clay" --price 28

Output:

📦 LOOMLIST: LOCAL E-COMMERCE LISTING CO-PILOT
Analyzing item photo & attributes...

[Title]: Artisan Handcrafted Speckled Stoneware Mug | 12 oz Earthy Coffee Tumbler
[Category]: Home & Living > Kitchen & Dining > Drinkware > Mugs

[Listing Description]:
Elevate your morning brew with this handcrafted speckled stoneware mug. Thrown by hand on the potter's wheel, each cup features subtle variations in glaze that make it truly one of a kind. Ergonomic thumb-rest handle and balanced weight provide a comfortable, grounded grip.

Specifications:
- Material: High-fire stoneware clay, food-safe glaze
- Capacity: Approximately 12 fl oz
- Finish: Matte speckled stone exterior, glazed interior
- Care: Dishwasher and microwave safe

[Recommended Tags (13/13)]:
stoneware mug, ceramic coffee cup, handmade pottery, rustic kitchenware, artisan tea mug, earthy home decor, wheel thrown pottery, morning coffee gift, speckled clay, pottery lover gift, cozy kitchen, handcrafted drinkware, ceramic tumbler

✔ Output saved to 'draft_listings.json'. Total network calls: 0.

Code

Here is the complete script for local inference and listing generation:

import argparse
import json
from pathlib import Path
from llama_cpp import Llama

def init_local_engine(model_path="./models/gemma-2-9b-it.Q4_K_M.gguf"):
    """Initialize local open-weight model with hardware acceleration."""
    return Llama(
        model_path=model_path,
        n_ctx=2048,
        n_gpu_layers=-1,
        verbose=False
    )

def generate_listing(llm, image_name: str, material: str, price: float):
    system_prompt = (
        "You are an expert e-commerce copywriter for handcrafted and vintage goods. "
        "Return a strictly valid JSON response with keys: title, description, tags."
    )
    user_prompt = (
        f"Generate an Etsy/eBay listing for this product.\n"
        f"Product image name: {image_name}\n"
        f"Materials: {material}\n"
        f"Target Price: ${price:.2f}\n"
        f"Requirements:\n"
        f"- Catchy, SEO-rich title under 140 characters.\n"
        f"- 2-paragraph description highlighting craft quality + bullet points.\n"
        f"- Exactly 13 comma-separated search tags."
    )

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt}
    ]

    response = llm.create_chat_completion(
        messages=messages,
        response_format={"type": "json_object"},
        max_tokens=512,
        temperature=0.7
    )

    raw_output = response["choices"][0]["message"]["content"]
    return json.loads(raw_output)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="LoomList Local Copywriter")
    parser.add_argument("--image", required=True, help="Path to product photo")
    parser.add_argument("--material", required=True, help="Key materials used")
    parser.add_argument("--price", type=float, required=True, help="Listing price")
    args = parser.parse_args()

    image_path = Path(args.image)
    if not image_path.exists():
        print(f"Error: {image_path} not found.")
        exit(1)

    print("Loading local Gemma 2 engine...")
    llm = init_local_engine()

    listing = generate_listing(llm, image_path.name, args.material, args.price)

    print("\n--- GENERATED LISTING ---")
    print(f"Title: {listing.get('title')}\n")
    print(f"Description:\n{listing.get('description')}\n")
    print(f"Tags: {', '.join(listing.get('tags', []))}")

    out_file = Path("draft_listings.json")
    existing_data = json.loads(out_file.read_text()) if out_file.exists() else []
    existing_data.append(listing)
    out_file.write_text(json.dumps(existing_data, indent=2))
    print(f"\nSaved listing to {out_file.name}")

How I Built It

Core Model: Google's Gemma 2 9B Instruct (4-bit quantized Q4_K_M), balancing nuanced creative copywriting with high local inference speed.
Inference Engine: llama.cpp through llama-cpp-python bindings, leveraging Metal on Apple Silicon and CUDA on Linux/Windows desktops.
Front-end / Deployment: Packaged as both a fast terminal CLI and a lightweight web UI deployable locally or hosted on Render via a web service container.
Data Flow: Zero external third-party API dependencies. All prompt engineering, structured JSON parsing, and listing history remain contained on the local filesystem.

Why Does Open Innovation Matter?

For a micro-business or solo side hustle, closed-source models pose severe drawbacks:

Zero Variable Cost: Cloud APIs charge per prompt, token, and image. With open-weight models, running 1,000 product descriptions costs the exact same as running 1: $0. This preserves the profit margins necessary to make a side hustle viable.
Complete Independence: Proprietary APIs frequently change pricing tiers, deprecate endpoints, or introduce strict usage caps. By building on open weights, the software continues operating predictably without risk of third-party platform lock-in.
Data Privacy: Makers often develop proprietary patterns or unreleased collections. Keeping drafts and catalog data offline protects unreleased designs from being funneled into commercial cloud training sets.

First User Feedback

I demoed the tool to a local artisan seller who operates an independent ceramics store on Etsy:

Immediate Reaction: She loved that she didn't have to navigate a complex AI chat dashboard or subscribe to a monthly copy generation SaaS.
Willingness to Pay: She offered to pay a one-time fee of $35 for an offline, standalone desktop app that she could keep permanently on her workshop Mac.
Future Feature Request: Direct integration with CSV bulk uploaders for Shopify and automated square-crop resizing for listing thumbnails.

My Agent Session

I used open-source developer tooling to assist with creating the JSON schema constraints and fine-tuning the prompt structure to ensure consistent 13-tag outputs matching Etsy's search limits.

Prize Categories

Best Use of Gemma
Best Use of Render

TrailCompanion 🌿: An Offline Trail & Foraging Guide Powered by Local Open-Weight AI

Saurabh Singh — Wed, 07 Oct 2026 11:07:41 +0000

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

What I Built

I love hiking, but I hate getting to a trailhead, losing my cell signal, and realizing I forgot to download the trail details or check the sunset time. So, I built TrailCompanion.

It’s a simple Python tool that runs entirely offline. You give it your location and how far you want to hike, and it filters a downloaded dataset of local trails. Then, it uses a tiny local AI model (Gemma 1B) to look at the trail stats and give you a quick, contextual safety check.

The whole point is to spend 30 seconds looking at your laptop in the trunk of your car, get the info you need, close the lid, and actually go outside! It's built for hikers, backpackers, and campers who want to explore off-grid without compromising on preparation.

Demo

I usually run it straight from the terminal right before hitting the trail.

Command:

python companion.py --location "Pine Barrens" --distance 8km

Output:

🌿 TRAILCOMPANION OFFLINE BRIEFING
Selected Route: Stump Pond Loop (7.8 km, 140m gain)

Estimated Duration: 2h 45m (excluding breaks)
[Local AI Tip]: "Sunset is at 6:18 PM today. If you step off
by 2:30 PM, you'll have plenty of buffer daylight. The trail
gets muddy after rain, so wear proper boots."

Code

Here is the main script. I didn't want anything bloated, so it's just standard Python and Pandas filtering a local CSV before handing the context over to the local AI.

import argparse
import sys
from pathlib import Path
import pandas as pd

def load_offline_trails(csv_path):
    if not Path(csv_path).exists():
        print("Error: Where is your trail CSV? Download it first!")
        sys.exit(1)
    return pd.read_csv(csv_path)

def get_ai_safety_tip(prompt_context):
    try:
        # Running Gemma locally so we don't need Wi-Fi
        from llama_cpp import Llama
        llm = Llama(model_path="./models/gemma-3-1b-it.gguf", n_ctx=512, verbose=False)
        output = llm(prompt_context, max_tokens=60, stop=["\n"], echo=False)
        return output["choices"][0]["text"].strip()
    except Exception:
        return "Couldn't load AI. Standard tip: bring extra water and watch the sun."

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Offline Trail Guide")
    parser.add_argument("--location", required=True, help="Where are you?")
    parser.add_argument("--distance", required=True, help="How far in km?")
    args = parser.parse_args()

    trails = load_offline_trails("data/trails.csv")
    match = trails[trails['region'].str.contains(args.location, case=False, na=False)]

    if match.empty:
        print(f"No offline trails found for {args.location}. Check the map.")
    else:
        print(match.iloc[0])
        nudge = get_ai_safety_tip(f"Give a short 1-sentence safety tip for hiking a {args.distance} loop.")
        print(f"\n[Local AI Tip]: {nudge}")

How I Built It

I used Google's Gemma 1B instruction-tuned model because it's small enough to run effortlessly on a standard laptop without making the hardware overheat or draining the battery in the field. I'm running it completely locally using llama.cpp and the llama-cpp-python bindings.

The app itself relies on a lightweight Python logic architecture. The script handles the hard conditional sorting of the local CSV data, and the local LLM acts as an edge-computing assistant to evaluate the trail stats and generate an immediate safety warning. No web frameworks, no cloud hosting, and zero network calls—just a raw script you can execute anywhere from a backpack.

Why Does Open Innovation Matter?

Closed APIs like OpenAI or Claude are great, but they are completely useless when you're 10 miles deep in a state park with zero bars of service.

Having an open-weight model I can run locally means this tool actually works where I need it to—in the middle of nowhere. It doesn't rely on the cloud, it doesn't cost money per query, and it respects privacy by keeping location data completely local. Without access to open-weight models like Gemma, building a truly disconnected, offline outdoor utility like this wouldn't be possible for an independent developer.

My Agent Session

I utilized a local AI coding assistant to help me figure out the correct llama-cpp-python bindings and argument syntax. This allowed me to suppress the verbose model loading logs directly from the Python script, ensuring the final terminal interface remained perfectly clean for outdoor usage.

Prize Categories

Best Use of Gemma