RAG-Dx: a diagnostic benchmark for retrieval

This dataset is for evaluation. It is not training data and should not be used to train or fine-tune models.

Most retrieval benchmarks give you a number. A number tells you that something is wrong, not what. RAG-Dx reports how much a retrieval stack degrades on each of eight specific failure modes, so the output points at a fix.

Code, harness and reproduction scripts: https://github.com/chakshu-dhannawat/rag-dx

What is in here

axis	what it isolates
vocabulary_gap	the user does not use the document's words
multi_hop	the answer needs two chunks joined by a bridge entity
negation	"not X" should not retrieve what "X" retrieves
entity_aliasing	acronym, expansion, and spelling variants of one entity
contradictory_sources	two indexed chunks disagree
temporal_staleness	an outdated and a current version are both indexed
chunk_boundary	the answer straddles a chunk boundary
numeric_tabular	a specific figure has to come out of a table

Four perturb the query. Four perturb the corpus.

How to use it

Every item is a matched pair: one information need, the same gold chunks, a control condition and a perturbed condition. The metric is the difference.

delta_recall@k = recall@k(control) - recall@k(perturbed)
delta_ndcg@k   =   ndcg@k(control) -   ndcg@k(perturbed)

Both are reported per axis with separate significance flags. Recall answers "did the perturbation cost me an answer?"; nDCG answers "did it cost me rank?". On the corpus-side axes these come apart, because a planted distractor usually demotes the gold chunk rather than evicting it from the top k and recall@k cannot see a demotion. See the limitation on recall blindness below before reading a 0.000 as a pass.

The delta matters more than either half. An absolute score confounds how hard the corpus is with how brittle the retriever is; holding the corpus constant across the pair leaves only the effect of the perturbation, and lets retrievers of different baseline strength be compared against their own controls.

pip install ragdx

from ragdx import evaluate

def my_retriever(query: str, k: int) -> list[str]:
    return [hit.chunk_id for hit in my_stack.search(query, k)]

print(evaluate(my_retriever, k=10).scorecard())

The files themselves load one axis at a time, which is the unit the whole design is built around:

from datasets import load_dataset

items   = load_dataset("Chakshu123/rag-dx", "negation",  split="test")
corpus  = load_dataset("Chakshu123/rag-dx", "corpus",    split="test")
planted = load_dataset("Chakshu123/rag-dx", "planted",   split="test")

There is a config per axis rather than one for all eight, because each item carries a provenance object recording how it was built and those fields are axis specific on purpose. There is no train split anywhere in here, and that is not an oversight.

Index corpus/chunks.jsonl plus every per-axis *.planted.jsonl file. The planted files are not a supplement, and four of the eight axes report nothing usable without them. They are not the four you would guess, so the specifics matter:

• negation fails hardest. Its control condition is scored against the planted chunk, so without negation.planted.jsonl control recall is 0.000 and the delta comes out negative rather than merely absent.
• chunk_boundary cannot be scored at all. Every one of its gold chunks is a re-split half living in chunk_boundary.planted.jsonl and appears nowhere else.
• contradictory_sources and numeric_tabular report a delta of exactly zero. The chunk their control condition excludes exists only in their planted file, so with nothing to exclude the two conditions collapse to the same ranking.

entity_aliasing still scores without entity_aliasing.planted.jsonl, but understates the effect, because the alias-bearing distractor the perturbed query is meant to attract is absent. vocabulary_gap, multi_hop and temporal_staleness need nothing beyond the base corpus. temporal_staleness plants nothing at all: both versions of the drifted text are already in chunks.jsonl.

How it was made

Full disclosure, because the generation procedure is the main thing a reader should be able to judge this on.

Generation. Queries were written by anthropic-claude-sonnet-5 and filtered by anthropic-claude-opus-5, both reached through an Anthropic-compatible API gateway. Two properties of that pipeline matter more than the model names:

