# tamimehsan/khorgosh architecture

> Architecture diagram of the GitHub repository tamimehsan/khorgosh, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-06-27). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/tamimehsan/khorgosh
- Repository: https://github.com/tamimehsan/khorgosh

## Overview

1. **Project shape**
   - This is a mostly **header-first C++ library** for RaBitQ quantization and approximate nearest neighbor search, with **Python bindings**, **sample apps**, **tests**, and **documentation**.
   - The root build is driven by **CMake**, with a separate **pyproject.toml** for the Python package surface.

2. **Core algorithm layer: RaBitQ quantization**
   - The main quantization logic lives under `include/rabitqlib/quantization/`.
   - Key responsibilities here are:
     - converting dense vectors into compact RaBitQ codes,
     - storing packed/extracted code layouts,
     - implementing the low-level RaBitQ estimator and its internal mechanics.
   - This is the foundation used by all search/index layers.

3. **Distance and similarity estimation**
   - `include/rabitqlib/index/estimator.hpp`, `lut.hpp`, and `query.hpp` provide the query-time machinery for computing approximate Euclidean distance, inner product, and cosine similarity from quantized data.
   - This layer is the boundary between “encoded vectors” and “search results”: it takes query vectors plus codes/LUTs and produces ranking scores.

4. **Vector search index integrations**
   - The library contains three search/index subsystems under `include/rabitqlib/index/`:
     - **IVF** in `index/ivf/`
     - **HNSW** in `index/hnsw/`
     - **Symmetric QG** in `index/symqg/`
   - These indexes all reuse RaBitQ codes, but differ in how candidates are generated and traversed during query execution.

5. **IVF subsystem**
   - The IVF implementation (`ivf.hpp`, `cluster.hpp`, `initializer.hpp`) is responsible for clustering vectors into coarse buckets and routing queries to a subset of candidates.
   - This is the “coarse pruning” search path: first narrow by centroid/cluster structure, then use RaBitQ-based scoring on candidates.

6. **HNSW subsystem**
   - The HNSW integration (`index/hnsw/hnsw.hpp`) wraps graph-based nearest-neighbor search around RaBitQ-coded data.
   - It depends on the vendored **hnswlib** implementation under `include/rabitqlib/third/hnswlib/`, which forms an external algorithm boundary inside the repository.

7. **QG / symmetric quantization path**
   - `index/symqg/qg.hpp` and `qg_builder.hpp` implement the QG pathway described in the README.
   - Architecturally, this path trades extra memory for better access patterns and faster querying by building multiple quantized representations per vector.

8. **FastScan acceleration**
   - `include/rabitqlib/fastscan/` contains FastScan-oriented query acceleration, including a higher-accuracy variant.
   - This is the main performance-oriented sublayer for distance estimation from compact codes, used when bitwise/LUT-style scanning is preferable to full raw-vector access.

9. **Utility and runtime support**
   - `include/rabitqlib/utils/` contains shared infrastructure used across the library:
     - vector/memory helpers,
     - I/O and buffering,
     - stopwatches,
     - hashing/visited-set utilities,
     - rotation/FHT helpers,
     - space/distance abstractions.
   - These are cross-cutting support modules rather than user-facing algorithms.

10. **Third-party dependencies are vendored**
   - The repository vendors **Eigen** and **hnswlib** under `include/rabitqlib/third/`.
   - That means core compilation does not rely on those being installed system-wide; they are part of the repo’s source boundary.

11. **Python surface**
   - Python support is split into two parts:
     - `python_bindings/` provides native bindings for the C++ library,
     - `python/` contains thin Python helpers/utilities such as I/O helpers and IVF-facing code.
   - The binding modules mirror the native subsystems: `rabitq`, `ivf`, `hnsw`, and `symqg`.

12. **Build and packaging boundary**
   - `python_bindings/CMakeLists.txt` and the top-level `CMakeLists.txt` define the native build.
   - `pyproject.toml` indicates the repo can also be treated as a Python-distributed package, but the core architecture remains C++-centric.

13. **Samples show the intended data flow**
   - `sample/cpp/` and `sample/python/` demonstrate the same pipeline in both languages:
     - build/initialize index,
     - quantize dataset vectors,
     - execute queries,
     - optionally rerank or evaluate recall.
   - The sample names make the primary flows explicit: `*_indexing` and `*_querying` for IVF, HNSW, QG, and quantizer demos.

