DEV Community: Abhishek

NameLock

Abhishek — Thu, 15 Oct 2026 13:47:16 +0000

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

The banner is already printed when the shop notices. The customer wrote Aadhya, with two a's, not Adya. The sheet says Adya. That sheet gets thrown away, and the shop prints it again.

A chat tool does this on its own. It "fixes" a spelling. For a flex and wedding shop, that fix is the mistake.

So I built NameLock. A local Gemma model drafts the banner line from the WhatsApp note. A plain Python check then refuses to print if one letter of a name has changed. I have not sold it, and I did not invent a shop or a first customer.

The customer wrote Aadhya. A tool that "fixes" spellings put Adya on the banner. That is a reprint. NameLock stamps Do not print, shows the two spellings, and keeps the print button off until the letters match.

What I Built

A print-shop name proof. The shop is the customer. A reprint costs a banner. I have not sold this to anyone, and I did not invent a shop or a price.

Orders look like this:

blue flex 6 by 3, birthday, name Aadhya, with two a's, not Adya

Gemma drafts Happy Birthday Aadhya. Then a plain Python check compares every name to the customer's own words. If a letter changed, the page stamps Do not print. One click puts the customer's spelling back. The stamp turns Safe to print, and the button turns on.

The check, in order:

Blocks a spelling the customer rejected ("not Adya").
Blocks a name that is not in the customer's message.
Blocks a name missing from the banner. A near miss (Adya for Aadhya) is named, and a repair is offered.
Asks for a confirmation, not a silent merge, when a name is close to a spelling the shop already approved.

Accents count: José is not Jose. The model may arrange the line. It may not change a name.

What it will not do:

It will not print a changed name. Skipping the button and posting Adya straight to /api/print still returns 409 and no page.
It will not store the WhatsApp message. Tiger gets the approved spelling only, after a banner actually prints.
It will not merge a close name on its own. Priyanca after an approved Priyanka asks the shop to confirm. It does not become Priyanka.

1. The desk. One page. The four steps (Message, Draft, Lock, Print) show where the job is.

2. The customer's message. Paste the WhatsApp text, or pick a sample. The page shows size, colour and occasion as tags. On the shop laptop, Gemma reads this. In the public demo, a scripted drafter does.

3. The lock stops a changed name. The drafted line is Happy Birthday Adya. The customer wrote Aadhya. Print stays off.

4. One click puts the name back. Use the customer's spelling on the banner restores Aadhya. The lock runs again. The repair is only offered if that text itself passes.

5. The print sheet. Proof passed, the names that were checked, and a yellow banner that fits the text. The server runs the lock a second time before it returns this page. Posting Adya straight to /api/print still gets a 409.

6. The shop remembers. Printed names are saved as approved spellings. The next time a message has a name that is close but not the same (Priyanca after Priyanka), the page asks. It does not merge them silently.

Demo

Live sample demo: PASTE-RENDER-URL-HERE

That page has no model. A scripted drafter builds the line. Tick Imitate a tool that fixes spellings, pick Two a's, not Adya, and draft. You should see the red stamp, then one click to green. The label on the page says it is scripted. Nothing you type is stored.

The real Gemma run stays on the shop laptop. A public page cannot call it.

Code

abhishekmsm51w-star / namelock

Banner name proof: Gemma drafts the line, a spelling lock blocks a changed name.

NameLock

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

One wrong letter in a name means a banner gets thrown away and printed again. NameLock lets a local open-weight model draft the banner line, then refuses to print if any name is not exactly as the customer wrote it.

What I Built

A flex-banner and wedding-card print shop gets orders as messy WhatsApp messages:

blue flex 6 by 3, birthday, name Aadhya, with two a's, not Adya

NameLock reads the message and drafts the banner (Happy Birthday Aadhya). Then a plain Python check compares every name on the banner to the customer's own words. If a letter changed, the page stamps Do not print, shows the customer's spelling next to the banner's spelling, and keeps the print button off One click puts the customer's spelling back, the stamp turns Safe to…

View on GitHub

MIT. Two files decide whether a banner can print. namelock/lock.py is the check, and it has no model in it. namelock/book.py is the spelling book, SQLite on the laptop or Tiger Cloud when DATABASE_URL is set.

The print gate in `namelock/app.py`

@app.post("/api/print")
def print_page(o: Order):
    v = verify(o.note, o.names, o.banner, approved=book.names())
    if not v.printable:
        raise HTTPException(409, "Not printable: " + "; ".join(i.message for i in v.issues))
    for n in v.names:
        book.approve(n)  # a printed name is an approved spelling
    return _print_html(o.banner, v.names)

Gemma lives in namelock/drafter.py. It asks Ollama for JSON and is never trusted. Whatever it returns goes through verify() before this gate. Sample mode, with no model, is NAMELOCK_BACKEND=demo. The run commands are in the repo README.

How I Built It

The model drafts. The lock decides. The server checks again before anything can print. On the shop laptop that drafter is Gemma through Ollama. On the public demo it is the scripted stand-in. Either way the same check runs, and a pass writes the name into approved_names.

Gemma is untrusted on purpose. gemma3:1b through Ollama returns JSON: names copied as typed, occasion, size, colour, banner line. The prompt says never respell a name. I still send every draft through lock.verify(). Swapping the model does not touch the check.

The lock is plain Python, and the tests notice if it breaks. NFC only, so José is not Jose. A possessive 's is not part of the name. An all-caps banner still matches. A repair is offered only when the repaired text itself passes the same check. 105 tests pass. I deleted the "name missing from the banner" rule on purpose and 26 tests failed, then I put the rule back.

