usearch 0.18.8 → 0.19.1

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "0.18.8"
+version = "0.19.1"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -251,7 +251,7 @@ index = Index(
     expansion_search=64, # Control the quality of search, optional
 )
 
-vector = np.array([0.2, 0.6, 0.4], dtype=np.float32)
+vector = np.array([0.2, 0.6, 0.4])
 index.add(42, vector)
 matches, distances, count = index.search(vector, 10)
 
@@ -259,6 +259,7 @@ assert len(index) == 1
 assert count == 1
 assert matches[0] == 42
 assert distances[0] <= 0.001
+assert np.allclose(index[42], vector)
 ```
 
 Python bindings are implemented with [`pybind/pybind11`](https://github.com/pybind/pybind11).
@@ -272,6 +273,13 @@ index.load('index.usearch') # Copy the whole index into memory
 index.view('index.usearch') # View from disk without loading in memory
 ```
 
+If you don't know anything about the index except its path, there are two more endpoints to know:
+
+```py
+Index.metadata('index.usearch') -> IndexMetadata
+Index.restore('index.usearch', view=False) -> Index
+```
+
 #### Batch Operations
 
 Adding or querying a batch of entries is identical to adding a single vector.
@@ -294,7 +302,9 @@ The first controls the number of threads spawned for the task.
 The second controls whether the vector itself will be persisted inside the index.
 If you can preserve the lifetime of the vector somewhere else, you can avoid the copy.
 
-#### User-Defined Metrics in Python
+#### User-Defined Metrics and JIT in Python
+
+##### [Numba][numba]
 
 Assuming the language boundary exists between Python user code and C++ implementation, there are more efficient solutions than passing a Python callable to the engine.
 Luckily, with the help of [Numba][numba], we can JIT compile a function with a matching signature and pass it down to the engine.
@@ -308,7 +318,7 @@ signature = types.float32(
     types.CPointer(types.float32))
 
 @cfunc(signature)
-def python_dot(a, b):
+def inner_product(a, b):
     a_array = carray(a, ndim)
     b_array = carray(b, ndim)
     c = 0.0
@@ -316,19 +326,161 @@ def python_dot(a, b):
         c += a_array[i] * b_array[i]
     return 1 - c
 
-index = Index(ndim=ndim, metric=python_dot.address)
+index = Index(ndim=ndim, metric=CompiledMetric(
+    pointer=inner_product.address,
+    kind=MetricKind.IP,
+    signature=MetricSignature.ArrayArray,
+))
 ```
 
-To use Numba JIT, install USearch with extras:
+Alternatively, you can avoid pre-defining the number of dimensions, and pass it separately:
+
+```py
+signature = types.float32(
+    types.CPointer(types.float32),
+    types.CPointer(types.float32),
+    types.uint64)
+
+@cfunc(signature)
+def inner_product(a, b, ndim):
+    a_array = carray(a, ndim)
+    b_array = carray(b, ndim)
+    c = 0.0
+    for i in range(ndim):
+        c += a_array[i] * b_array[i]
+    return 1 - c
+
+index = Index(ndim=ndim, metric=CompiledMetric(
+    pointer=inner_product.address,
+    kind=MetricKind.IP,
+    signature=MetricSignature.ArrayArraySize,
+))
+```
+
+```sh
+pip install numba
+```
+
+##### [Cppyy][cppyy]
+
+Similarly, you can use Cppyy with Cling to JIT-compile native C or C++ code and pass it to USearch, which may be a good idea, if you want to explicitly request loop-unrolling or other low-level optimizations!
+
+```py
+import cppyy
+import cppyy.ll
+
+cppyy.cppdef("""
+float inner_product(float *a, float *b) {
+    float result = 0;
+#pragma unroll
+    for (size_t i = 0; i != ndim; ++i)
+        result += a[i] * b[i];
+    return 1 - result;
+}
+""".replace("ndim", str(ndim)))
+
+function = cppyy.gbl.inner_product
+index = Index(ndim=ndim, metric=CompiledMetric(
+    pointer=cppyy.ll.addressof(function),
+    kind=MetricKind.IP,
+    signature=MetricSignature.ArrayArraySize,
+))
+```
 
 ```sh
