Flagship course · Pre-launch

Production RAG & LLM Engineering

Build a multi-tenant, production-grade Agentic RAG platform from an empty repository to a monitored deployment.

Most RAG tutorials stop at a notebook. This course walks through the architecture, code and operations of a real system: document ingestion, hybrid retrieval, grounded answers with citations, LangGraph agents, authorisation-aware search, Kafka workers, observability and Docker delivery, using the open-source platform the instructor built.

Join the waitlist See the curriculum Open-source code

Intermediate: comfortable with Python and basic SQL

What you will be able to do

  • Design a RAG architecture that handles large, changing, permission-scoped data
  • Ingest PDFs and text with chunking, metadata and selective vectorisation
  • Implement BM25, vector and hybrid retrieval on PostgreSQL + pgvector
  • Generate grounded, cited answers with context budgeting across LLM providers
  • Orchestrate agentic query flows with LangGraph, tools and guardrails
  • Run async pipelines with Kafka and Redis workers and track job state
  • Add multi-tenant auth, evaluation, Prometheus/Grafana monitoring and CI
  • Ship with Docker and operate it in production

The project you build

View on GitHub
01

FastAPI service with layered modules: api, core, storage, retrieval, query, llm, agent, workers, monitoring

02

PostgreSQL + pgvector schema with Alembic migrations and document/ingestion state machines

03

Kafka-driven ingestion and embedding workers with Redis job tracking

04

Hybrid retrieval, grounded synthesis via LiteLLM (OpenAI, Anthropic, Ollama…)

05

LangGraph agent for query planning and tool use

06

SuperTokens/Keycloak multi-tenant authentication and workspace scoping

07

Prometheus metrics, Grafana dashboards and alerts

08

React chat front end with uploads and citations; Docker Compose stack; 40+ automated tests

Curriculum

12 modules
01Foundations: from RAG to Agentic RAG4 lessons
  1. Why naive RAG fails on real data
  2. Metadata-first retrieval and selective vectorisation
  3. Architecture walkthrough of the platform
  4. Reading the RAG flow end to end
02Project setup & engineering discipline4 lessons
  1. Poetry, pyproject and a Makefile that enforces checks
  2. Configuration with pydantic-settings and .env
  3. Linting, typing and the test layout
  4. Docker Compose: API, worker and database images
03Storage & data model4 lessons
  1. PostgreSQL with async SQLAlchemy 2 and asyncpg
  2. Alembic migrations you can trust
  3. pgvector: embeddings as first-class columns
  4. Document and ingestion-job state machines
04Document ingestion pipeline4 lessons
  1. Upload API with multipart and workspace scoping
  2. PDF and text parsing, chunking strategies
  3. Object storage with S3-compatible clients
  4. Idempotent ingestion jobs and status tracking
05Async workers with Kafka & Redis4 lessons
  1. Producers, consumers and topics
  2. The embedding worker and back-pressure
  3. Redis for job state and caching
  4. Smoke tests for the pipeline
06Retrieval: BM25, vectors and hybrid4 lessons
  1. Lexical search that still matters
  2. Vector retrieval on pgvector
  3. Hybrid ranking and retrieval strategies
  4. Authorisation-aware filters
07Grounded generation4 lessons
  1. LiteLLM: one interface for every provider
  2. Context budgeting: chunks and tokens
  3. Citations and answer formats
  4. Handling "I don't know" honestly
08Agentic orchestration with LangGraph4 lessons
  1. Graphs, state and tools
  2. Query planning and multi-step retrieval
  3. Retries, budgets and guardrails
  4. Human oversight patterns
09Multi-tenancy & authentication4 lessons
  1. Tenants, workspaces and roles
  2. SuperTokens and Keycloak integration
  3. JWT validation and bootstrapping the first admin
  4. Auditing access
10Observability4 lessons
  1. Prometheus metrics for FastAPI
  2. Grafana dashboards and alert rules
  3. Structured logs and tracing
  4. Measuring retrieval and answer quality
11Testing & CI4 lessons
  1. Unit tests for retrieval, query and agents
  2. Smoke and integration tests against Docker
  3. Type checking and linting in CI
  4. Release checklists
12Front end, delivery & production4 lessons
  1. The React chat UI: uploads, questions, citations
  2. Building and shipping the Docker stack
  3. Cost control, rate limits and scaling
  4. Production hardening and what to monitor

Who it is for

  • Backend and Python developers moving into AI engineering
  • Engineers who have built a RAG demo and need it to survive production
  • Tech leads evaluating how to structure an LLM platform

Prerequisites

  • Python (functions, classes, async basics)
  • Basic SQL and HTTP APIs
  • Docker installed; an LLM provider key or Ollama

Your instructor

Mithlesh Upadhyay

Founder, W3Colleges · Computer Science & AI engineer

BE in Computer Science and M.Tech in Artificial Intelligence. Over six years in technical education: 15,000+ articles written, reviewed or published, four years leading content teams at GeeksforGeeks, and hands-on work in full-stack development, data science and production AI systems. He built the open-source Agentic RAG platform this course is based on.

More about the instructor

Questions

When does the course open?

The curriculum is being recorded now. Join the waitlist to get the launch date, the early-bird price and the first lessons before public release.

Is the code available?

The platform is open source on GitHub; the course explains how and why it is built that way, module by module, with exercises.

Do I need a paid LLM API?

No. Everything runs with Ollama locally; you can switch to OpenAI, Anthropic or others through LiteLLM when you want.

Will I get a certificate?

Yes, a certificate of completion after the checkpoints and the final project.

Launch updates

Get notified when a course opens.

One email per launch. No newsletter, no spam, unsubscribe any time.

Need this built for your company instead? AI & RAG Development