A collection of 430 pre-built graph indices for Approximate Nearest Neighbor Search, covering 5 index construction algorithms × 14 dataset configurations × 7 vertex orderings, spanning 1M to 50M points.

Constructing these graphs is the expensive part of working on graph-based ANN search: a single 40M-point index takes hours on a GPU, and a full sweep across algorithms and datasets takes days of compute. We release the finished graphs so that anyone studying graph topology, memory layout, or search algorithms can start from them instead of rebuilding.

The released files are integer adjacency lists and vertex-ID permutation maps. They are self-contained graph structures: pair them with the source vectors (obtained from their original providers) and you have a working index.


📄 Paper	https://openreview.net/forum?id=tF70hyyM6V
📚 arXiv	https://arxiv.org/abs/2508.15436
🌐 Project page	https://omron-sinicx.github.io/plasma
💻 Code	https://github.com/omron-sinicx/plasma

The indices span both classical descriptor datasets (SIFT, GIST, Deep) and modern text/image embeddings (Yandex T2I, OpenAI, Wikipedia, BioASQ, C4), so the same index type can be compared across very different data distributions and dimensionalities (96 → 1536 dims).

⚠️ No vectors are included

Every file in this repository contains integers only — graph adjacency lists and vertex-ID permutations. No embedding, feature vector, or any other element of the source corpora is redistributed here. Index-implementation binaries that embed the raw vectors (*.faissindex, *.diskann.data, and similar) are deliberately excluded.

To use these indices you must obtain the vectors yourself from their original providers, under those providers' own terms. See Reproducing a usable index and Source datasets and credits.

What you can do with these

Study vertex ordering / memory layout. Each graph ships with permutation maps for seven orderings, so the same topology can be laid out seven different ways.
Compare index topologies at fixed data. Five construction algorithms over the same points, so topology can be varied while everything else is held constant.
Skip construction entirely. Prototype a search kernel, a pruning rule, or a caching scheme against a real 40M-point graph without owning a GPU cluster.
Reproduce or extend the accompanying paper, which is what these graphs were originally built for.

Index	Description
`cagra`	GPU-built k-NN graph (NVIDIA CAGRA)
`nsg`	Navigating Spreading-out Graph
`nndescent`	NN-Descent k-NN graph
`diskann`	DiskANN / Vamana graph
`nssg`	Navigating Satellite System Graph — extra, beyond the four evaluated in the paper

Graph-reordering permutations are provided for seven methods:

Method	In the paper
`gorder`	GOrder
`rcm`	RCM (Reverse Cuthill–McKee)
`hubsort`	Hub Sort
`indegree`, `outdegree`	Degree Sort
`hubcluster`, `random`	extra baselines, beyond the paper's headline set

Datasets covered

Dataset	Dim	Metric	Indices	Files	Size
`sift-128-euclidean`	128	L2	cagra, nsg, nssg, nndescent, diskann	60	6.78 GiB
`gist-960-euclidean`	960	L2	cagra, nsg, nssg, nndescent, diskann	54	4.71 GiB
`deep1m-96-euclidean`	96	L2	cagra, nsg, nssg, nndescent, diskann	54	5.32 GiB
`deep10m`	96	L2	cagra, nsg, nndescent, diskann	18	22.10 GiB
`t2i1m-200`	200	L2 / IP	cagra, nsg, nssg, nndescent, diskann	52	5.54 GiB
`openai1m-1536-euclidean`	1536	L2	cagra, nsg, nndescent, diskann	53	5.21 GiB
`wikipedia1m-768-ip`	768	IP	cagra, nsg, nndescent, diskann	46	4.47 GiB
`wikipedia10m-768-ip`	768	IP	nndescent	11	14.95 GiB
`bioasq1m-1024-ip`	1024	IP	cagra, nsg, nndescent, diskann	46	4.56 GiB
`bioasq10m-1024-ip`	1024	IP	nndescent	11	15.11 GiB
`c45m-1536-ip`	1536	IP	nndescent	11	7.34 GiB
`deep40m-96-euclidean`	96	L2	cagra, nndescent	12	66.68 GiB
`deep50m-96-euclidean` †	96	L2	nsg	1	9.81 GiB
`sift_200nn.knng`	128	L2	200-NN ground-truth graph	1	0.75 GiB
Total				430	173.33 GiB

