README.md

---
license: other
license_name: ms-marco
license_link: https://microsoft.github.io/msmarco/
task_categories:
- text-retrieval
language:
- en
size_categories:
- 1M<n<10M
configs:
- config_name: default
  data_files:
  - split: train
    path: dataset/msmarco-passages.parquet
tags:
- retrieval
- dense-retrieval
- embeddings
- msmarco
- lilbee
- vector-index
---

# 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](https://github.com/tobocop2/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](https://asciinema.org) 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.

```bash
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

```toml
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](https://pypi.org/project/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

```bash
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](https://microsoft.github.io/msmarco/), 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.