usearch 0.2.3 → 0.4.0

package/javascript/lib.cpp

@@ -15,6 +15,8 @@
 #define NAPI_CPP_EXCEPTIONS
 #endif
 
+#include <new> // `std::bad_alloc`
+
 #include <napi.h>
 #include <node_api.h>
 
@@ -38,6 +40,10 @@ class Index : public Napi::ObjectWrap<Index> {
     Napi::Value GetCapacity(Napi::CallbackInfo const& ctx);
     Napi::Value GetConnectivity(Napi::CallbackInfo const& ctx);
 
+    void Save(Napi::CallbackInfo const& ctx);
+    void Load(Napi::CallbackInfo const& ctx);
+    void View(Napi::CallbackInfo const& ctx);
+
     void Add(Napi::CallbackInfo const& ctx);
     Napi::Value Search(Napi::CallbackInfo const& ctx);
 
@@ -54,6 +60,9 @@ Napi::Object Index::Init(Napi::Env env, Napi::Object exports) {
             InstanceMethod("connectivity", &Index::GetConnectivity),
             InstanceMethod("add", &Index::Add),
             InstanceMethod("search", &Index::Search),
+            InstanceMethod("save", &Index::Save),
+            InstanceMethod("load", &Index::Load),
+            InstanceMethod("view", &Index::View),
         });
 
     Napi::FunctionReference* constructor = new Napi::FunctionReference();
@@ -150,6 +159,57 @@ Napi::Value Index::GetCapacity(Napi::CallbackInfo const& ctx) {
     return Napi::Number::New(ctx.Env(), native_->capacity());
 }
 