• No label was generated. The pipeline selects the chunk that holds the fact before any model is called, so the gold label is a property of how the item was constructed. The model writes only the natural-language surface of the query. It never chooses which chunk is correct and never votes on whether an item is good.
• Models act only as filters that remove items. Candidates pass deterministic structural gates first, then a verifier model checks the question is answerable from the gold chunk and not recoverable from the distractors. Failures are dropped. Nothing is admitted because a model approved of it. Generation and verification use different models, so no item is both written and approved by the same weights.

Per-axis admission rates and every drop reason are published in reports/. Yield varies by axis and is reported rather than smoothed.

Intended use. Diagnosing which failure modes a retrieval system is vulnerable to, and comparing retrieval configurations against each other. That is the whole intended scope.

Limitations. These are real and you should read them before quoting a number.

• Four axes are underpowered and you should not quote their deltas. The eight axes are very unevenly sized: entity_aliasing has 507 items, vocabulary_gap 325, negation 316 and multi_hop 70, but temporal_staleness has 25, contradictory_sources 11, chunk_boundary 9 and numeric_tabular 8. At n=8 the paired standard error is wide enough that almost no delta clears it, so those rows will come back with significant set to false, which is the harness reporting the truth rather than failing. They are published anyway for two reasons: the axis definitions, the generators and the gates are the reusable part and they are complete, and dropping the thin axes to make a table look even would quietly turn an eight-axis benchmark into a four-axis one. Treat the four large axes as measurements and the four small ones as a working demonstration of the axis design. The reason they are thin is unglamorous and worth stating: the generation budget ran out mid-run, and the corpus-side axes are the expensive ones because each item needs a planted chunk that survives verification.

• On negation and multi_hop the two conditions are scored against different gold chunks, and on negation that introduces a confound. Both axes swap the gold set along with the query, because the correct answer to a negated question is a different chunk from the correct answer to the affirmative one. The corpus is identical in both conditions, so the pairing is still matched. But on negation the control gold is a model-written chunk authored to answer the control query, while the perturbed gold is real corpus text, so the control side is easier for a reason that is not polarity, and by a margin that varies by retriever. The dense baselines reach 0.95+ control recall against BM25's 0.79, which inflates their deltas relative to BM25's. The confound-free comparison is the perturbed condition across retrievers, same query and same real chunk: BM25 0.788 at k=10 against 0.52 to 0.59 for the four dense models. Prefer that number to the delta on this axis.

• A recall delta of 0.000 on a corpus-side axis is a metric limit, not a clean bill of health. Adding one planted chunk can demote the gold chunk by at most one rank, so delta_recall@k only moves when removing that chunk carries the gold chunk back across the cutoff, which with one distractor means the gold chunk sat at exactly rank k+1. Everywhere else it is pushed down but stays inside the top k, or was already too far outside to be rescued, and recall@k is a set-membership test that scores both conditions the same. Measured on BM25 at k=5, contradictory_sources, numeric_tabular and temporal_staleness all report a recall delta of exactly 0.000 while their nDCG deltas are +0.0853, +0.0712 and +0.0571. reports/results/rank_evidence.k5.json says why: the planted distractor outranks the gold chunk in 12 of 25 temporal_staleness items, 6 of 11 contradictory_sources items and 1 of 8 numeric_tabular items, and none of those 19 wins falls in the window where recall@5 can respond. Every scorecard therefore reports recall and nDCG side by side with separate significance flags, and Report.recall_blind_axes() names any axis where the two disagree in this direction. Read the nDCG column on the corpus-side axes.