These cover the 12 datasets used in the accompanying paper. († deep50m is an extra scale point not reported in the paper.) Larger configurations are covered by fewer index types simply because not every index could be built at that scale within our compute budget.

File naming

<index>_K<degree>_<dataset>_<metric>[_reordered_<method>][_mapping].<ext>

Part	Values
`<index>`	`cagra`, `nsg`, `nssg`, `nndescent`, `diskann`
`K<degree>`	`K32` (almost all), `K64` (a few SIFT configurations)
`<dataset>`	e.g. `sift-128-euclidean`, `bioasq1m-1024-ip`
`<metric>`	`l2` (Euclidean) or `ip` (inner product)
`<method>`	`gorder`, `rcm`, `hubsort`, `hubcluster`, `indegree`, `outdegree`, `random`

Examples:

cagra_K32_deep1m-96-euclidean_l2.adjlist                          # base graph
cagra_K32_deep1m-96-euclidean_l2_reordered_gorder_mapping.txt     # Gorder permutation
diskann_K32_bioasq1m-1024-ip_ip_reordered_gorder.adjlist          # reordered graph
diskann_K32_bioasq1m-1024-ip_ip_mapping_gorder.txt                # Gorder permutation

Two quirks to be aware of when globbing:

Two mapping-filename spellings — ..._reordered_<method>_mapping.txt and ..._mapping_<method>.txt. They are the same kind of file; the difference is only which build script emitted it.
Two files carry a stray .adjlist in the middle of the name, because the build script was handed a filename rather than a base name. The contents are normal:
```
nsg_K32_sift-128-euclidean_l2.adjlist_reordered_gorder.adjlist
nsg_K32_sift-128-euclidean_l2.adjlist_mapping_gorder.txt
```
A pattern like *_sift-128-euclidean_l2* still matches them; *_l2_reordered_* does not.

`*.adjlist` — adjacency list (ASCII)

<N> <K>                                  # header: number of vertices, out-degree
<vertex_id> <neighbor_1> ... <neighbor_K>
...                                      # N lines, vertex_id ascending from 0

`_mapping.txt` — vertex permutation (ASCII)

<N>                                      # header: number of vertices
<original_id> <new_id>
...                                      # N lines, original_id ascending from 0

The mapping is original → new. Concretely, for a reordering m:

reordered_graph[m[u]] == { m[w] : w in original_graph[u] }
reordered_vectors[m[u]] == original_vectors[u]

`sift_200nn.knng` — binary k-NN graph

The exact-search 200-NN graph for SIFT1M, used as ground truth for recall evaluation. Stored in TEXMEX ivecs format — little-endian int32 throughout, one record per query point:

[K=200][id_1] ... [id_200]     # repeated N = 1,000,000 times

The file is exactly 1_000_000 * (4 + 200*4) = 804,000,000 bytes.

knn = np.fromfile("sift_200nn.knng", dtype=np.int32).reshape(-1, 201)[:, 1:]

Downloading

Full download (~173 GiB) is rarely what you want. Fetch only what you need:

pip install -U huggingface_hub hf_xet

# One index type, one dataset
hf download omron-sinicx/plasma --repo-type dataset --local-dir ./plasma \
  --include 'cagra_K32_deep1m-96-euclidean_l2*'

# Base graphs only, no reordering permutations
hf download omron-sinicx/plasma --repo-type dataset --local-dir ./plasma \
  --include '*.adjlist' --exclude '*_reordered_*'

# Everything for one dataset, across all index types
hf download omron-sinicx/plasma --repo-type dataset --local-dir ./plasma \
  --include '*_sift-128-euclidean_l2*'

# Just the Gorder permutations
hf download omron-sinicx/plasma --repo-type dataset --local-dir ./plasma \
  --include '*gorder*.txt'

Check what a pattern would fetch before committing to it with --dry-run.

Reproducing a usable index

An adjacency list is only half of an index — you need the vectors it was built over.

