hossain0909/autorag-bench

AutoRAG Benchmark Recipe

Five source datasets · Versioned preparation · Verifiable reconstruction

26,643 source documents · 8,836 questions/queries · 18 reconstructed data configurations

Prepared collection v0.2.0 · Documentation updated 29 October 2026

Static overview · Quick start · Processing · Splits · Schemas · Source notices

Dataset summary

AutoRAG Benchmark Recipe is a reproducible preparation and distribution recipe for BEIR SciFact and the four domains of RAGRouter-Bench. It records which upstream files were collected, how records were normalized, how experimental query groups were assigned to splits, and how another machine can recreate the same prepared data with matching checksums.

The work was performed on a Windows PC. The resulting data can be reconstructed on a PC, Linux workstation, or DGX Spark without a GPU or a language model. The contribution is the preparation workflow, audit, split manifests, schemas, and reproducible handoff. The source corpora, questions, answers, and source annotations belong to their respective dataset authors.

What is actually hosted here: an ID-only split-assignment dataset, source URLs and hashes, reconstruction instructions, manifests, audits, and explanatory documentation. Source corpus text, questions, reference answers, and evidence snippets are not rehosted in this repository. The reconstruction program retrieves those files directly from the pinned upstream sources.

This is a benchmark preparation artifact. It is not a newly authored QA dataset, a trained router, a model checkpoint, or a collection of measured best-retrieval-strategy labels. No superiority over an existing RAG method is claimed.

Collection at a glance

Static composition chart

Component	Source domain	Original documents	Collected questions/queries	Explicit document-ID relevance available
RAGRouter MuSiQue	Encyclopedic / Wikipedia-derived	21,100	3,356	939
RAGRouter QuALITY	Narrative / long-form literature	265	1,198	1,198
RAGRouter UltraDomain legal	Legal documents	94	1,277	1,277
RAGRouter GraphRAG medical	Medical reference content	1	1,896	0
BEIR SciFact	Scientific claim retrieval	5,183	1,109	1,109
Total source records	Five components	26,643	8,836	4,523

Counts are measured from the downloaded files, before any retrieval chunking. The document total adds source records across components; it is not a claim that cross-source near-duplicate documents have been removed. SciFact contributes 809 official BEIR train queries and 300 official BEIR test queries. RAGRouter contributes 7,727 questions in total.

The downloaded QuALITY variant contains 1,198 questions, although the RAGRouter GitHub table lists 1,200. We retained the actual release and did not add or infer two missing records.

Sources and exact provenance

Source	Collected version	Verification
RAGRouter dataset	Commit abff378d9202caba636aa4d5bb9243db8103f70f	SHA-256 recorded separately for all eight corpus/question files
BEIR SciFact archive	Published scifact.zip referenced by BEIR	Published MD5 5f7d1de60b170fc8027bb7898e2efca1 matched; archive SHA-256 recorded

source-provenance.json records download URLs, file sizes, the RAGRouter revision, collection verification time, and hashes. reconstruction-plan.json records the expected source hashes and the exact file transformations and output hashes.

The RAGRouter GitHub README's anonymous download endpoint returned HTTP 401 during collection. The author-published Hugging Face release was located and used instead. No unrelated substitute version was silently introduced.

Matching a published checksum checks consistency with that reference. It does not independently certify the publisher, annotation correctness, or source rights.

Intended uses

This collection supports reproducible retrieval experiments, evidence-availability analysis, source question-type studies, debugging dataset adapters, and moving a fixed benchmark preparation between a development PC and a research machine. The separate official and experimental views support two different workflows:

• Source benchmark reproduction: use the official views and the source benchmark's evaluation protocol.
• Exploratory query-held-out experiments: use the explicitly named experimental splits and report this preparation version and split policy.

Training a supervised RAG-strategy selector requires additional, independently measured method outcomes. A source question's single_hop, multi_hop, or summary category is not a label saying that Hybrid, Graph, or another route is best. We did not create such labels from question wording.

How the collection was prepared

Static normalization diagram

1. Collect and preserve the originals

