DEV Community: Saptak Roy

ShopCraft AI: High-Converting Etsy & Shopify Listings Powered by Gemma 2

Saptak Roy — Tue, 13 Oct 2026 19:36:16 +0000

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

What I Built

Solo artisans, woodworkers, and vintage sellers face an exhausting bottleneck when expanding an e-commerce side hustle: listing friction.

Handmade merchants spend upwards of 30 to 45 minutes per product manually researching high-volume keywords, formatting narrative descriptions, and strictly staying within Etsy’s rigid search criteria:

Titles capped at 140 characters (where early keyword density determines click-through rate)
Exactly 13 algorithm tags, each capped strictly at 20 characters
Conversion-oriented bullet points outlining materials and care instructions

ShopCraft AI solves this problem in under 5 seconds. A seller simply enters raw notes—the item name, materials used, target audience, and key highlights—and ShopCraft formats a marketplace-ready, high-converting product listing adhering strictly to e-commerce SEO requirements.

Who Would Pay for It?

Solo creators on Etsy, Shopify, and Depop. Small makers cannot justify $20–$50/month enterprise SEO platforms like Marmalead or eRank when they only launch 5–15 products a month. A hyper-focused micro-SaaS priced at $5/month or $0.20 per batch listing offers an immediate return on investment for small shop owners.

Demo

Live Deployed App: https://shopcraft-ai-htvrhihrounmvh2qzkvsyj.streamlit.app

Try generating a listing with the default sample:

Product: Wheel-thrown Stoneware Matcha Bowl
Materials: White stoneware clay, food-safe moss green reactive glaze
Target Audience: Ceremonial matcha drinkers, minimalist home aesthetic
Features: 12oz capacity, built-in spout for pouring, microwave & dishwasher safe

Code

You can view the full repository, requirements, and deployment setup here:

rumparoy3012-ops / shopcraft-ai

How I Built It

ShopCraft AI is built around Google's open-weight model, Gemma 2 (2B Instruct).

Frontend & Orchestration: Built using Python and Streamlit, providing an uncluttered, responsive seller workspace.
Model Layer: The app integrates with Google Gemma 2 2B-IT, utilizing prompt instruction tuning to enforce structured field generation (Title, 13 SEO Tags, and Formatted Description).
Format Constraint: Because marketplace algorithms reject tags exceeding 20 characters, the prompt explicitly constrains Gemma 2 to produce comma-separated phrases under this character ceiling, avoiding post-processing failure.
Deployment: Hosted directly on Streamlit Community Cloud with continuous integration linked to GitHub.

Why Does Open Innovation Matter?

Why build this on an open-weight model like Gemma instead of relying on closed commercial APIs like OpenAI or Anthropic?

1. Sustainable Micro-SaaS Unit Economics

Closed APIs charge per prompt token and generated token. For an indie side hustle targeting micro-merchants at $5/month, unpredictable token usage and bursty scraping rapidly destroy profit margins. Gemma 2's open weights allow self-hosting, local deployment, or predictable fixed-cost container deployment where inference costs stay stable regardless of request volume.

2. Protecting Proprietary Seller IP

Handmade artisans frequently input confidential formulas, unreleased collections, and novel design techniques. With open models running on controlled instances, customer design notes and proprietary material compositions are never routed into closed third-party datasets for model retraining.

3. Model Independence & Longevity

Closed API providers routinely deprecate endpoints, alter hidden system prompts, or modify safety thresholds that break structured JSON/formatting parsers without notice. Open-weight models like Gemma 2 give builders permanent architectural stability: once the prompt and weights produce the intended schema, the service remains consistent indefinitely.

My First User

To test ShopCraft AI in the real world, I shared the live deployment with a local creator who sells handmade terracotta crafts and customized home decor.

The Test: She entered a listing for a hand-painted terracotta desk planter.

Her Feedback:

"Usually writing the tags is the most annoying part because Etsy cuts you off at 20 characters, and I keep having to re-count letters. The app gave me 13 tags that were ready to copy-paste. I'd definitely pay a small flat fee like ₹200–₹400 ($3–$5) a month if it saves me an hour every weekend."

Next Request:
She asked for an export button to copy all 13 tags into clipboard memory with a single click, which is slated for the next version update.

Prize Categories

Best Use of Gemma

Building Roshni: A Real-Time, Multi-Agent Financial Voice AI for Bharat 🇮🇳

Saptak Roy — Sat, 15 Aug 2026 03:21:08 +0000

