Training is frozen, and it never saw your own documents in the first place. This lesson names the standard fix — three ideas you already have, wired together — and shows the acronym you'll see on almost every "chat with your data" product: RAG.
Lesson 7 named the knowledge cutoff: training is finished and frozen before the model ever reaches you, so anything after that point genuinely was never shown to it. There's a second gap, just as real — anything that was never public in the first place. Your company's own documents, a private wiki, last week's meeting notes. No amount of training could have included them, because they were never there to read.
Neither gap can be closed by retraining. But both can be closed a completely different way: instead of teaching the model in advance, hand it the answer at the moment it's needed.
You already have every piece of this. Retrieval is Lesson 5's nearest-neighbor search — finding the right chunk of text by distance, not by matching exact words. Augmented means added to — specifically, poured into context, Lesson 8's word for background handed to the model right before it answers. Generation is what a model has done since Lesson 1: read what's in front of it, and predict. Put the three together and you get the term behind nearly every "chat with your own documents" product: RAG, for Retrieval-Augmented Generation.
Under the hood: your question gets its own embedding, that embedding finds the nearest chunks in a pile of your documents, and those chunks — not the whole archive, just the closest handful — get pasted into the prompt alongside your actual question. The model never "reads your wiki." It reads whatever got handed to it this one time, exactly like every other pour since Lesson 1.
RAG fixes what the model was never shown. It doesn't fix Lesson 7. If the search step hands back the wrong chunk — or nothing genuinely relevant exists in the documents at all — the model still answers fluently and confidently from whatever it was given. That's not a new failure. It's the same stray pick, just now leaning on your documents instead of the open internet.
Garbage in, garbage out, applies here exactly as it always has. A good retrieval step narrows what the model can lean on. It doesn't guarantee the lean is correct.
There's a second limit underneath that one, and it isn't a mistake — it's the shape of the tool itself. Nearest-neighbor search only ever finds one kind of connection: things that read alike. It has no way to notice a cause, a sequence, or a hierarchy between two facts that happen to share almost no words — a decision in one document and its consequence three documents later, a rule and the exception buried somewhere else entirely. No lexical overlap means no path for a similarity search to walk, even when the connection is real and important.
That's a structural gap, not a bug waiting to be patched. See orqo's knowledge graph for what the alternative looks like: typed relationships — causal, hierarchical, temporal, and more — that a system can actually follow, instead of hoping two related things happen to sound the same.
The pattern above searches once, before the model ever starts. But you already know a model can ask for a tool — Lesson 9 — and that it can keep asking, deciding for itself what to do next — Lesson 11. Nothing stops "search the documents" from being one more tool in that loop.
That's what people mean by agentic RAG: instead of one search handed over up front, the agent decides when to search, what to search for, and whether the first batch of matches was actually good enough to answer with — searching again, with a better question, if it wasn't. Same three ingredients. Just folded into the loop instead of run once before it.
RAG is genuinely the standard answer across the industry to "how does an AI know about our own stuff" — chunk the documents, embed them, search by similarity, hand the model what's close. Lesson 5 already showed you the mechanism, before this lesson ever gave the pattern its own name.
It's worth knowing you're looking at the industry default, not the only option — the section above already pointed at what a structural alternative actually looks like.
An agent that can act, and an agent that can retrieve whatever it needs from your own documents — both raise the same question, one more time, in a sharper form: what actually happens to everything that passes through it?
Everything from the lessons before this one, plus what this lesson added.
| The board | The word for it |
|---|---|
| The board and its pegs | The structure — the model |
| A single peg | A neuron |
| A single step from one peg to the next | A connection |
| How red or blue a patch of floor is | A weight — a parameter |
| The whole painted floor | The trained model |
| Boards stacked, one on the next | Layers — "deep" |
| Smearing the floor in, coin by coin | Training |
| Dropping one coin through a finished board | Using it — inference |
| Which slot you pour into | Your input — your prompt |
| The bins, relabelled with tokens | The vocabulary — every token it could pick |
| The tallest pile among the bins | The prediction — the likeliest next token |
| Feeding the growing line back in and running again | The loop — how one guess becomes a sentence |
| One bin's label, precisely | A token — not always a whole word |
| How many bins there are, in total | Vocabulary size — tens of thousands |
| The size of the mountain of text it was shown | Training data — measured in tokens |
| A bin's own address, plotted in space | An embedding — meaning turned into a list of numbers |
| How close two addresses sit | Similarity — how related two things are |
| The measurement's real name, out in the wild | Cosine similarity — same idea as similarity, different name |
| About meaning, not exact spelling | Semantic |
| A neighbourhood of addresses that share a topic | A domain — a cluster of related meaning |
| Scanning every address for whichever one sits closest to a new point | Nearest neighbor — the closest real match to a computed point |
| A small, separate machine that only plots words as points — it never writes a sentence | An embedding model — not the same as a language model |
| The total number of coloured patches, across every board | Parameters — the number people quote |
| How many tokens the funnel can hold in one pour | Input tokens — the context window |
| How many tokens come back out | Output tokens — what it writes back |
| Everything you've met so far, built at real-world size | A Large Language Model — an LLM |
| A shorter pile winning, extended forward with full confidence | A hallucination |
| The point where the training reading stopped | The knowledge cutoff |
| How sharp or blended the colour stays before a coin is poured | Temperature — the dial on how often a stray pick wins |
| Pouring the same slot twice, not always the same pile | Non-deterministic — same input, no guaranteed identical output |
| Background, examples, or a role, added right into the pour | Context |
| Asking for many small steps instead of one big leap | Chain-of-thought prompting |
| A friendly chat window built around the board | A product — like ChatGPT or Claude.ai |
| A door that lets software pour in and read out directly | An API |
| What each million tokens costs to send in or get back | API pricing — pricier for bigger models, and for output |
| Recalling the start of the line instead of re-pouring it | Cached tokens — priced far cheaper than fresh input |
| The board asking the app to go do something real before it answers | Tool use — or function calling |
| One shared shape for listing tools and calling them | MCP — Model Context Protocol |
| A program that speaks that shape and hands back its whole toolbox | An MCP server |
| The loop deciding, acting, and watching what happened, on repeat | An agent — a model with tools, looping until the goal is met |
| Deciding its own steps, and knowing when it's done | Autonomy |
| Reading what just happened before deciding what's next | Reactivity |
| Starting on its own, from a schedule or an event | Pro-activeness |
| Talking to other agents, and to people, not just tools | Social ability |
| + New in this lesson | |
| Search first, hand the model what you found, then let it answer | RAG — Retrieval-Augmented Generation |
| Folding the search step into the loop, so it can search again if needed | Agentic RAG |
46 rows now. It keeps growing as the course goes on.