RAG roadmap

Retrieval-augmented generation, from parsing a PDF to running a grounded system that people trust. Most of the difficulty is in retrieval and evaluation, not in the prompt - this roadmap is weighted accordingly.

15 stages255 topics

All roadmaps
0 of 255 done
Essential, don't skip Recommended, skip only with a reason Optional, awareness is enough Course on PracticAI

RAG is a subsystem, not a job title. This goes deep on one component of an AI application; you will still need backend, deployment, and general LLM engineering around it. Sections 2 and 3 are the classical information retrieval and embedding foundations that most RAG tutorials skip, and skipping them is why most RAG systems plateau.

1

Prerequisites

          2

          Information Retrieval Foundations

                      3

                      Embeddings

                                      4

                                      Ingestion and Parsing

                                                  5

                                                  Chunking

                                                          6

                                                          Indexing and Storage

                                                                      7

                                                                      Query Understanding

                                                                              8

                                                                              Retrieval

                                                                                      9

                                                                                      Ranking

                                                                                              10

                                                                                              Context and Generation

                                                                                                      11

                                                                                                      Grounding and Trust

                                                                                                              12

                                                                                                              Evaluation

                                                                                                                          13

                                                                                                                          Production Engineering

                                                                                                                                          14

                                                                                                                                          Observability

                                                                                                                                                  15

                                                                                                                                                  Beyond Text RAG

                                                                                                                                                          Triaging a bad answer

                                                                                                                                                          The core skill this roadmap builds. Work the stages in order and stop at the first one that fails - fixing a later stage while an earlier one is broken wastes weeks.

                                                                                                                                                          1. Is the answer in the corpus at all? Search the raw source directly. If it isn't there, this is a coverage problem, not a RAG problem.
                                                                                                                                                          2. Did ingestion capture it? Find the chunk containing the answer. If the parser dropped a table, mangled a PDF column, or split the fact across a boundary, stop here.
                                                                                                                                                          3. Did retrieval return it? Run the query and inspect the top 50 candidates. If the right chunk is absent, the problem is embedding, index, or query - not the model.
                                                                                                                                                          4. Did ranking surface it? If it's at rank 40 but you pass 5, the retriever works and the ranker doesn't.
                                                                                                                                                          5. Did it survive into the context? Check the final assembled prompt. Truncation and dedup quietly remove things.
                                                                                                                                                          6. Did the model use it? If the correct chunk was in context and the answer is still wrong, now it's a generation problem - position, prompt, or model.

                                                                                                                                                          Nearly every team skips to step 6 and starts tuning the prompt. Most real failures are at steps 2 and 3.

                                                                                                                                                          A RAG system's quality ceiling is set by retrieval, and its perceived quality is set by citations. You can have a system that is right most of the time and still not be trusted, because nobody can check it.