Building Roshni: An Ultra-Low Latency, Multi-Agent Financial Voice Assistant for Bharat 🇮🇳

How I built an end-to-end, multilingual financial voice AI using Murf Falcon, LiveKit Agents, Deepgram Nova-3, Google Gemini, and Next.js during the 10 Days of AI Voice Agents Challenge.

🌟 1. The Problem & Why Voice Matters for Bharat

In India, financial inclusion has accelerated rapidly with UPI, digital banking, and government-backed credit initiatives. However, navigating complex interest rates, eligibility criteria for government schemes (like PM Mudra or Sukanya Samriddhi Yojana), and understanding formal banking terms remains intimidating for millions of citizens—especially in regional and tier-2/3 heartlands where digital interfaces can be overwhelming.

Text-first interfaces fail where voice thrives.
When rural entrepreneurs or first-time bank customers have questions, they don't want to navigate complex web forms or read dense PDFs. They want to ask a direct question in their language and get an immediate, clear, spoken answer.

To solve this, I built Roshni AI (and her specialist counterpart, Vikram) — an ultra-low latency, conversational financial assistant engineered for natural voice interactions in English, Hindi (Devanagari script), and Hinglish.

🏗️ 2. High-Level Architecture & Tech Stack

Building a real-time conversational agent requires synchronizing four core pipelines with sub-second latency:

          [ 👤 User Microphone ]
                    │ (WebRTC Audio Stream)
                    ▼
      ┌─────────────────────────────┐
      │     LiveKit Agents Worker    │
      └──────────────┬──────────────┘
                     │

┌───────────────────────┼───────────────────────┐
▼ ▼ ▼


┌─────────────┐       ┌─────────────┐       ┌─────────────────┐
│  Deepgram   │ ────► │Google Gemini│ ────► │   Murf Falcon   │
│   Nova-3    │       │    (LLM)    │       │     Fast TTS    │
│  (Fast STT) │       │             │       │ (Anisha / Samar)│
└─────────────┘       └──────┬──────┘       └────────┬────────┘
│ (Tool / Handoff)      │
▼                       ▼
┌───────────────┐       [ 🔊 Audio Output ]
│ SQLite Memory │
│  & Analytics  │
└───────────────┘

The Stack:

TTS (Text-to-Speech): Murf Falcon — Delivering conversational Indian voices (Anisha for general banking and Samar for specialist schemes) with lightning-fast Time-To-First-Byte (TTFB ~95ms).
STT (Speech-to-Text): Deepgram Nova-3 (language="multi") for instantaneous multi-language speech recognition.
LLM Engine: Google Gemini (gemini-3.5-flash-lite) with strict prompt guardrails.
Real-time Transport & Orchestration: LiveKit Agents Framework + Silero VAD for natural turn-taking and interruption handling.
Frontend Portal & Dashboard: Next.js 15, Tailwind CSS, and LiveKit Components React.
Persistence & Call Analytics: SQLite with instant synchronous write pipelines.

🚀 3. Key Capabilities Built

🎙️ 1. Ultra-Realistic Indian Voices via Murf Falcon

Using Murf Falcon’s conversational voices transformed the agent from a robotic IVR into a warm, approachable advisor. By pacing sentences naturally and configuring TTFB optimization, conversational latency stayed under 1 second.

🔤 2. Native Devanagari Script Enforcement

A common flaw in bilingual voice bots is sending romanized Hindi (e.g., "namaste, aapka swagat hai") to TTS engines, causing English phonetic engines to mispronounce Indian syllables. I enforced strict system prompt constraints:

Always write Hindi in Devanagari script (e.g., "नमस्ते, आपका स्वागत है"). Never write romanized Hindi.

This simple prompt architecture ensured flawless Indian accent pronunciation every single turn.

🧠 3. Persistent Memory & User Recognition

Using SQLite (agent_memory.db), Roshni stores caller identity, preferred languages, and previous queries. Returning users are greeted by name with tailored suggestions based on their recorded financial profile.

🛠️ 4. Tool Execution & Dynamic Rate Lookups

Roshni accesses custom tools like check_scheme_rates to provide live, structured interest rate calculations for Fixed Deposits, Senior Citizen schemes, and Savings accounts without LLM hallucinations.

🤝 5. Multi-Agent Specialist Handoff (Day 9 Milestone)

One agent should not try to be an expert in everything. I split responsibilities between two distinct agents:

Roshni (General Banking): Powered by Murf Falcon Anisha. Handles general banking and savings queries.
Vikram (Government Scheme Specialist): Powered by Murf Falcon Samar. Specializes in PM Mudra loans, subsidies, and government welfare programs.

When a caller asks about government schemes, Roshni announces: "I will connect you to Vikram, our Government Scheme Specialist", and hands over the full conversation history to Vikram in real time.

# Multi-Agent Handoff in LiveKit
@function_tool
async def transfer_to_scheme_specialist(self, context: RunContext, query: str) -> str:
    """Handoff caller to Vikram for Government Scheme queries."""
    self.session_state["is_success"] = True
    record_call_outcome(self.call_id, "SUCCESS", "Transferred to Scheme Specialist")
    return "I will connect you to Vikram, our Government Scheme Specialist."

📈 6. Real-Time Call Analytics Dashboard

A dedicated Next.js dashboard tracks live call outcomes:

Total Calls, Successful Inquiries, and Failure rates.
Live inspection of active session reference IDs and reasons.
Zero-cache dynamic API endpoints polling local SQLite metrics every 2 seconds.

💥 4. Engineering Challenges & How I Solved Them

No real-world AI project works on the first try. Here were the biggest hurdles and how I conquered them:

⚡ Challenge 1: The 429 Quota Trap & Model Selection

The Problem: Experimental LLM versions like gemini-3.5-flash have an ultra-restrictive free tier limit of only 20 requests per day. Voice pipelines consume 10–15 calls per conversation due to streaming transcript evaluations, quickly causing 429 Too Many Requests crashes.
The Solution: I switched to gemini-3.5-flash-lite, which offers 500 daily requests, instantly resolving quota exhaustion and reducing inference latency.

⏱️ Challenge 2: Synchronous Network Blocking in Function Tools

The Problem: Making synchronous network calls inside tools blocked the Python asyncio event loop, causing LiveKit audio streams to stutter and trigger gateway timeouts.
The Solution: Refactored all tool network operations to use asynchronous non-blocking patterns (aiohttp), keeping audio streaming perfectly smooth.

💾 Challenge 3: SQLite Multi-Process Disconnect Race Conditions

The Problem: Logging call outcomes strictly on on_disconnected sometimes missed calls when sessions were terminated abruptly by the browser client.
The Solution: Implemented synchronous write-ahead logging—recording an initial session row immediately on connect and updating it instantly the moment a tool executes.

🛠️ 5. Step-by-Step Guide: Run Your Own Voice Agent

Want to run this agent locally? Here is how to get started in under 5 minutes:

Prerequisites

Python 3.10+
Node.js 18+
Free API Keys: LiveKit Cloud, Murf AI, Deepgram, and Google AI Studio.

Step 1: Clone the Repository

git clone [https://github.com/your-username/murf-livekit-starter-main.git](https://github.com/your-username/murf-livekit-starter-main.git)
cd murf-livekit-starter-main

Step 2: Configure Environment Variables

Create a .env file in backend/:

LIVEKIT_URL=wss://your-project.livekit.cloud
LIVEKIT_API_KEY=your_livekit_api_key
LIVEKIT_API_SECRET=your_livekit_api_secret
DEEPGRAM_API_KEY=your_deepgram_api_key
MURF_API_KEY=your_murf_api_key
GOOGLE_API_KEY=your_gemini_api_key

Step 3: Run Backend Agent

cd backend
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt
python src/agent.py dev

Step 4: Run Next.js Frontend

cd ../frontend
npm install
npm run dev

Open http://localhost:3000, click Start Session, and start talking!

🔮 What’s Next?

More Regional Dialects: Adding Tamil, Telugu, and Bengali voice models using Murf Falcon.
Direct Core Banking API Integration: Secure sandboxed mock transactions via voice biometric confirmation.
Low-bandwidth Audio Compression: Optimizing codecs for 2G/3G mobile connectivity in rural areas.

🔗 Links & Resources

🎙️ TTS Engine: Murf Falcon API (https://murf.ai/)
⚡ Realtime Engine: LiveKit Voice AI (https://livekit.io/)

MY ENTIRE CODE IS IN [ https://github.com/rumparoy3012-ops/DAY-1-AI-VOICE-AGENT-BUILDING ] SO IF VIEW IT FOR BETTER UNDERSTANDING.

Special thanks to the Murf AI team for organizing the #10DaysofAIVoiceAgents — VoiceForBharat Challenge!