What Gemma actually did. On 15 Oct 2026 I ran 20 invented names (Aadhya, Siobhan, José, D'souza, Mary-Anne and others) through gemma3:1b on this PC. The model did not respell any of them. It dropped 2 off the banner instead: Siobhan became a generic celebration line, and Mary-Anne became the size and colour. The lock caught both. 0 leaked. 0 false alarms. Median draft 0.4s. The first call took 61s while the model loaded.

The red stamp in the screenshots is not that Gemma run. The checkbox Imitate a tool that fixes spellings is a simulation I wrote, so a public page can show the bug without a model. The bench that catches 20 of 20 tests the lock against that simulation. It is not a score for Gemma.

Tiger stores spellings, not messages. After a banner prints, each name goes into one table on Tiger Cloud:

create table if not exists approved_names (
  key text primary key,
  name text not null
);

Next time a note is close to an approved spelling but not the same, the lock asks. This is a plain Postgres table. It is not pgvector and it is not hybrid search.

Render hosts the sample, not the model. render.yaml is one free Python web service with NAMELOCK_BACKEND=demo. There is no DATABASE_URL on Render, so the demo book is memory and dies on restart. Real notes stay on the laptop, where Ollama listens at 127.0.0.1:11434.

GitHub Actions fails the build if a changed name can print. .github/workflows/test.yml runs pytest, then bench.py twice: once with a faithful drafter, once with the simulated autocorrect. A leak is a red build.

Where data goes.

Path	Customer message	Names
Shop laptop, Ollama	Stays on the laptop. The model runs at `127.0.0.1:11434`.	Approved spellings in local SQLite, or in Tiger Cloud if `DATABASE_URL` is set. Names only.
Public demo on Render	Sample notes. The text you type hits the Render server and is not stored.	In memory. Lost on restart.

The page loads fonts from Google Fonts, so the browser contacts Google.

Not done. The 20 names are invented. There is no first user, so this post has no "what they said" section. The public demo cannot show Gemma.

The bug I actually hit

I built the lock because I expected Gemma to "fix" Aadhya into Adya, the way a chat tool does. On the real run it did not do that.

I gave gemma3:1b 20 invented names. It kept the spellings it used. It failed a different way: two names never reached the banner. Siobhan came back as a generic celebration line. Mary-Anne came back as the size and the colour. The lock stopped both. Nothing leaked, and there were no false alarms. The first call took 61 seconds while the model loaded. After that the median draft was 0.4 seconds.

The red Do not print stamp in the screenshots is not that Gemma run. The public demo has no model, so the checkbox Imitate a tool that fixes spellings is a simulation I wrote, to show the reprint bug on a page anyone can open. The 20-out-of-20 bench scores that simulation. It does not score Gemma.

Why Does Open Innovation Matter?

Three things a closed chat tool would not give this shop.

The messages stay on the counter. They hold names and phone numbers. With a local model they never leave the laptop.

There is no fee per banner. The shop prints many small jobs.

The shop can fix the behaviour, not hope for it. The bug is a hosted chat tool that "corrects" a spelling. With an open model I can pin the instructions, swap the model, and put a check after it that does not depend on the model. The lock does not care which model drafted the line.

Prize Categories

Best Use of Gemma. gemma3:1b through Ollama drafts every real banner. On the 20-name run it dropped Siobhan and Mary-Anne. The lock caught both. 0 leaked.
Best Use of Tiger Data. Printed names go into approved_names on Tiger Cloud, and a near spelling asks for confirmation. Plain table. Not vector search.
Best Use of Render. One free web service from render.yaml, sample notes only, no model and no database on the server. Live link is in Demo.
Best Use of GitHub Actions. Every push runs the tests and both 20-name benches. The build fails if a changed name could still print.

Built solo.

Plant Care AI

Abhishek — Tue, 06 Oct 2026 03:45:28 +0000

🌿 PlantCare AI — Take a Photo. Understand Your Plant. Go Touch Grass.

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

What I Built

Most gardening and plant diagnostic apps have a counterproductive design pattern: they try to keep you glued to your phone. Between endless scrolling forums, chat feeds, locked paywalls, and invasive notifications, the experience often pulls you away from nature rather than connecting you with it.

I built PlantCare AI to invert this dynamic.

PlantCare AI is a lightweight, privacy-first plant health assistant powered by Google's open-weight Gemma model family. It is built specifically around the Hacktoberfest 2026 Week 1 theme: "Touch Grass."

The Core Philosophy: The Screen is the Shortest Step

Instead of an AI chatbot designed for long conversations, the entire user journey takes less than 60 seconds:

$$\text{📸 Take Photo} \longrightarrow \text{🤖 Gemma Multimodal Inspection} \longrightarrow \text{🌱 Actionable Diagnosis} \longrightarrow \text{🌿 Touch Grass Task} \longrightarrow \text{🪴 Hands in the Dirt}$$

Key Features:

Instant Botanical Identification: Accurately recognizes common and botanical species names with confidence scoring.
Visual Health & Vitality Rating: Assesses overall vitality (Healthy, Mostly Healthy, Needs Attention, Unhealthy).
Possible Disease Assessment: Detects visual indicators consistent with fungal pathogens (e.g., Early Blight, Powdery Mildew), pest damage (e.g., Spider Mite stippling), and watering stress. It always includes a responsible safety disclaimer: AI visual analysis is an assessment, not a laboratory pathology test.
Practical Care Matrix: Straightforward recommendations for watering schedule, sunlight requirements, and potting soil drainage.
Hands-On Action Checklist: Interactive, actionable physical steps (e.g., prune diseased foliage with sanitized shears, increase ventilation, add clean mulch).
The "Touch Grass" Mission: Generates a single, real-world outdoor task (e.g., "Go outside, wipe dust off the broad leaves with a damp cloth in fresh outdoor air, and take three deep breaths"). When completed, clicking "✓ I Did It" triggers a celebratory confetti burst to reward real-world action!
Interactive Demo Mode: Includes 3 realistic pre-built botanical scenarios (Healthy Monstera, Tomato with Early Blight, Fiddle Leaf Fig with Pest Stress) so judges and users can test the full flow instantly without needing an API key.
Privacy By Design: Uploaded photos are processed in-memory and never stored on disk or databases. Zero login or tracking required.

Demo

Live Repository: https://github.com/abhishekusersfaci-lang/Plantcare-ai
Local Testing: Run npm run dev and open http://localhost:3000.

(If you deploy to Vercel or record a short video clip/Loom, you can paste the live link and embed your demo video or screenshot right here!)

Code

The complete source code is open source under the MIT License:

abhishekusersfaci-lang / Plantcare-ai

🌿 PlantCare AI

"Take a photo. Understand your plant. Help it grow."
An open-AI-powered plant health assistant built with Google's Gemma open-weight model family.
Created for the Hacktoberfest 2026 Open-Source AI Challenge (Week 1 Theme: "Touch Grass").

📌 Problem

Indoor gardeners, balcony farmers, and plant enthusiasts often notice wilting, yellowing leaves, or spots on their plants but have no idea what caused them or what steps to take. Commercial plant apps often lock diagnostic insights behind paywalls, require account registrations, or encourage endless screen-time browsing rather than getting users hands-on in the dirt.

🌱 Solution

PlantCare AI provides an instant, privacy-first plant health assessment powered by Google's open-weight Gemma model. With a single photograph, Gemma identifies the plant species, assesses vitality, detects visual symptoms consistent with common plant diseases, suggests tailored watering and sunlight advice, and gives the user one practical outdoor "Touch Grass" action to disconnect from their screen…

View on GitHub

Repository Link:

🔗 https://github.com/abhishekusersfaci-lang/Plantcare-ai

How I Built It

1. The Core AI Model: Gemma 4 Multimodal (`gemma-4-31b-it`)

At the heart of the diagnostic engine is Gemma, Google's family of lightweight, state-of-the-art open-weight models.

Why Gemma? Rather than using proprietary closed models like Gemini, the app strictly uses Gemma 4 (gemma-4-31b-it). Gemma 4 features a native multimodal architecture capable of reasoning over high-resolution image inputs and textual instructions simultaneously.
Multimodal Visual Diagnostics: The model inspects raw image bytes directly to recognize leaf venation, concentric lesion rings (such as target-spotting in Alternaria solani), chlorotic yellow margins, and pest damage.
Structured JSON Schema: Gemma returns structured, validated JSON conforming to our strict TypeScript schema, eliminating hallucinations and ensuring smooth rendering on the frontend.

2. Tech Stack

Framework: Next.js 15 (App Router, React 19, TypeScript)
Styling: Tailwind CSS with custom nature-inspired color tokens (emerald greens, forest tones, earth ambers, and glassmorphism)
AI Integration: Official Google GenAI SDK (@google/genai) running strictly server-side in Next.js Route Handlers (/api/analyze)
Micro-Interactions & Delight: canvas-confetti for the outdoor task celebration, lucide-react for botanical iconography, and CSS seedling animations

3. Architecture Overview

[User Camera / Photo Upload]
            │
            ▼
[Next.js Client (Drag & Drop / Camera Capture)]
            │ (POST multipart/form-data or Base64)
            ▼
[Server-side API Route: /api/analyze]
   ├── MIME Type Validation (JPG, PNG, WEBP)
   ├── Size Limit Check (< 10MB)
   └── Key / Demo Mode Resolver
            │
            ▼
[Google GenAI SDK with Gemma 4: gemma-4-31b-it]
            │
            ▼
[JSON Validator & Normalizer]
            │
            ▼
[Polished Plant Report + Touch Grass Interactive Card]

Why Does Open Innovation Matter?

Open-weight models like Gemma are pivotal for the future of specialized, privacy-sensitive AI applications:

Private & Local Edge Inference: Plant care happens in backyards, balconies, and remote greenhouses where internet connectivity may be scarce. Open weights make it possible to run inference completely offline on edge devices (via Ollama, llama.cpp, or on-device NPUs), ensuring farmers' and gardeners' photos never leave their hardware.
Community Fine-Tuning: Open weights allow researchers and agricultural universities to fine-tune Gemma on hyper-local plant diseases, rare native flora, and regional crop pests that proprietary commercial APIs ignore.
Transparency & Safety: In agriculture, understanding why an AI flagged a symptom matters. Open-source models allow developers to inspect prompt responses, inspect latent activations, and ensure diagnostic caveats are responsibly communicated.
No Vendor Lock-In: Developers are not tied to a single platform's pricing or sudden deprecation cycles; weights can be served across Google AI Studio, Vertex AI, Hugging Face, or self-hosted GPU clusters.

My Agent Session

This project was built and pair-programmed with an advanced AI coding agent in Google Antigravity IDE. The agent verified the latest official Google Gemma multimodal models (gemma-4-31b-it), scaffolded the complete Next.js 15 application, created custom SVG botanical assets, tested the live API route end-to-end, and ensured that .env.local API credentials stayed protected while pushing directly to GitHub.

Prize Categories

Google Gemma: Built with and powered by Google's open-weight Gemma multimodal model family (gemma-4-31b-it).
Touch Grass Challenge (Week 1): Encourages users to close the app, step outside into their gardens or balconies, and physically care for living plants.

Study Buddy

Abhishek — Fri, 02 Oct 2026 14:03:50 +0000

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

StudyBuddy — The Intelligent Focus, Flashcard & Quiz Companion

What I Built

I built StudyBuddy for my close friend Alex, who has been preparing for tech certifications and university exams while juggling a busy schedule. Alex constantly faced two major obstacles:

Focus fragmentation & tab overload: Juggling three separate tools for a Pomodoro timer, Quizlet for flashcards, and random online quiz sites — each loaded with paywalls, ads, and login prompts.
Passive vs. Active Recall: Alex often fell into the trap of passively reading notes instead of actively testing knowledge with practice questions.

StudyBuddy solves this by unifying Alex's entire study loop into a single, cohesive, distraction-free web application:

⏱️ Customizable Pomodoro Clock: Features an animated circular SVG countdown, quick +/- 1m and 5m adjusters, configurable focus and break durations, and a built-in Web Audio ambient noise generator (gentle rain, deep oceanic brown noise, and white noise) running 100% locally in the browser with zero external audio assets.
🗂️ Interactive 3D Flashcards: Built with spatial 3D CSS perspective flips. Alex can switch between curated decks (Web Development, Biology & Science) or create custom decks with an intuitive card manager. Supports quick keyboard shortcuts (Space to flip, Arrow keys to navigate, M for Mastered, and R for Review).
📝 Dual-Engine Quiz Platform:
- Instant Deck-to-Quiz: Converts any flashcard deck into a dynamic multiple-choice quiz on the fly, smartly generating distractors from other cards in the deck.
- Custom Quiz Builder: Allows Alex to create bespoke exams with custom options, designated correct answers, and instant explanations upon answering.
- Post-Quiz Review: Displays mastery percentage, letter grade badges, question-by-question breakdown of mistakes, and encouragement from the mascot.
🤖 Pixel Buddy Mascot: An animated, expressive companion widget with blinking eyes, a glowing halo, and mood shifts that cheers Alex on, shares science-backed study tips (the Feynman Technique, Interleaving, Active Recall), and celebrates milestone quiz scores.
🔒 Privacy-First & Zero Friction: Everything runs client-side with localStorage persistence, zero account logins required, and full JSON backup export/import capabilities.

Demo

Live Local Demo: Open [https://innovatorcloudy.github.io/studdybuddy/] in any modern browser.
Quick Preview & Workflow:
1. Focus: Start a 25-minute Pomodoro block, toggle ambient rain sounds, and set your target milestone.
2. Review: Flip through high-yield flashcards with 3D animation, marking items as mastered.
3. Test: Click "Quiz This Deck" to immediately test retention under test-like conditions with real-time feedback and explanations.
4. Track: Check daily streak, total focus minutes, and cards mastered in the Stats panel.

(You can also view a live deployed version hosted on GitHub Pages: https://innovatorcloudy.github.io/studdybuddy)

Code

The complete source code is lightweight, modular, and dependency-free:

Repository: https://github.com/Innovatorcloudy/studdybuddy

Architecture Highlights:

index.html: Clean semantic HTML5 structure with accessible ARIA tab patterns and accessible modal dialogs.
style.css: Modern dark-mode aesthetic inspired by twilight nebulae, featuring glassmorphism (backdrop-filter: blur), smooth 3D CSS transforms (rotateY(180deg)), and fluid responsive layout grids.
app.js: Pure Vanilla ES6+ featuring:
- Web Audio API synthesizer for harmonic completion chimes and procedural ambient sound buffers.
- State management engine syncing with localStorage.
- Dynamic distractor generator for automatic quiz creation from flashcard decks.

How I Built It

StudyBuddy was designed and developed through an agentic AI pair-programming workflow:

Iterative Problem Framing: I collaborated with an AI coding assistant to break Alex's study pain points down into a unified single-page architecture (Timer + Flashcards + Quiz + Mascot).
Zero-Dependency Sound Synthesis: Rather than bundling heavy MP3 audio files or relying on external CDNs that could fail offline, we used the browser's native Web Audio API to procedurally synthesize harmonic bell chimes and continuous Brownian/rain noise filters.
Adaptive Quiz Generation Algorithm: We engineered an automated quiz constructor that analyzes flashcard decks and dynamically pairs each prompt with randomized distractor answers drawn from the deck, ensuring instant quizzes with zero manual setup.
Accessible Micro-Interactions: The AI agent assisted in fine-tuning 3D card flips, SVG progress-ring math (stroke-dashoffset transitions), keyboard event listeners, and animated mascot state reactions.

Why Does Open Innovation Matter?

Open innovation and open-source tooling fundamentally democratize learning:

Education Without Paywalls: Essential learning tools shouldn't lock basic features like spaced repetition or custom quizzes behind expensive monthly subscriptions. By building on open web standards, anyone with a browser can study effectively for free.
Data Ownership & Privacy: Students' study habits, notes, and quiz histories shouldn't be harvested for ads or walled inside proprietary ecosystems. StudyBuddy stores everything locally on the user's device with easy JSON export/import.
Community Extensibility: Open innovation empowers students and educators to fork the codebase, adapt the mascot, integrate specialized medical or language flashcard decks, and tailor the experience to neurodiverse learning styles without corporate gatekeeping.

My Agent Session

Workspace: f:\dev
Agent Harness: Antigravity Agentic Assistant / Gemini 3.8
Session Highlights: Autonomous scaffolding of semantic HTML, responsive CSS design system with 3D flip dynamics, Web Audio API sound generator, interactive custom quiz builder, and live browser validation.

Prize Categories

Primary: Hacktoberfest Weekend Challenge: Build for a Friend
Categories:
- Build for a Friend (Personalized study buddy for Alex)
- Open Innovation / Open-Source AI (Accessible, privacy-first educational tool)
- Best Design & User Experience (Sleek dark mode, 3D card flipping, and animated companion)

Built with ❤️ for Alex and curious minds everywhere!

Jan Sahay — From a Financial Crisis to a Citizen AI Voice Assistant

Abhishek — Sat, 15 Aug 2026 10:29:08 +0000

🛡️ Jan Sahay (जन सहाय) — AI-Powered Citizen Assistance Platform

A 10-Day Journey Building a Real-Time, Multilingual Voice Agent for Financial Safety, Government Welfare & Cyber Fraud Containment

📖 The Story That Started It All

Imagine a small shopkeeper in Delhi named Ramesh.

One evening, Ramesh receives a message on his phone:

"Your bank account will be blocked tonight. Verify your KYC immediately by clicking the link below."

Anxious and rushed, he clicks the link. Within a few minutes, he realizes the message was fake and an unauthorized transaction has taken place.

Now he is gripped with panic and urgent questions:

What should he do right now?
Who should he contact?
Can he report the fraud and freeze his account before the money is moved?
Are there government schemes or emergency funds that could help his family recover?

The information exists across various portals and government websites—but finding the right, authoritative guidance during a crisis is overwhelmingly difficult. Most portals are text-heavy, loaded with bureaucratic jargon, or only in English.

That very question became the inspiration behind Jan Sahay (जन सहाय): a citizen-focused, voice-first AI platform built to make financial literacy, fraud prevention, government welfare schemes, and complaint guidance accessible to every citizen. Instead of navigating complex portals or waiting in queues, citizens can simply talk naturally in Hindi, English, or Hinglish to an empathetic AI voice assistant.

This document outlines the complete story, architecture, development log, challenges solved, and setup guide for Jan Sahay over 10 Days of Building Voice Agents.

🏛️ The 4 Core Functional Pillars

Rather than building a generic open-ended chatbot, Jan Sahay is structured around four foundational pillars designed specifically for citizen welfare and digital safety:

                  ┌──────────────────────────────┐
                  │          JAN SAHAY           │
                  │   Citizen Voice Assistant    │
                  └──────────────┬───────────────┘
                                 │
     ┌──────────────────┬────────┴─────────┬──────────────────┐
     ▼                  ▼                  ▼                  ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│  Financial   │ │    Fraud     │ │  Government  │ │  Complaint   │
│   Literacy   │ │  Prevention  │ │   Schemes    │ │  Assistance  │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘

💰 Financial Literacy: Jargon-free guidance on savings accounts, budgeting fundamentals, formal credit, interest rates, and long-term financial planning.
🛡️ Fraud Prevention: Real-time coaching on OTP/PIN safety, identifying phishing messages, fake caller identification, and avoiding malicious screen-sharing APKs.
🏛️ Government Welfare Schemes: Deterministic eligibility calculations and checklists for PMJDY, PMSBY, PMJJBY, Atal Pension Yojana (APY), Sukanya Samriddhi (SSY), PM Mudra Yojana, and PM-KISAN.
📞 Complaint & Emergency Triage: Structured step-by-step incident response for cybercrime reporting (1930 / cybercrime.gov.in), bank dispute filing for RBI Zero-Liability protection, and consumer forum escalations.

🏗️ System Architecture & Real-Time Voice Flow

Jan Sahay achieves sub-500ms voice turnaround times using real-time WebRTC audio streaming, streaming transcription, low-latency LLM reasoning, and natural Indian voice synthesis.

1. Real-Time Audio Pipeline Flow

flowchart LR
    A["🎙️ Citizen Speaks Audio"] --> B["⚡ LiveKit WebRTC<br/>Real-Time Transport"]
    B --> C["🗣️ Deepgram Nova-2<br/>Streaming Speech-to-Text"]
    C --> D["🧠 Google Gemini AI<br/>Reasoning & Intent"]
    D --> E["💰 Financial Rules Engine<br/>+ Caller Memory DB"]
    E --> F["🔊 Murf Falcon TTS<br/>Ultra-Fast Indian Voices"]
    F --> G["🗣️ Natural Voice<br/>Playback to Citizen"]

    G -.-> A

    style A fill:#1E293B,stroke:#38BDF8,color:#fff
    style B fill:#0284C7,stroke:#38BDF8,color:#fff
    style C fill:#0D9488,stroke:#2DD4BF,color:#fff
    style D fill:#6366F1,stroke:#A5B4FC,color:#fff
    style E fill:#D97706,stroke:#FDE68A,color:#fff
    style F fill:#EA580C,stroke:#FDBA74,color:#fff
    style G fill:#10B981,stroke:#6EE7B7,color:#fff

2. Complete Multi-Tier Architecture

                        ┌──────────────────────┐
                        │        CITIZEN       │
                        └──────────┬───────────┘
                                   │ (Speaks / Listens)
                                   ▼
                        ┌──────────────────────┐
                        │ Jan Sahay Web Portal │
                        │   (Next.js Client)   │
                        └──────────┬───────────┘
                                   │ WebRTC Audio Stream (LiveKit)
                                   ▼
                        ┌──────────────────────┐
                        │ LiveKit Voice Agent  │
                        └─────┬──────────┬─────┘
                              │          │
        ┌─────────────────────┘          └─────────────────────┐
        ▼                                                      ▼
┌───────────────┐                                      ┌───────────────┐
│   Deepgram    │ (Audio to Text)                      │  Murf Falcon  │ (Text to Audio)
│  Nova-2 STT   │                                      │   (TTS API)   │
└───────┬───────┘                                      └───────▲───────┘
        │                                                      │
        ▼                                                      │
┌──────────────────────────────────────────────────────────────┴───────┐
│                     Google Gemini Orchestrator                       │
└───────┬───────────────────────────────┬──────────────────────────────┘
        │                               │
        ▼                               ▼
┌───────────────┐               ┌───────────────┐
│ Caller Memory │               │ Rules Engine  │
│ (SQLite DB)   │               │ (Deterministic│
│               │               │ Scheme Logic) │
└───────────────┘               └───────────────┘

🎙️ Meet the Team of AI Specialists

Jan Sahay uses a multi-agent federation where a main intake guide dynamically hands off the conversation to dedicated domain specialists, matching their persona with the optimal Murf Falcon voice profile:

Specialist Avatar	Agent Role & Domain	Voice Profile	Supported Locales	Key Capabilities
Anisha	Main Intake & General Guide	`Anisha` (Murf Falcon)	`en-IN` / `hi-IN`	Warm intake, 2-turn scoping, personalized greetings, banking basics.
Samar	Cyber Safety & Emergency Containment	`Samar` (Murf Falcon)	`en-IN`	Golden hour containment, 1930 reporting, bank helpline lookup.
Pooja	Government Schemes & Pension Guide	`Pooja` (Murf Falcon)	`en-IN` / `hi-IN`	APY pension calculators, Sukanya Samriddhi (8.2%), PMJDY/PMSBY/PMJJBY.
Samar	Micro-Credit & Business Loans	`Samar` (Murf Falcon)	`en-IN`	PMMY Mudra loans (Shishu, Kishore, Tarun), PM SVANidhi vendor loans.
Palak	Agri-Financial & Crop Insurance	`Palak` (Murf Falcon)	`en-IN` / `hi-IN`	PMFBY 72-hr crop loss reporting, PM-KISAN e-KYC status, Kisan Credit Cards.

📅 10-Day Development Journey & Log

🟢 Day 1 — The Problem: Financial Confusion Is Everywhere

Key Realization: Financial information is available, but accessibility is broken. Ordinary citizens struggle with banking, digital safety (UPI fraud/phishing), welfare schemes, and dispute recourse.
Objective: Build an AI assistant that feels less like a search engine and more like a patient, empathetic citizen-support counselor.
Core Pillars Defined: Simple, Conversational, Multilingual, Trustworthy, and Voice-first.

🟢 Day 2 — Designing the Citizen Experience

Structured the core 4-pillar interaction model (Financial Literacy, Fraud Prevention, Government Schemes, Complaint Assistance).
Defined prompt rules prohibiting hallucinations and outlining empathetic responses for users facing financial distress.

🟢 Day 3 — Giving the AI a Memory

Problem: Stateless chatbots suffer from amnesia. If Ramesh calls today about his daughter's education fund and calls back tomorrow, repeating context causes friction.
Solution: Built the Caller Memory Database (backend/caller_data.db using SQLite) with schema for user_id, name, language_pref, demographic_facts, and discussed_schemes.
Privacy First: Integrated explicit verbal consent checks ("May I remember this for your next call?") before storing non-PII demographic facts.

🟢 Day 4 — Building the Government Scheme Knowledge Layer

Architecture Rule: LLM handles dialogue $\rightarrow$ Deterministic Rules Engine guarantees official policy truth.
Implemented exact formula calculators for:
- PMJDY: Zero balance, RuPay debit card, ₹2L accident insurance cover.
- PMSBY: Accidental death/disability cover (Age 18–70, ₹20/year premium, ₹2 Lakh cover).
- PMJJBY: Life insurance cover (Age 18–50, ₹436/year premium, ₹2 Lakh cover).
- APY: Atal Pension Yojana pension slabs (₹1,000–₹5,000/mo at age 60 based on entry age).
- SSY: Sukanya Samriddhi Yojana (Girl child < 10 yrs, current 8.2% interest, tax exemptions).

🟢 Day 5 — Turning Text Into a Real-Time Voice Conversation

Integrated LiveKit WebRTC Agents with Deepgram Nova-2 STT and Murf Falcon TTS.
Enabled streaming bidirectional audio with Silero VAD (Voice Activity Detection) for seamless turn detection and low-latency interruptions.

🟢 Day 6 — Making Jan Sahay Multilingual & Code-Mixed

Configured STT and TTS mappings for English (en-IN), Hindi (hi-IN), and conversational Hinglish.
Enforced single-language response purity per turn to eliminate double-audio slash artifacts ("Hello / नमस्ते").

🟢 Day 7 — Fraud Prevention as a First-Class Feature

Implemented Immediate Action Matrix for cyber safety:
- Strict alerts on OTP/PIN confidentiality.
- Screen-sharing warning triggers (AnyDesk, TeamViewer).
- Unverified QR code and UPI PIN receiving scam alerts.
- Golden Hour Protocols to halt fund movement.

🟢 Day 8 — Action-Oriented Complaint Assistance

Developed structured escalation protocols:
1. Banking Disputes: Card freeze, dispute filing within 3 days for RBI Zero-Liability.
2. Cybercrime Reporting: Guided walkthrough for cybercrime.gov.in and National Helpline 1930.
3. Human Escalation: Generates unique escalation reference IDs (e.g., ESC-XXXXX) logged to SQLite for officer review.

🟢 Day 9 — Building the Web Portal & Telemetry Dashboard

Developed a high-performance Next.js web application with a single-click 🎙️ "Start Talking" interface.
Built real-time telemetry tracking turn latency, outcome classifications (resolved/escalated), and active escalation queues at /api/dashboard.
Added telephony SIP outbound calling capability (backend/src/outbound_call.py).

🟢 Day 10 — Open-Source Release & Architecture Documentation

Packaged repository with automated startup scripts (start_app.ps1 / start_app.sh), comprehensive API documentation, and architecture diagrams.

🚧 Challenges Faced & How We Solved Them

1. 🌐 Multilingual & Language Switching Inconsistencies

The Problem: In bilingual English/Hindi environments, the agent sometimes randomly replied in Hindi to an English prompt or switched languages mid-conversation without user intent.
How We Solved It:
- Implemented session-level language tracking in SQLite memory.
- Enforced strict prompt guidelines: detect user language preference, maintain it consistently across turns, and switch languages only when explicitly requested by the citizen.
- Required native Devanagari script output for Hindi responses to ensure Murf Falcon TTS synthesizes authentic intonation.

2. 🧠 Hallucination-Free Financial Reasoning

The Problem: Financial queries involving age limits, cutoff dates, premium tiers, and pension returns must be 100% accurate. LLMs can hallucinate calculation schedules.
How We Solved It:
- Decoupled conversational empathy from calculations.
- Gemini extracts parameters (age, target pension, child age) and calls deterministic Python functions (calculate_apy_contribution, get_scheme_details).
- Verified math is returned to Gemini to format as a spoken response.

Citizen Question ──> Gemini AI (Intent Extraction) ──> Python Rules Engine ──> Verified Result ──> Murf Voice

3. 🔄 Dynamic Voice Profile Switching in WebRTC

The Problem: Tearing down WebRTC rooms when switching from Anisha to Samar or Pooja caused noticeable audio stutters and 2–3s delays.
How We Solved It: Kept the WebRTC audio transport live while dynamically swapping the Murf Falcon voice profile parameters in-flight during tool execution.

4. 🛡️ Accidental PII Memorization

The Problem: Panicked callers reporting fraud frequently blurt out card numbers or PINs.
How We Solved It: Built an automated sanitization regex layer in save_caller_facts and create_escalation that automatically scrubs card numbers, OTPs, PINs, and passwords before database commits.

🔮 What's Next on the Roadmap

📞 Telephony & IVR Toll-Free Access:
- SIP Trunking integration with Exotel / Twilio so citizens without smartphones can dial a toll-free number from any basic feature phone.
🗣️ Hyper-Local Regional Dialects:
- Expand beyond Hindi/English to regional languages (Bhojpuri, Maithili, Bengali, Marathi, Tamil, Telugu).
- Acoustic noise suppression tuned for busy Indian environments (markets, bus stops, railway stations).
📄 DigiLocker & Voice-Guided Application:
- Voice OTP authorization for instant eligibility verification via DigiLocker.
- Voice-guided form pre-filling for PM-KISAN and Sukanya Samriddhi portals.
📲 Multi-Channel Follow-ups (WhatsApp / SMS):
- Automated post-call summary SMS with verified helpline links, scheme forms, and grievance reference IDs.
- Instant downloadable PDF checklist generated at the end of the voice call.
🚨 Proactive Outbound Alerts:
- Automated voice alerts when subsidy installments (PM-KISAN, APY pensions) are credited.
- Geo-targeted voice broadcasts warning citizens about emerging phishing scams in their district.

🛠️ Step-by-Step Quickstart Guide

Prerequisites

Python 3.10+
uv (Fast Python package manager)

  # Windows (PowerShell)
  powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

  # macOS/Linux
  curl -LsSf https://astral.sh/uv/install.sh | sh

Node.js 18+ and pnpm

  npm install -g pnpm

LiveKit Cloud Account: cloud.livekit.io
Murf AI API Key: murf.ai/api/dashboard
Google AI Studio API Key: aistudio.google.com
Deepgram API Key: deepgram.com

Step 1: Clone the Repository & Configure Secrets

git clone https://github.com/your-username/jan-sahay-voice-agent.git
cd jan-sahay-voice-agent/murf-livekit-starter

Create .env.local files in both backend/ and frontend/:

backend/.env.local:

LIVEKIT_URL=wss://your-project.livekit.cloud
LIVEKIT_API_KEY=your_livekit_key
LIVEKIT_API_SECRET=your_livekit_secret
MURF_API_KEY=your_murf_falcon_api_key
DEEPGRAM_API_KEY=your_deepgram_api_key
GOOGLE_API_KEY=your_gemini_api_key

frontend/.env.local:

LIVEKIT_URL=wss://your-project.livekit.cloud
LIVEKIT_API_KEY=your_livekit_key
LIVEKIT_API_SECRET=your_livekit_secret

Step 2: Install Backend Dependencies

cd backend
uv sync
uv run python src/agent.py download-files

Step 3: Install Frontend Dependencies

cd ../frontend
pnpm install

Step 4: Run the Application

Option A: One-Click Startup Script (Recommended)

# Windows (PowerShell):
.\start_app.ps1

# Linux / macOS:
chmod +x start_app.sh
./start_app.sh

Option B: Separate Terminals

# Terminal 1: Backend Voice Worker
cd backend
uv run python src/agent.py dev

# Terminal 2: Frontend Web UI & Dashboard
cd frontend
pnpm dev

Open http://localhost:3000 in your browser, click "Start talking", grant microphone access, and begin speaking with Anisha!

📁 Repository Structure

jan-sahay/
├── README.md                           # Main documentation & 10-day build story
└── murf-livekit-starter/
    ├── start_app.ps1                   # Windows 1-click startup script
    ├── start_app.sh                    # Linux/macOS 1-click startup script
    ├── backend/
    │   ├── caller_data.db              # SQLite Caller Memory & Escalations DB
    │   ├── src/
    │   │   ├── agent.py                # Main LiveKit Agent & Multi-Specialist logic
    │   │   ├── db.py                   # SQLite memory CRUD, calculators & PII sanitizer
    │   │   ├── prompt.py               # Anisha persona & system guardrails
    │   │   ├── specialist_prompts.py   # Prompts for Samar, Pooja, and Palak
    │   │   └── outbound_call.py        # Telephony SIP outbound dialer
    │   └── pyproject.toml              # uv Python dependencies
    └── frontend/
        ├── app/
        │   ├── page.tsx                # Next.js Voice Assistant Web Interface
        │   └── api/dashboard/route.ts  # Observability & Escalations API
        └── package.json                # Frontend dependencies (pnpm)

my post mera post

Abhishek — Sat, 15 Aug 2026 05:58:28 +0000

happy guys

Navigatop

Abhishek — Sat, 11 Apr 2026 13:58:12 +0000

📖 Overview

Navigato Platinum is a premium...

In a venue hosting 132,000 attendees, congestion and emergency response are critical life-safety challenges. Navigato solves this by aggregating real-time occupancy data and delivering strategic insights via an AI-Grounded Spatial Hub.

🧠 Approach and Logic

Large venues suffer from "Information Blackouts" during peak events. Navigato creates a Single Source of Truth across defined zones (Gates, Food Courts, Pavilions).

1. Strategic Decision Making

Status Derivation: Zone health (Clear, Moderate, Crowded, Critical) is dynamically calculated using a weighted threshold algorithm based on live capacity-to-density ratios.
Pathfinding (Dijkstra's Algorithm): Navigation routes are not just the shortest path; they are the fastest path. The edge weights in our Dijkstra implementation are adjusted in real-time based on the congestion ratio of each zone.
AI Context Grounding: The Gemini assistant is "Stitched" into the stadium's live telemetry. Every prompt is injected with the current JSON state of the venue, enabling hyper-accurate, real-time advice.

⚡ The Twin-Engine™ Architecture

To achieve 100% startup stability on Google Cloud Run, Navigato utilizes a proprietary Twin-Engine boot sequence.

sequenceDiagram
    participant GCR as Google Cloud Run
    participant E1 as Engine 1 (Safe-Start)
    participant E2 as Engine 2 (Platinum Core)

    GCR->>E1: SIGINIT Launch
    E1->>E1: Bind Port 8080 (Instantly)
    Note over E1: Health Check Passed (2ms)
    E1->>E2: Modular Dynamic Import
    E2->>E2: Warm up AI Clusters & GCS Streams
    E2-->>E1: Core Synchronized
    Note over E1,E2: Platform 100% Operational

Engine 1 (The Shield): A lightweight Node.js entrypoint that binds to the assigned PORT immediately to prevent timeout errors.
Engine 2 (The Intelligence): The modular Express 5.0 application logic, loaded after the port is stable.

📂 Full Project Structure

├── server/                 # PLATINUM BACKEND ENGINE
│   ├── boot.ts             # Engine 1: Instant-bind bootstrapper
│   ├── index.ts            # Engine 2: Modular app logic (Express 5)
│   ├── routes/             # API Endpoints
│   │   ├── ai.ts           # Gemini 1.5 Flash Chat & Triage
│   │   └── incidents.ts    # GCS Visual Telemetry Pipeline
│   ├── services/           # External Service Layer
│   │   ├── gemini.ts       # Google Gen AI SDK Integration
│   │   ├── storage.ts      # Cloud Storage Stream Engine
│   │   └── analytics.ts    # BigQuery & Event Logging
│   └── middleware/         # Security & Auth
│       └── auth.ts         # Firebase Admin Token Verification
├── src/                    # ELITE FRONTEND HUB (React 19)
│   ├── components/         # Premium Component Library
│   │   ├── attendee/       # ZoneMap, LiveHub, Dispatch
│   │   └── layout/         # Glassmorphism Framework
│   ├── context/            # Global State (ZoneContext)
│   ├── hooks/              # Custom Logic (useAuth)
│   └── App.tsx             # Main System Entrypoint
├── Dockerfile              # Multi-Stage Production Shield
├── vite.config.js          # Advanced Rollup Code-Splitting
└── deploy.ps1              # One-Click Cloud Run Deployer

🛠️ Google Services Integration

Service	Integration Detail	Location
Google Cloud Run	Multi-stage container runtime with Twin-Engine boot.	`Dockerfile`, `boot.ts`
Google Maps JS API	Satellite imagery + Advanced Markers + Directions.	`ZoneMap.tsx`
Gemini 1.5 Flash	AI Chat Assistant & Visual Incident Triage.	`gemini.ts`, `ai.ts`
Cloud Storage	Visual telemetry streams for emergency dispatch.	`storage.ts`
Firebase Admin	Role-based custom claims & Token security.	`auth.ts`
Google Cloud Logging	Structured JSON logging for 100% observability.	`index.ts`, `boot.ts`

🏗️ System Visualizations

1. The Intelligence Pipeline (AI Triage)

graph TD
    A[Attendee Report] -->|Satellite Telemetry| B(Google Cloud Storage)
    A -->|Contextual Description| C(Navigato AI)
    B --> C
    C -->|Gemini 1.5 Flash| D{Strategic Severity}
    D -->|HIGH| E[Emergency Staff Dispatch]
    D -->|LOW/MED| F[Operational Logging]
    E --> G(Cloud Pub/Sub Alert)

2. The Platinum Cloud Stack

graph LR
    User[Attendee] -->|React 19| FE(Frontend Hub)
    FE -->|Vite 8 / ESM| BE(Platinum Core)
    BE -->|Twin-Engine™ Boot| CR(Cloud Run)
    CR -->|Security| FA(Firebase Admin)
    CR -->|Spatial| GM(Google Maps)
    CR -->|Gen AI| AI(Gemini 1.5)

🚀 Setup & Running locally

Environment Setup: Add your VITE_GOOGLE_MAPS_API_KEY to the .env file.
Install & Build:
```
npm install
npm run build
```
Ignite the Platform:
```
npm start
```

[!IMPORTANT]
Production Note: Navigato Platinum is optimized for the Narendra Modi Stadium geolocation. For local testing, use the "Force Sync" demo mode to bypass live GPS requirements.

Navigato Platinum • Strategic Crowd Intelligence

Built by Abhishek for Promptwars.

Building MovieSync in Public: A Real-Time Dashboard for Smarter Movie Intermissions

Abhishek — Fri, 10 Apr 2026 05:23:53 +0000

Building MovieSync in Public (with Antigravity) 🎬🚀

Building in public means sharing not just the outcome, but the tools and decisions behind it. While creating MovieSync, I also leveraged Antigravity to accelerate development and deployment, making the project faster to ship and easier to scale.

*The Problem
*
Movie intermissions are short, but queues are long. Whether it’s the washroom or food counter, people waste valuable break time waiting. There’s no visibility into crowd density, and decisions are made blindly.

*The Idea
*
MovieSync is a real-time venue dashboard that shows crowd levels across different areas using simple color indicators. Users can instantly decide where to go and avoid congestion.

Tech Stack

1. React + Vite (Frontend)
2. Vanilla CSS (Glassmorphism UI)
3. Docker (Multi-stage build)
4. Nginx (Static hosting)
5. Google Cloud Run (Serverless deployment)
6. Antigravity (Rapid development & cloud workflow acceleration)
7. Frontend Architecture

I built the UI with React and Vite to keep it lightweight and fast. Instead of using heavy UI frameworks, I hand-coded the layout with Vanilla CSS. The interface uses glassmorphism effects, smooth transitions, and micro-animations to create a premium experience.

Real-Time Simulation

Since real sensors were unavailable, I implemented dynamic simulators that mimic WebSocket-based IoT data. The dashboard updates crowd density in real time using:

Green → Low traffic
Orange → Moderate traffic
Red → High congestion
Docker Multi-Stage Build
The project uses a two-stage Docker setup:

Node stage builds optimized assets
Nginx stage serves the static SPA on port 8080

This keeps the container small and production-ready.

Cloud Deployment with Google Cloud Run

The container is deployed serverlessly using Google Cloud Run. It automatically scales based on traffic and integrates with Cloud Build for CI/CD.

Deployment command:

gcloud run deploy moviesync --source . --port 8080
Where Antigravity Helped

Antigravity helped streamline:

Rapid scaffolding of the project structure
Faster iteration during UI development
Simplified deployment workflow
Reduced setup complexity for cloud deployment
Improved developer productivity

Using Antigravity alongside Cloud Run made the entire process smoother and quicker.

Key Features

Real-time queue dashboard
Serverless scalable deployment
Lightweight UI
Dockerized production build
Antigravity-powered workflow
Open-source repository
What's Next
Real IoT sensor integration
WebSocket backend
Predictive analytics
Mobile PWA version
Multi-venue support
Final Thoughts

MovieSync demonstrates how modern tools like React, Docker, Google Cloud Run, and Antigravity can be combined to build scalable real-time applications quickly. Building in public made the journey more transparent and collaborative.

What are you building right now? 🚀

DEV Community: Abhishek

NameLock

What I Built

Demo

Code

abhishekmsm51w-star / namelock

Banner name proof: Gemma drafts the line, a spelling lock blocks a changed name.

NameLock

What I Built

The print gate in namelock/app.py

How I Built It

The bug I actually hit

Why Does Open Innovation Matter?

Prize Categories

Plant Care AI

🌿 PlantCare AI — Take a Photo. Understand Your Plant. Go Touch Grass.

What I Built

The Core Philosophy: The Screen is the Shortest Step

Key Features:

Demo

Code

abhishekusersfaci-lang / Plantcare-ai

🌿 PlantCare AI

📌 Problem

🌱 Solution

Repository Link:

How I Built It

1. The Core AI Model: Gemma 4 Multimodal (gemma-4-31b-it)

2. Tech Stack

3. Architecture Overview

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Study Buddy

StudyBuddy — The Intelligent Focus, Flashcard & Quiz Companion

What I Built

Demo

Code

Architecture Highlights:

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Jan Sahay — From a Financial Crisis to a Citizen AI Voice Assistant

🛡️ Jan Sahay (जन सहाय) — AI-Powered Citizen Assistance Platform

A 10-Day Journey Building a Real-Time, Multilingual Voice Agent for Financial Safety, Government Welfare & Cyber Fraud Containment

📖 The Story That Started It All

🏛️ The 4 Core Functional Pillars

🏗️ System Architecture & Real-Time Voice Flow

1. Real-Time Audio Pipeline Flow

2. Complete Multi-Tier Architecture

🎙️ Meet the Team of AI Specialists

📅 10-Day Development Journey & Log

🟢 Day 1 — The Problem: Financial Confusion Is Everywhere

🟢 Day 2 — Designing the Citizen Experience

🟢 Day 3 — Giving the AI a Memory

🟢 Day 4 — Building the Government Scheme Knowledge Layer

🟢 Day 5 — Turning Text Into a Real-Time Voice Conversation

🟢 Day 6 — Making Jan Sahay Multilingual & Code-Mixed

🟢 Day 7 — Fraud Prevention as a First-Class Feature

🟢 Day 8 — Action-Oriented Complaint Assistance

🟢 Day 9 — Building the Web Portal & Telemetry Dashboard

🟢 Day 10 — Open-Source Release & Architecture Documentation

🚧 Challenges Faced & How We Solved Them

1. 🌐 Multilingual & Language Switching Inconsistencies

2. 🧠 Hallucination-Free Financial Reasoning

3. 🔄 Dynamic Voice Profile Switching in WebRTC

4. 🛡️ Accidental PII Memorization

🔮 What's Next on the Roadmap

🛠️ Step-by-Step Quickstart Guide

Prerequisites

Step 1: Clone the Repository & Configure Secrets

Step 2: Install Backend Dependencies

Step 3: Install Frontend Dependencies

Step 4: Run the Application

Option A: One-Click Startup Script (Recommended)

Option B: Separate Terminals

📁 Repository Structure

my post mera post

Navigatop

The print gate in `namelock/app.py`

1. The Core AI Model: Gemma 4 Multimodal (`gemma-4-31b-it`)