1. Get the vectors from the original distributor (see Source datasets and credits). Use the same base vectors, in the same order, as that section specifies; vertex IDs in the adjacency lists are positions in that original ordering.

2. Load the graph.

import numpy as np

def load_adjlist(path):
    with open(path) as f:
        n, k = map(int, f.readline().split())
        adj = np.empty((n, k), dtype=np.int32)
        for line in f:
            parts = line.split()
            adj[int(parts[0])] = parts[1:]
    return adj

def load_mapping(path):
    with open(path) as f:
        n = int(f.readline())
        m = np.empty(n, dtype=np.int32)
        for line in f:
            u, v = line.split()
            m[int(u)] = int(v)
    return m            # m[original_id] -> new_id

3. Apply a reordering to your vectors so they match a reordered graph:

vectors = np.load("deep1m_base.npy")           # shape (N, D), original order
m       = load_mapping("cagra_K32_deep1m-96-euclidean_l2_reordered_gorder_mapping.txt")
adj     = load_adjlist("cagra_K32_deep1m-96-euclidean_l2.adjlist")

reordered_vectors = np.empty_like(vectors)
reordered_vectors[m] = vectors                 # reordered_vectors[m[u]] = vectors[u]
reordered_adj = m[adj[np.argsort(m)]]          # relabel and reorder rows

4. Search. Feed reordered_vectors and reordered_adj to your graph-search routine (beam search / greedy best-first). The point of the reordering is locality: neighbouring vertices land on nearby cache lines and pages — the paper measures the resulting DRAM bandwidth utilisation and L1/L2 hit rates alongside recall and QPS.

For the construction and search code that produced these graphs, see: https://github.com/omron-sinicx/plasma

Source datasets and credits

The graphs in this repository were built over vectors produced by other people. We redistribute none of those vectors. Each dataset must be obtained from its original provider, under that provider's own terms. Credit belongs to the creators below.

Classical descriptor datasets

SIFT1M · GIST1M — Hervé Jégou, Matthijs Douze, Cordelia Schmid (INRIA / TEXMEX). Local SIFT and global GIST descriptors, introduced with Product Quantization for Nearest Neighbor Search (IEEE TPAMI, 2011). Terms: public domain / CC0-equivalent — no usage restrictions stated by the distributor. The 1B-scale sibling (BIGANN) is released as CC0 by Big ANN Benchmarks. → http://corpus-texmex.irisa.fr/

DEEP (deep1m, deep10m, deep40m, deep50m) — Artem Babenko and Victor Lempitsky (Yandex Research). Subsets of DEEP1B: image embeddings taken from the last fully-connected layer of a GoogLeNet pretrained on ImageNet classification, introduced in Efficient Indexing of Billion-Scale Datasets of Deep Descriptors (CVPR, 2016). License: CC BY 4.0 (Big ANN Benchmarks, "Release terms"). → https://research.yandex.com/blog/benchmarks-for-billion-scale-similarity-search → https://big-ann-benchmarks.com/neurips21.html

Modern embeddings

Yandex Text-to-Image (t2i1m) — Yandex Research. Database vectors are image embeddings from Se-ResNeXt-101; queries are textual embeddings from a DSSM variant. A deliberately cross-modal benchmark, where queries and database points come from different distributions. License: CC BY 4.0 (Big ANN Benchmarks, "Release terms"). → https://big-ann-benchmarks.com/neurips21.html

OpenAI Embed. (openai1m) — text embeddings of the WikiText corpus, generated by an OpenAI embedding model (1536-dim). Obtained via the Big ANN Benchmarks collection. Terms: the underlying WikiText corpus is CC BY-SA 3.0 (derived from Wikipedia); OpenAI's terms for model outputs apply to the embeddings themselves. → https://big-ann-benchmarks.com/ → Simhadri et al., Results of the Big ANN: NeurIPS'23 competition (2024)

The following three come from VectorDBBench (Zilliz, 2023), whose harness is MIT-licensed. VectorDBBench states no unified license for the datasets themselves, so the terms of the underlying corpus and of the embedding provider both apply. → https://github.com/zilliztech/VectorDBBench

Wikipedia (wikipedia1m, wikipedia10m) — text embeddings of the Wikipedia corpus, generated by the Cohere V2 model (768-dim). Terms: Wikipedia text is CC BY-SA; Cohere's terms apply to the embeddings.

