I build AI agents that ship. LangGraph pipelines, GraphRAG retrieval, and the observability that keeps them honest.

Enterprise GraphRAG observability

→ ~90% lower latency (4.5s → <500ms)

The problem. Root-cause analysis in distributed systems is slow. When something breaks, engineers end up tracing service dependencies by hand to work out what a given bug affected.

What I built. An observability platform built on a custom GraphRAG engine that maps service dependencies and automates root-cause analysis. A hybrid LLM router classifies intent using Groq Llama-3.1-8B and GLiNER for zero-shot NER, backed by LadybugDB, a custom multi-hop graph database that runs batched Cypher traversals. The React Flow frontend visualizes the blast radius of a bug across GitHub PRs and Jira tickets, with plain-English summaries.

• Batched Cypher queries in LadybugDB eliminate N+1 bottlenecks
• Sustained 13 req/s with zero errors under a 25-way concurrent load test
• Interactive blast-radius view spanning GitHub PRs and Jira tickets

AI mock-interview platform

→ Sub-millisecond session latency at scale

The problem. Interview prep tends to be either expensive coaching or a static question bank. Neither feels realistic, offers meaningful feedback, or scales.

What I built. A voice-first interview platform with a 6-phase adaptive pipeline and 4-dimensional scoring, with live proctoring via FaceNet512, MediaPipe, and YOLOv8. Session state moves through a 3-tier store, from in-memory to Redis to PostgreSQL.

• RAG over 10K+ document chunks keeps follow-up questions grounded
• Sarvam AI for STT/TTS, with a gamification engine spanning XP and 7 rank tiers

Parallel-universe AI for X profiles

→ 4 validated personas from one LLM call

The problem. A viral AI toy is easy to demo and hard to keep working — external APIs rate-limit, keys go missing, and results have to unfurl cleanly when someone shares them.

What I built. AltEgo turns any public X/Twitter handle into four exaggerated 'parallel-universe' versions of the account. It fetches recent tweets and runs them through a single Groq call (Kimi K2, with an automatic Llama 3.3 70B fallback) that returns validated JSON for all four personas — each a different archetype from a pool of 20, with a parody handle, tweets that mimic the person's real writing style, vibe stats, and an absurd engagement projection. Every external dependency degrades gracefully: with no API keys it runs a fully functional demo mode on deterministic sample data, so local dev and CI need zero setup. Results are cached per handle in Upstash Redis, and each one gets a short URL with a dynamically generated Open Graph image so it previews cleanly on X.

• Graceful degradation: full demo mode with zero API keys, real APIs swap in when configured
• Per-result Open Graph images via next/og, plus downloadable 4-in-1 share cards
• Custom hand-drawn 'sketchbook' design system — SVG doodles, marker type, Framer Motion

Realtime collaborative whiteboard

→ In active development

The problem. Multiplayer whiteboards like Figma and Excalidraw depend on realtime sync that doesn't conflict and clean recovery after a dropped connection. The hard part is the backend, not the canvas.

What I built. A backend-first collaborative whiteboard built around an immutable operation log, snapshot-based replay, per-room version ordering, and websocket broadcast — the same primitives behind Figma and Excalidraw multiplayer. I designed the system before implementing it, with 18+ diagrams covering architecture, schema, sequence flows, reconnect recovery, and a Redis pub/sub scaling path.

• Cursors and presence are kept off the persisted write path to keep the op-log clean
• Scaling path designed from single-instance to Redis pub/sub

RL traffic optimization

→ 30% lower average wait time

The problem. Fixed-timer traffic signals don't respond to real congestion, so an intersection can sit red over an empty lane while traffic backs up beside it.

What I built. A real-time vision pipeline tracks vehicles across 4-lane intersections, and a reinforcement-learning agent uses the live counts to adjust signal timing dynamically.

• 94% vehicle detection accuracy at 30 FPS
• Analyzes 500+ traffic patterns an hour, improving flow efficiency by 40%

AI job-application automation

→ 100+ applications tracked end-to-end

The problem. Applying to jobs manually is slow, repetitive, and rarely tailored to each specific posting.

What I built. It generates tailored LaTeX resumes, cover letters, and cold emails, with an async scheduler that polls Gmail and sends context-aware follow-ups. A human stays in the loop throughout.

• Hybrid scoring: TF-IDF 40%, keyword 35%, tech-match 25%
• Redis-cached sub-second recommendations

Semantic resume matching

→ Deployed full-stack on AWS

The problem. Manual resume screening is slow and prone to bias, and strong candidates often get filtered out over keyword mismatches.

What I built. It scores resumes against a job description using SentenceTransformers for semantic matching, with LLaMA 3 generating feedback on what's missing.

• Semantic matching rather than simple keyword overlap
• Groq generates the feedback; MongoDB tracks applications

Gesture-based audio control

→ 96% recognition across 12 commands

The problem. Hands-free audio control without wearables or extra hardware — just a webcam.

What I built. A computer-vision system that maps hand gestures to audio commands in real time, using MediaPipe landmarks and lightweight ML classifiers.

• Real-time at 30 FPS with <100ms latency