usearch 0.2.0 → 0.2.3

package/javascript/lib.cpp

@@ -9,6 +9,12 @@
  *  @see NodeJS docs: https://nodejs.org/api/addons.html#hello-world
  *
  */
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#define _USE_MATH_DEFINES
+#define NAPI_CPP_EXCEPTIONS
+#endif
+
 #include <napi.h>
 #include <node_api.h>
 
@@ -87,8 +93,8 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
             accuracy = accuracy_t::f64_k;
         else if (accuracy_str == "f16")
             accuracy = accuracy_t::f16_k;
-        else if (accuracy_str == "i8q100")
-            accuracy = accuracy_t::i8q100_k;
+        else if (accuracy_str == "f8")
+            accuracy = accuracy_t::f8_k;
         else {
             Napi::TypeError::New(env, "Supported metrics are: [ip, cos, l2_sq, haversine]")
                 .ThrowAsJavaScriptException();

package/objc/USearchObjective.mm

@@ -0,0 +1,150 @@
+#import "USearchObjective.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#import "advanced.hpp"
+#pragma clang diagnostic pop
+
+using namespace unum::usearch;
+using namespace unum;
+
+using distance_t = punned_distance_t;
+using native_index_t = auto_index_gt<UInt32>;
+using shared_index_t = std::shared_ptr<native_index_t>;
+
+@interface Index ()
+
+@property (readonly) shared_index_t native;
+
+- (instancetype)initWithIndex:(shared_index_t)native;
+
+@end
+
+@implementation Index
+
+- (instancetype)initWithIndex:(shared_index_t)native {
+    self = [super init];
+    _native = native;
+    return self;
+}
+
+- (Boolean)isEmpty {
+    return _native->size() != 0;
+}
+
+- (UInt32)dimensions {
+    return static_cast<UInt32>(_native->dimensions());
+}
+
+- (UInt32)connectivity {
+    return static_cast<UInt32>(_native->connectivity());
+}
+
+- (UInt32)length {
+    return static_cast<UInt32>(_native->size());
+}
+
+- (UInt32)capacity {
+    return static_cast<UInt32>(_native->capacity());
+}
+
+- (UInt32)expansion_add {
+    return static_cast<UInt32>(_native->config().expansion_add);
+}
+
+- (UInt32)expansion_search {
+    return static_cast<UInt32>(_native->config().expansion_search);
+}
+
++ (instancetype)indexIP:(UInt32)dimensions connectivity:(UInt32)connectivity {
+    std::size_t dims = static_cast<std::size_t>(dimensions);
+    config_t config;
+    config.connectivity = static_cast<std::size_t>(connectivity);
+    shared_index_t ptr = std::make_shared<native_index_t>(native_index_t::ip(dims, accuracy_t::f32_k, config));
+    return [[Index alloc] initWithIndex:ptr];
+}
+
++ (instancetype)indexL2:(UInt32)dimensions connectivity:(UInt32)connectivity {
+    std::size_t dims = static_cast<std::size_t>(dimensions);
+    config_t config;
+    config.connectivity = static_cast<std::size_t>(connectivity);
+    shared_index_t ptr = std::make_shared<native_index_t>(native_index_t::l2(dims, accuracy_t::f32_k, config));
+    return [[Index alloc] initWithIndex:ptr];
+}
+
++ (instancetype)indexHaversine:(UInt32)connectivity {
+    config_t config;
+    config.connectivity = static_cast<std::size_t>(connectivity);
+    shared_index_t ptr = std::make_shared<native_index_t>(native_index_t::haversine(accuracy_t::f32_k, config));
+    return [[Index alloc] initWithIndex:ptr];
+}
+
+- (void)addSingle:(UInt32)label
+           vector:(Float32 const * _Nonnull)vector {
+    _native->add(label, vector);
+}
+
+- (UInt32)searchSingle:(Float32 const* _Nonnull)vector
+                 count:(UInt32)wanted
+                labels:(UInt32* _Nullable)labels
+             distances:(Float32* _Nullable)distances {
+    std::size_t found = _native->search(vector, static_cast<std::size_t>(wanted), labels, distances);
+    return static_cast<UInt32>(found);
+}
+
+- (void)addPrecise:(UInt32)label
+            vector:(Float64 const * _Nonnull)vector {
+    _native->add(label, (f64_t const *)vector);
+}
+
+- (UInt32)searchPrecise:(Float64 const* _Nonnull)vector
+                  count:(UInt32)wanted
+                 labels:(UInt32* _Nullable)labels
+              distances:(Float32* _Nullable)distances {
+    std::size_t found = _native->search((f64_t const *)vector, static_cast<std::size_t>(wanted), labels, distances);
+    return static_cast<UInt32>(found);
+}
+
+- (void)addImprecise:(UInt32)label
+              vector:(void const * _Nonnull)vector {
+    _native->add(label, (f16_converted_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);
+    return static_cast<UInt32>(found);
+}
+
+- (void)clear { _native->clear(); }
+
+- (void)save:(NSString*)path {
+    char const *path_c = [path UTF8String];
+    if (!path_c)
+        @throw [NSException exceptionWithName:@"Can't save to disk"
+                                       reason:@"The path must be convertible to UTF8"
+                                     userInfo:nil];
+    _native->save(path_c);
+}
+
+- (void)load:(NSString*)path {
+    char const *path_c = [path UTF8String];
+    if (!path_c)
+        @throw [NSException exceptionWithName:@"Can't load from disk"
+                                       reason:@"The path must be convertible to UTF8"
+                                     userInfo:nil];
+    _native->load(path_c);
+}
+
+- (void)view:(NSString*)path {
+    char const *path_c = [path UTF8String];
+    if (!path_c)
+        @throw [NSException exceptionWithName:@"Can't view from disk"
+                                       reason:@"The path must be convertible to UTF8"
+                                     userInfo:nil];
+    _native->view(path_c);
+}
+
+@end

package/objc/include/USearchObjective.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSUInteger, Quantization) {
+    kSinglePrecision,
+    kHalfPrecision,
+    kDoublePrecision
+};
+
+@interface Index: NSObject
+
+@property (readonly) UInt32 dimensions;
+@property (readonly) UInt32 connectivity;
+@property (readonly) UInt32 expansion_add;
+@property (readonly) UInt32 expansion_search;
+
+@property (readonly) UInt32 length;
+@property (readonly) UInt32 capacity;
+@property (readonly) Boolean isEmpty;
+
+- (instancetype)init
+NS_UNAVAILABLE;
+
++ (instancetype)indexIP:(UInt32)dimensions connectivity:(UInt32)connectivity NS_SWIFT_NAME(indexIP(dimensions:connectivity:));
++ (instancetype)indexL2:(UInt32)dimensions connectivity:(UInt32)connectivity NS_SWIFT_NAME(l2(dimensions:connectivity:));
++ (instancetype)indexHaversine:(UInt32)connectivity NS_SWIFT_NAME(indexHaversine(connectivity:));
+
+- (void)addSingle:(UInt32)label
+           vector:(Float32 const* _Nonnull)vector
+NS_SWIFT_NAME(addSingle(label:vector:));
+
+- (UInt32)searchSingle:(Float32 const* _Nonnull)vector
+               count:(UInt32)count
+              labels:(UInt32* _Nullable)labels
+           distances:(Float32* _Nullable)distances
+NS_SWIFT_NAME(searchSingle(vector:count:labels:distances:));
+
+- (void)addPrecise:(UInt32)label
+            vector:(Float64 const* _Nonnull)vector
+NS_SWIFT_NAME(addPrecise(label:vector:));
+
+- (UInt32)searchPrecise:(Float64 const* _Nonnull)vector
+                count:(UInt32)count
+               labels:(UInt32* _Nullable)labels
+            distances:(Float32* _Nullable)distances
+NS_SWIFT_NAME(searchPrecise(vector:count:labels:distances:));
+
+- (void)addImprecise:(UInt32)label
+              vector:(void const* _Nonnull)vector
+NS_SWIFT_NAME(addImprecise(label:vector:));
+
+- (UInt32)searchImprecise:(void const* _Nonnull)vector
+                  count:(UInt32)count
+                 labels:(UInt32* _Nullable)labels
+              distances:(Float32* _Nullable)distances
+NS_SWIFT_NAME(searchImprecise(vector:count:labels:distances:));
+
+
+- (void)save:(NSString*)path NS_SWIFT_NAME(dump(path:));
+- (void)load:(NSString*)path NS_SWIFT_NAME(load(path:));
+- (void)view:(NSString*)path NS_SWIFT_NAME(view(path:));
+- (void)clear NS_SWIFT_NAME(clear());
+
+@end
+
+NS_ASSUME_NONNULL_END

package/package.json

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

package/pyproject.toml

@@ -10,15 +10,15 @@ filterwarnings = ["error"]
 
 [tool.cibuildwheel]
 build-verbosity = 0
+
+skip = ["*musllinux*", "*i686*", "pp*"]
+
+[tool.cibuildwheel.linux]
 before-build = [
     "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps",
     "mkdir -p build/usearch",
     "git submodule update --init --recursive"
 ]
-
-skip = ["*musllinux*", "*i686*", "pp*"]
-
-[tool.cibuildwheel.linux]
 manylinux-x86_64-image = "manylinux_2_28"
 manylinux-aarch64-image = "manylinux_2_28"
 
@@ -29,5 +29,19 @@ before-all = [
 repair-wheel-command = "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
 
 [tool.cibuildwheel.macos]
+before-build = [
+    "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps",
+    "mkdir -p build/usearch",
+    "git submodule update --init --recursive"
+]
 archs = ["x86_64", "universal2", "arm64"]
 repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+
+[tool.cibuildwheel.windows]
+before-build = [
+    "rd /s /q {project}\\CMakeCache.txt {project}\\build {project}\\build_debug {project}\\CMakeFiles.txt {project}\\_deps || echo Done",
+    "md build\\usearch",
+    "git submodule update --init --recursive"
+]
+archs = ["x86", "AMD64"]

package/python/bench.py

@@ -1,25 +1,28 @@
-import datetime
+import time
 import numpy as np
 import fire
 
-import faiss
-import usearch
-
-import struct
 import numpy as np
+from numba import cfunc, types, carray
+
+from faiss import IndexHNSWFlat, IndexIVFPQ
+from usearch.index import Index
+from usearch.io import load_matrix
+
 
 def measure(f) -> float:
-    a = datetime.datetime.now()
+    a = time.time_ns()
     f()
-    b = datetime.datetime.now()
+    b = time.time_ns()
     c = b - a
-    print(f'Took: {c.seconds:.2f} seconds')
-    return c.seconds
+    secs = c / (10 ** 9)
+    print(f'- Took: {secs:.2f} seconds')
+    return secs
 
 
 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')
+    print(f'- Performance: {vectors.shape[0]/dt:.2f} vectors/s')
 
 
 def bench_usearch(index, vectors: np.array, queries: np.array, neighbors: np.array):
@@ -27,7 +30,26 @@ def bench_usearch(index, vectors: np.array, queries: np.array, neighbors: np.arr
     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')
+    print(f'- Performance: {vectors.shape[0]/dt:.2f} vectors/s')
+
+
+# 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),
+    types.size_t, types.size_t)
+
+
+@cfunc(signature_f32)
+def inner_product_f32(a, b, n, m):
+    a_array = carray(a, n)
+    b_array = carray(b, n)
+    c = types.float32(0)
+    for i in range(n):
+        c += a_array[i] * b_array[i]
+    return types.float32(1 - c)
 
 
 def main(
@@ -44,31 +66,51 @@ def main(
     neighbors_mat = load_matrix(neighbors)
     dim = vectors_mat.shape[1]
 
-    # Test FAISS
-    index = faiss.IndexHNSWFlat(dim, connectivity)
+    print('USearch: HNSW')
+    index = Index(
+        ndim=dim,
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
+
+    print('USearch: HNSW + Numba JIT')
+    index = Index(
+        ndim=dim,
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+        metric_pointer=inner_product_f32.address,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
+
+    print('USearch: HNSW + Numba JIT + Half Precision')
+    index = Index(
+        ndim=dim,
+        dtype='f16',
+        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
     index.hnsw.efConstruction = expansion_add
     bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
 
-    # Test FAISS with default Product Quantization
+    print('FAISS: HNSW + IVFPQ')
     nlist = 10000  # Number of inverted lists (number of partitions or cells).
     nsegment = 16  # Number of segments for PQ (number of subquantizers).
     nbit = 8       # Number of bits to encode each segment.
-    coarse_quantizer = faiss.IndexHNSWFlat(dim, connectivity)
-    index = faiss.IndexIVFPQ(coarse_quantizer, dim, nlist, nsegment, nbit)
+    coarse_quantizer = IndexHNSWFlat(dim, connectivity)
+    index = IndexIVFPQ(coarse_quantizer, dim, nlist, nsegment, nbit)
     index.train(vectors_mat)
     index.nprobe = 10
     bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
 
-    # Test USearch `Index`
-    index = usearch.Index(
-        ndim=dim,
-        expansion_add=expansion_add,
-        expansion_search=expansion_search,
-        connectivity=connectivity,
-    )
-    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
-
 
 if __name__ == '__main__':
     fire.Fire(main)

package/python/lib.cpp

@@ -59,6 +59,25 @@ struct hash_index_w_meta_t : public hash_index_t {
     span_gt<hash_word_t const> buffer() const noexcept { return {buffer_.data(), buffer_.size()}; }
 };
 
+template <typename scalar_at> punned_stateful_metric_t udf(std::size_t metric_uintptr) {
+    return [metric_uintptr](byte_t const* a_bytes, byte_t const* b_bytes, std::size_t n, std::size_t m) -> distance_t {
+        using metric_t = punned_distance_t (*)(scalar_at const*, scalar_at const*, std::size_t, std::size_t);
+        metric_t metric_ptr = reinterpret_cast<metric_t>(metric_uintptr);
+        scalar_at const* a = reinterpret_cast<scalar_at const*>(a_bytes);
+        scalar_at const* b = reinterpret_cast<scalar_at const*>(b_bytes);
+        return metric_ptr(a, b, n / sizeof(scalar_at), m / sizeof(scalar_at));
+    };
+}
+
+punned_stateful_metric_t udf(std::size_t metric_uintptr, accuracy_t accuracy) {
+    switch (accuracy) {
+    case accuracy_t::f8_k: return udf<f8_bits_t>(metric_uintptr);
+    case accuracy_t::f16_k: return udf<f16_bits_t>(metric_uintptr);
+    case accuracy_t::f32_k: return udf<f32_t>(metric_uintptr);
+    case accuracy_t::f64_k: return udf<f64_t>(metric_uintptr);
+    }
+}
+
 static native_index_t make_index(   //
     std::size_t dimensions,         //
     std::size_t capacity,           //
@@ -79,9 +98,8 @@ 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());
-    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);
+    if (metric_uintptr)
+        return native_index_t::udf(dimensions, udf(metric_uintptr, accuracy), accuracy, config);
     else
         return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
 }
@@ -137,7 +155,7 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
 
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vector_info.format == "e")
-        index.add(label, reinterpret_cast<f16_converted_t const*>(vector_data), 0, copy);
+        index.add(label, reinterpret_cast<f16_bits_t const*>(vector_data), 0, copy);
     else if (vector_info.format == "f")
         index.add(label, reinterpret_cast<float const*>(vector_data), 0, copy);
     else if (vector_info.format == "d")
@@ -146,7 +164,9 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
         throw std::invalid_argument("Incompatible scalars in the vector!");
 }
 
-static void add_many_to_index(native_index_t& index, py::buffer labels, py::buffer vectors, bool copy) {
+static void add_many_to_index(                                    //
+    native_index_t& index, py::buffer labels, py::buffer vectors, //
+    bool copy, std::size_t threads = 0) {
 
     py::buffer_info labels_info = labels.request();
     py::buffer_info vectors_info = vectors.request();
@@ -179,8 +199,8 @@ static void add_many_to_index(native_index_t& index, py::buffer labels, py::buff
     if (vectors_info.format == "e")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             label_t label = *reinterpret_cast<label_t const*>(labels_data + task_idx * labels_info.strides[0]);
-            f16_converted_t const* vector =
-                reinterpret_cast<f16_converted_t const*>(vectors_data + task_idx * vectors_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);
         });
     else if (vectors_info.format == "f")
@@ -216,7 +236,7 @@ static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, s
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vector_info.format == "e")
         count = index.search( //
-            reinterpret_cast<f16_converted_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), 0);
     else if (vector_info.format == "f")
         count = index.search( //
             reinterpret_cast<float const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
@@ -272,7 +292,7 @@ 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) {
-            f16_converted_t const* vector = (f16_converted_t const*)(vectors_data + task_idx * vectors_info.strides[0]);
+            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));
         });