BioASQ (bioasq1m, bioasq10m) — text embeddings of the BioASQ question-answering corpus, generated by an OpenAI model (1024-dim). Terms: BioASQ distributes its corpus under its own terms and requires registration; OpenAI's terms apply to the embeddings. Verify BioASQ's conditions before use. → http://bioasq.org/

C4 (c45m) — text embeddings of the Colossal Clean Crawled Corpus (C4), generated by the Cohere V3 model (1536-dim). C4 was released by AllenAI as a cleaned scrape of Common Crawl, introduced with the T5 paper (Raffel et al., JMLR 2020). Terms: the C4 corpus is ODC-BY, and Common Crawl's terms apply to the scraped content; Cohere's terms apply to the embeddings. → https://huggingface.co/datasets/allenai/c4

License

What is released here, and under what terms

Every file in this repository is one of three things, and all of them are integers only:

File	Content
`*.adjlist`	graph adjacency lists — vertex IDs and their neighbour IDs
`_mapping.txt`	vertex-ID permutations — pairs of integer IDs
`sift_200nn.knng`	one exact 200-NN ground-truth graph — vertex IDs

These files are released under CC BY 4.0 (Creative Commons Attribution 4.0 International, https://creativecommons.org/licenses/by/4.0/) by their authors:

Yutaro Oguri — The University of Tokyo
Mai Nishimura — OMRON SINIC X Corporation
Yusuke Matsui — The University of Tokyo

You may share and adapt them for any purpose, including commercially, so long as you give appropriate credit. Citing the paper below satisfies this.

What this license does not cover

The source vectors. We do not host, redistribute, or relicense any embedding or feature vector. Rights in those remain entirely with their original providers, and you must obtain them yourself under those providers' terms — enumerated per dataset in Source datasets and credits.

How these files relate to the source datasets

Each adjacency list is computed from a source dataset: a vertex ID is a position in that dataset's own ordering, and an edge records that two points were near each other under the stated metric. The permutation maps are one step further removed — they are computed from the graph alone, not from the vectors.

No file here contains vector values, and the vectors cannot be reconstructed from them: knowing that point 42 neighbours point 907 says nothing about either point's coordinates.

We nonetheless treat each graph as carrying the attribution expectations of the dataset it was derived from, and credit every source explicitly.

In practice

If you use files from this repository:

Attribute the Plasma authors for the graphs — CC BY 4.0, satisfied by the citation below.
Obtain the vectors from their original provider and comply with that provider's terms. Some require registration (BioASQ); some carry share-alike or attribution conditions on the underlying corpus.
Attribute the source dataset's creators. For DEEP and Yandex T2I this is a CC BY 4.0 obligation in its own right; for the others see the per-dataset entries.

This summary is offered in good faith and is not legal advice.

Citation

Yutaro Oguri, Mai Nishimura, Yusuke Matsui. Plasma: A Layout-Aware Benchmark Reveals Memory Layout Matters for Graph-based ANNS on GPU. The 2nd Workshop on Vector Databases (VecDB) at Very Large Data Bases (VLDB), 2026. The University of Tokyo · OMRON SINIC X Corporation

@inproceedings{oguri2026plasma,
  author    = {Yutaro Oguri and Mai Nishimura and Yusuke Matsui},
  title     = {Plasma: A Layout-Aware Benchmark Reveals Memory Layout
               Matters for Graph-based ANNS on GPU},
  booktitle = {The 2nd Workshop on Vector Databases (VecDB) at
               Very Large Data Bases (VLDB)},
  year      = {2026},
  url       = {https://openreview.net/forum?id=tF70hyyM6V},
  eprint    = {2508.15436},
  archivePrefix = {arXiv}
}

Downloads last month: 317

Total file size:

186 GB

Paper for omron-sinicx/plasma

PLASMA: A Layout-Aware Benchmark Reveals Memory Layout Matters for Graph-based ANNS on GPU

Paper • 2508.15436 • Published Aug 21, 2025

Plasma — Pre-built Graph Indices for ANN Search

⚠️ No vectors are included