+void Index::Save(Napi::CallbackInfo const& ctx) {
+    Napi::Env env = ctx.Env();
+
+    int length = ctx.Length();
+    if (length == 0 || !ctx[0].IsString()) {
+        Napi::TypeError::New(env, "Function expects a string path argument").ThrowAsJavaScriptException();
+        return;
+    }
+
+    try {
+        std::string path = ctx[0].As<Napi::String>();
+        native_->save(path.c_str());
+    } catch (...) {
+        Napi::TypeError::New(env, "Serialization failed").ThrowAsJavaScriptException();
+    }
+}
+
+void Index::Load(Napi::CallbackInfo const& ctx) {
+    Napi::Env env = ctx.Env();
+
+    int length = ctx.Length();
+    if (length == 0 || !ctx[0].IsString()) {
+        Napi::TypeError::New(env, "Function expects a string path argument").ThrowAsJavaScriptException();
+        return;
+    }
+
+    try {
+        std::string path = ctx[0].As<Napi::String>();
+        native_->load(path.c_str());
+    } catch (...) {
+        Napi::TypeError::New(env, "Loading failed").ThrowAsJavaScriptException();
+    }
+}
+
+void Index::View(Napi::CallbackInfo const& ctx) {
+    Napi::Env env = ctx.Env();
+
+    int length = ctx.Length();
+    if (length == 0 || !ctx[0].IsString()) {
+        Napi::TypeError::New(env, "Function expects a string path argument").ThrowAsJavaScriptException();
+        return;
+    }
+
+    try {
+        std::string path = ctx[0].As<Napi::String>();
+        native_->view(path.c_str());
+    } catch (...) {
+        Napi::TypeError::New(env, "Memory-mapping failed").ThrowAsJavaScriptException();
+    }
+}
+
 void Index::Add(Napi::CallbackInfo const& ctx) {
     Napi::Env env = ctx.Env();
     if (ctx.Length() < 2 || !ctx[0].IsNumber() || !ctx[1].IsTypedArray())
@@ -166,7 +226,14 @@ void Index::Add(Napi::CallbackInfo const& ctx) {
 
     if (native_->size() + 1 >= native_->capacity())
         native_->reserve(ceil2(native_->size() + 1));
-    native_->add(label, vector);
+
+    try {
+        native_->add(label, vector);
+    } catch (std::bad_alloc const&) {
+        Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
+    } catch (...) {
+        Napi::TypeError::New(env, "Insertion failed").ThrowAsJavaScriptException();
+    }
 }
 
 Napi::Value Index::Search(Napi::CallbackInfo const& ctx) {
@@ -190,13 +257,20 @@ Napi::Value Index::Search(Napi::CallbackInfo const& ctx) {
 
     Napi::Uint32Array matches_js = Napi::Uint32Array::New(env, wanted);
     Napi::Float32Array distances_js = Napi::Float32Array::New(env, wanted);
-    std::size_t count = native_->search(vector, wanted, matches_js.Data(), distances_js.Data());
-
-    Napi::Object result_js = Napi::Object::New(env);
-    result_js.Set("labels", matches_js);
-    result_js.Set("distances", distances_js);
-    result_js.Set("count", Napi::Number::New(env, count));
-    return result_js;
+    try {
+        std::size_t count = native_->search(vector, wanted, matches_js.Data(), distances_js.Data());
+        Napi::Object result_js = Napi::Object::New(env);
+        result_js.Set("labels", matches_js);
+        result_js.Set("distances", distances_js);
+        result_js.Set("count", Napi::Number::New(env, count));
+        return result_js;
+    } catch (std::bad_alloc const&) {
+        Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
+        return {};
+    } catch (...) {
+        Napi::TypeError::New(env, "Search failed").ThrowAsJavaScriptException();
+        return {};
+    }
 }
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports) { return Index::Init(env, exports); }

package/objc/USearchObjective.mm

@@ -107,14 +107,14 @@ using shared_index_t = std::shared_ptr<native_index_t>;
 
 - (void)addImprecise:(UInt32)label
               vector:(void const * _Nonnull)vector {
-    _native->add(label, (f16_converted_t const *)vector);
+    _native->add(label, (f16_bits_t const *)vector);
 }
 
 - (UInt32)searchImprecise:(void const* _Nonnull)vector
                     count:(UInt32)wanted
                    labels:(UInt32* _Nullable)labels
                 distances:(Float32* _Nullable)distances {
-    std::size_t found = _native->search((f16_converted_t const *)vector, static_cast<std::size_t>(wanted), labels, distances);
+    std::size_t found = _native->search((f16_bits_t const *)vector, static_cast<std::size_t>(wanted), labels, distances);
     return static_cast<UInt32>(found);
 }
 

package/objc/include/USearchObjective.h

@@ -10,6 +10,7 @@ typedef NS_ENUM(NSUInteger, Quantization) {
     kDoublePrecision
 };
 
+API_AVAILABLE(ios(13.0), macos(10.15), tvos(13.0), watchos(6.0))
 @interface Index: NSObject
 
 @property (readonly) UInt32 dimensions;
@@ -33,9 +34,9 @@ NS_UNAVAILABLE;
 NS_SWIFT_NAME(addSingle(label:vector:));
 
 - (UInt32)searchSingle:(Float32 const* _Nonnull)vector
-               count:(UInt32)count
-              labels:(UInt32* _Nullable)labels
-           distances:(Float32* _Nullable)distances
+                 count:(UInt32)count
+                labels:(UInt32* _Nullable)labels
+             distances:(Float32* _Nullable)distances
 NS_SWIFT_NAME(searchSingle(vector:count:labels:distances:));
 
 - (void)addPrecise:(UInt32)label
@@ -43,9 +44,9 @@ NS_SWIFT_NAME(searchSingle(vector:count:labels:distances:));
 NS_SWIFT_NAME(addPrecise(label:vector:));
 
 - (UInt32)searchPrecise:(Float64 const* _Nonnull)vector
-                count:(UInt32)count
-               labels:(UInt32* _Nullable)labels
-            distances:(Float32* _Nullable)distances
+                  count:(UInt32)count
+                 labels:(UInt32* _Nullable)labels
+              distances:(Float32* _Nullable)distances
 NS_SWIFT_NAME(searchPrecise(vector:count:labels:distances:));
 
 - (void)addImprecise:(UInt32)label
@@ -53,9 +54,9 @@ NS_SWIFT_NAME(searchPrecise(vector:count:labels:distances:));
 NS_SWIFT_NAME(addImprecise(label:vector:));
 
 - (UInt32)searchImprecise:(void const* _Nonnull)vector
-                  count:(UInt32)count
-                 labels:(UInt32* _Nullable)labels
-              distances:(Float32* _Nullable)distances
+                    count:(UInt32)count
+                   labels:(UInt32* _Nullable)labels
+                distances:(Float32* _Nullable)distances
 NS_SWIFT_NAME(searchImprecise(vector:count:labels:distances:));
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.2.3",
+    "version": "0.4.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
@@ -18,5 +18,11 @@
     },
     "scripts": {
         "test": "node javascript/test.js"
+    },
+    "devDependencies": {
+        "@semantic-release/exec": "^6.0.3",
+        "@semantic-release/git": "^10.0.1",
+        "conventional-changelog-eslint": "^3.0.9",
+        "semantic-release": "^21.0.2"
     }
 }

