Faiss is an MIT-licensed C++ library for efficient similarity search and clustering of dense vectors, with complete Python and NumPy wrappers, developed primarily at Meta's Fundamental AI Research group, and it is intended for engineers and researchers who need nearest-neighbour search over vector sets that range from small collections to sets that possibly do not fit in RAM.

What it is

Faiss is a library that stores a set of vectors and provides a search function over them using L2 (Euclidean) distance, dot products, or cosine similarity on normalized vectors. Each instance is represented as a vector and identified by an integer, and the library supplies a range of index types built around that abstraction. Some of those index types are simple baselines, such as exact search, while most correspond to explicit trade-offs in search time, search quality, memory used per index vector, training time, adding time, and the need for external data for unsupervised training. The library lives in the AI and machine learning infrastructure ecosystem, alongside the vector-search components of retrieval and recommendation systems, and it is written in C++ with the Python interface and GPU support both optional.

The concrete problem it solves is the cost of comparing a query vector against a stored vector set directly. Rather than scanning every stored vector, Faiss provides indexing structures such as HNSW and NSG, which add a structure on top of the raw vectors to make searching more efficient, and compression-based methods, which use only a compressed representation of the vectors. Compression methods based on binary vectors and compact quantization codes do not require the original vectors to be kept at all, and they can scale to billions of vectors in main memory on a single server, generally at the cost of a less precise search. That is what the library replaces: brute-force comparison against every candidate vector, and the memory footprint that keeping all original vectors implies.

Key capabilities

• Index types covering exact search and approximate search, with comparison by L2 (Euclidean) distance, dot product, and cosine similarity on normalized vectors.
• Compression-based methods that rely solely on a compressed representation of the vectors and can scale to billions of vectors in main memory on a single server, trading precision for scale.
• Graph-based indexing structures, specifically HNSW and NSG, layered on top of the raw vectors to make searching more efficient.
• GPU implementations that accept input from either CPU or GPU memory and act as drop-in replacements for CPU indexes, for example replacing IndexFlatL2 with GpuIndexFlatL2, with copies to and from GPU memory handled automatically.
• Single-GPU and multi-GPU usage, with optional support through CUDA or AMD ROCm, plus optional enabling of NVIDIA cuVS backend implementations.
• Complete Python and NumPy wrappers, distributed as precompiled Anaconda packages named faiss-cpu, faiss-gpu, and faiss-gpu-cuvs.
• Supporting code for evaluation and parameter tuning, with build instructions in INSTALL.md, a changelog in CHANGELOG.md, and reproduction material for the Polysemous codes and Billion-scale similarity search with GPUs papers under benchs/README.md.

Who uses it and how

• Teams running a server with GPUs use GPU indexes as a drop-in replacement for CPU indexes; results are faster when both input and output remain resident on GPU memory.
• Teams holding very large vector sets use compressed-domain indexes to keep billions of vectors in main memory on a single server instead of sharding across many machines.
• Researchers reproduce published results for Polysemous codes and for billion-scale similarity search with GPUs using the benchmark material referenced from benchs/README.md.
• Engineers choosing an index type work through the documented trade-offs of search time, search quality, memory per index vector, training time, adding time, and dependence on external data for unsupervised training.
• Python users install the precompiled conda package rather than building the C++ library, while teams needing custom builds compile with cmake.

Getting started

Install the precompiled Python packages faiss-cpu, faiss-gpu, or faiss-gpu-cuvs from Anaconda, or compile from source with cmake following INSTALL.md. The only required dependency is a BLAS implementation; CUDA, AMD ROCm, and the cuVS backend are optional.

How it compares

The facts provided name no paid products that Faiss replaces, and they name no comparable tools either. Within this registry it stands alone: no sibling project is cited alongside it for similarity search and clustering of dense vectors.

When to use it — and when not to

A self-hoster must operate a build toolchain around cmake and a BLAS implementation, and must additionally supply a CUDA or AMD ROCm stack to use the GPU indexes; index training, parameter tuning, and the storage strategy for compressed or graph-based structures remain the operator's responsibility. Anyone who wants a managed service, a hosted endpoint, or a database-style API should not pick this up, because Faiss is a library rather than a service. Two honest weaknesses are visible in the record: the topics list is empty, which makes the project harder to discover through registry browsing, and the open issue count stands at 327, so expect a busy tracker; the README's performance claim for the GPU implementation is explicitly dated March 2017 and should be treated as historical rather than current.

@article{douze2024faiss,
      title={The Faiss library},
      author={Matthijs Douze and Alexandr Guzhva and Chengqi Deng and Jeff Johnson and Gergely Szilvasy and Pierre-Emmanuel Mazaré and Maria Lomeli and Lucas Hosseini and Hervé Jégou},
      year={2024},
      eprint={2401.08281},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

@article{johnson2019billion,
  title={Billion-scale similarity search with {GPUs}},
  author={Johnson, Jeff and Douze, Matthijs and J{\'e}gou, Herv{\'e}},
  journal={IEEE Transactions on Big Data},
  volume={7},
  number={3},
  pages={535--547},
  year={2019},
  publisher={IEEE}
}