lilbeee/msmarco-ingest

MS MARCO passages, indexed end to end by lilbee

The complete MS MARCO passage collection, 8,841,823 passages, embedded with Qwen3-Embedding-8B and built into a searchable index in 7 hours 17 minutes on a single 8-GPU machine.

This repository holds the index itself, the passage text, the full telemetry of the run that produced it, and a screen recording of that run as it happened.

What is here

path	size	what
index/	156 GB	a complete lilbee data root: 8,841,823 vectors at 4096 dimensions, an IVF-PQ vector index and a BM25 full-text index, ready to search
dataset/	5.8 GB	the passage text as parquet and jsonl, no vectors, for anyone who wants the corpus rather than the index
telemetry/	128 MB	every sampler from the run, including one line per extracted file for all 8.8M of them
recording/	65 MB	ten hourly asciinema casts of the live dashboard, start to finish
corpus/	1.3 GB	the source passages as ingested, 1000 files per directory

The Hub's viewer previews the passage text from dataset/. The index under index/ is a directory of Lance files, which the viewer cannot render: download it and point lilbee at it.

How it was built

One command.

lilbee sync

No environment variables, no sharding the corpus by hand, no merge step. lilbee detects the eight GPUs, spawns one ingest worker per card, gives each worker its own slice of the corpus by hashing the filename, and folds the eight resulting shards into one index at the end.

The corpus is laid out 1000 files per directory. That detail is not cosmetic: a single flat directory of 8.8M files measured 3.3x slower.

What it cost

phase	wall time
stage the corpus, count it, pull the 8 GB embedder	9 min 25 s
embed 8,841,823 passages across 8 GPUs	6 h 05 min
fold 8 shards into one index (147 GB)	59 min
build the corpus-wide vector and full-text indexes	9 min
total	7 h 17 min

Throughput was 406 passages/second while embedding, and 337/second measured across the whole run including the merge and the index build.

How evenly the eight GPUs were used

This is the number the work was really about, so here it is in full.

shard	passages
0	1,106,004
1	1,106,945
2	1,106,486
3	1,105,689
4	1,104,890
5	1,103,417
6	1,103,110
7	1,105,282

0.3% between the fullest and the emptiest shard, and they sum to exactly 8,841,823.

Per-card utilisation, sampled every 2 seconds on all eight cards for the length of the run:

window	mean	p10	p50	p90	readings at exactly 0%
while embedding (6.05 h)	84.9%	47%	94%	95%	5.0%
whole run (7.29 h)	70.7%	0%	94%	95%	20.8%

The whole-run row is lower because the last 68 minutes are the merge and the index build, which use no GPU at all. The share of readings at exactly 0% is the honest measure of whether the cards were being fed: a mean can read near 90% while a third of the samples are flat zero.

Configuration

embedding_model = "Qwen/Qwen3-Embedding-8B-GGUF/Qwen3-Embedding-8B-Q8_0.gguf"
embedding_dim = 4096
embed_batch_sequences = 64
enable_ocr = false
ingest_processes = 0        # 0 means one worker per GPU
concept_graph = false
wiki = false
entity_extraction = false

• Embedder: Qwen3-Embedding-8B, Q8_0 quantisation, 4096 dimensions, served by llama.cpp (one server per card, roughly 9.9 GB of VRAM each).
• Extraction: xberg 1.0.4. Median 1 ms per passage, 94.7% at or under 3 ms, across all 8,841,823 files.
• Vector index: IVF-PQ. Keyword index: BM25. Both built corpus-wide after the merge.
• OCR, table and layout detection are off because MS MARCO passages are plain text of about 325 bytes with no scans, images or tables. They would have detected nothing.
• Concept graphs and entity extraction are off. Both are retrieval-time features worth measuring on a corpus with conceptual structure, which a passage collection is not.

Hardware

8x NVIDIA H100 SXM 80GB HBM3, 160 vCPU, 1.5 TB RAM, RunPod EUR-IS-3. The index was written to a network volume rather than the container disk, so it outlives the machine that built it.

Using the index

pip install lilbee
lilbee search "your query" --data-dir /path/to/index

Or point lilbee at it with LILBEE_DATA=/path/to/index. The index carries the embedder identity in its metadata, so a query is embedded with the same model that built it.

Passage identifiers survive the round trip. A result whose source is 08392/8392571.txt is MS MARCO passage 8392571, and the directory is the passage id integer-divided by 1000. That makes the index directly gradeable against the published MS MARCO relevance judgments.

Reading the telemetry

telemetry/extract.trace.log.gz has one line per extracted file for all 8,841,823 of them, with the elapsed time, page count and chunk count of each. gpu.csv is per-card utilisation every 2 seconds. rows.csv is the merged and per-shard row counts every 20 seconds, which is what the throughput and evenness figures above are computed from. SUMMARY.txt is the whole thing summarised.

Provenance and caveats

• Passages come from MS MARCO, and the original dataset's terms apply to the text. This repository adds an index over it, not new text.
• Retrieval quality has not been graded yet. This repository documents how the index was built and how fast, not how well it retrieves. Row counts, table integrity and shard evenness were verified; MRR and nDCG were not measured.
• The 8-GPU ingest path was still an unmerged branch when this ran (feat/native-multi-gpu-ingest), on lilbee 0.6.90b420.dev728.
• The parquet and jsonl exports needed a fix before they could be produced at all: pyarrow's string type addresses column data with 32-bit offsets, which caps a column at 2 GB, and this corpus has about 3 GB of text. The files here were written with 64-bit offsets and verified to read back at 8,841,823 rows.