MegaQuery-680M

We built this dataset of synthetic search queries and hard negatives from FinePDFs, for training text retrieval models. Each example pairs a query with its source document and other documents that look similar, together with relevance scores.

Read more: Blog post · Code and reproduction scripts · Data guide and schemas

The blog post explains the motivation and design choices. We will share the scripts for reproducing data generation, negative mining, and release preparation in our code repository, along with a detailed pipeline walkthrough.

How we built it

We reimplement the synthetic retrieval-data approach from Qwen3 Embedding with modifications for FinePDFs. The idea is to start with a document and generate queries that someone might use to find it, guided by a user persona, query type, difficulty, and target length.

We use FinePDFs as our document corpus. Our pipeline supports different query-generation models. We use the most relevant retrieved persona and randomly sample query types, difficulty levels, and target lengths to generate several variants per document. We embed documents with Qwen/Qwen3-Embedding-0.6B and retrieve negative candidates by cosine similarity to the positive document. We use wissamantoun/bge-reranker-v2-gemma-seq-cls to score the primary query against the positive document and each candidate. We retain the retrieval and reranker scores so users can choose their own training selection rules.

We retrieve the Top-k = 96 non-self candidates, skip the first 32 ranks, and rerank the remaining 64 candidates. We remove repeated negative references and candidates resolving to the positive document. We include our model settings, document truncation limits, and pipeline provenance in each language's data/<config>/release_manifest.json.

This release

We release 677,214,506 queries in 172,942,907 query groups, with separate English and French configurations.

Language	Training config	Query groups	Queries, including additional queries	Referenced FinePDFs documents	Negatives per group
English	eng_Latn	145,619,690	569,212,798	145,543,330	57–64
French	fra_Latn	27,323,217	108,001,708	27,312,687	16–64

Both languages reference HuggingFaceFW/finepdfs, split train, at commit 220bac3acbf07789502c621d2d33952f51ac7f86.

What is included

We provide two kinds of Parquet tables, separately for each language:

• eng_Latn / fra_Latn: the primary query, its positive and negative document indices, aligned scores, generation metadata, and other_queries.
• eng_Latn_document_refs / fra_Latn_document_refs: source document identifiers, source shard names, and row positions for referenced documents.

Each row groups queries sharing a positive document. The reranker scores apply only to the primary query. Additional queries can reuse the document references for retrieval training. We order negative lists by descending retrieval score; keep all score lists aligned with negative_idxs when selecting examples.

We reference document text in the pinned FinePDFs source and include manifests and Python helpers to recover it without rerunning generation or mining. See GUIDE.md for the full schemas and readable examples.

Load the data

Install the reading dependencies with pip install datasets huggingface_hub pyarrow.

from datasets import load_dataset

DATASET_ID = "wissamantoun/MegaQuery-680M"
CONFIG = "eng_Latn"  # Use "fra_Latn" for French.
train = load_dataset(DATASET_ID, CONFIG, split="train", streaming=True)
row = next(iter(train))
print(row["query"], row["positive_idx"], row["negative_idxs"][:3])

IDs are local to a language. Keep the language config alongside query and document indices when mixing English and French examples. Use the same config for training rows and source documents.

Recommended for training: prepare the source corpus once

Use load_source_dataset() to prepare the full source corpus for this language as a locally cached, memory-mapped Arrow dataset. Its row positions match the released document indices, so training can retrieve text directly without building a Python ID lookup dictionary.

First, download the small helper files and manifests:

import sys
from huggingface_hub import snapshot_download

release_dir = snapshot_download(
    DATASET_ID,
    repo_type="dataset",
    allow_patterns=[
        "source_manifest.json", "release_manifest.json", "_SUCCESS",
        f"data/{CONFIG}/source_manifest.json",
        f"data/{CONFIG}/release_manifest.json", f"data/{CONFIG}/_SUCCESS",
        "finepdf_release.py", "release_data.py",
        "materialize_release_training.py",
    ],
)
sys.path.insert(0, release_dir)
from finepdf_release import load_source_dataset

documents = load_source_dataset(release_dir, config=CONFIG).select_columns(["text"])

document_ids = [row["positive_idx"], *row["negative_idxs"][:8]]
texts = documents[document_ids]["text"]
print({"query": row["query"], "positive": texts[0], "negatives": texts[1:]})

The first preparation downloads the entire source language split and builds the Arrow cache; allow time and disk space for both. Subsequent loads reuse the cache. Memory mapping keeps the corpus on disk instead of loading all text into RAM. You can choose the Arrow cache location with cache_dir="/path/to/arrow-cache". If you already have the pinned FinePDFs snapshot, pass local_source_root="/path/to/finepdfs" to reuse those source files during preparation.

For a batch containing lists of source document indices, text lookup is:

examples["documents"] = [
    documents[document_ids]["text"]
    for document_ids in examples["document_ids"]
]

Document indices depend on the source order. They are zero-based positions in the pinned FinePDFs snapshot, concatenated in the shard order listed in data/<config>/source_manifest.json. load_source_dataset() reproduces this order. Keep the document corpus in that order and retain every row; shuffle or filter training examples separately. Selecting only the text column preserves document positions. Indices are not row numbers in document_refs. If your training batch requires a fixed number of negatives, select training rows with enough candidates; keep the document corpus intact.

Inspect examples or prepare a small subset

Use FinePDFResolver for selective lookups without preparing the full Arrow corpus. It reads source Parquet row groups as needed, which makes scattered lookups less suitable for the inner loop of a large training run.

from finepdf_release import FinePDFResolver, iter_training_examples

with FinePDFResolver(release_dir, config=CONFIG) as resolver:
    example = next(iter_training_examples([row], resolver, num_negatives=8))
    print(example)  # query, positive, negative_0, ... text columns

The resolver downloads pinned source shards as needed, or accepts the same local_source_root argument. A small sample with scattered negatives can still require several large source shards.

For a text-only subset, use materialize_release_training.py; its usage is explained in the guide. all_queries=True in the iterator expands additional queries into separate examples without attaching the primary query's scores.

Using the supervision

We generate queries and compute relevance scores automatically. Our mined hard negatives can include other relevant documents, so you can filter candidates with the retained scores. We do not apply an additional reranker-score threshold. Avoid treating other queries sharing the same positive document as negatives of each other when building training batches.

License and attribution

We release this dataset under odc-by. Source documents come from HuggingFaceFW/finepdfs. See its dataset card for source attribution and usage information. We build our data-generation recipe on Qwen3 Embedding.