usearch 0.1.8 → 0.1.10

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">USearch</h1>
 <h3 align="center">
-C++11 Single Header Vector Search<br/>
-Compact, yet Powerful<br/>
+Smaller & Faster Single-File<br/>
+Vector Search Engine<br/>
 </h3>
 <br/>
 
@@ -17,30 +17,126 @@ Compact, yet Powerful<br/>
 <a href="https://github.com/unum-cloud/usearch"><img height="25" src="https://github.com/unum-cloud/.github/raw/main/assets/github.svg" alt="GitHub"></a>
 </p>
 
-- [x] Single C++11 header implementation, easily extendible.
-- [x] 4B+ sized space efficient point-clouds with `uint40_t`.
-- [x] Half-precision support with [`maratyszcza/fp16`](https://github.com/maratyszcza/fp16).
-- [x] View from disk, without loading into RAM.
-- [x] Any metric, includes: 
+- [x] [Single C++11 header][usearch-header] implementation, easily extendible.
+- [x] [4B+](#go-beyond-4b-entries) sized space efficient point-clouds with `uint40_t`.
+- [x] [Half-precision](#quantize-on-the-fly) support with [`maratyszcza/fp16`](https://github.com/maratyszcza/fp16).
+- [x] [View from disk](#view-larger-indexes-from-disk), without loading into RAM.
+- [x] [Any metric](#define-custom-metrics), includes: 
   - [x] Euclidean, Dot-product, Cosine,
   - [x] Jaccard, Hamming, Haversine.
   - [x] Hardware-accelerated [`ashvardanian/simsimd`](https://github.com/ashvardanian/simsimd). 
 - [x] Variable dimensionality vectors.
 - [x] Don't copy vectors if not needed.
-- [x] Bring your threads.
+- [x] [Bring your threads](#bring-your-threads), like OpenMP.
 - [x] Multiple vectors per label.
-- [x] Python bindings: `pip install usearch`.
-- [x] JavaScript bindings: `npm install usearch`.
-- [x] Rust bindings: `cargo add usearch`.
-- [x] Java bindings: `cloud.unum:usearch` on GitHub.
+- [x] [Python](#python) bindings: `pip install usearch`.
+- [x] [JavaScript](#java) bindings: `npm install usearch`.
+- [x] [Rust](#rust) bindings: `cargo add usearch`.
+- [x] [Java](#java) bindings: `cloud.unum:usearch` on GitHub.
 - [ ] GoLang bindings.
-- [ ] Wolfram language bindings.
+- [x] Wolfram language bindings.
 - [x] For Linux: GCC, Clang.
 - [x] For MacOS: Apple Clang.
 - [ ] For Windows.
 - [ ] Multi-index lookups in Python.
 - [ ] Thread-safe `reserve`.
-- [ ] Distributed construction.
+- [ ] Distributed construction with MPI.
+- [x] AI + Vector Search = Semantic Search.
+
+[usearch-header]: https://github.com/unum-cloud/usearch/blob/main/include/usearch/usearch.hpp
+
+## Features
+
+### Define Custom Metrics
+
+Most vector-search packages focus on just 2 metrics - "Inner Product distance" and "Euclidean distance".
+The lack of dedicated "Cosine distance" can be justified with the simplicity of normalizing such vectors on the fly.
+But that hardly exhausts the list of possible metrics.
+
+![USearch: Vector Search Approaches](assets/usearch-approaches-white.png)
+
+Older approaches indexing high-dimensional spaces, like KD-Trees and Locality Sensitive Hashing are hardly extendible to vectors/objects of variable length.
+Modern NSW-like approaches, however, only require two objects to be comparable.
+This means, the index can be extended to support fuzzy search with Levenstein distance over strings.
+USearch implements HNSW, and provides some uncommon-to-vector-search "similarity measures" and "distances" out of the box: Haversine, Jaccard, Hamming, etc.
+
+### Bring your Threads
+
+Most AI, HPC, or Big Data packages use some form of a thread pool.
+Instead of spawning additional threads within USearch, we focus on thread-safety of the `add` function.
+
+```cpp
+#pragma omp parallel for
+    for (std::size_t i = 0; i < n; ++i)
+        native.add(label, span_t{vector, dims}, omp_get_thread_num());
+```
+
+During initialization we allocate enough temporary memory for all the cores on the machine.
+On call, the user can simply supply the identifier of the current thread, making this library easy to integrate with OpenMP and similar tools.
+
+### Go Beyond 4B Entries
+
+Constructing a vector index is a memory-intensive task.
+Depending on your configuration parameters, part of the memory will be allocated towards copies of vectors, and another part to the Small World Graph, common to NSW-like algorithms.
+Choosing the right data-structures and numeric types can have profound implications on both.
+
+![USearch uint40_t support](assets/usearch-neighbor-types.png)
+
+Internally, some point "label" is mapped into an integer identifier for every stored vector.
+Most implementations hard-code it to `uint32_t`, as people rarely store more than 4 Billion vectors.
+But when they do, software becomes unusable.
+Others hard-code it to `uint64_t`, which hardly space-efficient.
+We added a tiny class - `uint40_t`, that should be enough for collections up to 1 Trillion vectors.
+
+### View Larger Indexes from Disk
+
+To construct a large index one may use a beefy RAM-optimized machine, like the AWS `u-24tb1.metal` instances with 24 TB of RAM.
+Those are, however, pricy, and would cost you over $200/hour.
+
+|          |   To Build    |    To Serve    |
+| :------- | :-----------: | :------------: |
+| Instance | u-24tb1.metal | is4gen.8xlarge |
+| Price    |   ~ $200/h    |    ~$4.5/h     |
+| RAM      |     24 TB     |     192 GB     |
+| SSD      |      EBS      |     30 TB      |
+
+You wouldn't want to have them running all the time.
+So, if you are working on large datasets, but don't need the in-RAM throughput, you can simply view an existing dataset from disk, without ever loading it fully into memory.
+
+> Construct on large machines, deploy on the cheap ones.
+
+### Quantize on the Fly
+
+Most modern CPU have at least partial support for `half`-precision `f16_t` arithmetic.
+USearch supports automatic down-casting and up-casting between `f32_t`, `f16_t`, `f64_t`, and `i8q100_t` representations.
+
+> Making vectors smaller will help pack more of them in-memory, while also increasing performance on CPUs implementing native support for target type.
+
+## Performance
+
+Below are the performance numbers for a benchmark running on the 64 cores of AWS `c7g.metal` "Graviton 3"-based instances.
+We fix the default configuration in the top line and show the affects of various parameters by changing one parameter at a time.
+
+|  Vectors   | Connectivity | EF @ A | EF @ S | **Add**, QPS | **Search**, QPS | **Recall @1** |
+| :--------: | :----------: | :----: | :----: | :----------: | :-------------: | ------------: |
+| `f32` x256 |      16      |  128   |   64   |    75'640    |     131'654     |         99.3% |
+|            |              |        |        |              |                 |               |
+| `f32` x256 |      12      |  128   |   64   |    81'747    |     149'728     |         99.0% |
+| `f32` x256 |      32      |  128   |   64   |    64'368    |     104'050     |         99.4% |
+|            |              |        |        |              |                 |               |
+| `f32` x256 |      16      |   64   |   32   |   128'644    |     228'422     |         97.2% |
+| `f32` x256 |      16      |  256   |  128   |    39'981    |     69'065      |         99.2% |
+|            |              |        |        |              |                 |               |
+| `f16` x256 |      16      |   64   |   32   |   128'644    |     228'422     |         97.2% |
+| `f32` x256 |      16      |  256   |  128   |    39'981    |     69'065      |         99.2% |
+
+The main columns are:
+
+- Add: Number of insertion Queries Per Second.
+- Search: Number search Queries Per Second.
+- Recall @1: How often does approximate search yield the exact best match?
+
+To read more and reproduce, jump to [benchmarking section](#benchmarking).
 
 ## Usage
 
@@ -91,22 +187,41 @@ index.view("index.usearch"); // Memory-mapping from disk
 ```
 
 The `add` is thread-safe for concurrent index construction.
+For advanced users, more compile-time abstraction are available.
+
+```cpp
+template <typename metric_at = ip_gt<float>,            //
+          typename label_at = std::size_t,              // `uint32_t`, `uuid_t`...
+          typename id_at = std::uint32_t,               // `uint40_t`, `uint64_t`...
+          typename scalar_at = float,                   // `double`, `half`, `char`...
+          typename allocator_at = std::allocator<char>> //
+class index_gt;
+```
+
+One may also define a custom metric, such as Damerau–Levenshtein distance, to compute the similarity between variable length strings.
+The only constraint is the function signature:
+
+```cpp
+struct custom_metric_t {
+    T operator()(T const* a, T const* b, std::size_t a_length, std::size_t b_length) const;
+};
+```
 
 ### Python
 
 Python bindings are implemented with [`pybind/pybind11`](https://github.com/pybind/pybind11).
 Assuming the presence of Global Interpreter Lock in Python, on large insertions we spawn threads in the C++ layer.
 
-```sh
+```python
 $ pip install usearch
 
 import numpy as np
 import usearch
 
 index = usearch.Index(
-    dim=256, # Define the number of dimensions in input vectors
+    ndim=256, # Define the number of dimensions in input vectors
     metric='cos', # Choose the "metric" or "distance", default = 'ip', optional
-    dtype='f16', # Quantize to 'f16' or 'i8q100' if needed, default = 'f32', optional
+    dtype='f32', # Quantize to 'f16' or 'i8q100' if needed, default = 'f32', optional
     connectivity=16, # How frequent should the connections in the graph be, optional
     expansion_add=128, # Control the recall of indexing, optional
     expansion_search=64, # Control the quality of search, optional
@@ -125,13 +240,184 @@ assert len(index) == n
 matches, distances, counts = index.search(vectors, 10)
 ```
 
-## Features
+### JavaScript
 
-### Bring your Threads
+```js
+// npm install usearch
 
-## Performance
+var index = new usearch.Index({ metric: 'cos', connectivity: 16, dimensions: 2 })
+assert.equal(index.connectivity(), 16)
+assert.equal(index.dimensions(), 2)
+assert.equal(index.size(), 0)
+
+index.add(15, new Float32Array([10, 20]))
+assert.equal(index.size(), 2)
+
+var results = index.search(new Float32Array([13, 14]), 2)
+assert.deepEqual(results.labels, new Uint32Array([15, 16]))
+assert.deepEqual(results.distances, new Float32Array([45, 130]))
+```
+
+### Rust
+
+Being a systems-programming language, Rust has better control over memory management and concurrency, but lacks function overloading.
+Aside from the `add` and `search`, it also provides `add_in_thread` and `search_in_thread` which let users identify the calling thread to use underlying temporary memory more efficiently.
+
+```rust
+// cargo add usearch
+
+let quant: &str = "f16";
+let index = new_ip(5,  &quant, 0, 0, 0).unwrap();
+
+assert!(index.reserve(10).is_ok());
+assert!(index.capacity() >= 10);
+assert!(index.connectivity() != 0);
+assert_eq!(index.dimensions(), 5);
+assert_eq!(index.size(), 0);
+
+let first: [f32; 5] = [0.2, 0.1, 0.2, 0.1, 0.3];
+let second: [f32; 5] = [0.2, 0.1, 0.2, 0.1, 0.3];
+
+assert!(index.add(42, &first).is_ok());
+assert!(index.add(43, &second).is_ok());
+assert_eq!(index.size(), 2);
+
+// Read back the tags
+let results = index.search(&first, 10).unwrap();
+assert_eq!(results.count, 2);
+
+// Validate serialization
+assert!(index.save("index.usearch").is_ok());
+assert!(index.load("index.usearch").is_ok());
+assert!(index.view("index.usearch").is_ok());
+
+// There are more "metrics" available
+assert!(new_l2(5,  &quant, 0, 0, 0).is_ok());
+assert!(new_cos(5,  &quant, 0, 0, 0).is_ok());
+assert!(new_haversine(&quant, 0, 0, 0).is_ok());
+```
+
+### Java
+
+```java
+Index index = new Index.Config().metric("cos").dimensions(2).build();
+float vec[] = {10, 20};
+index.add(42, vec);
+int[] labels = index.search(vec, 5);
+```
+
+### GoLang
+
+### Wolfram
+
+## Benchmarking
+
+All major HNSW implementation share an identical list of hyper-parameters:
+
+- connectivity (often called `M`),
+- expansion on additions (often called `efConstruction`),
+- expansion on search (often called `ef`).
+
+The default values vary drastically.
+
+|  Library  | Connectivity | EF @ A | EF @ S |
+| :-------: | :----------: | :----: | :----: |
+| `hnswlib` |      16      |  200   |   10   |
+|  `FAISS`  |      32      |   40   |   16   |
+| `USearch` |      16      |  128   |   64   |
+
+
+To achieve best results, please compile locally and check out various configuration options.
+
+```sh
+cmake -B ./build_release \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DUSEARCH_USE_OPENMP=1 \
+    -DUSEARCH_USE_JEMALLOC=1 && \
+    make -C ./build_release -j
+
+./build_release/bench --help
+```
+
+Which would print the following instructions:
+
+```txt
+SYNOPSIS
+        ./build_release/bench [--vectors <path>] [--queries <path>] [--neighbors <path>] [-b] [-j
+                              <integer>] [-c <integer>] [--expansion-add <integer>]
+                              [--expansion-search <integer>] [--native|--f16quant|--i8quant]
+                              [--ip|--l2|--cos|--haversine] [-h]
+
+OPTIONS
+        --vectors <path>
+                    .fbin file path to construct the index
+
+        --queries <path>
+                    .fbin file path to query the index
+
+        --neighbors <path>
+                    .ibin file path with ground truth
+
+        -b, --big   Will switch to uint40_t for neighbors lists with over 4B entries
+        -j, --threads <integer>
+                    Uses all available cores by default
+
+        -c, --connectivity <integer>
+                    Index granularity
+
+        --expansion-add <integer>
+                    Affects indexing depth
+
+        --expansion-search <integer>
+                    Affects search depth
+
+        --native    Use raw templates instead of type-punned classes
+        --f16quant  Enable `f16_t` quantization
+        --i8quant   Enable `int8_t` quantization
+        --ip        Choose Inner Product metric
+        --l2        Choose L2 Euclidean metric
+        --cos       Choose Angular metric
+        --haversine Choose Haversine metric
+        -h, --help  Print this help information on this tool and exit
+```
 
 ## TODO
 
 - JavaScript: Allow calling from "worker threads".
 - Rust: Allow passing a custom thread ID.
+
+## AI + Vector Search = Semantic Search
+
+AI has a growing number of applications, but one of the coolest classic ideas is to use it for Semantic Search.
+One can take an encoder model, like the multi-modal UForm, and a web-programming framework, like UCall, and build an image search platform in just 20 lines of Python.
+
+```python
+import ucall.rich_posix as ucall
+import uform
+import usearch
+
+import numpy as np
+from PIL import Image
+
+server = ucall.Server()
+model = uform.get_model('unum-cloud/uform-vl-multilingual')
+index = usearch.Index(ndim=256)
+
+@server
+def add(label: int, photo: Image.Image):
+    image = model.preprocess_image(photo)
+    vector = model.encode_image(image).detach().numpy()
+    labels = np.array([label], dtype=np.longlong)
+    index.add(labels, vector, copy=True)
+
+@server
+def search(query: str) -> np.ndarray:
+    tokens = model.preprocess_text(query)
+    vector = model.encode_text(tokens).detach().numpy()
+    neighbors = index.search(vector, 3)
+    return neighbors[0][:neighbors[2][0]]
+
+server.run()
+```
+
+Check [that](https://github.com/ashvardanian/image-search) and [other](https://github.com/unum-cloud/examples) examples on our corporate GitHub 🤗

package/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.10

package/build.gradle

@@ -90,7 +90,7 @@ publishing {
 
             pom {
                 name = "USearch"
-                description = "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration"
+                description = "Smaller & Faster Single-File Vector Search Engine from Unum"
                 url = "https://github.com/unum-cloud/usearch"
                 licenses {
                     license {

package/include/usearch/usearch.hpp

@@ -136,6 +136,30 @@ template <typename scalar_at> struct l2_squared_gt {
     }
 };
 
+/**
+ *  @brief  Hamming distance computes the number of differing elements in
+ *          two arrays. An example would be a chess board.
+ */
+template <typename scalar_at> struct hamming_gt {
+    using scalar_t = scalar_at;
+    using result_type = std::size_t;
+
+    inline std::size_t operator()(scalar_t const* a, scalar_t const* b, std::size_t elements,
+                                  std::size_t = 0) const noexcept {
+        std::size_t matches{};
+#if defined(__GNUC__)
+#pragma GCC ivdep
+#elif defined(__clang__)
+#pragma clang loop vectorize(enable)
+#elif defined(_OPENMP)
+#pragma omp simd reduction(+ : matches)
+#endif
+        for (std::size_t i = 0; i != elements; ++i)
+            matches += a[i] != b[i];
+        return matches;
+    }
+};
+
 /**
  *  @brief  Hamming distance computes the number of differing bits in
  *          two arrays of integers. An example would be a textual document,

package/java/test/IndexTest.java

@@ -19,7 +19,12 @@ public class IndexTest {
     public void test() {
         String path = "./tmp/";
         deleteDirectoryFiles(path);
-        // new Index("cos", "f32", 1, 10, 1, 1, 1);
+
+        // Index index = new Index.Config().metric("cos").dimensions(2).build();
+        // float vec[] = {10, 20};
+        // index.add(42, vec);
+        // int[] labels = index.search(vec, 5);
+
         System.out.println("Java Tests Passed!");
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "usearch",
-    "version": "0.1.8",
-    "description": "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration",
+    "version": "0.1.10",
+    "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
     "repository": {

package/python/bench.py

@@ -1,89 +1,62 @@
 import datetime
 import numpy as np
+import fire
+
+from usearchh.io import load_matrix
 
 import faiss
 import usearch
 
 
-print('Welcome to basic kANN benchmark!')
-
-
-def read_matrix(filename: str, start_row: int = 0, count_rows: int = None):
-    """
-    Read *.ibin, *.hbin, *.fbin, *.dbin files with matrixes.
-    Args:
-        :param filename (str): path to the matrix file
-        :param start_row (int): start reading vectors from this index
-        :param count_rows (int): number of vectors to read. If None, read all vectors
-    Returns:
-        Parsed matrix (numpy.ndarray)
-    """
-    dtype = np.float32
-    scalar_size = 4
-    if filename.endswith('.fbin'):
-        dtype = np.float32
-        scalar_size = 4
-    elif filename.endswith('.dbin'):
-        dtype = np.float64
-        scalar_size = 8
-    elif filename.endswith('.hbin'):
-        dtype = np.float16
-        scalar_size = 2
-    elif filename.endswith('.ibin'):
-        dtype = np.int32
-        scalar_size = 4
-    else:
-        raise Exception('Unknown file type')
-    with open(filename, 'rb') as f:
-        rows, cols = np.fromfile(f, count=2, dtype=np.int32)
-        rows = (rows - start_row) if count_rows is None else count_rows
-        arr = np.fromfile(
-            f, count=rows * cols, dtype=dtype,
-            offset=start_row * scalar_size * cols)
-    return arr.reshape(rows, cols)
-
-
-print('Will read datasets!')
-xb = read_matrix('datasets/wiki_1M/base.1M.fbin')
-xq = read_matrix('datasets/wiki_1M/query.public.100K.fbin')
-
-d = 256  # vector size
-M = 16
-efSearch = 32  # number of entry points (neighbors) we use on each layer
-efConstruction = 128  # number of entry points used on each layer
-labels = np.arange(xb.shape[0], dtype=np.longlong)
-print('Will benchmark algorithms!')
-
-
 def measure(f) -> float:
     a = datetime.datetime.now()
     f()
     b = datetime.datetime.now()
     c = b - a
-    print(f'Took: {c.seconds} seconds')
+    print(f'Took: {c.seconds:.2f} seconds')
     return c.seconds
 
 
-def construct_both() -> tuple:
+def bench_faiss(index, vectors: np.array, queries: np.array, neighbors: np.array):
+    dt = measure(lambda: index.add(vectors))
+    print(f'- FAISS: {vectors.shape[0]/dt:.2f} vectors/s')
 
-    index_meta = faiss.IndexHNSWFlat(d, M)
-    index_meta.hnsw.efSearch = efSearch
-    index_meta.hnsw.efConstruction = efConstruction
-    dt_meta = measure(lambda: index_meta.add(xb))
 
-    index_unum = usearch.make_index(
-        expansion_add=efConstruction,
-        expansion_search=efSearch,
-        connectivity=M,
-    )
-    dt_unum = measure(lambda: index_unum.add(labels, xb, copy=False))
+def bench_usearch(index, vectors: np.array, queries: np.array, neighbors: np.array):
+    labels = np.arange(vectors.shape[0], dtype=np.longlong)
+    assert len(index) == 0
+    dt = measure(lambda: index.add(labels, vectors))
+    assert len(index) == vectors.shape[0]
+    print(f'- USearch: {vectors.shape[0]/dt:.2f} vectors/s')
+
+
+def main(
+    vectors: str,
+    queries: str,
+    neighbors: str,
+    connectivity: int = 16,
+    expansion_add: int = 128,
+    expansion_search: int = 64,
+):
 
-    return dt_meta, dt_unum
+    vectors_mat = load_matrix(vectors)
+    queries_mat = load_matrix(queries)
+    neighbors_mat = load_matrix(neighbors)
+    dim = vectors_mat.shape[1]
+
+    index = faiss.IndexHNSWFlat(dim, connectivity)
+    index.hnsw.efSearch = expansion_search
+    index.hnsw.efConstruction = expansion_add
+    bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
+
+    index = usearch.Index(
+        ndim=dim,
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
 
-experiments = 10
-durations = [construct_both() for _ in range(experiments)]
-dt_meta = sum(x[0] for x in durations)
-dt_unum = sum(x[1] for x in durations)
-print(f'- FAISS vectors per second: {xb.shape[0]*experiments/dt_meta:.2f}')
-print(f'- USearch vectors per second: {xb.shape[0]*experiments/dt_unum:.2f}')
+if __name__ == '__main__':
+    fire.Fire(main)

package/python/lib.cpp

@@ -36,7 +36,8 @@ static native_index_t make_index(   //
     std::string const& metric,      //
     std::size_t connectivity,       //
     std::size_t expansion_add,      //
-    std::size_t expansion_search    //
+    std::size_t expansion_search,   //
+    std::size_t metric_uintptr      //
 ) {
 
     config_t config;
@@ -48,7 +49,11 @@ static native_index_t make_index(   //
     config.max_threads_search = std::thread::hardware_concurrency();
 
     accuracy_t accuracy = accuracy_from_name(scalar_type.c_str(), scalar_type.size());
-    return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
+    punned_metric_t metric_ptr = reinterpret_cast<punned_metric_t>(metric_uintptr);
+    if (metric_ptr)
+        return native_index_t::udf(dimensions, metric_ptr, accuracy, config);
+    else
+        return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
 }
 
 static void add_to_index(native_index_t& index, py::buffer labels, py::buffer vectors, bool copy) {
@@ -173,15 +178,16 @@ PYBIND11_MODULE(usearch, m) {
 
     auto i = py::class_<native_index_t>(m, "Index");
 
-    i.def(py::init(&make_index),                                             //
-          py::kw_only(),                                                     //
-          py::arg("dim"),                                                    //
-          py::arg("capacity") = 0,                                           //
-          py::arg("dtype") = std::string("f32"),                             //
-          py::arg("metric") = std::string("ip"),                             //
-          py::arg("connectivity") = config_t::connectivity_default_k,        //
-          py::arg("expansion_add") = config_t::expansion_add_default_k,      //
-          py::arg("expansion_search") = config_t::expansion_search_default_k //
+    i.def(py::init(&make_index),                                              //
+          py::kw_only(),                                                      //
+          py::arg("ndim"),                                                    //
+          py::arg("capacity") = 0,                                            //
+          py::arg("dtype") = std::string("f32"),                              //
+          py::arg("metric") = std::string("ip"),                              //
+          py::arg("connectivity") = config_t::connectivity_default_k,         //
+          py::arg("expansion_add") = config_t::expansion_add_default_k,       //
+          py::arg("expansion_search") = config_t::expansion_search_default_k, //
+          py::arg("metric_pointer") = 0                                       //
     );
 
     i.def(                     //