@@ -371,7 +391,7 @@ void hash_buffer(hash_index_w_meta_t& index, py::buffer vector) {
         throw std::invalid_argument("Array elements must be 16, 32, or 64 bit hashable integers!");
 }
 
-PYBIND11_MODULE(usearch, m) {
+PYBIND11_MODULE(index, m) {
     m.doc() = "Unum USearch Python bindings";
 
     auto i = py::class_<native_index_t>(m, "Index");
@@ -393,7 +413,8 @@ PYBIND11_MODULE(usearch, m) {
         py::arg("labels"),         //
         py::arg("vectors"),        //
         py::kw_only(),             //
-        py::arg("copy") = true     //
+        py::arg("copy") = true,    //
+        py::arg("threads") = 0     //
     );
 
     i.def(                        //
@@ -415,6 +436,8 @@ PYBIND11_MODULE(usearch, m) {
     i.def_property_readonly("ndim", &native_index_t::dimensions);
     i.def_property_readonly("connectivity", &native_index_t::connectivity);
     i.def_property_readonly("capacity", &native_index_t::capacity);
+    i.def_property_readonly( //
+        "dtype", [](native_index_t const& index) -> std::string { return accuracy_name(index.accuracy()); });
 
     i.def("save", &save_index<native_index_t>, py::arg("path"));
     i.def("load", &load_index<native_index_t>, py::arg("path"));

package/python/test.py

@@ -1,7 +1,6 @@
 import numpy as np
 
-import usearch
-
+from usearch.index import Index, SetsIndex
 from numba import cfunc, types, carray
 
 # Showcases how to use Numba to JIT-compile similarity measures for USearch.
@@ -29,13 +28,13 @@ vectors = np.random.uniform(
     0, 0.3, (count_vectors, count_dimensions)).astype(np.float32)
 labels = np.array(range(count_vectors), dtype=np.longlong)
 
-index_udf = usearch.Index(ndim=96, metric_pointer=python_dot.address)
+index_udf = Index(ndim=96, metric_pointer=python_dot.address)
 index_udf.add(labels, vectors, copy=True)
 results = index_udf.search(vectors, 10)
 print('found', results[0].shape, results[1].shape, results[2].shape)
 
 
-index = usearch.Index(ndim=96)
+index = Index(ndim=96)
 index.add(labels, vectors, copy=True)
 assert index.ndim == count_dimensions
 assert index.capacity >= count_vectors
@@ -45,7 +44,7 @@ results = index.search(vectors, 10)
 print('found', results[0].shape, results[1].shape, results[2].shape)
 
 
-index_sets = usearch.SetsIndex()
+index_sets = SetsIndex()
 index_sets.add(10, np.array([10, 12, 15], dtype=np.uint32))
 index_sets.add(11, np.array([11, 12, 15, 16], dtype=np.uint32))
 results = index_sets.search(np.array([12, 15], dtype=np.uint32), 20)

package/rust/lib.cpp

@@ -24,9 +24,20 @@ Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, s
     return results;
 }
 
-void Index::add(uint32_t label, rust::Slice<float const> vector) const { return add_in_thread(label, vector, 0); }
+void Index::add(uint32_t label, rust::Slice<float const> vector) const {
+    index_->add(label, vector.data()); //
+}
+
 Matches Index::search(rust::Slice<float const> vector, size_t count) const {
-    return search_in_thread(vector, count, 0);
+    Matches results;
+    results.labels.reserve(count);
+    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());
+    results.labels.truncate(results.count);
+    results.distances.truncate(results.count);
+    return results;
 }
 
 void Index::reserve(size_t capacity) const { index_->reserve(capacity); }

package/setup.py

@@ -1,19 +1,31 @@
 import os
 import sys
-from setuptools import setup, find_packages
+from setuptools import setup
 from pybind11.setup_helpers import Pybind11Extension
 
 
 compile_args = ['-std=c++11', '-O3']
+link_args = []
+
+if sys.platform == 'linux':
+    compile_args.append('-fopenmp')
+    link_args.append('-lgomp')
 
 if sys.platform == 'darwin':
-    compile_args.append('-mmacosx-version-min=10.13')
+    # MacOS 10.15 orhigher is needed for `aligned_alloc` support.
+    # https://github.com/unum-cloud/usearch/actions/runs/4975434891/jobs/8902603392
+    compile_args.append('-mmacosx-version-min=10.15')
+
+if sys.platform == 'win32':
+    compile_args = ['/std:c++14', '/O2']
+
 
 ext_modules = [
     Pybind11Extension(
-        'usearch',
+        'usearch.index',
         ['python/lib.cpp'],
         extra_compile_args=compile_args,
+        extra_link_args=link_args,
     ),
 ]
 
@@ -30,7 +42,8 @@ setup(
 
     name=__lib_name__,
     version=__version__,
-    packages=find_packages(),
+    packages=['usearch'],
+    package_dir={'usearch': 'python/usearch'},
 
     description='Smaller & Faster Single-File Vector Search Engine from Unum',
     long_description=long_description,

package/simsimd/include/simsimd/simsimd.h

@@ -255,6 +255,21 @@ inline static simsimd_f32_t simsimd_dot_f32x4avx2(simsimd_f32_t const* a, simsim
 #endif
 }
 
+inline static simsimd_f32_t simsimd_dot_f16x16avx512(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
+#if defined(__AVX512F__)
+    __m512 ab_vec = _mm512_set1_ps(0);
+    for (size_t i = 0; i != d; i += 16)
+        ab_vec = _mm512_fmadd_ps(                     //
+            _mm512_cvtxph_ps(_mm256_loadu_ph(a + i)), //
+            _mm512_cvtxph_ps(_mm256_loadu_ph(b + i)), //
+            ab_vec);
+    return _mm512_reduce_add_ps(ab_vec);
+#else
+    (void)a, (void)b, (void)d;
+    return 0;
+#endif
+}
+
 inline static int32_t simsimd_dot_i8x16avx2(int8_t const* a, int8_t const* b, size_t d) {
 #if defined(__AVX2__)
     __m256i ab_vec = _mm256_set1_epi32(0);