Your RAG demo lied to you
Picture the demo. Someone built a chatbot over the company's documentation and they're showing it off. They ask it ten questions, it answers all ten beautifully, the room is impressed, and the project gets funded. Nobody says out loud that the person asking the questions also wrote the answers' source documents, so they unconsciously phrased every question in the vocabulary the docs already used. The retrieval never had to work hard. It was a layup.
Then it ships, and a few hundred real people start asking it real questions, and the magic curdles. The answers are fine, then they're sometimes wrong, then people stop trusting it, and three months later the project is "being re-evaluated." I've watched this arc enough times to recognize it from the demo. The demo is where RAG looks easy. Production is where you find out retrieval is a search problem wearing a chatbot costume, and search is hard.
Here's where it comes apart.
Real questions don't speak the document's language
In the demo, the question and the answer share words, so similarity search finds the right chunk on the first try. Real users describe their problem in their words, which are not the manual's words. They ask "why does it keep logging me out" and the relevant page is titled "Session Token Expiration Policy." The embedding for the question and the embedding for the answer aren't as close as you'd hope, and the right chunk doesn't make the top of the list. The model answers from whatever did, confidently, and it's wrong in a way that reads completely plausible.
The corpus rots as it grows
A clean demo corpus is a few dozen well-chosen documents. A real corpus is everything accumulated over years: three slightly different versions of the same policy, a deprecated runbook nobody deleted, a draft that was never finalized, and a page that flatly contradicts another page because two teams wrote them a year apart. All of it is retrievable. The model has no idea which one is canonical, so it pulls whatever embeds closest to the question and presents last year's dead procedure as current fact. The bigger the corpus, the more confidently wrong this gets.
Stale beats wrong, and you won't notice
Documents change. Indexes don't, unless you make them. The single most common production failure I see is a confidently cited answer drawn from a version of the document that stopped being true two months ago, because nobody owns the re-indexing pipeline, and "it worked when we set it up" quietly became "it's been serving stale answers since the last reorg." There's no error for this. The system looks healthy. It's just lying with a citation attached, which is worse than lying without one, because the citation buys it credibility.
It answers when it should shrug
Ask the demo a question outside its documents and watch what happens. A well-built system says it doesn't know. A typical one retrieves the closest-but-irrelevant chunks anyway, because there's always something with a non-zero similarity score, then dutifully builds an answer out of material that doesn't address the question. The instinct of a general chatbot is to always have an answer. For a system people will act on, that instinct is a liability, and tuning against it is most of the work. An honest "I couldn't find this" is a feature you have to fight for, because the default is a confident fabrication.
There are more failure modes. One-shot retrieval can't handle a question that needs two lookups chained together, the kind where you can't write the second query until you've read the first results; that's agentic retrieval territory, and a single embedding search will never get there. Chunk boundaries slice answers in half, so neither piece is retrievable on its own. And underneath all of it, almost nobody measures retrieval quality, so when recall quietly degrades as the corpus triples in size, no number moves, no alert fires, just a vague sense months later that "it used to be better."
What the ones that work do
The RAG systems that survive contact with real users aren't running a smarter model or a fancier vector store. They've done the boring things.
They measure retrieval on its own, continuously, with a held-out set of real questions and their known-correct sources, so when recall@k starts sliding they see it as a number rather than a vibe. They tune hard for abstention, because they've decided a missed answer is cheaper than a wrong one. They treat the freshness of the index as a first-class problem with an owner, not a setup step. They run hybrid search and rerank instead of trusting raw vector similarity, because keyword search catches the exact terms that embeddings smear and the reranker fixes the ordering. They cite sources, so a wrong answer is auditable instead of mysterious. They curate the corpus, because contradictory, duplicated, stale documents produce contradictory, duplicated, stale answers no matter how good the model is.
None of that demos well. That's exactly why the demo lied. If you're about to greenlight a RAG project off a flawless ten-question demo, do yourself a favor: ask the worst, most off-vocabulary, most adversarial questions you can think of, against the full messy corpus, and watch what comes back. That's the product. The demo was the trailer.