RAG Course: Build and Debug Production RAG Systems

Building a RAG pipeline takes an afternoon. Knowing why it returned the wrong three chunks — and proving your fix worked — is the part this track is about.

For engineers whose retrieval system technically works and occasionally answers from the wrong document.

What you will be able to do

• Choose a chunking strategy from the shape of your documents rather than from a blog post's default of 512 tokens.
• Understand what an embedding actually encodes, and why two passages that read as similar are not always retrieved together.
• Run and interpret vector search: similarity metrics, top-k, and the reranking step most pipelines skip.
• Measure retrieval separately from generation — the single change that turns 'the answer was wrong' into a diagnosable defect.
• Recognise the standard production failures: empty retrieval answered confidently, stale index, chunk boundaries that split the answer in half, and one relevant document buried under nine irrelevant ones.

Curriculum

Retrieval-Augmented Generation (RAG)

• Why RAG Exists
• Embeddings
• Vector Similarity
• Vector Databases
• Chunking
• Retrieval Pipeline
• Hybrid Search
• RAG Evaluation
• RAG, End to End

Model Evaluation

• Why Evaluate
• Automatic Metrics
• Human Evaluation
• A/B Testing
• Monitoring

A lesson from this track

An embedding is not a summary and it is not a keyword index. Treating it as either is the root cause of most retrieval bugs that survive to production, because both intuitions are close enough to work in testing.

Embeddings

What you build

• A complete RAG pipeline over your own documents — ingestion, chunking, embedding, retrieval and generation — in Spring Boot.
• A retrieval evaluation harness that scores retrieval on its own, so a chunking change produces a number instead of an opinion.
• Production failure labs where retrieval is already broken and you diagnose it from the evidence: the trace, the retrieved chunks and the answer.

Questions

Which vector database does it use?

The lessons cover what the choice actually changes — index types, filtering, and the operational cost of each — rather than selling one. The runnable project uses an embedded store so it runs on a laptop with no infrastructure.

Do I need RAG at all, or is a bigger context window enough?

That question is answered directly and early, with the cost and latency arithmetic behind it. For a lot of applications the honest answer is no, and knowing that before building a pipeline is worth more than the pipeline.

What makes these 'production' labs?

They are diagnosis exercises built from failures that actually happen: you are given a broken system and its evidence, and you work out the cause and verify a fix. You are not asked to implement a pipeline from a blank file.

Does it cover evaluation properly?

Yes — the evaluation module is part of this track rather than an appendix, because a RAG system you cannot measure is one you cannot improve on purpose.

Start the curriculum