package/python/bench.py

@@ -12,30 +12,50 @@ from usearch.io import load_matrix
 
 def measure(f) -> float:
     a = time.time_ns()
-    f()
+    result = f()
     b = time.time_ns()
     c = b - a
     secs = c / (10 ** 9)
     print(f'- Took: {secs:.2f} seconds')
-    return secs
+    return secs, result
 
 
 def bench_faiss(index, vectors: np.array, queries: np.array, neighbors: np.array):
-    dt = measure(lambda: index.add(vectors))
-    print(f'- Performance: {vectors.shape[0]/dt:.2f} vectors/s')
+    dt, _ = measure(lambda: index.add(vectors))
+    print(f'- Performance: {vectors.shape[0]/dt:.2f} insertions/s')
+
+    dt, results = measure(lambda: index.search(queries, neighbors.shape[1]))
+    print(f'- Performance: {queries.shape[0]/dt:.2f} queries/s')
+
+    recall_at_one = 0.0
+    matches = results[1]
+    for i in range(queries.shape[0]):
+        recall_at_one += neighbors[i, 0] in matches[i, :]
+    recall_at_one /= queries.shape[0]
+    print(f'- Recall@1: {recall_at_one * 100:.2f} %')
 
 
 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))
+    dt, _ = measure(lambda: index.add(labels, vectors))
     assert len(index) == vectors.shape[0]
-    print(f'- Performance: {vectors.shape[0]/dt:.2f} vectors/s')
+    print(f'- Performance: {vectors.shape[0]/dt:.2f} insertions/s')
+
+    dt, results = measure(lambda: index.search(queries, neighbors.shape[1]))
+    print(f'- Performance: {queries.shape[0]/dt:.2f} queries/s')
 
+    recall_at_one = 0.0
+    matches = results[0]
+    for i in range(queries.shape[0]):
+        recall_at_one += neighbors[i, 0] in matches[i, :]
+    recall_at_one /= queries.shape[0]
+    print(f'- Recall@1: {recall_at_one * 100:.2f} %')
 
 # Showcases how to use Numba to JIT-compile similarity measures for USearch.
 # https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
 
