Building a Voice RAG System Under a 200ms Latency Budget

Shourya Parashar — Sat, 05 Sep 2026 03:30:00 +0000

What happens when you combine Voice AI + RAG + multilingual retrieval, but give yourself a strict 200ms latency budget?

That was the challenge behind my HH Goa 2026 Task 2 project.

I built a voice-driven RAG system on the AI4Bharat MSMARCO-XI dataset, designed to retrieve relevant information, generate grounded answers, and gracefully refuse when the evidence isn't strong enough.

The Pipeline

Voice
  ↓
Speech-to-Text
  ↓
Query Guard
  ↓
Hybrid Retrieval
  ↓
RRF + MMR
  ↓
Grounded Answer
  ↓
Verification

What made it interesting?

Instead of relying only on vector search, I combined:

Dense retrieval
BM25+ sparse retrieval
Reciprocal Rank Fusion
MMR reranking
Multiple chunking strategies
Retrieval confidence checks
Prompt-injection protection
Grounding verification
Extractive fallback answers

The goal wasn't just to make the system answer.

It was to make it answer only when it has enough evidence.

The part I cared about most: latency

I instrumented every stage and benchmarked the complete pipeline.

The final results:

Metric	Result
P50	7.87 ms
P70	9.62 ms
P100	40.71 ms
Benchmark runs	927
Within 200ms	100%

I also tested the actual HTTP service separately, instead of relying only on in-process benchmarks.

A few lessons

The biggest takeaway wasn't a particular model or framework.

It was that good AI systems are often about making the right engineering trade-offs.

A bigger model isn't always better.

More retrieval isn't always better.

And sometimes the best answer is simply:

"I don't have enough evidence to answer that."

This project pushed me to think about RAG not just as retrieval + generation, but as a complete system with latency, reliability, safety, and verification built into the architecture.

Built with

Python · FastAPI · BM25+ · Dense Retrieval · RRF · MMR · Sarvam · Claude · Docker

If you're interested in the implementation, the complete project is here:

GitHub: https://github.com/im-shourya/HHGOA-TASK2

Built for HH Goa 2026 — Shortlisting Task 2.

AI #RAG #Python #LLM #MachineLearning #VoiceAI #InformationRetrieval

KanbanFlow

Shourya Parashar — Sat, 25 Apr 2026 20:37:33 +0000

I Built a Zero-Backend Kanban Board with React + TypeScript — Here's What I Learned

No server. No database. No login. Just pure React — and it actually works great.

Why I Built KanbanFlow
Every Kanban tool I used asked me to sign up, connect to a server, or pay for features I didn't need. I wanted something that just opened and worked — instantly, privately, offline.

So I built KanbanFlow — a fully-featured Kanban board that lives entirely in your browser. No account. No backend. No setup.

What It Does

Unlimited columns and tasks — fully customizable
Drag & drop task movement across columns
Priority tagging — High, Medium, Low, None
Due dates with overdue highlighting
Live search + priority filtering
Dark / Light theme toggle
Auto-saves to localStorage — data persists across sessions

Tech Stack

React 18 + Vite 5 + TypeScript 5 + Tailwind CSS + React Router v6

No Redux. No external state library. Just React's useState and useReducer — keeping it lean.

The Interesting Part — localStorage as a Database

Most people reach for Firebase or Supabase immediately. But for a personal productivity tool, localStorage is genuinely underrated.

// Auto-save board state on every change
useEffect(() => {
  localStorage.setItem('kanban-board', JSON.stringify(board));
}, [board]);

// Load on mount
const [board, setBoard] = useState<Board>(() => {
  const saved = localStorage.getItem('kanban-board');
  return saved ? JSON.parse(saved) : defaultBoard;
});

This pattern gives you:

Instant persistence with zero latency
Works completely offline
No auth, no API keys, no cost
Data stays on the user's machine (privacy win)

The tradeoff? No cross-device sync. For a personal board, that's totally acceptable.

Drag & Drop Without a Library

Instead of reaching for react-beautiful-dnd or dnd-kit, I implemented drag and drop using the native HTML5 Drag and Drop API — which kept the bundle size tiny.

const handleDragStart = (e: DragEvent, taskId: string) => {
  e.dataTransfer.setData('taskId', taskId);
};

const handleDrop = (e: DragEvent, targetColumnId: string) => {
  const taskId = e.dataTransfer.getData('taskId');
  moveTask(taskId, targetColumnId);
};

Project Structure

I kept the component tree flat and predictable:

src/
├── types/kanban.ts         # All types + constants
├── components/kanban/
│   ├── TaskCard.tsx
│   ├── KanbanColumn.tsx
│   ├── TaskForm.tsx
│   ├── Header.tsx
│   └── Toolbar.tsx
└── pages/
    └── Index.tsx           # Main orchestrator

One rule I followed: no component does more than one thing. KanbanColumn renders a column. TaskCard renders a card. Index.tsx wires them together.

Try It

Live: kanbanflow.shouryaparashar.in
GitHub: github.com/im-shourya/KanbanFlow

Built by Shourya Parashar — Full Stack Developer.

If you found this useful, drop a ⭐ on GitHub — it genuinely helps!

DEV Community: Shourya Parashar