This dataset contains text from DragonBall (CC BY-NC-SA 4.0), Natural Questions (CC BY-SA 3.0) and MS MARCO (Microsoft's terms: non-commercial research use only). Each subset is distributed under its source's terms, and our annotations under CC BY 4.0 (see LICENSES.md). By requesting access you agree to use the DragonBall and MS MARCO subsets for non-commercial research only, to respect the share-alike terms of DragonBall and Natural Questions, and to cite the source datasets.

RAGLog Faults

Stage-level fault labels for 3,134 question runs of five real retrieval-augmented generation (RAG) pipelines, with the full trace of every run and how each label was reached.

For every run the dataset records what each pipeline stage (query rewriter, embedder, retriever, reranker, generator) received and returned, and whether that stage was at fault. Labels are per stage, not per answer: a run can have a correct answer and a faulty stage, or a wrong answer caused by an earlier stage. It is meant for evaluating and training methods that localize faults inside RAG pipelines from their logs, without reference answers at run time.

Access

The files are gated: log in to Hugging Face and accept the source datasets' terms on this page (access is granted immediately). To download from a script, authenticate first, then load a subset (dragonball, nq or msmarco):

hf auth login            # or set HF_TOKEN

from datasets import load_dataset
runs = load_dataset("Hira221/raglog-faults", "dragonball")

Without logging in and accepting the terms, file downloads return HTTP 401.

	DragonBall	Natural Questions	MS MARCO	Total
Questions	150	150	150	450
Development runs (natural and live-injected)	350	250	250	850
Development runs with replayed faults (training only)	150	–	–	150
Test runs, natural faults	500	500	500	1,500
Test runs, live-injected faults	187	241	206	634
of which in the final injected test set	153	157	170	480

Every subset covers the same five pipelines, each run with its own documents, settings and models:

Pipeline	Rewriter	Embedder	Retriever	Reranker	Generator
RAGFlow	–	Cohere embed-english-v3.0	Elasticsearch (in-process, reconstructed)	Cohere rerank-english-v3.0	GPT-4.1 nano
LightRAG (naive mode)	–	BGE-M3	Qdrant	Jina reranker v2	GPT-4o
Quivr	GPT-4o	OpenAI text-embedding-ada-002	FAISS (in-process, reconstructed)	Cohere rerank-multilingual-v3.0	GPT-4o
Onyx	Gemini 3.5 Flash	Nomic embed-text-v1	Vespa	–	Gemini 3.5 Flash
Verba	–	Nomic embed-text	Weaviate	–	Llama 3 (Ollama)

A stage is labeled only where the pipeline has it and its call is visible in the log. Retrieval inside RAGFlow and Quivr happens in-process; there the retrieved set is reconstructed from the reranker's input and marked in the trace.

Settings were harmonized across pipelines where their design allows: about 512-token chunks with 50 tokens of overlap, 6 chunks passed to the generator, up to 64 candidates for the reranker, and no chat history between questions.

Splits

development: runs used to build and tune a detector. DragonBall's development split also contains 100 runs with Rewriter and Embedder faults injected live.
development_replay (DragonBall only): 150 runs whose Retriever or Reranker fault was made offline by editing a recorded clean run and re-running only the generator. They were used for training only. All evaluation data uses live injection.
test_natural: 1,500 runs (100 questions per dataset per pipeline) with whatever faults the pipelines made on their own.
test_injected: 634 runs in which a fault was injected live, through the logging proxy, into one stage while the pipeline ran, so every later stage reacted to it. in_final_set marks the 480-run evaluation set: 30 runs per pipeline–stage pair, taking first the runs where the judges confirmed a fault at the injected stage.

Questions do not overlap between development and test.

How the labels were made

Each run was judged by two LLM judges, GPT-5.1 and Claude Sonnet 5.5, given the question, the reference answer and evidence, and the full trace. Each judge decides, per stage, whether that stage deviated from what it should have done (a fault), and gives its findings and a reason.
Where the two judges agreed, that is the label (label_source: consensus). Where they disagreed, Claude Opus 5.5 adjudicated (adjudicated).
In the development split, 19 Generator labels were corrected by hand after a review of 64 borderline cases (+manual; the rule and each change are in the judgment records).
Injected runs are labeled like every other run: an injection that the pipeline absorbed (for example, a moved chunk while the evidence still reached the Generator) is not a fault. injected_stage_confirmed says whether the judges found a fault at the injected stage.
Test labels are the judges' alone: no manual correction.

A fault is any deviation of a stage from correct behavior, whether or not it changed the final answer. For injected runs, the ground truth is the judges' labels: the injection says where a fault was introduced, the judges say where one actually occurred. injected_stage_confirmed records whether they agree.

Fault types

Each faulty stage also carries its fault type (field fault_codes), using the RAG taxonomy RAGEC (Leung et al., EACL 2026), extended with two codes for the stages RAGEC does not cover:

Stage	Codes
Rewriter	RW the rewrite changes the intent of the question or drops or alters a constraint (our addition)
Embedder	EM the text sent for embedding is not a faithful rendering of the query (our addition)
Chunking (counted under Retriever)	E1 overchunking, E2 underchunking, E3 a chunk boundary separates information from what it supports
Retriever	E4 needed chunks not retrieved, E5 retrieved chunks only loosely related, E6 keyword match without the query's intent
Reranker	E7 needed chunks ranked too low to be passed on, E8 irrelevant chunks ranked high and passed on
Generator	E9 should have abstained, E9b refused although the context held the answer, E10 fabricated content, E11 relies on its own knowledge instead of the context, E12 incomplete, E13 misrepresents the context, E14 does not address the question, E15 wrong temporal order, E16 wrong number or calculation

E1 and E2 never occur: the chunker runs once, when documents are ingested, so no question's log shows it. E3 is not assigned either: in the 17 replayed chunk-split runs where the judges found a fault, the Retriever did not return the evidence, and they coded it as E4. A stage can carry several codes. The codes describe the fault; whether a stage is at fault (labels) is decided from the judges' findings by fixed rules, for example "the needed evidence is in no retrieved chunk" makes the Retriever the fault.

Files

Each subset has the same layout. All files join on id.

<subset>/
  runs/        one line per run: question, reference answer and evidence, pipeline answer, stages, labels
  traces/      the normalized trace of each run (gzip): rewrites, embedded text, candidates, ranking, context, answer
  judgments/   both judges' per-stage verdicts and reasons, the final label and how it was reached
  injections/  per injected run: method, stage, fault type, what was changed, whether the judges confirmed it
annotations/labels.jsonl   ids and labels only, no source text

Field-by-field descriptions are in schema.md.

Fault types injected

Stage	Fault types
Rewriter	constraint added (e.g. a year), constraint dropped, entity swapped, overgeneralized
Embedder	truncated, typo in the key term, entity removed, stale input, diluted input
Retriever	evidence not retrieved; replay only: chunk split
Reranker	evidence demoted below the cut-off, evidence partly demoted; replay only: distractors promoted
Generator	evidence buried among similar-entity distractors

Limitations

Labels come from LLM judges, with adjudication and a manual review of borderline development cases. They are not human annotations, and some will be wrong, most often for Generator faults where a statement is arguably supported.
Natural faults are uneven across stages: Embedder faults are rare (10 in the natural test split) and Rewriter faults only occur in the two pipelines that rewrite.
For 18 live-injected development runs no record of the injection could be matched to the run (record_found: false); in 15 of them the judges found no fault at the injected stage, and in 2 the injected stage is missing from the trace, so the injection was probably not applied.
Each pipeline ran with one configuration; other settings of the same pipeline may fail differently.

Licenses

The subsets contain text from their source datasets and are distributed under those datasets' terms. Our own annotations are CC BY 4.0. See LICENSES.md.

Part	License
`dragonball/`	CC BY-NC-SA 4.0 (from DragonBall)
`nq/`	CC BY-SA 4.0 (Natural Questions is CC BY-SA 3.0)
`msmarco/`	MS MARCO terms: non-commercial research use
`annotations/`, `schema.md`, this card	CC BY 4.0

Citation

Dataset DOI: 10.57967/hf/11214

@misc{naveed2026raglogfaults,
  author    = {Naveed, Hira and Barnett, Scott and Kurniawan, Stefanus and Grundy, John and Arora, Chetan and Khalajzadeh, Hourieh and Haggag, Omar},
  title     = {{RAGLog Faults}},
  year      = {2026},
  publisher = {Hugging Face},
  doi       = {10.57967/hf/11214},
  url       = {https://huggingface.co/datasets/Hira221/raglog-faults}
}

If you use this dataset, please cite it and the RAGLog paper (citation to be added on publication), the source datasets DragonBall (RAGEval, Zhu et al., 2024), Natural Questions (Kwiatkowski et al., 2019) and MS MARCO (Bajaj et al., 2016), and the RAGEC taxonomy (Leung et al., EACL 2026).

Downloads last month: 210

Total file size:

97.9 MB

Agree to the source datasets' terms to access RAGLog Faults