+
 signature_f32 = types.float32(
     types.CPointer(types.float32),
     types.CPointer(types.float32),
@@ -85,7 +105,7 @@ def main(
     )
     bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
-    print('USearch: HNSW + Numba JIT + Half Precision')
+    print('USearch: HNSW + Half Precision')
     index = Index(
         ndim=dim,
         dtype='f16',
@@ -95,6 +115,16 @@ def main(
     )
     bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
+    print('USearch: HNSW + Quarter Precision')
+    index = Index(
+        ndim=dim,
+        dtype='f8',
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
+
     print('FAISS: HNSW')
     index = IndexHNSWFlat(dim, connectivity)
     index.hnsw.efSearch = expansion_search

package/python/lib.cpp

@@ -145,21 +145,24 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
     if (vector_info.ndim != 1)
         throw std::invalid_argument("Expects a vector, not a higher-rank tensor!");
 
-    ssize_t vector_dimensions = vector_info.shape[0];
+    Py_ssize_t vector_dimensions = vector_info.shape[0];
     char const* vector_data = reinterpret_cast<char const*>(vector_info.ptr);
-    if (vector_dimensions != static_cast<ssize_t>(index.dimensions()))
+    if (vector_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
     if (index.size() + 1 >= index.capacity())
         index.reserve(ceil2(index.size() + 1));
 
+    add_config_t config;
+    config.store_vector = copy;
+
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vector_info.format == "e")
-        index.add(label, reinterpret_cast<f16_bits_t const*>(vector_data), 0, copy);
+        index.add(label, reinterpret_cast<f16_bits_t const*>(vector_data), config);
     else if (vector_info.format == "f")
-        index.add(label, reinterpret_cast<float const*>(vector_data), 0, copy);
+        index.add(label, reinterpret_cast<float const*>(vector_data), config);
     else if (vector_info.format == "d")
-        index.add(label, reinterpret_cast<double const*>(vector_data), 0, copy);
+        index.add(label, reinterpret_cast<double const*>(vector_data), config);
     else
         throw std::invalid_argument("Incompatible scalars in the vector!");
 }
@@ -180,10 +183,10 @@ static void add_many_to_index(                                    //
     if (vectors_info.ndim != 2)
         throw std::invalid_argument("Expects a matrix of vectors to add!");
 
-    ssize_t labels_count = labels_info.shape[0];
-    ssize_t vectors_count = vectors_info.shape[0];
-    ssize_t vectors_dimensions = vectors_info.shape[1];
-    if (vectors_dimensions != static_cast<ssize_t>(index.dimensions()))
+    Py_ssize_t labels_count = labels_info.shape[0];
+    Py_ssize_t vectors_count = vectors_info.shape[0];
+    Py_ssize_t vectors_dimensions = vectors_info.shape[1];
+    if (vectors_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
     if (labels_count != vectors_count)
@@ -198,56 +201,68 @@ static void add_many_to_index(                                    //
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "e")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+            add_config_t config;
+            config.store_vector = copy;
+            config.thread = thread_idx;
             label_t label = *reinterpret_cast<label_t const*>(labels_data + task_idx * labels_info.strides[0]);
             f16_bits_t const* vector =
                 reinterpret_cast<f16_bits_t const*>(vectors_data + task_idx * vectors_info.strides[0]);
-            index.add(label, vector, thread_idx, copy);
+            index.add(label, vector, config);
         });
     else if (vectors_info.format == "f")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+            add_config_t config;
+            config.store_vector = copy;
+            config.thread = thread_idx;
             label_t label = *reinterpret_cast<label_t const*>(labels_data + task_idx * labels_info.strides[0]);
             float const* vector = reinterpret_cast<float const*>(vectors_data + task_idx * vectors_info.strides[0]);
-            index.add(label, vector, thread_idx, copy);
+            index.add(label, vector, config);
         });
     else if (vectors_info.format == "d")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+            add_config_t config;
+            config.store_vector = copy;
+            config.thread = thread_idx;
             label_t label = *reinterpret_cast<label_t const*>(labels_data + task_idx * labels_info.strides[0]);
             double const* vector = reinterpret_cast<double const*>(vectors_data + task_idx * vectors_info.strides[0]);
-            index.add(label, vector, thread_idx, copy);
+            index.add(label, vector, config);
         });
     else
         throw std::invalid_argument("Incompatible scalars in the vectors matrix!");
 }
 