All five components were downloaded to local storage. Original corpus/question files and the BEIR archive were preserved separately from prepared versions. The RAGRouter revision was pinned, and original files were fingerprinted before the reconstruction package was created. No model weights or paid API calls were needed for collection or preparation.

2. Inspect actual formats and repair adapter assumptions

The upstream RAGRouter release is not uniform: some .json files are JSONL, and the medical corpus is one JSON object rather than a JSON array. The loader was extended to accept these observed formats. JSONL parsing uses literal newline record boundaries so a Unicode line separator inside a document does not accidentally split a record.

Structural validation checks required identifiers, duplicate source/query IDs, nonempty content, and source references where supplied. Unsupported structures are rejected rather than silently discarded.

3. Normalize serialization while retaining source content

Prepared data use UTF-8 JSONL, explicit column names, and string identifiers. Corpus rows and RAGRouter question rows retain an original_json field containing the complete source object. This preserves source fields and values; it does not preserve the source file's whitespace or original byte formatting.

Reference answers and supporting facts were not rewritten, corrected, or generated. The immutable official views retain every original source record. Experimental views add split/group metadata and isolate conflicts as described below. Prepared corpus records are not retrieval chunks; any later chunking is a separate experimental choice.

4. Audit relevance annotations

The first adapter audit incorrectly treated every supporting-fact annotation as a snippet. A deeper check found objects containing nested doc_id fields. The loader and preparation were corrected to retain those explicit source IDs. This correction is reflected in the 3,414-query relevance count below.

5. Group questions and create separately named experimental views

Exact normalized questions, close lexical matches, and identical nonempty evidence sets are grouped before deterministic split assignment. Conflicting answers within an exact question group quarantine the connected group. The official source views are still retained in full.

6. Package and verify the handoff

The package records source fingerprints, prepared-file fingerprints, split manifests, measured audits, source notices, and reconstruction code. Fresh upstream downloads were used to test reconstruction. Every one of the 30 prepared data files matched its expected SHA-256 checksum.

Experimental splits and duplicate handling

Static grouping diagram

RAGRouter grouping rule

Grouping is performed within each domain. Questions are connected when any of the following conditions holds:

1. Their question texts have the same normalized word sequence.
2. Their complete, nonempty normalized supporting-fact sets are identical.
3. Their question word-trigram set Jaccard similarity is at least 0.85.

Text normalization applies Unicode NFKC, case folding, and word-token extraction. Grouping takes transitive closure: if A connects to B and B connects to C, all three remain in the same component. Questions shorter than three words use exact/evidence grouping without approximate trigram matching.

Each component uses the lexicographically smallest source question ID as its stable assignment key. The program hashes autorag-split-v1-seed42: followed by that ID with SHA-256, takes the first 16 hexadecimal digits as an integer, and applies modulo 100:

Hash interval	Experimental assignment
0–79	Train
80–89	Validation
90–99	Test

The intervals target 80/10/10 allocation, but observed ratios vary with group sizes. They are not a claim of exact stratification. The assignments are deterministic; model performance was not used to select a split.

Conflicts and retained duplicates

The current normalization identifies 112 repeated question rows beyond the first occurrence. The earlier whitespace-only audit counted 107; the newer count also normalizes punctuation and Unicode representation. The manifests also record 13 qualifying nonexact trigram-match edges; edges are not the same as a count of independent duplicate clusters.

Seven exact-question groups contain different normalized reference answers. Their connected components contain 14 records, which are excluded from the experimental train/validation/test sets and retained under quarantine. No answer was automatically selected as correct.

Nonconflicting duplicates remain in their assigned split, preserving source annotations. For evaluation, consider selecting one representative per group or using group-weighted metrics to avoid giving repeated questions extra weight.

Domain	Train	Validation	Test	Quarantine	Total retained
MuSiQue	2,664	349	331	12	3,356
QuALITY	949	115	134	0	1,198
UltraDomain legal	1,032	112	133	0	1,277
GraphRAG medical	1,485	207	202	2	1,896
RAGRouter total	6,130	783	800	14	7,727

See the group manifests for source IDs, group IDs, assignments, detected near-match edges, and conflicting ID groups. The root assignments.jsonl exposes the ID-only assignments in the Hugging Face viewer.

