usearch 0.2.4 → 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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.2.4",
+    "version": "0.4.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",

package/python/lib.cpp

@@ -153,13 +153,16 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
     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!");
 }
@@ -198,28 +201,37 @@ 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();
     Py_ssize_t vector_dimensions = vector_info.shape[0];
@@ -233,16 +245,19 @@ static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, s
     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!");
 
@@ -265,14 +280,14 @@ 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!");
 
@@ -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!");
@@ -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"),        //
@@ -479,7 +506,7 @@ PYBIND11_MODULE(index, m) {
             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<Py_ssize_t>(count)});
             auto labels_proxy = labels_py.mutable_unchecked<1>();
-            auto found = index.search(view, count, &labels_proxy(0), nullptr, 0);
+            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;
         },
@@ -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")  //
@@ -529,7 +556,7 @@ PYBIND11_MODULE(index, m) {
             hash_buffer(index, array);
             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);
+            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;
         },

package/rust/lib.cpp

@@ -9,7 +9,9 @@ using native_index_t = typename Index::native_index_t;
 Index::Index(std::shared_ptr<native_index_t> index) : index_(index) {}
 
 void Index::add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const {
-    index_->add(label, vector.data(), thread, true);
+    add_config_t config;
+    config.thread = thread;
+    index_->add(label, vector.data(), config);
 }
 
 Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const {
@@ -18,7 +20,9 @@ Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, s
     results.distances.reserve(count);
     for (size_t i = 0; i != count; ++i)
         results.labels.push_back(0), results.distances.push_back(0);
-    results.count = index_->search(vector.data(), count, results.labels.data(), results.distances.data(), thread);
+    search_config_t config;
+    config.thread = thread;
+    results.count = index_->search(vector.data(), count, results.labels.data(), results.distances.data(), config);
     results.labels.truncate(results.count);
     results.distances.truncate(results.count);
     return results;

package/src/advanced.hpp

@@ -469,21 +469,21 @@ class auto_index_gt {
     void reserve(std::size_t capacity) { index_->reserve(capacity); }
 
     // clang-format off
-    void add(label_t label, f16_bits_t const* vector) { return add(label, vector, true, casts_.from_f16); }
-    void add(label_t label, f32_t const* vector) { return add(label, vector, true, casts_.from_f32); }
-    void add(label_t label, f64_t const* vector) { return add(label, vector, true, casts_.from_f64); }
+    void add(label_t label, f16_bits_t const* vector) { return add(label, vector, casts_.from_f16); }
+    void add(label_t label, f32_t const* vector) { return add(label, vector, casts_.from_f32); }
+    void add(label_t label, f64_t const* vector) { return add(label, vector, casts_.from_f64); }
 
-    void add(label_t label, f16_bits_t const* vector, std::size_t thread, bool copy) { return add(label, vector, thread, copy, casts_.from_f16); }
-    void add(label_t label, f32_t const* vector, std::size_t thread, bool copy) { return add(label, vector, thread, copy, casts_.from_f32); }
-    void add(label_t label, f64_t const* vector, std::size_t thread, bool copy) { return add(label, vector, thread, copy, casts_.from_f64); }
+    void add(label_t label, f16_bits_t const* vector, add_config_t config) { return add(label, vector, config, casts_.from_f16); }
+    void add(label_t label, f32_t const* vector, add_config_t config) { return add(label, vector, config, casts_.from_f32); }
+    void add(label_t label, f64_t const* vector, add_config_t config) { return add(label, vector, config, casts_.from_f64); }
 
     std::size_t search(f16_bits_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances) const { return search(vector, wanted, matches, distances, casts_.from_f16); }
     std::size_t search(f32_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances) const { return search(vector, wanted, matches, distances, casts_.from_f32); }
     std::size_t search(f64_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances) const { return search(vector, wanted, matches, distances, casts_.from_f64); }
 
-    std::size_t search(f16_bits_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread) const { return search(vector, wanted, matches, distances, thread, casts_.from_f16); }
-    std::size_t search(f32_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread) const { return search(vector, wanted, matches, distances, thread, casts_.from_f32); }
-    std::size_t search(f64_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread) const { return search(vector, wanted, matches, distances, thread, casts_.from_f64); }
+    std::size_t search(f16_bits_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, search_config_t config) const { return search(vector, wanted, matches, distances, config, casts_.from_f16); }
+    std::size_t search(f32_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, search_config_t config) const { return search(vector, wanted, matches, distances, config, casts_.from_f32); }
+    std::size_t search(f64_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, search_config_t config) const { return search(vector, wanted, matches, distances, config, casts_.from_f64); }
 
     static auto_index_gt ip(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, config_t config = {}) { return make(dimensions, accuracy, ip_metric(dimensions, accuracy), make_casts(accuracy), config); }
     static auto_index_gt l2(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, config_t config = {}) { return make(dimensions, accuracy, l2_metric(dimensions, accuracy), make_casts(accuracy), config); }
@@ -549,38 +549,40 @@ class auto_index_gt {
     }
 
     template <typename scalar_at>
-    void add(label_t label, scalar_at const* vector, std::size_t thread, bool copy, cast_t const& cast) {
+    void add(label_t label, scalar_at const* vector, add_config_t config, cast_t const& cast) {
         byte_t const* vector_data = reinterpret_cast<byte_t const*>(vector);
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
-        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * thread;
+        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
         bool casted = cast(vector_data, casted_vector_bytes_, casted_data);
         if (casted)
-            vector_data = casted_data, vector_bytes = casted_vector_bytes_, copy = true;
+            vector_data = casted_data, vector_bytes = casted_vector_bytes_, config.store_vector = true;
 
-        index_->add(label, {vector_data, vector_bytes}, thread, copy);
+        index_->add(label, {vector_data, vector_bytes}, config);
     }
 
     template <typename scalar_at>
     std::size_t search(                              //
         scalar_at const* vector, std::size_t wanted, //
         label_t* matches, distance_t* distances,     //
-        std::size_t thread, cast_t const& cast) const {
+        search_config_t config, cast_t const& cast) const {
 
         byte_t const* vector_data = reinterpret_cast<byte_t const*>(vector);
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
-        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * thread;
+        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
         bool casted = cast(vector_data, casted_vector_bytes_, casted_data);
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
-        return index_->search({vector_data, vector_bytes}, wanted, matches, distances, thread);
+        return index_->search({vector_data, vector_bytes}, wanted, matches, distances, config);
     }
 
-    template <typename scalar_at> void add(label_t label, scalar_at const* vector, bool copy, cast_t const& cast) {
+    template <typename scalar_at> void add(label_t label, scalar_at const* vector, cast_t const& cast) {
         thread_lock_t lock = thread_lock();
-        return add(label, vector, lock.thread_id, copy, cast);
+        add_config_t config;
+        config.thread = lock.thread_id;
+        return add(label, vector, config, cast);
     }
 
     template <typename scalar_at>
@@ -589,7 +591,9 @@ class auto_index_gt {
         label_t* matches, distance_t* distances,     //
         cast_t const& cast) const {
         thread_lock_t lock = thread_lock();
-        return search(vector, wanted, matches, distances, lock.thread_id, cast);
+        search_config_t config;
+        config.thread = lock.thread_id;
+        return search(vector, wanted, matches, distances, config, cast);
     }
 
     static auto_index_gt make(                            //

package/src/bench.cpp

@@ -43,6 +43,7 @@ using namespace unum::usearch;
 using namespace unum;
 
 using vector_id_t = std::uint32_t;
+using vector_view_t = span_gt<float const>;
 
 template <typename element_at>
 std::size_t offset_of(element_at const* begin, element_at const* end, element_at v) noexcept {
@@ -271,12 +272,14 @@ struct running_stats_printer_t {
 template <typename index_at, typename vector_id_at, typename real_at>
 void index_many(index_at& native, std::size_t n, vector_id_at const* ids, real_at const* vectors, std::size_t dims) {
 
-    using span_t = span_gt<float const>;
     running_stats_printer_t printer{n, "Indexing"};
 
 #pragma omp parallel for schedule(static, 32)
     for (std::size_t i = 0; i < n; ++i) {
-        native.add(ids[i], span_t{vectors + dims * i, dims}, omp_get_thread_num(), true);
+        add_config_t config;
+        config.thread = omp_get_thread_num();
+        config.store_vector = true;
+        native.add(ids[i], vector_view_t{vectors + dims * i, dims}, config);
         printer.progress++;
         if (omp_get_thread_num() == 0)
             printer.refresh();
@@ -284,18 +287,20 @@ void index_many(index_at& native, std::size_t n, vector_id_at const* ids, real_a
 }
 
 template <typename index_at, typename vector_id_at, typename real_at>
-void search_many(index_at& native, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted,
-                 vector_id_at* ids, real_at* distances) {
+void search_many( //
+    index_at& native, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted, vector_id_at* ids,
+    real_at* distances) {
 
-    using span_t = span_gt<float const>;
     running_stats_printer_t printer{n, "Search"};
 
 #pragma omp parallel for schedule(static, 32)
     for (std::size_t i = 0; i < n; ++i) {
-        native.search(                                //
-            span_t{vectors + dims * i, dims}, wanted, //
-            ids + wanted * i, distances + wanted * i, //
-            omp_get_thread_num());
+        search_config_t config;
+        config.thread = omp_get_thread_num();
+        native.search(                                       //
+            vector_view_t{vectors + dims * i, dims}, wanted, //
+            ids + wanted * i, distances + wanted * i,        //
+            config);
         printer.progress++;
         if (omp_get_thread_num() == 0)
             printer.refresh();

package/swift/Index+Sugar.swift

@@ -5,6 +5,7 @@
 //  Created by Ashot Vardanian on 5/11/23.
 //
 
+@available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 extension Index {
 
     public func add(label: UInt32, vector: ArraySlice<Float32>) -> () {

package/swift/Test.swift

@@ -8,6 +8,7 @@
 import Foundation
 import USearch
 
+@available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 func testUnit() throws {
     let index = Index.l2(dimensions: 4, connectivity: 8)
     let vectorA: [Float32] = [0.3, 0.5, 1.2, 1.4]