-static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, std::size_t wanted) {
+static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, std::size_t wanted, bool exact) {
 
     py::buffer_info vector_info = vector.request();
-    ssize_t vector_dimensions = vector_info.shape[0];
+    Py_ssize_t vector_dimensions = vector_info.shape[0];
     char const* vector_data = reinterpret_cast<char const*>(vector_info.ptr);
-    if (vector_dimensions != static_cast<ssize_t>(index.dimensions()))
+    if (vector_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
-    py::array_t<label_t> labels_py(static_cast<ssize_t>(wanted));
-    py::array_t<distance_t> distances_py(static_cast<ssize_t>(wanted));
+    py::array_t<label_t> labels_py(static_cast<Py_ssize_t>(wanted));
+    py::array_t<distance_t> distances_py(static_cast<Py_ssize_t>(wanted));
     std::size_t count{};
     auto labels_py1d = labels_py.mutable_unchecked<1>();
     auto distances_py1d = distances_py.mutable_unchecked<1>();
 
+    search_config_t config;
+    config.exact = exact;
+
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vector_info.format == "e")
         count = index.search( //
-            reinterpret_cast<f16_bits_t const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
+            reinterpret_cast<f16_bits_t const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), config);
     else if (vector_info.format == "f")
         count = index.search( //
-            reinterpret_cast<float const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
+            reinterpret_cast<float const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), config);
     else if (vector_info.format == "d")
         count = index.search( //
-            reinterpret_cast<double const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
+            reinterpret_cast<double const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), config);
     else
         throw std::invalid_argument("Incompatible scalars in the query vector!");
 
-    labels_py.resize(py_shape_t{static_cast<ssize_t>(count)});
-    distances_py.resize(py_shape_t{static_cast<ssize_t>(count)});
+    labels_py.resize(py_shape_t{static_cast<Py_ssize_t>(count)});
+    distances_py.resize(py_shape_t{static_cast<Py_ssize_t>(count)});
 
     py::tuple results(3);
     results[0] = labels_py;
@@ -265,25 +280,25 @@ static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, s
  *      2. matrix of distances,
  *      3. array with match counts.
  */
-static py::tuple search_many_in_index(native_index_t& index, py::buffer vectors, std::size_t wanted) {
+static py::tuple search_many_in_index(native_index_t& index, py::buffer vectors, std::size_t wanted, bool exact) {
 
     if (wanted == 0)
         return py::tuple(3);
 
     py::buffer_info vectors_info = vectors.request();
     if (vectors_info.ndim == 1)
-        return search_one_in_index(index, vectors, wanted);
+        return search_one_in_index(index, vectors, wanted, exact);
     if (vectors_info.ndim != 2)
         throw std::invalid_argument("Expects a matrix of vectors to add!");
 
-    ssize_t vectors_count = vectors_info.shape[0];
-    ssize_t vectors_dimensions = vectors_info.shape[1];
+    Py_ssize_t vectors_count = vectors_info.shape[0];
+    Py_ssize_t vectors_dimensions = vectors_info.shape[1];
     char const* vectors_data = reinterpret_cast<char const*>(vectors_info.ptr);
-    if (vectors_dimensions != static_cast<ssize_t>(index.dimensions()))
+    if (vectors_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
-    py::array_t<label_t> labels_py({vectors_count, static_cast<ssize_t>(wanted)});
-    py::array_t<distance_t> distances_py({vectors_count, static_cast<ssize_t>(wanted)});
+    py::array_t<label_t> labels_py({vectors_count, static_cast<Py_ssize_t>(wanted)});
+    py::array_t<distance_t> distances_py({vectors_count, static_cast<Py_ssize_t>(wanted)});
     py::array_t<Py_ssize_t> counts_py(vectors_count);
     auto labels_py2d = labels_py.mutable_unchecked<2>();
     auto distances_py2d = distances_py.mutable_unchecked<2>();
@@ -292,21 +307,30 @@ static py::tuple search_many_in_index(native_index_t& index, py::buffer vectors,
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "e")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+            search_config_t config;
+            config.thread = thread_idx;
+            config.exact = exact;
             f16_bits_t const* vector = (f16_bits_t const*)(vectors_data + task_idx * vectors_info.strides[0]);
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
-                index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), thread_idx));
+                index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), config));
         });
     else if (vectors_info.format == "f")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+            search_config_t config;
+            config.thread = thread_idx;
+            config.exact = exact;
             float const* vector = (float const*)(vectors_data + task_idx * vectors_info.strides[0]);
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
-                index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), thread_idx));
+                index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), config));
         });
     else if (vectors_info.format == "d")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+            search_config_t config;