• Rank preservation is not established, and this is the limitation to read first. arXiv 2505.22830 shows LLM-authored benchmark items tend to be easier than human-authored ones and, worse, may not preserve the ordering of the systems under test. Ordering is the only product a benchmark has, so that check is run here against BEIR SciFact: human annotated, unrelated to this corpus, same retriever objects on both sides. The result is Kendall tau = -0.200 across six retrievers, exact permutation p = 0.719, published in reports/results/calibration.json.

  That is an absence of evidence for preservation, not evidence that the orderings are inverted. At six systems the two-sided permutation test only reaches p < 0.05 at tau >= 0.867, so it can detect near-perfect agreement and nothing weaker, and the observed tau is entirely consistent with chance. Two consequences, pointing opposite ways:

  • Do not use the absolute control scores to pick a retriever. The check that would license that has not passed, and a check that has not passed is not one that has been waived.
  • Do not read it as a refutation either. Six systems cannot produce one. Adding retrievers is the fix, and anyone who runs more should regenerate the page.

  The deltas, which are what this dataset is for, are a within-system comparison of the same retriever against itself and do not depend on the cross-system ordering being right. Two design choices also push against the underlying risk: labels come from construction rather than generation, and difficulty comes from the contrast between paired conditions rather than from the generator, so whatever makes generated text uniformly easier applies to both halves of the pair and largely cancels.

• The control condition is computed by filtering, not by a second index. For retrievers that score documents independently, which covers BM25, dense vectors and their fusions, this is equivalent to an index that never contained the planted chunks. It is an approximation for retrievers whose scoring depends on the corpus as a whole, such as MMR-style diversification.

• Domain coverage is technical and regulatory English. Kubernetes documentation, SEC filings and US federal regulations. Results here should not be assumed to transfer to conversational, multilingual or biomedical retrieval.

• Some axes have stronger isolated resources elsewhere. For negation specifically, NevIR and ExcluIR are more focused datasets. RAG-Dx's contribution on that axis is that it sits in a comparable frame with seven others, not that it is the best negation set available.

• Synthetic chunks are present by design. Every planted chunk lives in a per-axis *.planted.jsonl and none are mixed into corpus/chunks.jsonl, so they can always be separated from source text by which file they came from. Most also carry a synthetic:: prefixed id, but chunk_boundary is the exception worth knowing about: its planted chunks are the two halves of a real source chunk, so they keep the source prefix and only the offsets in the id change. They are re-splits of published text rather than written text, which is why they are not marked synthetic. Filter on the file, not on the prefix.

Sources. The corpus is built only from material that permits redistribution.

source	documents	license
Kubernetes documentation, v1.28 and v1.36	1,917	CC BY 4.0
SEC EDGAR 10-K filings	975	SEC permission to redistribute, see below
US eCFR titles 21, 29, 40	1,453	US government edict, public domain

The EDGAR row deserves a correction that is easy to get wrong and that earlier drafts of this card did get wrong. EDGAR filings are not US government works. They are authored by private registrants, who hold the copyright; the SEC hosts them and grants permission to access and redistribute the public dissemination feeds. That is a permission grant, not 17 U.S.C. 105, and it is why this table no longer calls them public domain. The eCFR is genuinely uncopyrightable, as a federal government edict.

Temporal drift is observed rather than simulated, and the sources contribute very unevenly. Across the corpus there are 1,280 chunk pairs where the same passage carries a changed value between two versions, and 1,274 of those are year-over-year EDGAR filings against only 6 from the Kubernetes version pair. The Kubernetes v1.28 and v1.36 snapshots do contain real drift and docs/corpus-verification.md in the repository names eight verified examples, but as a matter of volume it is the EDGAR filings that carry temporal_staleness.

License and attribution

CC BY 4.0. This is inherited, not chosen. The Kubernetes documentation is CC BY 4.0 and its attribution requirement flows downstream to anything containing it. The eCFR material is public domain and imposes no condition of its own. The EDGAR material is redistributed under the SEC's permission to use its public dissemination feeds, as described above.

Kubernetes documentation content is Copyright The Kubernetes Authors, licensed CC BY 4.0, redistributed here from the release-1.28 and release-1.36 branches of kubernetes/website.

The harness code in the linked repository is Apache 2.0.

Citation

@misc{ragdx2026,
  title  = {RAG-Dx: A Diagnostic Benchmark for Retrieval Failure Modes},
  author = {Dhannawat, Chakshu},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Chakshu123/rag-dx}
}