class PrakharRaj:
def __init__(self):
self.role = "Founding Engineer @ AgentLine · Backend & Infra"
self.education = "B.Tech ECE @ IIT Bhilai (2024–2028, CGPA 8.56)"
self.focus = ["developer platforms for AI agents", "webhooks & realtime", "distributed backends"]
self.roles = ["AI/ML Lead @ GDG IIT Bhilai", "Coordinator @ E-Cell"]
self.shipping = "production systems, not just notebooks"
def current_work(self):
return "AgentLine — an open-source phone + SMS API for AI agents ☎️"- ☎️ Founding Engineer @ AgentLine — open-source phone + SMS API for AI agents (AgentLineHQ/AgentLine, MIT): REST, MCP server, SDKs, signed webhooks, hosted cloud
- 🔭 Co-founder & Full-Stack Engineer @ RaahiKart — P2P parcel-logistics platform, Shark Tank India Round 2 selection
- 💬 Shipped WhatsApp Business API notifications and Razorpay webhook / idempotent payment flows for live B2B clients at Miar International; built TaskForge, a Go + PostgreSQL job queue measured at 3k+ jobs/s
- 🤖 I build infrastructure that developers and their AI agents build on, and I own it end to end — decide what to build, ship it, watch how it's used, improve it
- ⚙️ I care about the unglamorous parts: schemas, indexing, rate limiting, caching, observability, fault tolerance
- 🧪 Research in agentic LLM frameworks (5G/6G diagnostics) + paper reviews at ICLR 2025 & NAACL 2025
- 🎯 Mentoring 30+ students in ML fundamentals, RAG, and AI agents
☎️ What I'm building now — AgentLine
FastAPI · PostgreSQL · Redis · WebSockets · MCP · Docker · SignalWire / Twilio / Plivo / Telnyx · Deepgram · Cartesia · LiveKit / Pipecat · MIT
Give any AI agent a real phone number. One API for outbound/inbound PSTN calls, SMS, IVR navigation and transcripts, consumed over REST or MCP from Claude Code, Cursor, Codex, OpenClaw and Hermes. Self-host with one docker-compose up, or use the hosted version at agentline.cloud.
Your agent (Claude Code · Cursor · Codex · OpenClaw · Hermes)
└─ REST / MCP / skill.md ─▶ AgentLine API ─▶ carrier router ─▶ SignalWire · Twilio · Plivo · Telnyx ─▶ PSTN
│ (per-country routing, failover)
├─ voice runtime: Deepgram STT → LLM → Cartesia TTS (or LiveKit / Pipecat)
└─ events & transcripts ─▶ relay WebSocket (ACK/replay) │ signed webhook │ event mailbox
What I own in it:
| Area | What's there |
|---|---|
| Core platform | Async FastAPI over Postgres + Redis, hashed API keys, auth middleware, versioned migrations, one-command Docker Compose, Railway deploy |
| Developer surface | REST + OpenAPI, built-in MCP server (14 tools), one-file installable skill, Python (agentline-ai) & Node clients, /.well-known/agentline.json discovery |
| Reliable delivery | Persistent outbound WebSocket relay with reconnect + ACK/replay + turn-safe context; HMAC-signed per-agent webhooks as fallback; durable event mailbox — no caller turn is dropped if your runtime is offline |
| Voice pipeline | Deepgram STT → OpenAI-compatible LLM → Cartesia TTS on the carrier media socket; semantic end-of-turn detection, barge-in, real DTMF for IVR menus; pluggable runtimes |
| Telephony | Provider registry + router with per-country routing and automatic failover across four carriers |
Agentic AI & LLMs
Backend & Infrastructure
Languages & Core CS
DSA · Operating Systems · DBMS · Computer Networks · Computer Architecture · System Design (HLD/LLD)
I design from the request inward — every endpoint sits behind a deliberate path of DNS → edge → gateway → service → data, with failure handled at each hop.
┌──────────────────────────────────────────────┐
client ──▶ DNS resolve ──▶ │ Nginx / Apache (TLS termination · reverse │
(HTTPS) (A / CNAME) │ proxy · L7 load balancing · rate-limited │
│ routing · gzip · health checks) │
└───────────────────────┬──────────────────────┘
▼
┌──────────────────────────────────────────────┐
│ API Gateway · JWT auth · per-IP / per-key│
│ token-bucket rate limiting (Redis-backed) │
└───────────────────────┬──────────────────────┘
▼
┌───────────────────────────────────────────────────────────────────┐
│ FastAPI services (async) │
│ • Pydantic request/response schemas + dependency injection │
│ • idempotency keys · retry budgets · circuit breakers │
│ • structured logging + request tracing (correlation IDs) │
└───────┬───────────────────┬───────────────────────┬───────────────┘
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐
│ Redis │ │ Kafka │ │ PostgreSQL / Mongo │
│ • cache-aside│ │ • event bus │ │ • indexed, normalized │
│ • sessions │ │ • async work │ │ • txns · pooling │
│ • rate limits│ │ • decoupling │ │ • read replicas │
└──────────────┘ └──────┬───────┘ └──────────────────────┘
▼
┌──────────────────┐
│ async workers / │
│ consumers │
└──────────────────┘
Infrastructure & networking
- DNS & edge — A/CNAME resolution, reverse & forward proxy, TLS termination, L7 load balancing, health checks
- Rate limiting — token-bucket / sliding-window limits per IP & per API key, enforced at the gateway via Redis counters to harden APIs against abuse and bursts
- Caching (Redis) — cache-aside reads, session storage, distributed locks, and rate-limit state; tuned TTLs and invalidation to cut DB load
- Messaging (Kafka) — event-driven decoupling, async task fan-out to consumer workers, producer/consumer back-pressure handling, replayable streams
- Fault tolerance — retry budgets, circuit breakers, multi-provider fallback chains, graceful degradation, idempotency keys
FastAPI service design (the patterns I actually ship)
# Endpoint protected by JWT + Redis-backed rate limit, served async with
# clean schemas, dependency injection, and cache-aside reads.
@router.get("/v1/routes/{route_id}", response_model=RouteOut)
async def get_route(
route_id: UUID,
user: User = Depends(verify_jwt), # auth dependency
_: None = Depends(rate_limit(limit=60, window=60)), # 60 req / min / key
cache: Redis = Depends(get_redis),
db: AsyncSession = Depends(get_session),
):
if cached := await cache.get(f"route:{route_id}"): # cache-aside hit
return RouteOut.model_validate_json(cached)
route = await routes_repo.fetch(db, route_id) # async DB read
if route is None:
raise HTTPException(404, "Route not found")
await cache.set(f"route:{route_id}", route.model_dump_json(), ex=120) # warm cache
await events.publish("route.viewed", route_id=route_id) # Kafka event, fire-and-forget
return routeAPI Gateway design · REST + WebSockets · microservices · horizontal scaling · connection pooling · observability & tracing · async message queues
💡 Each project below targets a real bottleneck — the framing is Problem → System → Result.
⚙️ TaskForge — High-Throughput Distributed Job Queue (Go + PostgreSQL, no broker)
Go · PostgreSQL · Docker · Prometheus / Grafana · k6
- 3,000+ jobs/s in local load tests;
SELECT … FOR UPDATE SKIP LOCKED+ fencing tokens → zero duplicate claims across 200 jobs × 16 workers (tested under-race) - Partial index cut claim latency 31 ms → 0.22 ms; idempotency keys enforced by a partial unique index
- Retries with equal-jitter backoff, dead-letter queue with replay, lease renewal, crash recovery (SIGKILL a worker mid-job, another reclaims it)
- DNS-level SSRF prevention for outbound webhook jobs; 28 MB distroless image; Go stdlib HTTP only — every number is measured and reproducible from the repo
TypeScript · Node / Express · PostgreSQL / Prisma · React · WhatsApp Business API · Razorpay
- Real-time booking with WhatsApp template notifications and delivery-status webhooks for live B2B clients
- Razorpay HMAC-SHA256 webhook verification + an idempotent order state machine — no duplicate bookings or charges under concurrent load
- JWT auth, RBAC, input validation and rate limiting on every public route
📦 RaahiKart — Peer-to-Peer Parcel Logistics Platform
Node.js · Express · PostgreSQL · WebSockets · JWT · Docker · Apache/Nginx · CI/CD
- Matches parcel senders with travellers across shared train/bus routes — live in production
- Real-time route-matching engine on WebSocket bidirectional sync, holding 100+ concurrent users at low latency
- Normalized PostgreSQL schemas (indexing, transactions) + JWT auth + protected REST routes; behind an Apache/Nginx reverse proxy for TLS termination and rate-limited routing
- Scaled 0 → 100+ registered users; 🦈 Shark Tank India Round 2 national selection
LangChain · FastAPI · Playwright · Async Workers · LLM Tool-Calling
- Autonomous agent owning the full lifecycle: natural-language query → multi-source price scrape → economical-route selection → booking → confirmation
- LLM dynamically selects scraping / comparator / booking tools via tool-calling; browser-automation layer with state recovery handles CAPTCHAs & inconsistent DOMs without human-in-the-loop
- Async task queues, structured tool-call schemas, per-tool tracing, retry budgets & fallback chains
🩺 Cortex AI — Multimodal Health-Aware AI Assistant
FastAPI · Whisper · Qwen-VL · Llama (QLoRA) · ChromaDB
- Microservices for voice (Whisper) + vision (Qwen-VL) + LLM behind a unified gateway with sub-200 ms routing
- Three-modal pipeline with real-time sentiment adaptation + persistent multi-session memory via ChromaDB
- Integrating PPG-based heartbeat sync on wearable data to flag early cardiac-risk indicators in the reasoning loop
💊 SmartAMR — Clinical Antibiotic-Resistance Decision Support
FastAPI · XGBoost · SHAP · Hybrid RAG (FAISS + BM25) · LangChain · MySQL
- Predicts resistance across 15 antibiotics (multi-label XGBoost) with SHAP explainability
- Hybrid BM25 + FAISS retrieval (40/60 ensemble) grounds every recommendation in EUCAST/WHO evidence — no dosage hallucinations
- 3-provider LLM fallback (Groq → Gemini → OpenRouter) with HTTP-429 retry for resilience; JWT auth + per-user isolation
🔗 Domino — Repository-Wide Change-Impact Intelligence
FastAPI · NetworkX · LangChain + Gemini · PostgreSQL · React · Docker
- Predicts a code change's downstream blast radius before deployment as a 0–100 impact score
- Builds repo-wide dependency graphs across 4 layers (file, function-call, class, service) with NetworkX
- Routes traversal results to a Gemini + LangChain layer for plain-English risk reports + recommended test set
FastAPI · RAG · Vector DB · LangChain
- Retrieval-augmented advisory over curated tax documentation with citation-aware, source-traceable answers
- 📄 Co-author — Autonomous Agentic-LLM Framework for PCAP Analysis in 5G/6G Telecom Diagnostics (under review)
- Built the PCAP Analysis Agent: 80+ pre-compiled diagnostic tests fused with an agentic reasoning loop that writes Wireshark filters on the fly
- Benchmarked GPT-4o, Nemotron-70B, Llama 3.1 70B, Qwen 3 32B, Phi-4, Gemma 2 27B → 84.1% on 3GPP TS understanding
- 🦈 Shark Tank India Round 2 — national selection (RaahiKart)
- 📚 ICLR 2025 — paper review & reproduction (LLM training-efficiency / loss strategies; cross-modal representation learning)
- 📚 NAACL 2025 — fine-tuning strategies for multilingual LLMs (review & implementation study)
- 🧩 Codeforces Pupil · active on LeetCode
Building the infrastructure that agents build on — and the systems that reason, act, and recover.
📫 prakhar@agentline.cloud · LinkedIn · agentline.cloud