+            config.thread = thread_idx;
+            config.exact = exact;
             double const* vector = (double const*)(vectors_data + task_idx * vectors_info.strides[0]);
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
-                index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), thread_idx));
+                index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), config));
         });
     else
         throw std::invalid_argument("Incompatible scalars in the query matrix!");
@@ -364,8 +388,8 @@ inline std::uint64_t hash(std::uint64_t v) noexcept {
 template <typename scalar_at>
 inline void hash_typed_buffer(hash_index_w_meta_t& index, py::buffer_info const& vector_info) noexcept {
     char const* vector_data = reinterpret_cast<char const*>(vector_info.ptr);
-    ssize_t vector_dimensions = vector_info.shape[0];
-    ssize_t vector_stride = vector_info.strides[0];
+    Py_ssize_t vector_dimensions = vector_info.shape[0];
+    Py_ssize_t vector_stride = vector_info.strides[0];
     std::memset(index.buffer_.data(), 0, index.words_ * sizeof(hash_word_t));
 
     for (std::size_t i = 0; i != static_cast<std::size_t>(vector_dimensions); ++i) {
@@ -428,7 +452,8 @@ PYBIND11_MODULE(index, m) {
     i.def(                               //
         "search", &search_many_in_index, //
         py::arg("query"),                //
-        py::arg("count") = 10            //
+        py::arg("count") = 10,           //
+        py::arg("exact") = false         //
     );
 
     i.def("__len__", &native_index_t::size);
@@ -463,7 +488,9 @@ PYBIND11_MODULE(index, m) {
                 index.reserve(ceil2(index.size() + 1));
             auto proxy = set.unchecked<1>();
             auto view = set_view_t{proxy.data(0), static_cast<std::size_t>(proxy.shape(0))};
-            index.add(label, view, 0, copy);
+            add_config_t config;
+            config.store_vector = copy;
+            index.add(label, view, config);
         },                     //
         py::arg("label"),      //
         py::arg("set"),        //
@@ -477,10 +504,10 @@ PYBIND11_MODULE(index, m) {
             validate_set(set);
             auto proxy = set.unchecked<1>();
             auto view = set_view_t{proxy.data(0), static_cast<std::size_t>(proxy.shape(0))};
-            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<ssize_t>(count)});
+            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<Py_ssize_t>(count)});
             auto labels_proxy = labels_py.mutable_unchecked<1>();
-            auto found = index.search(view, count, &labels_proxy(0), nullptr, 0);
-            labels_py.resize(py_shape_t{static_cast<ssize_t>(found)});
+            auto found = index.search(view, count, &labels_proxy(0), nullptr);
+            labels_py.resize(py_shape_t{static_cast<Py_ssize_t>(found)});
             return labels_py;
         },
         py::arg("set"),       //
@@ -515,7 +542,7 @@ PYBIND11_MODULE(index, m) {
             if (index.size() + 1 >= index.capacity())
                 index.reserve(ceil2(index.size() + 1));
             hash_buffer(index, array);
-            index.add(label, index.buffer(), 0);
+            index.add(label, index.buffer());
         },                //
         py::arg("label"), //
         py::arg("array")  //
@@ -527,10 +554,10 @@ PYBIND11_MODULE(index, m) {
             if (index.size() + 1 >= index.capacity())
                 index.reserve(ceil2(index.size() + 1));
             hash_buffer(index, array);
-            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<ssize_t>(count)});
+            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<Py_ssize_t>(count)});
             auto labels_proxy = labels_py.mutable_unchecked<1>();
-            auto found = index.search(index.buffer(), count, &labels_proxy(0), nullptr, 0);
-            labels_py.resize(py_shape_t{static_cast<ssize_t>(found)});
+            auto found = index.search(index.buffer(), count, &labels_proxy(0), nullptr);
+            labels_py.resize(py_shape_t{static_cast<Py_ssize_t>(found)});
             return labels_py;
         },
         py::arg("array"),     //