Ready-made course · 2 days · Intermediate
RAG: From Fundamentals to Production
A two-day course on retrieval-augmented generation as an engineering discipline: why naive RAG fails, and how to design a system that can be evaluated, secured and operated.
Many RAG systems fail for ordinary reasons: poor parsing, arbitrary chunking, weak retrieval, no reranking, no evaluation, and a prompt that asks the model to sound certain. The result is fluent answers with weak grounding, which is worse than a search box.
This course teaches RAG properly. You start with architecture, embeddings and vector databases, then spend serious time on ingestion, parsing, chunking, metadata and retrieval strategy. Hybrid search, reranking, query rewriting, context construction, citations and access control are treated as the difference between a demo and a system.
Labs compare a weak pipeline with an improved one on the same corpus. The second day moves into production architecture: evaluation, hallucination reduction, permissions, monitoring, performance and cost.
You build a production-style RAG system you can explain, measure and harden — not a notebook that only works on a handful of happy questions.
- Who it is for
- Developers, ML engineers and architects who will design, implement or review retrieval-augmented systems.
- Before you start
- Professional software development experience and familiarity with APIs. Some exposure to LLMs is expected. Vector-database experience is helpful but not required.
You will be able to
- Design a RAG architecture with explicit stages for ingestion, retrieval, generation and evaluation.
- Implement parsing, chunking and metadata strategies that match the document types in play.
- Compare similarity search, hybrid search, reranking and query rewriting on the same questions.
- Construct prompts that use retrieved evidence, citations and refusal when evidence is missing.
- Evaluate retrieval and grounded generation separately, and reduce hallucination without hiding the problem.
- Apply access control so retrieval cannot leak documents the user is not allowed to see.
- Specify production monitoring, performance and cost controls for a RAG service.
Modules
8 quarter-day modules. Each one can go into a custom course on its own.
RAG as an architecture
- The stages: ingest, index, retrieve, assemble, generate and cite.
- Where RAG fits, and where fine-tuning or plain search fits better.
- The failure modes of each stage.
- Choosing a vector store and a framework, or neither.
Ingestion and chunking
- Parsing PDFs, HTML, Office documents and tables.
- Chunking strategies, overlap and structure-aware splitting.
- Metadata worth keeping for filtering and citations.
- Lab: ingest a corpus and inspect the worst chunks.
Embeddings and vector search
- Embedding models: choosing, comparing and versioning.
- Vector indexes, similarity and approximate search.
- Filters and namespaces.
- Lab: index a corpus and run a question set against it.
Hybrid search and reranking
- Keyword search and where vectors lose to it.
- Hybrid retrieval and score fusion.
- Rerankers, query rewriting and generated FAQs.
- Lab: improve recall on the questions vector search misses.
Measuring retrieval
- A question set with known good sources.
- Recall, precision and ranking metrics.
- Faithfulness and answer relevance.
- Lab: compare two retrieval configurations with numbers, not impressions.
Grounded answers and citations
- Assembling a grounded prompt from retrieved chunks.
- Citations a reader can follow back to the source.
- Refusing when retrieval is empty or sources conflict.
- Lab: complete the RAG path and test it on held-out questions.
Retrieval with permissions
- Document-level access control carried into the index.
- Tenant isolation and per-user filtering.
- Keeping permissions in sync with the source systems.
- Testing that one user cannot see another’s documents.
Running RAG in production
- Keeping the index fresh: incremental updates and deletions.
- Re-embedding and migrating without downtime.
- Monitoring retrieval quality and answer quality.
- Cost and latency at scale.
Practical work
You build a RAG system on a realistic corpus. The first pipeline is deliberately naive. Subsequent labs improve parsing, chunking, retrieval, reranking, citations and evaluation. The closing system is production-shaped: measurable, permission-aware and operable, not merely fluent.
You take away
- A working production-style RAG implementation
- Weak-versus-improved retrieval comparisons on a fixed question set
- Chunking, metadata and evaluation templates
- A production architecture and operations checklist
Combine it with
- Building AI Agents · 2 days
- Agentic RAG Systems · 2 days