14. **Tests cover both primitives and integration edges**
   - `tests/unit/` focuses on utility-level correctness, especially rotation and vector-space helpers.
   - `tests/integration/` includes bit pack/unpack validation, which is an important architectural boundary because code layout and decoding are central to correctness.

15. **Documentation mirrors the architecture**
   - `docs/docs/` is organized by conceptual subsystem: quick start, index types, kernel/IP behavior, and detailed RaBitQ internals.
   - The docs structure reflects the code structure: quantization core first, then search/index integrations, then estimator/rotator/reranking details.

16. **Overall data flow**
   - The main runtime flow is: **raw vectors** → **RaBitQ quantization / packing** → **index-specific organization (IVF/HNSW/QG)** → **query-time estimation via LUT/FastScan/helpers** → **top-k candidates and optional reranking**.
   - The key architectural boundary is that most query-time scoring operates on **compact codes**, not raw vectors, unless a specific path chooses to rerank or inspect originals.

Main entry points: [`include/rabitqlib/quantization/rabitq.hpp`](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/rabitq.hpp) (RaBitQ Core), [`python_bindings/rabitq_bindings.cpp`](https://github.com/tamimehsan/khorgosh/blob/main/python_bindings/rabitq_bindings.cpp) (Python Bindings), [`include/rabitqlib/index/ivf/ivf.hpp`](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/ivf.hpp) (IVF Index), [`docs/docs/index.md`](https://github.com/tamimehsan/khorgosh/blob/main/docs/docs/index.md) (Docs Site)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_core["Core Library"]
  node_quant_core["RaBitQ Core<br/>quantization core<br/>[rabitq.hpp]"]
  node_data_layout["Code Layout<br/>[data_layout.hpp]"]
  node_pack_excode["Pack / Extract<br/>packing<br/>[pack_excode.hpp]"]
  node_estimator["Estimator<br/>query scoring<br/>[estimator.hpp]"]
  node_lut["Lookup Tables<br/>query support<br/>[lut.hpp]"]
  node_query["Query API<br/>query orchestration<br/>[query.hpp]"]
  node_ivf["IVF Index<br/>coarse index<br/>[ivf.hpp]"]
  node_ivf_cluster["Clustering<br/>[cluster.hpp]"]
  node_ivf_init["Initializer<br/>ivf init<br/>[initializer.hpp]"]
  node_hnsw["HNSW Index<br/>graph index<br/>[hnsw.hpp]"]
  node_symqg["SymQG<br/>symmetric quantization<br/>[qg.hpp]"]
  node_qg_builder["QG Builder<br/>[qg_builder.hpp]"]
  node_fastscan["FastScan<br/>scan acceleration<br/>[fastscan.hpp]"]
  node_highacc_fastscan["High-Acc Scan<br/>scan variant"]
end

subgraph group_support["Support"]
  node_utils["Utilities<br/>shared infra<br/>[tools.hpp]"]
  node_eigen["Eigen<br/>vendored linear algebra"]
  node_hnswlib["hnswlib<br/>vendored ANN<br/>[hnswlib.h]"]
end

subgraph group_bindings["Python Surface"]
  node_bindings_common["Bindings Common<br/>binding support"]
  node_cpp_bindings["Python Bindings<br/>native bindings"]
  node_python_helpers["Python Helpers<br/>[ivf.py]"]
end

subgraph group_examples["Samples"]
  node_cpp_samples["C++ Samples<br/>examples<br/>[quantizer.cpp]"]
  node_py_samples["Python Samples<br/>examples<br/>[utils.py]"]
end

subgraph group_qa["Validation"]
  node_unit_tests["Unit Tests<br/>[space_test.cpp]"]
  node_integration_tests["Integration Tests"]
end

subgraph group_docs["Docs"]
  node_docs_root["Docs Site<br/>documentation<br/>[index.md]"]
end

node_build["CMake Build<br/>build system<br/>[CMakeLists.txt]"]
node_pyproject["Py Project<br/>package config<br/>[pyproject.toml]"]

node_build -->|"builds"| node_quant_core
node_build -->|"builds"| node_cpp_bindings
node_build -->|"builds"| node_cpp_samples
node_pyproject -->|"packages"| node_python_helpers
node_quant_core -->|"uses"| node_data_layout
node_quant_core -->|"uses"| node_pack_excode
node_quant_core -->|"feeds"| node_estimator
node_estimator -->|"builds"| node_lut
node_query -->|"orchestrates"| node_estimator
node_query -->|"accelerates"| node_fastscan
node_fastscan -->|"variant"| node_highacc_fastscan
node_ivf -->|"routes by"| node_ivf_cluster
node_ivf -->|"initializes"| node_ivf_init
node_ivf -->|"scores with"| node_query
node_hnsw -->|"wraps"| node_hnswlib
node_hnsw -->|"scores with"| node_query
node_symqg -->|"built by"| node_qg_builder
node_symqg -->|"scores with"| node_query
node_cpp_bindings -->|"shares glue"| node_bindings_common
node_cpp_bindings -->|"exposes"| node_quant_core
node_cpp_bindings -->|"exposes"| node_ivf
node_cpp_bindings -->|"exposes"| node_hnsw
node_cpp_bindings -->|"exposes"| node_symqg
node_python_helpers -->|"supports"| node_ivf
node_cpp_samples -->|"demonstrates"| node_quant_core
node_cpp_samples -->|"demonstrates"| node_ivf
node_cpp_samples -->|"demonstrates"| node_hnsw
node_cpp_samples -->|"demonstrates"| node_symqg
node_py_samples -->|"demonstrates"| node_python_helpers
node_py_samples -->|"calls"| node_cpp_bindings
node_unit_tests -->|"verifies"| node_utils
node_integration_tests -->|"verifies"| node_pack_excode
node_docs_root -->|"documents"| node_quant_core
node_docs_root -->|"documents"| node_ivf
node_docs_root -->|"documents"| node_hnsw
node_docs_root -->|"documents"| node_symqg
node_docs_root -->|"documents"| node_fastscan
node_quant_core -->|"depends on"| node_utils
node_estimator -->|"depends on"| node_utils
node_fastscan -->|"depends on"| node_utils
node_quant_core -->|"depends on"| node_eigen

click node_build "https://github.com/tamimehsan/khorgosh/blob/main/CMakeLists.txt"
click node_pyproject "https://github.com/tamimehsan/khorgosh/blob/main/pyproject.toml"
click node_quant_core "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/rabitq.hpp"
click node_data_layout "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/data_layout.hpp"
click node_pack_excode "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/pack_excode.hpp"
click node_estimator "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/estimator.hpp"
click node_lut "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/lut.hpp"
click node_query "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/query.hpp"
click node_ivf "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/ivf.hpp"
click node_ivf_cluster "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/cluster.hpp"
click node_ivf_init "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/initializer.hpp"
click node_hnsw "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/hnsw/hnsw.hpp"
click node_symqg "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/symqg/qg.hpp"
click node_qg_builder "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/symqg/qg_builder.hpp"
click node_fastscan "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/fastscan/fastscan.hpp"
click node_highacc_fastscan "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/fastscan/highacc_fastscan.hpp"
click node_utils "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/utils/tools.hpp"
click node_eigen "https://github.com/tamimehsan/khorgosh/tree/main/include/rabitqlib/third/Eigen/Core"
click node_hnswlib "https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/third/hnswlib/hnswlib.h"
click node_bindings_common "https://github.com/tamimehsan/khorgosh/blob/main/python_bindings/bindings_common.hpp"
click node_cpp_bindings "https://github.com/tamimehsan/khorgosh/blob/main/python_bindings/rabitq_bindings.cpp"
click node_python_helpers "https://github.com/tamimehsan/khorgosh/blob/main/python/ivf.py"
click node_cpp_samples "https://github.com/tamimehsan/khorgosh/blob/main/sample/cpp/quantizer.cpp"
click node_py_samples "https://github.com/tamimehsan/khorgosh/blob/main/sample/python/utils.py"
click node_unit_tests "https://github.com/tamimehsan/khorgosh/blob/main/tests/unit/rabitqlib/utils/space_test.cpp"
click node_integration_tests "https://github.com/tamimehsan/khorgosh/blob/main/tests/integration/bit_pack_unpack_test.cpp"
click node_docs_root "https://github.com/tamimehsan/khorgosh/blob/main/docs/docs/index.md"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_quant_core,node_data_layout,node_pack_excode,node_estimator,node_lut,node_query,node_ivf,node_ivf_cluster,node_ivf_init,node_hnsw,node_symqg,node_qg_builder,node_fastscan,node_highacc_fastscan toneBlue
class node_utils,node_eigen,node_hnswlib toneAmber
class node_bindings_common,node_cpp_bindings,node_python_helpers toneMint
class node_cpp_samples,node_py_samples toneRose
class node_unit_tests,node_integration_tests toneIndigo
class node_docs_root toneTeal
class node_build,node_pyproject toneNeutral
```

## Components

### Core Library

Header-first C++ quantization, estimation, and search primitives.

- [RaBitQ Core](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/rabitq.hpp): quantization core · Main RaBitQ quantization and packed-code implementation. · `include/rabitqlib/quantization/rabitq.hpp`
- [Code Layout](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/data_layout.hpp): code layout · Packed and extracted code representations. · `include/rabitqlib/quantization/data_layout.hpp`
- [Pack / Extract](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/quantization/pack_excode.hpp): packing · Encode and decode compact RaBitQ layouts. · `include/rabitqlib/quantization/pack_excode.hpp`
- [Estimator](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/estimator.hpp): query scoring · Approximate distance and similarity estimation from encoded data. · `include/rabitqlib/index/estimator.hpp`
- [Lookup Tables](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/lut.hpp): query support · LUT machinery used by query-time scoring. · `include/rabitqlib/index/lut.hpp`
- [Query API](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/query.hpp): query orchestration · Query-side boundary between codes, scores, and ranking. · `include/rabitqlib/index/query.hpp`
- [IVF Index](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/ivf.hpp): coarse index · Cluster-based candidate pruning with RaBitQ scoring. · `include/rabitqlib/index/ivf/ivf.hpp`
- [Clustering](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/cluster.hpp): ivf clustering · Centroid and bucket organization for coarse routing. · `include/rabitqlib/index/ivf/cluster.hpp`
- [Initializer](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/ivf/initializer.hpp): ivf init · Build-time initialization and setup for IVF structures. · `include/rabitqlib/index/ivf/initializer.hpp`
- [HNSW Index](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/hnsw/hnsw.hpp): graph index · Graph-based ANN search over RaBitQ-coded data. · `include/rabitqlib/index/hnsw/hnsw.hpp`
- [SymQG](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/symqg/qg.hpp): symmetric quantization · Symmetric quantized search path with multiple representations. · `include/rabitqlib/index/symqg/qg.hpp`
- [QG Builder](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/index/symqg/qg_builder.hpp): qg build · Builds the multi-representation QG structures. · `include/rabitqlib/index/symqg/qg_builder.hpp`
- [FastScan](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/fastscan/fastscan.hpp): scan acceleration · Accelerated compact-code distance estimation path. · `include/rabitqlib/fastscan/fastscan.hpp`
- [High-Acc Scan](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/fastscan/highacc_fastscan.hpp): scan variant · Higher-accuracy FastScan-oriented estimator variant. · `include/rabitqlib/fastscan/highacc_fastscan.hpp`

### Support

Shared utilities and vendored dependencies.

- [Utilities](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/utils/tools.hpp): shared infra · Cross-cutting helpers for memory, I/O, math, and spaces. · `include/rabitqlib/utils/tools.hpp`
- [Eigen](https://github.com/tamimehsan/khorgosh/tree/main/include/rabitqlib/third/Eigen/Core): vendored linear algebra · Vendored Eigen dependency boundary. · `include/rabitqlib/third/Eigen/Core`
- [hnswlib](https://github.com/tamimehsan/khorgosh/blob/main/include/rabitqlib/third/hnswlib/hnswlib.h): vendored ANN · Vendored graph-search dependency boundary. · `include/rabitqlib/third/hnswlib/hnswlib.h`

### Python Surface

Native bindings and Python helpers.

- [Bindings Common](https://github.com/tamimehsan/khorgosh/blob/main/python_bindings/bindings_common.hpp): binding support · Shared C++ binding glue and type conversions. · `python_bindings/bindings_common.hpp`
- [Python Bindings](https://github.com/tamimehsan/khorgosh/blob/main/python_bindings/rabitq_bindings.cpp): native bindings · Native extension entry points for RaBitQ, IVF, HNSW, and SymQG. · `python_bindings/rabitq_bindings.cpp`
- [Python Helpers](https://github.com/tamimehsan/khorgosh/blob/main/python/ivf.py): python helpers · Thin Python-facing utilities and IVF helpers. · `python/ivf.py`

### Samples

C++ and Python usage flows.

- [C++ Samples](https://github.com/tamimehsan/khorgosh/blob/main/sample/cpp/quantizer.cpp): examples · End-to-end demos for indexing and querying across subsystems. · `sample/cpp/quantizer.cpp`
- [Python Samples](https://github.com/tamimehsan/khorgosh/blob/main/sample/python/utils.py): examples · Python demos mirroring the C++ usage flows. · `sample/python/utils.py`

### Validation

Tests covering primitives and integration boundaries.

- [Unit Tests](https://github.com/tamimehsan/khorgosh/blob/main/tests/unit/rabitqlib/utils/space_test.cpp): tests · Utility-level correctness checks for shared primitives. · `tests/unit/rabitqlib/utils/space_test.cpp`
- [Integration Tests](https://github.com/tamimehsan/khorgosh/blob/main/tests/integration/bit_pack_unpack_test.cpp): integration tests · Boundary tests for packed-code and layout correctness. · `tests/integration/bit_pack_unpack_test.cpp`

### Docs

Conceptual documentation mirrored to the code structure.

- [Docs Site](https://github.com/tamimehsan/khorgosh/blob/main/docs/docs/index.md): documentation · Conceptual documentation organized by subsystem. · `docs/docs/index.md`

### Other components

- [CMake Build](https://github.com/tamimehsan/khorgosh/blob/main/CMakeLists.txt): build system · Top-level native build plus Python packaging entry points. · `CMakeLists.txt`
- [Py Project](https://github.com/tamimehsan/khorgosh/blob/main/pyproject.toml): package config · Python packaging surface for distributed use. · `pyproject.toml`

## Connections

- CMake Build → RaBitQ Core: builds · Compiles the core header library.
- CMake Build → Python Bindings: builds · Builds native Python extension modules.
- CMake Build → C++ Samples: builds · Builds sample applications.
- Py Project → Python Helpers: packages · Defines Python-distributed package surface.
- RaBitQ Core → Code Layout: uses · Relies on code layout representations.
- RaBitQ Core → Pack / Extract: uses · Encodes and decodes compact codes.
- RaBitQ Core → Estimator: feeds · Provides quantized data for query-time scoring.
- Estimator → Lookup Tables: builds · Uses lookup tables for approximate scoring.
- Query API → Estimator: orchestrates · Runs scoring over encoded vectors and queries.
- Query API → FastScan: accelerates · Can use scan-oriented acceleration paths.
- FastScan → High-Acc Scan: variant · Includes a higher-accuracy scanning variant.
- IVF Index → Clustering: routes by · Uses coarse clusters to prune candidates.
- IVF Index → Initializer: initializes · Build-time setup and index construction.
- IVF Index → Query API: scores with · Reuses shared query-time estimation machinery.
- HNSW Index → hnswlib: wraps · Depends on vendored graph-search implementation.
- HNSW Index → Query API: scores with · Uses shared scoring boundary for coded vectors.
- SymQG → QG Builder: built by · Builder constructs the multi-representation index.
- SymQG → Query API: scores with · Uses query-time estimation boundary.
- Python Bindings → Bindings Common: shares glue · Common conversion and binding support.
- Python Bindings → RaBitQ Core: exposes · Exposes RaBitQ to Python.
- Python Bindings → IVF Index: exposes · Exposes IVF search to Python.
- Python Bindings → HNSW Index: exposes · Exposes HNSW search to Python.
- Python Bindings → SymQG: exposes · Exposes SymQG search to Python.
- Python Helpers → IVF Index: supports · Thin Python-side utilities for IVF workflows.
- C++ Samples → RaBitQ Core: demonstrates · Shows quantizer usage and code generation.
- C++ Samples → IVF Index: demonstrates · Shows IVF indexing and querying flow.
- C++ Samples → HNSW Index: demonstrates · Shows HNSW indexing and querying flow.
- C++ Samples → SymQG: demonstrates · Shows SymQG indexing and querying flow.
- Python Samples → Python Helpers: demonstrates · Shows Python-side usage patterns.
- Python Samples → Python Bindings: calls · Exercises the native extension surface.
- Unit Tests → Utilities: verifies · Covers rotation and space helpers.
- Integration Tests → Pack / Extract: verifies · Checks bit pack/unpack correctness.
- Docs Site → RaBitQ Core: documents · Explains quantizer and estimator internals.
- Docs Site → IVF Index: documents · Explains IVF architecture and usage.
- Docs Site → HNSW Index: documents · Explains HNSW integration.
- Docs Site → SymQG: documents · Explains QG path and query behavior.
- Docs Site → FastScan: documents · Covers compact-code acceleration details.
- RaBitQ Core → Utilities: depends on · Uses shared vector, memory, and math helpers.
- Estimator → Utilities: depends on · Uses shared helper abstractions.
- FastScan → Utilities: depends on · Uses shared support utilities.
- RaBitQ Core → Eigen: depends on · Uses vendored linear algebra support.