We have added 4 new parts to our hands-on RAG Systems course:
Together, these parts cover the engineering around retrieval: how the model searches, how evidence survives a long task, how the index stays consistent, and how search scales beyond memory.
Each part includes the complete implementation.
Why care?
Knowing how to chunk, embed, and retrieve documents is a useful foundation.
Production RAG work soon expands into problems usually associated with search engineering, backend systems, ML infrastructure, and agent design.
Part 16 develops the first of those skills: retrieval policy design.
Instead of treating retrieval as one fixed top-k call, the model can choose between lexical search, semantic search, file inspection, and bounded reading.
It can reformulate the query after seeing evidence and stop when the required claims are supported.
The implementation also covers the failure modes created by that freedom. Retrieval can repeat the same evidence, launch overlapping calls, stay committed to a rejected hypothesis, or consume the context budget without making progress.
Learning to trace and control those decisions is useful far beyond RAG. The same reasoning applies to agents that browse, investigate code, query databases, or work across several tools.
Part 17 moves into context engineering.
A long-running retrieval loop needs rules for what remains in the active context, what gets cleared, what can be compacted, and what should live in an external record.
The chapter compares clearing tool results, summarising history, external notes, searchable session logs, and sub-agent isolation.
These are core design choices for agent memory. They determine whether a system can recover an earlier fact, preserve exact identifiers, and continue a long task without carrying every intermediate result in the prompt.
Part 18 introduces the backend and distributed-systems side of RAG.
Choosing between pgvector and a dedicated vector database is only one part of that work. The harder questions concern ownership and consistency.
The implementation covers what happens when a document changes, gets deleted, or loses a permission. It builds direct dual writes, transactional outboxes, version guards, reconciliation jobs, and filtered retrieval.
Operating a vector store safely requires both the retrieval API and the update path that prevents stale or unauthorized evidence.
Part 19 moves into search infrastructure at ten million vectors.
It covers product quantization, scalar quantization, binary codes, RaBitQ, IVF, HNSW, caching, disk-backed vectors, and exact rescoring.
The useful skill here is learning to reason about recall, memory, latency, and index freshness together. A faster index is not useful if it misses the evidence the application needs or slows down as soon as its cache becomes too small.
Together, the four parts provide a practical way to locate failures across the complete retrieval path:
A weak query or repeated search points to the retrieval policy.
Relevant candidates that never reach the answer point to context handling.
Old documents or incorrect permissions point to synchronization and filtering.
Falling recall or rising latency at scale points to the index, cache, or storage layout.
Being able to trace a failure to the right layer gives you something concrete to demonstrate in a portfolio project or explain in a RAG architecture interview.

A developer who can explain where retrieval failed, which layer owns the fix, and what tradeoff the fix introduces demonstrates more than framework familiarity.
The progression across these parts supports a clear career path: from building RAG applications to engineering agentic retrieval, search systems, and the infrastructure that keeps them reliable.
👉 Over to you: Which layer of production RAG would strengthen your current skill set most?
Good day!