Scope: these are query-held-out, shared-corpus splits. They do not guarantee unseen documents, topics, answers, all semantic paraphrases, or no cross-domain overlap. Identical evidence sets are grouped; merely sharing one evidence item does not necessarily connect two otherwise different sets. The medical corpus contains only one original document, so document-held-out evaluation is not possible within that component. These splits are not the original paper's official evaluation protocol.

Relevance labels and unknown ground truth

Static relevance diagram

Some supporting facts are evidence strings; others are objects with doc_id and text fields. We retain source-provided document relevance only when every supporting fact explicitly names an existing corpus ID. A string counts as an ID only if it exactly matches an existing source ID; we do not search for a likely document and turn the result into a label.

RAGRouter component	Explicit source-ID relevance	Unknown/unresolved
MuSiQue	939	2,417
QuALITY	1,198	0
Legal	1,277	0
Medical	0	1,896
Total	3,414	4,313

For resolved annotations, document_relevance_available is true and relevant_document_ids retains the source IDs. For unresolved annotations, the flag is false and the ID list is empty. An empty unresolved list does not mean the question has no relevant documents. Retrieval quality should be reported as unavailable for those annotations, not silently scored as zero.

Source-ID validation is structural: it verifies that a referenced document exists. It does not prove that the document is semantically relevant, the supporting text is accurate, or the reference answer is correct. gold_route remains null for every RAGRouter question.

SciFact: official and clean views

Static SciFact diagram

The official BEIR train and test query ID sets are disjoint. However, two train IDs—1291 and 871—have normalized question text matching official test text. The official views are retained unchanged. A separately named scifact_clean configuration excludes those two train records, leaving 807 development queries.

Remaining normalized question-text groups use the same seeded hash function, with an 80/20 train/validation threshold. The clean view contains:

View	Train	Validation	Test
scifact_official	809	—	300
scifact_clean	644	163	300

The 300 official test queries are unchanged. The validator checks that no normalized exact question text crosses the clean train/validation/test sets. This does not certify the absence of semantic paraphrases.

scifact_qrels retains the official relevance records: 919 train qrel rows and 339 test qrel rows. When using a clean split, join or filter qrels by that split's selected query IDs. A validation query derived from official train still uses its relevance annotation from the official train qrels.

BEIR split names should not be confused with the original SciFact verification task's split naming. Use the relevant source protocol when making comparisons.

What files are hosted here?

README.md                       Detailed card and animated field guide
assignments.jsonl                7,727 ID-only RAGRouter split assignments
assets/                         Seven GIF explanations and static PNG versions
reconstruct.py                  Standard-library reconstruction program
validate.py                     Package verifier; optional Hugging Face loading
reconstruction-plan.json         Source transforms, ID selections, output hashes
source-provenance.json           Source URLs, pinned revision, original hashes
SHA256SUMS.txt                   Checksums for this recipe repository
LICENSE-SOURCES.md              Component declarations and publication boundary
CITATION.bib                    Source benchmark citations
UPLOAD.md                       Upload and Spark handoff instructions
REPRODUCTION-LICENSE.txt         License for the preparation program
full-package-metadata/          Full-data card, audits, group manifests,
                                dependency versions and expected full-data hashes

The full-package-metadata/ folder describes the data that will be reconstructed; it does not contain the corpus or QA data itself. The outer checksum manifest verifies this recipe. The inner full-data checksum manifest verifies the reconstructed output folder. Neither checksum file hashes itself.

Data schemas

Hosted viewer: split_assignments

Field	Type	Meaning
dataset	string	Source component, such as musique
question_id	string	Original source question identifier
group_id	string	Stable 24-character hash identifier for its connected group
split	string	train, validation, test, or quarantine

The viewer's physical split is called assignments. The split column records the experimental assignment. The repository has 7,727 viewer rows, not 8,836: SciFact query selections are recorded in the reconstruction plan and materialized into their own data configurations after reconstruction.

Reconstructed corpus rows

Field	Type	Meaning
id	string	Original document ID, converted to string
title	string	Source title; an empty title may remain empty
text	string	Source document body before retrieval chunking
original_json	string	Serialized complete original source record

Reconstructed RAGRouter question rows