-pip install usearch[jit]
+conda install -c conda-forge cppyy
+```
+
+##### [PeachPy][peachpy]
+
+We have covered JIT-ing Python with Numba and C++ with Cppyy and Cling.
+How about writing Assembly directly?
+That is also possible.
+Below is an example of constructing the "Inner Product" distance for 8-dimensional `f32` vectors for x86 using [PeachPy][peachpy].
+
+```py
+from peachpy import (
+    Argument,
+    ptr,
+    float_,
+    const_float_,
+)
+from peachpy.x86_64 import (
+    abi,
+    Function,
+    uarch,
+    isa,
+    GeneralPurposeRegister64,
+    LOAD,
+    YMMRegister,
+    VSUBPS,
+    VADDPS,
+    VHADDPS,
+    VMOVUPS,
+    VFMADD231PS,
+    VPERM2F128,
+    VXORPS,
+    RETURN,
+)
+
+a = Argument(ptr(const_float_), name="a")
+b = Argument(ptr(const_float_), name="b")
+
+with Function(
+    "inner_product", (a, b), float_, target=uarch.default + isa.avx2
+) as asm_function:
+    
+    # Request two 64-bit general-purpose registers for addresses
+    reg_a, reg_b = GeneralPurposeRegister64(), GeneralPurposeRegister64()
+    LOAD.ARGUMENT(reg_a, a)
+    LOAD.ARGUMENT(reg_b, b)
+
+    # Load the vectors
+    ymm_a = YMMRegister()
+    ymm_b = YMMRegister()
+    VMOVUPS(ymm_a, [reg_a])
+    VMOVUPS(ymm_b, [reg_b])
+
+    # Prepare the accumulator
+    ymm_c = YMMRegister()
+    ymm_one = YMMRegister()
+    VXORPS(ymm_c, ymm_c, ymm_c)
+    VXORPS(ymm_one, ymm_one, ymm_one)
+
+    # Accumulate A and B product into C
+    VFMADD231PS(ymm_c, ymm_a, ymm_b)
+
+    # Reduce the contents of a YMM register
+    ymm_c_permuted = YMMRegister()
+    VPERM2F128(ymm_c_permuted, ymm_c, ymm_c, 1)
+    VADDPS(ymm_c, ymm_c, ymm_c_permuted)
+    VHADDPS(ymm_c, ymm_c, ymm_c)
+    VHADDPS(ymm_c, ymm_c, ymm_c)
+
+    # Negate the values, to go from "similarity" to "distance"
+    VSUBPS(ymm_c, ymm_one, ymm_c)
+
+    # A common convention is to return floats in XMM registers
+    RETURN(ymm_c.as_xmm)
+
+python_function = asm_function.finalize(abi.detect()).encode().load()
+metric = CompiledMetric(
+    pointer=python_function.loader.code_address,
+    kind=MetricKind.IP,
+    signature=MetricSignature.ArrayArray,
+)
+index = Index(ndim=ndim, metric=metric)
 ```
 
 [numba]: https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
+[cppyy]: https://cppyy.readthedocs.io/en/latest/
+[peachpy]: https://github.com/Maratyszcza/PeachPy
 
 #### Tooling
 
+To work with `bbin`, `fbin`, `ibin`, `hbin` matrix files USearch provides `load_matrix` and `save_matrix`.
+Such files are standard in k-ANN tasks and represent a binary object with all the scalars, prepended by two 32-bit integers - the number of rows and columns in the matrix.
+
 ```py
 from usearch.index import Index
 from usearch.io import load_matrix, save_matrix
