Skip to content
View prakhar-raj-031104's full-sized avatar

Block or report prakhar-raj-031104

Block user

Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users.

You must be logged in to block users.

Content in all repositories owned by your account will be closed.
Maximum 250 characters. Please don’t include any personal information such as legal names or email addresses. This note will only be visible to you.
Report abuse

Contact GitHub support about this user’s behavior. Learn more about reporting abuse.

Report abuse
prakhar-raj-031104/README.md
Prakhar Raj Singhal — Founding Engineer @ AgentLine

Typing roles

Profile views Followers AgentLine AgentLine stars IIT Bhilai Shark Tank

AgentLine RaahiKart LinkedIn Email LeetCode Codeforces

Contribution snake animation

🧠 About

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

🛠️ Tech Stack

Agentic AI & LLMs

LangChain LangGraph Ollama HuggingFace PyTorch TensorFlow ChromaDB FAISS

Backend & Infrastructure

FastAPI Node.js Express Next.js PostgreSQL MongoDB Redis Kafka Docker AWS Nginx

Languages & Core CS

Python Go TypeScript C++ Java JavaScript SQL

DSA · Operating Systems · DBMS · Computer Networks · Computer Architecture · System Design (HLD/LLD)


⚙️ Backend-First Architecture

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 route

API Gateway design · REST + WebSockets · microservices · horizontal scaling · connection pooling · observability & tracing · async message queues


🚀 Featured Projects

💡 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

💬 WhatsApp Business API + Payments in Production — Miar International

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

🎫 SmartTrix — End-to-End Agentic Booking System

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

🤖 Tax Consultant RAG — Grounded Tax-Advisory System

FastAPI · RAG · Vector DB · LangChain

  • Retrieval-augmented advisory over curated tax documentation with citation-aware, source-traceable answers

🔬 Research & Achievements

  • 📄 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


‹ /›  GitHub Analytics  ‹ /›

GitHub stats Top languages

Streak stats

Trophies

Activity graph


Building the infrastructure that agents build on — and the systems that reason, act, and recover.
📫 prakhar@agentline.cloud · LinkedIn · agentline.cloud

Pinned Loading

  1. TaskForge TaskForge Public

    Distributed job queue in Go + PostgreSQL, 3,000+ jobs/s, zero duplicate claims

    Go

  2. multimodal-ai-assistant multimodal-ai-assistant Public

    Multimodal AI assistant with vision, speech, memory and agent capabilities

    Python 1

  3. ProcessLens-Multimodal-Process-Intelligence-Copilot ProcessLens-Multimodal-Process-Intelligence-Copilot Public

    Agentic Graph-RAG copilot that turns UI screenshots into process graphs

    Python

  4. VaultStack_AI-AgenticRAG VaultStack_AI-AgenticRAG Public

    Production hybrid-search RAG (Qdrant + BM25 + reranking) over 10k+ enterprise docs

    Python

  5. Smart-AMR Smart-AMR Public

    Clinical decision-support backend: XGBoost + SHAP + cited RAG

    TypeScript

  6. NextGen-Ventures NextGen-Ventures Public

    Full-stack B2B platforms with Razorpay payments and idempotent order flows

    TypeScript 1