0:00Last time, we added a second model that reorders search results, and measured whether it helped.
0:06This time, a retrieval system gives a bad answer, and we work out which step caused it.
0:11First, the bad answer itself, from a support assistant answering a customer.
0:16Then we follow the passage a correct answer needs through the system, and stop at the first step where it goes missing.
0:22We test the language model separately, because a bad answer alone doesn't tell us whether the model could have done better.
0:29Then we make one change where the evidence was lost, and check that it worked.
0:34Finally, what to work on for each thing you might find. Let's start with the assistant.
0:40This script is a small support assistant for a software product. It answers one customer question from the product's help pages.
0:48The customer is on an annual plan, and wants to know how long they have to ask for a refund.
0:52The retriever finds the five passages from the help pages most similar to the question.
0:57Those five go into a prompt, and a language model writes the answer from them.
1:02We run the assistant on that question.
1:05It retrieves the passages, builds the prompt, and waits for the model's reply.
1:10The model says the passages give no refund window for annual plans, and offers the monthly rule of thirty days instead.
1:18But the help pages do cover annual plans. They get forty-five days, so a customer reading this answer comes away with the wrong idea.
1:26The right answer was written down, and somewhere between the help pages and the model it was lost. Let's look at the steps it passes through.
1:36A correct answer needs one passage from the help pages, the annual refund rule. To reach the answer, it has to pass through four steps.
1:45It starts in the help pages, split into short passages.
1:48The retriever compares the question with every passage and ranks them by similarity.
1:53So it takes in both the question and the passages.
1:56The context builder keeps the top passages and puts them into a prompt with the question.
2:03It works from the retriever's ranking, so a passage ranked too low never gets in.
2:08And the language model writes the answer. The prompt tells it to use only those passages.
2:14Its reply is the answer the customer saw.
2:17Each step is a checkpoint we can test. First, is the evidence in the help pages at all?
2:22Second, does the retriever find it, and where does it rank it?
2:26Third, does it make it into the prompt the model receives?
2:30And fourth, given the evidence, does the model answer correctly?
2:34We check them in this order and stop at the first one that fails, because that's where the evidence was lost. Before we test them, let's see these steps in code.
2:46This file holds the help pages, the retriever, and the code that builds the prompt.
2:52The help pages are split into passages, one per section. This one is the monthly refund rule, the thirty days the model quoted.
3:01Further down is the annual rule, forty-five days from purchase. That's the evidence a correct answer needs, and the passage we'll follow.
3:08The retriever compares the question's embedding with every passage's, sorts them by similarity, and keeps the top k.
3:15This function builds the prompt. It joins the passages into one block, tells the model to answer only from it, and puts the question last.
3:24The model call is a single function in llm.py. With these pieces, each checkpoint becomes a short script, starting with the help pages.
3:35The first check starts with what a correct answer must contain.
3:38Here that's forty-five days. We know the exact wording, so a plain text search is enough.
3:43It collects every passage that contains that text, then prints how many there are and the first one's id.
3:50The assistant's answer is still above. Now we search the help pages.
3:54One passage matches, from the refund policy's section on annual plans.
3:59So the first checkpoint passes. Whatever went wrong, the answer was written down.
4:03In a large collection you may not know the exact wording. Then search for the key terms and read the passages that come back. Next, did the retriever find it?
4:15The second check puts the customer's question to the retriever, word for word as they asked it.
4:22It asks for twenty results. There are only eighteen passages, so we get every one of them, in ranked order.
4:28For each result it prints the rank, the similarity score and the passage's id, and flags the passage containing forty-five days.
4:37We run the retrieval check.
4:39It prints all eighteen passages, most similar first.
4:42The monthly refund rule ranks first. It's about refunds and a time limit, like the question, but it covers the other kind of plan.
4:49The assistant passes the top five passages to the model.
4:53The annual rule is sixth, just below that cutoff. So the retriever did find it. Whether sixth is too low depends on how many passages the next step keeps.
5:04A similarity score measures how alike two texts are, not whether one answers the question. Next, we check what reached the model.
5:14The third check rebuilds the prompt the assistant sends, and looks for the evidence in it.
5:19First from the top five passages, as the assistant does. Then it tests whether forty-five days appears anywhere in the prompt's text.
5:27Then it does the same with the top ten.
5:30We run the prompt check.
5:32It prints one line for each cutoff.
5:34With five passages, the evidence isn't there, so the model never received it. This is the first checkpoint that fails, and that makes it our diagnosis.
5:43With ten, the evidence gets in. So the cutoff of five is where a fix belongs.
5:49Before changing anything, let's mark what we've found on the system's steps.
5:55The annual rule is in the help pages, and the retriever found it.
5:58It came out of the ranking in sixth place.
6:01The context builder kept the top five, so this is where the evidence stopped.
6:05Missing the cutoff by one place was enough to keep it from the model.
6:09That leaves the model. It answered without the evidence, so this run can't tell us whether it would have answered correctly with it.
6:16A selection problem and a model problem can happen together, so we test the model separately, by giving it the evidence directly.
6:26This script asks the model the customer's question twice.
6:30The first prompt holds only the passage with forty-five days, so retrieval and the cutoff play no part. It tests the model by itself.
6:40The second uses the top ten passages, which is the fix we're considering.
6:44The prompt check is still above. Now we run both prompts.
6:47Each prompt is a separate call to the model, so the two answers arrive one after the other.
6:53With the evidence in front of it, the model answers correctly. So the model can use this passage, and the cutoff is enough to explain the bad answer.
7:01With the cutoff at ten, the original question now gets the right answer. It also explains what happens after the forty-five days.
7:09So the fix checks out twice, first in the prompt and now in the answer, though only for this one question.
7:16A wider cutoff sends more text with every question. That costs tokens, and it can distract the model on questions that already worked, so test those before you keep it.
7:29In our case the cutoff was the first failure. In another system a different checkpoint may fail first, and each one points to different work.
7:36If the evidence isn't in your documents, no change to retrieval will help. Someone has to write it down.
7:42If it's there but the search doesn't return it, look at how the documents were split. Then check how the question is phrased, and which embedding model you use.
7:52If it's found but dropped before the prompt, change how many passages you keep, rerank them, or check whether a token limit trims the prompt.
8:01If the model had the evidence and still got it wrong, work on the prompt or the model.
8:06Either way, keep the failing question as a test, and run it after every change.
8:11When a retrieval system gives a bad answer, decide what a correct answer must contain, then check each step in order.
8:19The first step where the evidence is missing is where the fix belongs. Test the model separately, and check any fix in the prompt and in the answer.
8:28That's the last video in this series. We've gone from turning text into vectors, through chunking, search, rewriting and reranking, to finding what went wrong when an answer fails.

Diagnosing Bad Answers

Created by Abhyuday DesaiPublished 4 Oct, v1Runs 8 min 46 sec

0 views

About this video

In Episode 06 of Retrieval Explained, a support assistant tells a customer on an annual plan that the help pages give no refund window for it, though they say forty-five days. We follow the passage a correct answer needs through four checkpoints and stop at the first one that fails: the passage is in the help pages, the retriever ranks it sixth, and the prompt keeps only the top five. Given the passage directly, the model answers correctly, so keeping the top ten fixes this question, and we check that fix in the prompt and in the answer.

You'll learn how to:

Start a diagnosis from what a correct answer must contain
Check four steps in order: the documents, the retriever's ranking, the prompt, and the model
Test the model on its own by giving it the evidence directly
Check a fix in the prompt and in the answer, and weigh what a wider cutoff costs
Know what to work on for each finding, and keep the failing question as a test

This video is for developers maintaining a retrieval system that gives wrong answers. It is the last video in the series and draws on the steps from the five before it. The code runs from the companion repo and calls a language model.

What changed

v104 Oct 2026abhydesai8 min 46 secb9e8014

First published version.

0 views0 likes on this version