Click any words you think contain an error. Click again to unmark.
Mark at least one word to submit.
The bug is the line `chunk_order: similarity_desc`. It tells the pipeline to arrange retrieved chunks strictly from most similar to least similar before pasting them into the prompt.
That sounds reasonable, but it ignores how LLMs read long prompts. Models attend strongly to the beginning of the context, moderately to the end, and weakly to the middle. This pattern is called **lost in the middle**: attention follows a U-shape.
With strict similarity descending order, the single best chunk lands first (good), but the second- and third best chunks land right in that weak middle zone. The model under-reads exactly the high value evidence you most want it to use, and faithfulness drops.
The fix is to reorder: put your strongest chunks at both the head and the tail of the prompt, and let the weaker chunks sit in the middle where attention is low anyway. A common policy is `head_tail_alternating`. It's a one line config change that recovers the wasted positions.
The defect is `chunk_order: similarity_desc`. Ranking chunks by descending similarity feels correct, but it collides with the **lost in the middle** property of LLM attention.
Empirically, accuracy on long contexts traces a U-shape against the position of the relevant information: strong at the start, weaker through the middle, partially recovering at the end. Strict similarity descending order places chunk 1 at the head (attended), but chunks 2 through 5 (your next best evidence) fall into the low attention trough. The model effectively skims past them.
The fix is a positional interleave such as `head_tail_alternating`: top-1 at position 0, top-2 at the tail, top-3 at position 1, top-4 second from tail, alternating inward. High-confidence chunks occupy the head and tail where attention is strong; medium-confidence chunks fill the middle valley that's under-read regardless.
The other lines are fine. A 200k-token window, `temperature: 0.0`, citation injection, and a grounding directive are all sensible. Worth noting: a large context window dampens the U-shape but does not remove it; position aware ordering still pays off at any length.
Quick reference
TL;DR
The bug is chunk_order: similarity_desc. It buries the second best chunks in the prompt's middle, where attention is weakest. Reorder so strong chunks sit at the head and tail.
Imagine handing someone a thick stack of pages and asking them to answer from it. People skim the first few pages carefully, glance at the last page, and barely read the middle. LLMs behave the same way: they pay strong attention to the start of a prompt, decent attention to the end, and much weaker attention to the middle. This is called 'lost in the middle.' Now the bug: the config sorts retrieved chunks strictly best to worst, so the top chunk sits first (good) but the second best chunk lands in that ignored middle (bad). The fix is to spread your strongest chunks across the head and the tail, where the model actually reads, and let the so so chunks fill the middle valley nobody attends to.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Only one to three chunks are injected into the prompt All of them sit in the strong head band, so positional reordering changes almost nothing and adds needless complexity.
Total assembled context is short, well under a few thousand tokens The U-shaped attention dip is negligible at short lengths, so the model reads the middle adequately without reordering.
Order itself carries meaning, such as chronological logs or step sequences Sandwiching by confidence would scramble a sequence the model must read in order, hurting answers more than the middle dip would.
You have not yet measured a position sensitivity regression Reordering is a fix for a measured U-shape problem; applying it blind can mask retrieval issues you should address first.
Quick scan · 2–4 min
Everything important, quickly.
4 min: name the buggy line, explain the U-shaped lost-in-the-middle curve, give the head_tail_alternating fix, and add the long context doesn't fix it nuance plus how you'd eval it.
Code example
python
def head_tail_alternating(chunks):
# chunks already sorted best -> worst by rerank score
n = len(chunks)
ordered = [None] * n
left, right = 0, n - 1
for i, c in enumerate(chunks):
if i % 2 == 0: # ranks 1,3,5 -> head inward
ordered[left] = c
left += 1
else: # ranks 2,4,6 -> tail inward
ordered[right] = c
right -= 1
return ordered # strong chunks at both ends, weak in the middle
Side-by-side
Chunk order policy
Where best chunk lands
Where 2nd-best lands
Long-context faithfulness
similarity_desc (the bug)
Head (attended)
Middle valley (under-read)
Regresses on long queries
similarity_asc (reversed)
Tail (OK)
Middle valley (under-read)
Still loses the middle
head_tail_alternating (fix)
Head (attended)
Tail (attended)
Recovers wasted positions
Real-world examples
Real products, models, and research that use this idea.
1LlamaIndex ships a LongContextReorder node postprocessor that interleaves ranked chunks to the head and tail specifically to counter lost-in-the-middle.
2LangChain offers a LongContextReorder document transformer applying the same head/tail sandwich before prompt assembly.
3Anthropic's long-context guidance for Claude recommends placing the most critical documents near the top and bottom of the prompt rather than the middle.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you design an eval to prove the reorder actually helps, not just looks plausible?
Sign in or go Pro to see the approach for this follow-up.
QReranking already orders by relevance; why doesn't a strong reranker make ordering moot?
Sign in or go Pro to see the approach for this follow-up.
QWhen might similarity_desc actually be fine, and when is reordering not worth it?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Assuming a 200k-token context window eliminates the lost in the middle effect. A larger window makes the valley shallower but it never goes away; position still matters.