Raj Kumar Nelluri

AI Engineer · LLM Systems · Multi-Agent Architecture · Production Deployment

B.Tech Artificial Intelligence — Amrita Vishwa Vidyapeetham  ·  MS Computer Science — Pace University, New York

I build AI systems where the model is never the single point of failure.

Every system on this page puts a deterministic engine in front of the LLM.
Rules decide. The model explains. That is the difference between a demo and something you can deploy.

Systems Running In Production

	System	What It Does	Live
🧠	ai-org	Autonomous multi-agent org that ships a security-certified full-stack app from one sentence	self-hosted
📈	Fintel	9-node LangGraph agent → deterministic BUY/HOLD/SELL in under 30s
🎬	CineNeuro	Predicts a human audience's brain response to a trailer before anyone watches it
🏥	MedEval	ER triage assistant where 68 clinical rules — not the LLM — assign urgency
📚	RAG Chatbot	Citation-grounded document QA that refuses to answer when context is thin

_{All four public demos run on AWS EC2 behind Nginx + Let's Encrypt. Docker Compose, cross-built linux/amd64, pushed through Docker Hub.}

I'm an AI Engineer working on LLM systems that survive contact with production — multi-agent pipelines, agentic orchestration, retrieval, and the unglamorous infrastructure that keeps them honest.

The pattern in everything I build is the same: I don't let a language model make the decision that matters. In Fintel a deterministic scoring engine issues the BUY/HOLD/SELL and GPT-4o is only allowed to explain it. In MedEval a pure-Python rules engine assigns the ESI urgency level and the LLM is structurally barred from touching it. In ai-org roughly 56 deterministic integrity gates stand between generated code and a deploy, each one grounded in a real captured bug and locked with a regression test. The model is a component, not the architecture.

• Agentic systems — LangGraph StateGraph pipelines, fan-out/fan-in orchestration, typed state with reducers, conditional aborts, tool calling
• Multi-agent engineering — specialised agents for analysis, architecture, codegen, security review, QA and deploy, coordinated end to end without a human in the loop
• Retrieval — adaptive chunking, MMR + BM25 hybrid retrieval, score-based reranking, citation injection, confidence guardrails that refuse rather than hallucinate
• Reliability engineering for LLM output — deterministic gates, regression-locked fixes, hallucinated-import blocklists, self-healing rewrite loops, LLM-as-judge evaluation harnesses
• Applied research — Meta FAIR's TRIBE v2 brain-encoding model in a real product, with a fix contributed back upstream
• Production infrastructure — FastAPI, Docker multi-stage builds, AWS EC2, Nginx, Let's Encrypt, GitHub Actions CI, Redis, Postgres, Langfuse tracing

A model that doesn't reach production is a prototype. A model nobody can trust in production is a liability.

Repository ↗

A multi-agent pipeline that turns a plain-English business idea into a deployed, security-certified full-stack web application — with no human in the loop.

Most "AI builds your app" projects generate code and stop. The hard part isn't generation, it's reliability: making AI-generated code actually compile, pass a real security review, pass QA, and survive a deploy. That's the entire thesis here.

flowchart LR
    A["Plain-English<br/>idea"] --> B["BA +<br/>Architect"] --> C["Developer<br/>Agents"]
    C --> D{"Integrity Engine<br/>~56 gates"}
    D -->|fail| C
    D -->|pass| E{"Opus<br/>Security Review"}
    E -->|not certified| C
    E -->|certified| F{"QA<br/>build + tests"}
    F -->|fail| C
    F -->|pass| G["DevOps<br/>deploy"] --> H["Live<br/>URL"]

Roughly 56 numbered fixes, each one a deterministic gate. Every gate is grounded in a bug that was actually captured in a real run, and every gate is locked with a regression test. They validate code during generation and after every rewrite, catching what AI codegen actually ships in practice:

hallucinated imports and submodules · broken schemas · dangling foreign keys · unsafe auto-fixes · truncated / unparseable frontend files · missing auth or login flows · JWT-in-URL

Nothing deploys unless it is security-certified and passes a real build plus QA.

Python LangGraph FastAPI Next.js PostgreSQL Redis Docker Compose Claude Opus Auth0 Stripe

Live ↗ · Repository ↗

Enter a ticker, get a deterministic BUY / HOLD / SELL / INSUFFICIENT_DATA call with a confidence score, a full score breakdown, and a plain-English explanation.

GPT-4o never makes the investment decision. It classifies news sentiment and writes the explanation — that's it. The decision is locked by a deterministic scoring engine before the explanation node ever runs, which removes hallucination from the only part of the pipeline that carries real consequences.

flowchart LR
    A["dispatch"] --> B["market data<br/>sequential first"]
    B --> C["fundamentals<br/>Alpha Vantage"]
    B --> D["news +<br/>sentiment"]
    C --> E["indicators<br/>MA · RSI · vol"]
    D --> E
    E --> F["scores<br/>deterministic"]
    F --> G["decision<br/>NO LLM"]
    G --> H["explanation<br/>GPT-4o"]
    H --> I["guardrails"]

Why sequential, then parallel. Alpha Vantage's free tier enforces a 1 req/sec burst limit — firing market data and fundamentals simultaneously returned 429s. The fix was to fetch market data sequentially first, then fan out to fundamentals (Alpha Vantage) and news (Tavily), which hit different APIs and don't conflict.

Python FastAPI LangGraph GPT-4o Alpha Vantage Tavily Redis Pydantic v2 Structlog Chart.js Docker AWS EC2

Live ↗ · Repository ↗

Predicts the second-by-second neural engagement of a human audience watching a movie trailer — before it is shown to a single real person.

Upload an MP4 and get a brain engagement timeline, scene-level insights, audience persona breakdown, competitive benchmarking, and a downloadable PDF report. It replaces a $50K–$200K studio focus group with a software pipeline.

Built on Meta FAIR's TRIBE v2 brain-encoding model, vendored and modified — three multimodal encoders feeding a predictor that outputs 20,484 fMRI vertices per segment.

MP4 (≤500MB) → events_df (video / audio / word events via MoviePy + WhisperX)
     → TRIBE v2 inference → (n_segments, 20484) fMRI predictions
     → 7 brain regions → weighted linear combination → 5 emotions
     → peak detection (≥0.65) + drop detection (≤0.35) → top 3 each
     → 3 audience personas (distinct emotion weight vectors)
     → benchmark vs 5 baseline trailers → ReportLab PDF

Meta FAIR TRIBE v2 V-JEPA2 Wav2Vec-BERT Llama 3.2 3B WhisperX FastAPI React 19 Recharts ReportLab FFmpeg Docker AWS EC2 + g4dn.xlarge

Live ↗ · Repository ↗

Free-text chief complaint in, an Emergency Severity Index level (1–5) out — with the exact rules that produced it.

The LLM is structurally barred from making the urgency decision. A pure-Python rules engine assigns the ESI level. The model does exactly two things: convert free text into structured booleans, and rephrase clinical rationale into lay language. In a clinical setting that separation isn't a nice-to-have, it's the entire safety argument.

flowchart LR
    A["complaint<br/>+ vitals"] --> B["LLM call 1<br/>extract 95 fields"]
    B --> C["68 YAML rules<br/>PURE PYTHON"]
    C --> D["LLM call 2<br/>explain"]
    D --> E["ESI 1–5<br/>+ decision path"]

Two UI modes: patient view shows the explanation only; doctor view shows the explanation plus the decision path and the rule IDs that fired.

Python FastAPI LangGraph GPT-4o-mini Pydantic v2 Langfuse React 19 TypeScript Vite Tailwind Docker GitHub Actions AWS EC2

Live ↗ · Repository ↗

Citation-grounded document QA that refuses to answer when the retrieved context isn't good enough.

The interesting engineering here isn't the retrieval, it's everything wrapped around it — the guard rails, the cache, the classifier, and the reranker that together decide whether the model is even allowed to speak.

rate limit (20/min) → token guard (400) → query cap (500 chars)
     → Redis cache (SHA-256 key, 1hr TTL)
     → follow-up detection + LLM query rewrite
     → classification (COMPLEX / FACTUAL / AMBIGUOUS / KEYWORD)
     → MMR retrieval → score reranking + dedup → confidence guardrail
     → GPT-4o (temp=0) strict citation prompt
     → answer + sources + timings

Python FastAPI LangChain 0.3 GPT-4o ChromaDB Redis 7 SlowAPI tiktoken React 18 TypeScript Vite Tailwind Framer Motion Docker Nginx AWS EC2

While building CineNeuro I hit a crash in TRIBE v2's eventstransforms.py: it requested float16 unconditionally, which CTranslate2 and WhisperX cannot execute on CPU. The fix selects int8 on CPU and keeps float16 on GPU — a real bug found by using the research code in production, and sent back upstream.

The Contribution Machine

_{Regenerated every 12 hours by a GitHub Action chewing through the contribution grid.}

Let's Work Together

I'm actively seeking AI Engineer, LLM Engineer, Agentic Systems and Applied AI roles at US tech companies and startups.

_{Available immediately  ·  US-based (OPT / STEM OPT)  ·  Open to remote and on-site}

_{build's green — the cat's off duty}