Field	Type	Meaning
id	string	Original question identifier
question	string	Original question text
answer	string	Source reference answer; source lists joined with |
query_type	string	Original question category
supporting_facts	list of strings	Source evidence strings; object-valued facts are serialized as JSON strings
gold_route	null	No best-retrieval-method label has been supplied
document_relevance_available	boolean	Whether every source fact resolves through an explicit corpus ID
relevant_document_ids	list of strings	Source IDs for resolved annotations, empty when unknown
original_json	string	Complete original annotation, preserving its original structure
group_id	string, experimental/quarantine views only	Connected component identifier

The string serialization of object-valued evidence keeps a consistent viewer schema across domains. Use original_json to recover the original nested structure. Reference answers and supporting facts must remain reference annotations, not query inputs or additional retrieval corpus documents.

Reconstructed SciFact rows

• Query views: id and question strings.
• Qrels: query_id, document_id, and integer relevance.
• Corpus: the four corpus fields described above.

Full schemas and the 18 configuration declarations are also available in the reconstructed-data card.

Quick start

1. Inspect the hosted split assignments

For a private repository, authenticate with hf auth login first. Do not place access tokens in notebooks, commands saved to the repository, or dataset files.

from datasets import load_dataset

assignments = load_dataset(
    "hossain0909/autorag-bench",
    "split_assignments",
    split="assignments",
    token=True,  # Required while the repository is private.
)
print(len(assignments))  # 7727

2. Download an immutable recipe snapshot

Select a commit SHA from this repository's history. An immutable revision is preferable to a moving main for an experiment that must be reproducible.

from huggingface_hub import snapshot_download

recipe_dir = snapshot_download(
    repo_id="hossain0909/autorag-bench",
    repo_type="dataset",
    revision="REPLACE_WITH_A_COMMIT_SHA_FROM_THIS_REPOSITORY",
    local_dir="./autorag-bench-recipe",
    token=True,
)

3. Reconstruct on the PC or Spark

python ./autorag-bench-recipe/reconstruct.py --out ./autorag-bench-data

The reconstruction program uses Python's standard library. It downloads the pinned original files, checks their hashes, normalizes the specified records, applies the saved ID/group assignments, and checks every prepared data-file hash. No model, GPU, paid inference API, or AutoRAG application installation is required. Source usage terms still apply.

To reuse already downloaded originals without downloading them again:

python ./autorag-bench-recipe/reconstruct.py \
  --out ./autorag-bench-data \
  --source-root /path/to/originals

That source root must contain beir/scifact/ and ragrouter/<domain>/. The original collection cache supplies the source-notice files for a fully offline run; if those notices are absent, the program retrieves and hash-checks them. Use a fresh output directory: the program refuses to overwrite an existing one.

4. Validate and load reconstructed data

python -m pip install -r ./autorag-bench-data/requirements-hf.txt
python ./autorag-bench-data/reproduction/validate_hf_release.py \
  ./autorag-bench-data --load-all

from datasets import load_dataset

questions = load_dataset(
    "./autorag-bench-data",
    "musique_experimental",
)
corpus = load_dataset(
    "./autorag-bench-data",
    "musique_corpus",
    split="corpus",
)
scifact_qrels = load_dataset("./autorag-bench-data", "scifact_qrels")

The pinned loader versions used during preparation are recorded in full-package-metadata/requirements-hf.txt. Loading the data uses standard JSON builders, not Hugging Face custom remote dataset code. reconstruct.py is an explicit preparation program that the user chooses to run.

Reconstruction and validation evidence

Static reconstruction diagram

Check performed	Observed result	What it does not establish
Full project regression suite	35 tests passed during preparation	Scientific superiority or production certification
UTF-8 JSONL serialization and source-record audit	Source records retained; official views preserved	Factual correctness of every source answer
Actual Hugging Face loader checks	All 18 full-data configurations loaded	Hosted corpus availability in this recipe repository
Uploaded recipe readback	7,727 assignment rows loaded successfully	Gold routing labels
Source reconstruction from fresh network downloads	All 30 prepared data files matched their expected hashes	Future availability of upstream URLs
Group/split validation	Recorded groups do not cross experimental splits	Absence of all semantic, topic, or document leakage
SciFact clean split check	No normalized exact question-text overlap; official test unchanged	Absence of paraphrases