@@ -338,6 +490,28 @@ index = Index(ndim=vectors.shape[1])
 index.add(labels, vectors)
 ```
 
+One may often want to evaluate the quality of the constructed index before running in production.
+The trivial way is to measure `recall@1` on the entries already present in the index.
+
+```py
+from usearch.eval import recall_members
+
+assert recall_members(index, exact=True) == 1
+print(recall_members(index, exact=False))
+```
+
+In case you have some ground-truth data for more than one entry, you compare search results against expected values:
+
+```py
+from usearch.eval import relevance, dcg, ndcg, random_vectors
+
+vectors = random_vectors(index=index)
+matches_approximate = index.search(vectors)
+matches_exact = index.search(vectors, exact=True)
+relevance_scores = relevance(matches_exact, matches_approximate)
+print(dcg(relevance_scores), ndcg(relevance_scores))
+```
+
 ### JavaScript
 
 #### Installation
@@ -471,6 +645,7 @@ https://github.com/unum-cloud/usearch
 let index = Index.l2sq(dimensions: 3, connectivity: 8)
 let vectorA: [Float32] = [0.3, 0.5, 1.2]
 let vectorB: [Float32] = [0.4, 0.2, 1.2]
+index.reserve(2)
 index.add(label: 42, vector: vectorA[...])
 index.add(label: 43, vector: vectorB[...])
 
@@ -547,22 +722,16 @@ server.run()
 
 We have pre-processed some commonly used datasets, cleaning the images, producing the vectors, and pre-building the index.
 
-| Dataset                             | Size | Images |          Preprocessed |
-| :---------------------------------- | ---: | -----: | --------------------: |
-| [Unsplash 25K][unsplash-25k-origin] |    - |   25 K | [HF][unsplash-25k-hf] |
-| [Unsplash 2M][unsplash-2m-origin]   |    - |    2 M |  [HF][unsplash-2m-hf] |
-| [LAION 400M][laion-400m-origin]     |    - |  400 M |   [HF][laion-400m-hf] |
-| [LAION 5B][laion-5b-origin]         |    - |    5 B |     [HF][laion-5b-hf] |
+| Dataset                              | Size | Images |          Preprocessed |
+| :----------------------------------- | ---: | -----: | --------------------: |
+| [Unsplash 25K][unsplash-25k-origin]  |    - |   25 K | [HF][unsplash-25k-hf] |
+| [Createve Captions 3M][cc-3m-origin] |    - |    3 M |        [HF][cc-3m-hf] |
 
 
 [unsplash-25k-origin]: https://unum.cloud
-[unsplash-2m-origin]: https://unum.cloud
-[laion-400m-origin]: https://unum.cloud
-[laion-5b-origin]: https://unum.cloud
+[cc-3m-origin]: https://unum.cloud
 [unsplash-25k-hf]: https://unum.cloud
-[unsplash-2m-hf]: https://unum.cloud
-[laion-400m-hf]: https://unum.cloud
-[laion-5b-hf]: https://unum.cloud
+[cc-3m-hf]: https://unum.cloud
 
 ### USearch + RDKit = Molecular Search
 
@@ -593,31 +762,9 @@ index.add(labels, fingerprints)
 matches = index.search(fingerprints, 10)
 ```
 
-RDKit [provides][rdkit-fingerprints] following fingerprinting techniques:
-
-- Atom-Pair, 
-- Topological Torsion, 
-- Morgan,
-- Layered Fingerprints.
-
-We have preprocessed some of the most commonly used datasets, and made it available for free on the HuggingFace portal, together with visual interface.
-
-| Dataset                   |     Size |   Molecules |     Preprocessed |
-| :------------------------ | -------: | ----------: | ---------------: |
-| [PubChem][pubchem-origin] |     8 GB | 115'034'339 | [HF][pubchem-hf] |
-| [GDB 13][gdb13-origin]    |   2.3 GB | 977'468'301 |   [HF][gdb13-hf] |
-| [REAL][real-origin]       | > 100 GB |         6 B |    [HF][real-hf] |
-
 [smiles]: https://en.wikipedia.org/wiki/Simplified_molecular-input_line-entry_system
 [rdkit-fingerprints]: https://www.rdkit.org/docs/RDKit_Book.html#additional-information-about-the-fingerprints
 
-[gdb13-origin]: https://zenodo.org/record/5172018/files/gdb13.tgz?download=1
-[pubchem-origin]: ftp://ftp.ncbi.nlm.nih.gov/pubchem/Compound/Extras/CID-SMILES.gz
-[real-origin]: https://enamine.net/compound-collections/real-compounds/real-database
-[pubchem-hf]: https://unum.cloud
-[gdb13-hf]: https://unum.cloud
-[real-hf]: https://unum.cloud
-
 ## TODO
 
 - JavaScript: Allow calling from "worker threads".

package/c/lib.cpp

@@ -1,4 +1,6 @@
-#include "../src/index_punned_dense.hpp"
+#include <cassert>
+
+#include <usearch/index_punned_dense.hpp>
 
 extern "C" {
 #include "usearch.h"
@@ -12,10 +14,11 @@ using distance_t = usearch_distance_t;
 using index_t = index_punned_dense_gt<label_t>;
 using add_result_t = index_t::add_result_t;
 using search_result_t = index_t::search_result_t;
-using seerialization_result_t = index_t::seerialization_result_t;
+using serialization_result_t = index_t::serialization_result_t;
 
 using span_t = span_gt<float>;
 
+// helper functions that are not part of the C ABI
 metric_kind_t to_native_metric(usearch_metric_kind_t kind) {
     switch (kind) {
     case usearch_metric_ip_k: return metric_kind_t::ip_k;
@@ -37,30 +40,76 @@ scalar_kind_t to_native_scalar(usearch_scalar_kind_t kind) {
     case usearch_scalar_f64_k: return scalar_kind_t::f64_k;
     case usearch_scalar_f16_k: return scalar_kind_t::f16_k;
     case usearch_scalar_f8_k: return scalar_kind_t::f8_k;
-    case usearch_scalar_b1_k: return scalar_kind_t::b1_k;
+    case usearch_scalar_b1_k: return scalar_kind_t::b1x8_k;
     default: return scalar_kind_t::unknown_k;
     }
 }
 
-void usearch_init(usearch_init_options_t* options, usearch_index_t* index, usearch_error_t* error) {
+add_result_t add_(index_t* index, usearch_label_t label, void const* vector, scalar_kind_t kind) {
+    switch (kind) {
+    case scalar_kind_t::f32_k: return index->add(label, (f32_t const*)vector);
+    case scalar_kind_t::f64_k: return index->add(label, (f64_t const*)vector);
+    case scalar_kind_t::f16_k: return index->add(label, (f16_t const*)vector);
+    case scalar_kind_t::f8_k: return index->add(label, (f8_bits_t const*)vector);
+    case scalar_kind_t::b1x8_k: return index->add(label, (b1x8_t const*)vector);
+    default: return add_result_t{}.failed("Unknown scalar kind!");
+    }
+}
+
+bool get_(index_t* index, label_t label, void* vector, scalar_kind_t kind) {
+    switch (kind) {
+    case scalar_kind_t::f32_k: return index->get(label, (f32_t*)vector);
+    case scalar_kind_t::f64_k: return index->get(label, (f64_t*)vector);
+    case scalar_kind_t::f16_k: return index->get(label, (f16_t*)vector);
+    case scalar_kind_t::f8_k: return index->get(label, (f8_bits_t*)vector);
+    case scalar_kind_t::b1x8_k: return index->get(label, (b1x8_t*)vector);
+    default: return index->empty_search_result().failed("Unknown scalar kind!");
+    }
+}
+
+search_result_t search_(index_t* index, void const* vector, scalar_kind_t kind, size_t n) {
+    switch (kind) {
+    case scalar_kind_t::f32_k: return index->search((f32_t const*)vector, n);
+    case scalar_kind_t::f64_k: return index->search((f64_t const*)vector, n);
+    case scalar_kind_t::f16_k: return index->search((f16_t const*)vector, n);
+    case scalar_kind_t::f8_k: return index->search((f8_bits_t const*)vector, n);
+    case scalar_kind_t::b1x8_k: return index->search((b1x8_t const*)vector, n);
+    default: return index->empty_search_result().failed("Unknown scalar kind!");
+    }
+}
+
+index_punned_dense_metric_t udf(metric_kind_t kind, usearch_metric_t raw_ptr) {
+    index_punned_dense_metric_t result;
+    result.kind_ = kind;
+    result.func_ = [raw_ptr](punned_vector_view_t a, punned_vector_view_t b) -> distance_t {
+        return raw_ptr((void const*)a.data(), (void const*)b.data());
+    };
+    return result;
+}
+
+extern "C" {
 
-    config_t config;
-    config.expansion_add = static_cast<std::size_t>(expansion_add);
-    config.expansion_search = static_cast<std::size_t>(expansion_search);
-    config.connectivity = static_cast<std::size_t>(connectivity);
-    config.max_elements = static_cast<std::size_t>(capacity);
-    config.max_threads_add = std::thread::hardware_concurrency();
-    config.max_threads_search = std::thread::hardware_concurrency();
+usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
 
-    scalar_kind_t accuracy = scalar_kind_from_name(accuracy_str, accuracy_len);
-    metric_kind_t metric_kind = metric_from_name(metric_str, metric_len);
-    index_t index = index_t::make(metric_kind, static_cast<std::size_t>(dimensions), accuracy, config);
+    assert(options && error);
+
+    index_config_t config;
+    config.connectivity = options->connectivity;
+    index_t index =        //
+        options->metric ?  //
+            index_t::make( //
+                options->dimensions, udf(to_native_metric(options->metric_kind), options->metric), config,
+                to_native_scalar(options->quantization), options->expansion_add, options->expansion_search)
+                        :  //
+            index_t::make( //
+                options->dimensions, to_native_metric(options->metric_kind), config,
+                to_native_scalar(options->quantization), options->expansion_add, options->expansion_search);
 
     index_t* result_ptr = new index_t(std::move(index));
     return result_ptr;
 }
 
-void usearch_free(index_t* index) { delete index; }
+void usearch_free(usearch_index_t index, usearch_error_t*) { delete reinterpret_cast<index_t*>(index); }
 
 void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->save(path);
@@ -101,17 +150,6 @@ void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t*) {
     reinterpret_cast<index_t*>(index)->reserve(capacity);
 }
 
-add_result_t add_(index_t* index, usearch_label_t label, void const* vector, scalar_kind_t kind) {
-    switch (kind) {
-    case scalar_kind_t::f32_k: return index->add(label, (f32_t const*)vector);
-    case scalar_kind_t::f64_k: return index->add(label, (f64_t const*)vector);
-    case scalar_kind_t::f16_k: return index->add(label, (f16_t const*)vector);
-    case scalar_kind_t::f8_k: return index->add(label, (f8_bits_t const*)vector);
-    case scalar_kind_t::b1x8_k: return index->add(label, (b1x8_t const*)vector);
-    default: return add_result_t{}.failed("Unknown scalar kind!");
-    }
-}
-
 void usearch_add(                                                                                 //
     usearch_index_t index, usearch_label_t label, void const* vector, usearch_scalar_kind_t kind, //
     usearch_error_t* error) {
@@ -121,18 +159,7 @@ void usearch_add(
 }
 
 bool usearch_contains(usearch_index_t index, usearch_label_t label, usearch_error_t*) {
-    reinterpret_cast<index_t*>(index)->contains(label);
-}
-
-search_result_t search_(index_t* index, void const* vector, scalar_kind_t kind, size_t n) {
-    switch (kind) {
-    case scalar_kind_t::f32_k: return index->search((f32_t const*)vector, n);
-    case scalar_kind_t::f64_k: return index->search((f64_t const*)vector, n);
-    case scalar_kind_t::f16_k: return index->search((f16_t const*)vector, n);
-    case scalar_kind_t::f8_k: return index->search((f8_bits_t const*)vector, n);
-    case scalar_kind_t::b1x8_k: return index->search((b1x8_t const*)vector, n);
-    default: return search_result_t{}.failed("Unknown scalar kind!");
-    }
+    return reinterpret_cast<index_t*>(index)->contains(label);
 }
 
 size_t usearch_search(                                                                           //
@@ -147,21 +174,14 @@ size_t usearch_search(
     return result.dump_to(found_labels, found_distances);
 }
 
-bool get_(index_t* index, void const* vector, scalar_kind_t kind) {
-    switch (kind) {
-    case scalar_kind_t::f32_k: return index->get((f32_t const*)vector, n);
-    case scalar_kind_t::f64_k: return index->get((f64_t const*)vector, n);
-    case scalar_kind_t::f16_k: return index->get((f16_t const*)vector, n);
-    case scalar_kind_t::f8_k: return index->get((f8_bits_t const*)vector, n);
-    case scalar_kind_t::b1x8_k: return index->get((b1x8_t const*)vector, n);
-    default: return search_result_t{}.failed("Unknown scalar kind!");
-    }
-}
-
 bool usearch_get(                                 //
     usearch_index_t index, usearch_label_t label, //
     void* vector, usearch_scalar_kind_t kind, usearch_error_t*) {
-    return search_(reinterpret_cast<index_t*>(index), vector, to_native_scalar(kind));
+    return get_(reinterpret_cast<index_t*>(index), label, vector, to_native_scalar(kind));
 }
 
-void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t*) {}
+void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t* error) {
+    if (error != nullptr)
+        *error = "USearch does not support removal of elements yet.";
+}
+}

package/c/test.c

@@ -0,0 +1,182 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "usearch.h"
+
+float* read_fvecs_file(const char* filename, size_t* num_vectors, size_t* vector_dim) {
+    struct stat st;
+    FILE* file;
+    size_t cnt;
+    float skip;
+
+    ;
+    if (stat(filename, &st) == -1) {
+        printf("Failed to read file: %s err: %d: %s\n", filename, errno, strerror(errno));
+        return NULL;
+    }
+
+    file = fopen(filename, "rb");
+    if (file == NULL) {
+        printf("Failed to open file: %s\n", filename);
+        return NULL;
+    }
+
+    // Read the number of vectors and vector dimension from the file
+    cnt = fread(vector_dim, sizeof(int), 1, file);
+    assert(cnt == 1);
+    if (st.st_size % ((*vector_dim + 1) * sizeof(float)) != 0) {
+        printf("File does not contain a whole number of vectors.\n Vector dim: %ld, file size: %ld\n", *vector_dim,
+               st.st_size);
+        fclose(file);
+        return NULL;
+    }
+
+    *num_vectors = st.st_size / ((*vector_dim + 1) * sizeof(float));
+
+    // Allocate memory for the array
+    float* data = (float*)malloc(*num_vectors * *vector_dim * sizeof(float));
+    if (data == NULL) {
+        printf("Memory allocation failed.\n");
+        fclose(file);
+        return NULL;
+    }
+
+    // Read the data from the file into the array
+    for (size_t i = 0; i < *num_vectors; i++) {
+        cnt = fread(data + i * *vector_dim, sizeof(float), *vector_dim, file);
+        assert(cnt == *vector_dim);
+        if (i == *num_vectors - 1) {
+            break;
+        }
+        cnt = fread(&skip, sizeof(float), 1, file);
+        assert(cnt == 1);
+    }
+
+    fclose(file);
+    return data;
+}
+
+// log every this many iterations in test loops
+const int LOG_GRANULARITY = 10000;
+
+void test_index(float* data, size_t num_vectors, size_t vector_dim) {
+    usearch_init_options_t opts;
+    usearch_index_t idx;
+    usearch_error_t error = NULL;
+    clock_t start;
+    opts.connectivity = 2; // 32 in faiss
+    opts.dimensions = vector_dim;
+    opts.expansion_add = 40;    // 40 in faiss
+    opts.expansion_search = 16; // 10 in faiss
+    opts.metric_kind = usearch_metric_ip_k;
+    opts.metric = NULL;
+    opts.quantization = usearch_scalar_f32_k;
+
+    // results arrays
+    int k = 10;
+    num_vectors /= 10;
+    usearch_label_t* labels = (usearch_label_t*)calloc(k, sizeof(usearch_label_t));
+    float* distances = (float*)calloc(k, sizeof(float));
+
+    fprintf(stderr, "read %ld vectors of dimension %ld\n", num_vectors, vector_dim);
+    fprintf(stderr, "initializing usearch...\n");
+    idx = usearch_init(&opts, &error);
+    if (error != NULL) {
+        fprintf(stderr, "usearch error: %s\n", error);
+        assert(false);
+    }
+
+    fprintf(stderr, "reserving capacity...\n");
+    usearch_reserve(idx, num_vectors, &error);
+    assert(!error);
+
+    fprintf(stderr, "adding vectors...\n");
+    for (size_t i = 0; i < num_vectors; i++) {
+        if (i % LOG_GRANULARITY == 0) {
+            fprintf(stderr, "added %ld vectors...\n", i);
+        }
+        usearch_label_t label = i;
+        usearch_add(idx, label, data + i * vector_dim, usearch_scalar_f32_k, &error);
+        assert(!error);
+    }
+
+    fprintf(stderr, "checking containment of vectors...\n");
+    for (size_t i = 0; i < num_vectors; i++) {
+        if (i % LOG_GRANULARITY == 0) {
+            fprintf(stderr, "checked %ld vectors...\n", i);
+        }
+        usearch_label_t label = i;
+        assert(usearch_contains(idx, label, &error));
+        assert(!error);
+    }
+
+    assert(!usearch_contains(idx, -1, &error));
+    assert(!error);
+
+    fprintf(stderr, "searching vectors...\n");
+    for (size_t i = 0; i < num_vectors; i++) {
+        if (i % LOG_GRANULARITY == 0) {
+            fprintf(stderr, "searched %ld vectors...\n", i);
+        }
+        const void *query_vector = data + i * vector_dim;
+        usearch_search(idx, query_vector, usearch_scalar_f32_k, k, labels, distances, &error);
+        assert(!error);
+    }
+
+    fprintf(stderr, "saving the index...\n");
+    start = clock();
+    usearch_save(idx, "usearch_index.bin", &error);
+    assert(!error);
+    fprintf(stderr, "saving took %.2f ms\n", ((double)(clock() - start)) / CLOCKS_PER_SEC * 1000);
+
+    fprintf(stderr, "destroying the index...\n");
+    start = clock();
+    usearch_free(idx, &error);
+    assert(!error);
+    fprintf(stderr, "destroying the index took %.2f ms\n", ((double)(clock() - start)) / CLOCKS_PER_SEC * 1000);
+
+    fprintf(stderr, "loading the index...\n");
+    start = clock();
+    idx = usearch_init(&opts, &error);
+    assert(!error);
+    assert(usearch_size(idx, &error) == 0);
+    assert(!error);
+    usearch_load(idx, "usearch_index.bin", &error);
+    assert(!error);
+    fprintf(stderr, "loading the index took %.2f ms\n", ((double)(clock() - start)) / CLOCKS_PER_SEC * 1000);
+    assert(usearch_size(idx, &error) == num_vectors);
+    assert(!error);
+    usearch_free(idx, &error);
+
+    fprintf(stderr, "viewing the index...\n");
+    start = clock();
+    idx = usearch_init(&opts, &error);
+    assert(!error);
+    assert(usearch_size(idx, &error) == 0);
+    assert(!error);
+    usearch_view(idx, "usearch_index.bin", &error);
+    assert(!error);
+    fprintf(stderr, "viewing the index took %.2f ms\n", ((double)(clock() - start)) / CLOCKS_PER_SEC * 1000);
+    assert(usearch_size(idx, &error) == num_vectors);
+    assert(!error);
+    usearch_free(idx, &error);
+
+}
+
+int main() {
+    const char* filename = "sift/sift_base.fvecs";
+    size_t num_vectors = 0, vector_dim = 0;
+    float* data = read_fvecs_file(filename, &num_vectors, &vector_dim);
+    if (data != NULL) {
+
+        test_index(data, num_vectors, vector_dim);
+
+        free(data); // Remember to free the dynamically allocated memory
+    }
+    return 0;
+}