The animations are original schematic explanations of this implementation. They are not recordings of training, GPU execution, live benchmarks, or measured performance. Each has a static alternative for readers who prefer no motion.

Limitations, bias, and responsible use

• No best-route supervision: gold_route is null. Question categories must not be relabeled as winning retrieval methods without independent evidence.
• Partial retrieval labels: 4,313 RAGRouter questions have unresolved document relevance. Unknown ground truth is not a negative label.
• Shared-corpus evaluation: experimental held-out questions may refer to documents, topics, or answers encountered in training. Word-trigram grouping is a lexical check, not an exhaustive semantic deduplicator.
• Source annotation quality: semantic relevance, evidence fidelity, reference correctness, and answer completeness were not independently adjudicated. Quarantine detects one specific conflict pattern, not every labeling problem.
• Domain and language coverage: the collection is English and inherits its sources' sampling, domain, historical, and generated-question biases. It is not representative of all enterprise or multilingual retrieval workloads.
• Medical and legal text: these are research benchmarks, not clinical or legal advice. No patient-record de-identification or comprehensive personal-data certification is claimed. Users remain responsible for their own review.
• Scientific scope: no neural retriever, learned router, full GraphRAG, iterative RAG comparison, model-generation benchmark, DGX throughput result, or cost advantage was established by this preparation task.
• Dependency on upstream availability: pinning hashes detects changed files, but does not guarantee that a source remains online. A mismatch causes reconstruction to fail rather than silently accepting a different version.

Licenses, attribution, and publication design

The hosted recipe avoids rehosting source corpus and QA text because the available metadata does not resolve article-level redistribution rights for every component. The original QuALITY release documents article-level license fields that are absent from the transformed RAGRouter corpus. A software license on a medical benchmark repository does not, by itself, license every underlying medical document. Private visibility does not create extra rights.

We preserve the source declarations instead of assigning one blanket license to all content: RAGRouter's card declares MIT; the BEIR SciFact card declares CC BY-SA 4.0; the original SciFact notice identifies claims/evidence under CC BY 4.0 and the abstracts database under ODC-By 1.0. The detailed component matrix, original-source links, attribution, and scope are in LICENSE-SOURCES.md.

The AutoRAG application's Personal Noncommercial License applies to the preparation program as stated in REPRODUCTION-LICENSE.txt; it does not replace or add restrictions to independently licensed source dataset contents. This recipe does not assert ownership over upstream documents or annotations.

Version history and what we contributed

Stage	Work completed
Collection / v0.1.0 staging	Located official sources, pinned RAGRouter, verified SciFact archive checksum, preserved originals, normalized JSONL, recorded initial audits
v0.2.0 preparation	Fixed nested source-ID handling, documented label availability, grouped duplicate/evidence components, quarantined conflicting answers, created deterministic experimental splits and clean SciFact view
Hugging Face handoff	Published the recipe privately under hossain0909/autorag-bench, verified every initial uploaded file, and loaded the 7,727 hosted assignment rows
Animated dataset card	Added this detailed methodology, schema and usage guide plus seven GIF explanations and seven static equivalents; source data and split assignments remain unchanged

The initial recipe upload is recorded at commit f52208bf4f216d3e516e4a39178da8cb5827072b. For new experiments, pin the commit containing the documentation/assets and manifests you actually used. Presentation updates do not retroactively change that earlier commit.

Citation and maintenance

Preparation is maintained through hossain0909 and the AutoRAG Router project. Please credit the original benchmark authors. Core citations are provided in CITATION.bib: RAGRouter-Bench (Wang et al.), BEIR (Thakur et al.), and SciFact (Wadden et al.). Also cite the source-domain datasets when your study uses their records; attribution links are in LICENSE-SOURCES.md.

When reporting results, record the recipe commit SHA, source revisions, data configuration, split protocol, handling of duplicate groups/quarantine, relevance coverage, chunking, model/retriever versions, and evaluation metrics. Link any proposed source correction to an affected ID rather than silently rewriting the official views.