usearch 0.1.0 → 0.1.4

package/.github/workflows/release.yml

@@ -55,8 +55,8 @@ jobs:
           path: ./wheelhouse/*.whl
   
   
-  publish_wheels:
-    name: Publish Wheels to PyPi
+  publish_python:
+    name: Publish Python
     runs-on: ubuntu-20.04
     needs: build_wheels
     environment:
@@ -78,6 +78,35 @@ jobs:
           verbose: true
           print_hash: true
 
+  publish_javascript:
+    name: Publish JavaScript
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - run: git submodule update --init --recursive
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - run: npm install
+      - run: npm ci
+      - run: npm test
+      - uses: JS-DevTools/npm-publish@v2
+        with:
+          token: ${{ secrets.NPM_TOKEN }}
+
+  publish_rust:
+    name: Publish Rust
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - uses: actions-rs/toolchain@v1
+      with:
+          toolchain: stable
+          override: true
+    - uses: katyo/publish-crates@v2
+      with:
+          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}          
 
   deploy_docs:
     name: Deploy Docs
@@ -85,7 +114,7 @@ jobs:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-22.04
-    needs: publish_wheels
+    needs: publish_python
     steps:
       - name: Checkout
         uses: actions/checkout@v3

package/CMakeListsInstructuons.md

@@ -65,12 +65,17 @@ node src/test.js
 npm publish
 ```
 
-### JavaScript
+### Rust
 
 ```sh
-cargo run
+cargo test -p usearch
+cargo publish
 ```
 
+### Java
+
+### Wolfram
+
 ## Benchmarks
 
 ### Datasets

package/{cargo.toml → Cargo.toml}

@@ -1,13 +1,17 @@
 [package]
 name = "usearch"
-version = "0.1.0"
+version = "0.1.4"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "The Tiny Vector Search Engine from Unum"
 edition = "2021"
 license = "Apache-2.0"
-publish = false
+publish = true
 repository = "https://github.com/unum-cloud/usearch"
 
+[lib]
+name = "usearch"
+path = "src/lib.rs"
+
 [dependencies]
 cxx = "1.0"
 

package/README.md

@@ -17,7 +17,7 @@ Compact, yet Powerful<br/>
 <a href="https://github.com/unum-cloud/usearch"><img height="25" src="https://github.com/unum-cloud/.github/raw/main/assets/github.svg" alt="GitHub"></a>
 </p>
 
-- [x] Single C++11 header, easily extendible.
+- [x] Single C++11 header implementation, easily extendible.
 - [x] 4B+ sized space efficient point-clouds with `uint40_t`.
 - [x] Half-precision support with [`maratyszcza/fp16`](https://github.com/maratyszcza/fp16).
 - [x] View from disk, without loading into RAM.
@@ -29,14 +29,16 @@ Compact, yet Powerful<br/>
 - [x] Don't copy vectors if not needed.
 - [x] Bring your threads.
 - [x] Multiple vectors per label.
-- [x] CPython bindings for Python 3.
-- [ ] Node.js bindings for JavaScript.
+- [x] Python bindings: `pip install usearch`
+- [x] JavaScript bindings: `npm install usearch`
+- [x] Rust bindings: `cargo add usearch`
 - [ ] Wolfram language bindings.
 - [x] For Linux: GCC, Clang.
 - [x] For MacOS: Apple Clang.
 - [ ] For Windows.
+- [ ] Multi-index lookups in Python.
+- [ ] Thread-safe `reserve`.
 - [ ] Distributed construction.
-- [ ] Multi-index lookups.
 
 ## Usage
 
@@ -67,3 +69,9 @@ FetchContent_MakeAvailable(usearch)
 ### Bring your Threads
 
 ## Performance
+
+
+## TODO
+
+- JavaScript: Allow calling from "worker threads".
+- Rust: Allow passing a custom thread ID.

package/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.4

package/build.rs

@@ -1,5 +1,5 @@
 fn main() {
-    cxx_build::bridge("src/main.rs")
+    cxx_build::bridge("src/lib.rs")
         .file("src/rust.cpp")
         .flag_if_supported("-std=c++11")
         .include("include")
@@ -8,7 +8,9 @@ fn main() {
         .include("simsimd/include")
         .compile("usearch");
 
-    println!("cargo:rerun-if-changed=src/main.rs");
+    println!("cargo:rerun-if-changed=src/lib.rs");
     println!("cargo:rerun-if-changed=src/rust.cpp");
-    println!("cargo:rerun-if-changed=src/rust.h");
+    println!("cargo:rerun-if-changed=src/rust.hpp");
+    println!("cargo:rerun-if-changed=src/advanced.hpp");
+    println!("cargo:rerun-if-changed=include/usearch/usearch.hpp");
 }

package/include/usearch/usearch.hpp

@@ -59,9 +59,9 @@ using f32_t = float;
  */
 enum class f16_t : std::uint16_t {};
 
-template <typename at> constexpr at angle_to_radians(at angle) noexcept { return angle * M_PI / 180; }
+template <typename at> at angle_to_radians(at angle) noexcept { return angle * M_PI / 180.f; }
 
-template <typename at> constexpr at square(at value) noexcept { return value * value; }
+template <typename at> at square(at value) noexcept { return value * value; }
 
 inline std::size_t ceil2(std::size_t v) noexcept {
     v--;
@@ -223,22 +223,22 @@ template <typename scalar_at> struct pearson_correlation_gt {
 template <typename scalar_at> struct haversine_gt {
     using scalar_t = scalar_at;
     using result_type = scalar_t;
-    static_assert(std::is_floating_point<scalar_t>::value, "Latitude and longitude must be floating-node");
+    static_assert(!std::is_integral<scalar_t>::value, "Latitude and longitude must be floating-node");
 
     inline scalar_t operator()(scalar_t const* a, scalar_t const* b, std::size_t = 2, std::size_t = 2) const noexcept {
         scalar_t lat_a = a[0], lon_a = a[1];
         scalar_t lat_b = b[0], lon_b = b[1];
 
-        scalar_t lat_delta = angle_to_radians(lat_b - lat_a);
-        scalar_t lon_delta = angle_to_radians(lon_b - lon_a);
+        scalar_t lat_delta = angle_to_radians<scalar_t>(lat_b - lat_a);
+        scalar_t lon_delta = angle_to_radians<scalar_t>(lon_b - lon_a);
 
-        scalar_t converted_lat_a = angle_to_radians(lat_a);
-        scalar_t converted_lat_b = angle_to_radians(lat_b);
+        scalar_t converted_lat_a = angle_to_radians<scalar_t>(lat_a);
+        scalar_t converted_lat_b = angle_to_radians<scalar_t>(lat_b);
 
-        scalar_t x = square(std::sin(lat_delta / 2)) +
-                     std::cos(converted_lat_a) * std::cos(converted_lat_b) * square(std::sin(lon_delta / 2));
+        scalar_t x = square(std::sin(lat_delta / 2.f)) +
+                     std::cos(converted_lat_a) * std::cos(converted_lat_b) * square(std::sin(lon_delta / 2.f));
 
-        return std::atan2(std::sqrt(x), std::sqrt(1 - x));
+        return std::atan2(std::sqrt(x), std::sqrt(1.f - x));
     }
 };
 
@@ -506,7 +506,7 @@ struct config_t {
     /// @brief Hyper-parameter controlling the quality of indexing.
     /// Defaults to 40 in FAISS and 200 in hnswlib.
     /// > It is called `efConstruction` in the paper.
-    static constexpr std::size_t expansion_construction_default_k = 128;
+    static constexpr std::size_t expansion_add_default_k = 128;
 
     /// @brief Hyper-parameter controlling the quality of search.
     /// Defaults to 16 in FAISS and 10 in hnswlib.
@@ -514,7 +514,7 @@ struct config_t {
     static constexpr std::size_t expansion_search_default_k = 64;
 
     std::size_t connectivity = connectivity_default_k;
-    std::size_t expansion_add = expansion_construction_default_k;
+    std::size_t expansion_add = expansion_add_default_k;
     std::size_t expansion_search = expansion_search_default_k;
 
     ///

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.1.0",
+    "version": "0.1.4",
     "description": "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
@@ -15,5 +15,8 @@
     "dependencies": {
         "bindings": "~1.2.1",
         "node-addon-api": "^3.0.0"
+    },
+    "scripts": {
+        "test": "node src/test.js"
     }
 }

package/src/advanced.hpp

@@ -59,6 +59,14 @@ class f16_converted_t {
     inline f16_converted_t operator-(f16_converted_t other) const noexcept { return {float(*this) - float(other)}; }
     inline f16_converted_t operator*(f16_converted_t other) const noexcept { return {float(*this) * float(other)}; }
     inline f16_converted_t operator/(f16_converted_t other) const noexcept { return {float(*this) / float(other)}; }
+    inline f16_converted_t operator+(float other) const noexcept { return {float(*this) + other}; }
+    inline f16_converted_t operator-(float other) const noexcept { return {float(*this) - other}; }
+    inline f16_converted_t operator*(float other) const noexcept { return {float(*this) * other}; }
+    inline f16_converted_t operator/(float other) const noexcept { return {float(*this) / other}; }
+    inline f16_converted_t operator+(double other) const noexcept { return {float(*this) + other}; }
+    inline f16_converted_t operator-(double other) const noexcept { return {float(*this) - other}; }
+    inline f16_converted_t operator*(double other) const noexcept { return {float(*this) * other}; }
+    inline f16_converted_t operator/(double other) const noexcept { return {float(*this) / other}; }
 
     inline f16_converted_t& operator+=(float v) noexcept {
         uint16_ = fp16_ieee_from_fp32_value(v + fp16_ieee_to_fp32_value(uint16_));
@@ -164,6 +172,26 @@ enum class accuracy_t {
     i8q100_k,
 };
 
+inline bool str_equals(char const* begin, size_t len, char const* other_begin) noexcept {
+    size_t other_len = strlen(other_begin);
+    return len == other_len && strncmp(begin, other_begin, len) == 0;
+}
+
+inline accuracy_t accuracy(char const* str, size_t len) {
+    accuracy_t accuracy;
+    if (str_equals(str, len, "f32"))
+        accuracy = accuracy_t::f32_k;
+    else if (str_equals(str, len, "f64"))
+        accuracy = accuracy_t::f64_k;
+    else if (str_equals(str, len, "f16"))
+        accuracy = accuracy_t::f16_k;
+    else if (str_equals(str, len, "i8q100"))
+        accuracy = accuracy_t::i8q100_k;
+    else
+        throw std::runtime_error("Unknown type, choose: f32, f16, f64, i8q100");
+    return accuracy;
+}
+
 enum class isa_t {
     auto_k,
     neon_k,
@@ -252,11 +280,11 @@ class auto_index_gt {
     };
 
     std::size_t dimensions_ = 0;
+    std::size_t casted_vector_bytes_ = 0;
     accuracy_t accuracy_ = accuracy_t::f32_k;
-    std::unique_ptr<index_t> index_;
-
     isa_t acceleration_ = isa_t::auto_k;
-    std::size_t casted_vector_bytes_ = 0;
+
+    std::unique_ptr<index_t> index_;
     mutable std::vector<byte_t> cast_buffer_;
     struct casts_t {
         cast_t from_i8q100{};
@@ -269,6 +297,13 @@ class auto_index_gt {
     config_t root_config_;
 
   public:
+    auto_index_gt() = default;
+    auto_index_gt(auto_index_gt&& other)
+        : dimensions_(other.dimensions_), casted_vector_bytes_(other.casted_vector_bytes_), accuracy_(other.accuracy_),
+          acceleration_(other.acceleration_), index_(std::move(other.index_)),
+          cast_buffer_(std::move(other.cast_buffer_)), casts_(std::move(other.casts_)),
+          root_metric_(std::move(other.root_metric_)), root_config_(std::move(other.root_config_)) {}
+
     std::size_t dimensions() const noexcept { return dimensions_; }
     std::size_t connectivity() const noexcept { return index_->connectivity(); }
     std::size_t size() const noexcept { return index_->size(); }
@@ -292,20 +327,12 @@ class auto_index_gt {
     std::size_t search(f16_converted_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread = 0) 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 = 0) 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 = 0) const { return search(vector, wanted, matches, distances, thread, casts_.from_f64); }
-    // clang-format on
 
-    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);
-    }
-
-    static auto_index_gt cos(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) {
-        return {};
-    }
-    static auto_index_gt haversine(accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) { return {}; }
+    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); }
+    static auto_index_gt cos(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) { return make(dimensions, accuracy, cos_metric(dimensions, accuracy), make_casts(accuracy), config); }
+    static auto_index_gt haversine(accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) { return make(2, accuracy, haversine_metric(accuracy), make_casts(accuracy), config); }
+    // clang-format on
 
     auto_index_gt fork() const {
         auto_index_gt result;
@@ -339,8 +366,10 @@ class auto_index_gt {
     }
 
     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 {
+    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 {
 
         byte_t const* vector_data = reinterpret_cast<byte_t const*>(vector);
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
@@ -412,7 +441,7 @@ class auto_index_gt {
         if (supports_arm_sve())
             return {
                 pun_metric<simsimd_f32_t>([](simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) noexcept {
-                    return 1 - simsimd_dot_f32sve(a, b, d);
+                return 1 - simsimd_dot_f32sve(a, b, d);
                 }),
                 isa_t::sve_k,
             };
@@ -461,7 +490,7 @@ class auto_index_gt {
         }
     }
 
-    static metric_and_meta_t l2_metric(std::size_t dimensions, accuracy_t accuracy) {
+    static metric_and_meta_t l2_metric(std::size_t, accuracy_t accuracy) {
         switch (accuracy) {
         case accuracy_t::i8q100_k: return {};
         case accuracy_t::f16_k: return {pun_metric<f16_converted_t>(l2_squared_gt<f16_converted_t>{}), isa_t::auto_k};
@@ -471,7 +500,7 @@ class auto_index_gt {
         }
     }
 
-    static metric_and_meta_t cos_metric(std::size_t dimensions, accuracy_t accuracy) {
+    static metric_and_meta_t cos_metric(std::size_t, accuracy_t accuracy) {
         switch (accuracy) {
         case accuracy_t::i8q100_k: return {};
         case accuracy_t::f16_k: return {pun_metric<f16_converted_t>(cos_gt<f16_converted_t>{}), isa_t::auto_k};
@@ -480,6 +509,16 @@ class auto_index_gt {
         default: return {};
         }
     }
+
+    static metric_and_meta_t haversine_metric(accuracy_t accuracy) {
+        switch (accuracy) {
+        case accuracy_t::i8q100_k: return {};
+        case accuracy_t::f16_k: return {pun_metric<f16_converted_t>(haversine_gt<f16_converted_t>{}), isa_t::auto_k};
+        case accuracy_t::f32_k: return {pun_metric<f32_t>(haversine_gt<f32_t>{}), isa_t::auto_k};
+        case accuracy_t::f64_k: return {pun_metric<f64_t>(haversine_gt<f64_t>{}), isa_t::auto_k};
+        default: return {};
+        }
+    }
 };
 
 using auto_index_t = auto_index_gt<std::int64_t, std::uint32_t>;

package/src/bench.cpp

@@ -256,7 +256,7 @@ struct args_t {
     std::string path_neighbors;
 
     std::size_t connectivity = config_t::connectivity_default_k;
-    std::size_t expansion_add = config_t::expansion_construction_default_k;
+    std::size_t expansion_add = config_t::expansion_add_default_k;
     std::size_t expansion_search = config_t::expansion_search_default_k;
     std::size_t threads = std::thread::hardware_concurrency();
 
@@ -273,6 +273,19 @@ struct args_t {
     bool metric_haversine = false;
 };
 
+template <typename index_at, typename dataset_at> //
+index_at type_punned_index_for_metric(dataset_at& dataset, args_t const& args, config_t config, accuracy_t accuracy) {
+    if (args.metric_ip)
+        return index_at::ip(dataset.dimensions(), accuracy, config);
+    if (args.metric_l2)
+        return index_at::l2(dataset.dimensions(), accuracy, config);
+    if (args.metric_cos)
+        return index_at::cos(dataset.dimensions(), accuracy, config);
+    if (args.metric_haversine)
+        return index_at::haversine(accuracy, config);
+    return index_at{};
+}
+
 template <typename index_at, typename dataset_at> //
 void run_type_punned(dataset_at& dataset, args_t const& args, config_t config) {
 
@@ -282,16 +295,7 @@ void run_type_punned(dataset_at& dataset, args_t const& args, config_t config) {
     if (args.quantize_i8)
         accuracy = accuracy_t::i8q100_k;
 
-    index_at index;
-    if (args.metric_ip)
-        index = index_at::ip(dataset.dimensions(), accuracy, config);
-    if (args.metric_l2)
-        index = index_at::l2(dataset.dimensions(), accuracy, config);
-    if (args.metric_cos)
-        index = index_at::cos(dataset.dimensions(), accuracy, config);
-    if (args.metric_haversine)
-        index = index_at::haversine(accuracy, config);
-
+    index_at index{type_punned_index_for_metric<index_at>(dataset, args, config, accuracy)};
     std::printf("- Hardware acceleration: %s\n", isa(index.acceleration()));
     std::printf("-- Will benchmark in-memory\n");
 

package/src/lib.rs

@@ -0,0 +1,83 @@
+#[cxx::bridge]
+pub mod ffi {
+    
+    // Shared structs with fields visible to both languages.
+    struct Matches {
+        count: usize,
+        labels: Vec<u32>,
+        distances: Vec<f32>,
+    }
+
+    // C++ types and signatures exposed to Rust.
+    unsafe extern "C++" {
+        include!("rust.hpp");
+
+        type Index;
+
+        fn new_ip(dimensions: usize, quantization: &str, connectivity: usize, expansion_add: usize, expansion_search: usize) -> Result<UniquePtr<Index>>;
+        fn new_l2(dimensions: usize, quantization: &str, connectivity: usize, expansion_add: usize, expansion_search: usize) -> Result<UniquePtr<Index>>;
+        fn new_cos(dimensions: usize, quantization: &str, connectivity: usize, expansion_add: usize, expansion_search: usize) -> Result<UniquePtr<Index>>;
+        fn new_haversine(quantization: &str, connectivity: usize, expansion_add: usize, expansion_search: usize) -> Result<UniquePtr<Index>>;
+
+        fn reserve(self: &Index, capacity: usize) -> Result<()>;
+
+        fn dimensions(self: &Index) -> usize;
+        fn connectivity(self: &Index) -> usize;
+        fn size(self: &Index) -> usize;
+        fn capacity(self: &Index) -> usize;
+
+        fn add(self: &Index, label: u32, vector: &[f32]) -> Result<()>;
+        fn search(self: &Index, query: &[f32], count: usize) -> Result<Matches>;
+
+        fn add_in_thread(self: &Index, label: u32, vector: &[f32], thread: usize) -> Result<()>;
+        fn search_in_thread(self: &Index, query: &[f32], count: usize, thread: usize) -> Result<Matches>;
+
+        fn save(self: &Index, path: &str) -> Result<()>;
+        fn load(self: &Index, path: &str) -> Result<()>;
+        fn view(self: &Index, path: &str) -> Result<()>;
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use crate::ffi::new_ip;
+    use crate::ffi::new_l2;
+    use crate::ffi::new_cos;
+    use crate::ffi::new_haversine;
+
+    #[test]
+    fn integration() {
+
+        let quant = "f16";
+        let index = new_ip(5,  &quant, 0, 0, 0).unwrap();
+    
+        assert!(index.reserve(10).is_ok());
+        assert!(index.capacity() >= 10);
+        assert!(index.connectivity() != 0);
+        assert_eq!(index.dimensions(), 5);
+        assert_eq!(index.size(), 0);
+    
+        let first: [f32; 5] = [0.2, 0.1, 0.2, 0.1, 0.3];
+        let second: [f32; 5] = [0.2, 0.1, 0.2, 0.1, 0.3];
+    
+        assert!(index.add(42, &first).is_ok());
+        assert!(index.add(43, &second).is_ok());
+        assert_eq!(index.size(), 2);
+    
+        // Read back the tags
+        let results = index.search(&first, 10).unwrap();
+        assert_eq!(results.count, 2);
+    
+        // Validate serialization
+        assert!(index.save("index.rust.usearch").is_ok());
+        assert!(index.load("index.rust.usearch").is_ok());
+        assert!(index.view("index.rust.usearch").is_ok());
+    
+        // Make sure every function is called at least once
+        assert!(new_ip(5,  &quant, 0, 0, 0).is_ok());
+        assert!(new_l2(5,  &quant, 0, 0, 0).is_ok());
+        assert!(new_cos(5,  &quant, 0, 0, 0).is_ok());
+        assert!(new_haversine(&quant, 0, 0, 0).is_ok());
+    }
+}

package/src/python.cpp

@@ -195,15 +195,15 @@ PYBIND11_MODULE(usearch, m) {
 
     auto i = py::class_<native_index_t>(m, "Index");
 
-    i.def(py::init(&make_index),                                                 //
-          py::kw_only(),                                                         //
-          py::arg("dim"),                                                        //
-          py::arg("capacity") = 0,                                               //
-          py::arg("dtype") = std::string("f32"),                                 //
-          py::arg("metric") = std::string("ip"),                                 //
-          py::arg("connectivity") = config_t::connectivity_default_k,            //
-          py::arg("expansion_add") = config_t::expansion_construction_default_k, //
-          py::arg("expansion_search") = config_t::expansion_search_default_k     //
+    i.def(py::init(&make_index),                                             //
+          py::kw_only(),                                                     //
+          py::arg("dim"),                                                    //
+          py::arg("capacity") = 0,                                           //
+          py::arg("dtype") = std::string("f32"),                             //
+          py::arg("metric") = std::string("ip"),                             //
+          py::arg("connectivity") = config_t::connectivity_default_k,        //
+          py::arg("expansion_add") = config_t::expansion_add_default_k,      //
+          py::arg("expansion_search") = config_t::expansion_search_default_k //
     );
 
     i.def(                     //

package/src/rust.cpp

@@ -1,23 +1,72 @@
-#include "rust.h"
-
-#include "advanced.hpp"
+#include "usearch/src/rust.hpp"
+#include "usearch/src/lib.rs.h"
 
 using namespace unum::usearch;
 using namespace unum;
 
-class Index::impl {
-    friend Index;
-    downcasting_index_t native_;
-};
+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);
+}
+
+Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const {
+    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(), thread);
+    results.labels.truncate(results.count);
+    results.distances.truncate(results.count);
+    return results;
+}
+
+void Index::add(uint32_t label, rust::Slice<float const> vector) const { return add_in_thread(label, vector, 0); }
+Matches Index::search(rust::Slice<float const> vector, size_t count) const {
+    return search_in_thread(vector, count, 0);
+}
+
+void Index::reserve(size_t capacity) const { index_->reserve(capacity); }
+
+size_t Index::dimensions() const { return index_->dimensions(); }
+size_t Index::connectivity() const { return index_->connectivity(); }
+size_t Index::size() const { return index_->size(); }
+size_t Index::capacity() const { return index_->capacity(); }
+
+void Index::save(rust::Str path) const { index_->save(std::string(path).c_str()); }
+void Index::load(rust::Str path) const { index_->load(std::string(path).c_str()); }
+void Index::view(rust::Str path) const { index_->view(std::string(path).c_str()); }
+
+accuracy_t accuracy(rust::Str quant) { return accuracy(quant.data(), quant.size()); }
+
+std::unique_ptr<Index> wrap(native_index_t&& index) {
+    std::shared_ptr<native_index_t> native = std::make_shared<native_index_t>(std::move(index));
+    return std::unique_ptr<Index>(new Index(native));
+}
+
+config_t config(size_t connectivity, size_t exp_add, size_t exp_search) {
+    config_t result;
+    result.connectivity = connectivity ? connectivity : config_t::connectivity_default_k;
+    result.expansion_add = exp_add ? exp_add : config_t::expansion_add_default_k;
+    result.expansion_search = exp_search ? exp_search : config_t::expansion_search_default_k;
+    return result;
+}
 
-Index::Index() : impl(new class Index::impl) {}
+std::unique_ptr<Index> new_ip(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
+    return wrap(native_index_t::ip(dims, accuracy(quant), config(connectivity, exp_add, exp_search)));
+}
 
-void Index::add(uint64_t label, rust::Slice<float const> vector) const {}
-Results Index::search(rust::Slice<float const> vector, uint64_t count) const { return {}; }
+std::unique_ptr<Index> new_l2(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
+    return wrap(native_index_t::l2(dims, accuracy(quant), config(connectivity, exp_add, exp_search)));
+}
 
-uint64_t Index::dim() const { return impl->native_.dim(); }
-uint64_t Index::connectivity() const { return impl->native_.connectivity(); }
-uint64_t Index::size() const { return impl->native_.size(); }
-uint64_t Index::capacity() const { return impl->native_.capacity(); }
+std::unique_ptr<Index> new_cos(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
+    return wrap(native_index_t::cos(dims, accuracy(quant), config(connectivity, exp_add, exp_search)));
+}
 
-std::unique_ptr<Index> new_index() { return std::make_unique<Index>(); }
+std::unique_ptr<Index> new_haversine(rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
+    return wrap(native_index_t::haversine(accuracy(quant), config(connectivity, exp_add, exp_search)));
+}

package/src/rust.hpp

@@ -0,0 +1,46 @@
+#pragma once
+#include "rust/cxx.h"
+
+#include <memory> // `std::shared_ptr`
+
+#include "advanced.hpp"
+
+struct Matches;
+
+enum class Metric;
+
+enum class Accuracy;
+
+class Index {
+  public:
+    using label_t = std::uint32_t;
+    using distance_t = unum::usearch::punned_distance_t;
+    using native_index_t = unum::usearch::auto_index_gt<label_t>;
+
+    Index(std::shared_ptr<native_index_t> index);
+
+    void reserve(size_t) const;
+
+    void add(uint32_t label, rust::Slice<float const> vector) const;
+    void add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const;
+
+    Matches search(rust::Slice<float const> vector, size_t count) const;
+    Matches search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const;
+
+    size_t dimensions() const;
+    size_t connectivity() const;
+    size_t size() const;
+    size_t capacity() const;
+
+    void save(rust::Str path) const;
+    void load(rust::Str path) const;
+    void view(rust::Str path) const;
+
+  private:
+    std::shared_ptr<native_index_t> index_;
+};
+
+std::unique_ptr<Index> new_ip(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search);
+std::unique_ptr<Index> new_l2(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search);
+std::unique_ptr<Index> new_cos(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search);
+std::unique_ptr<Index> new_haversine(rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search);

package/src/main.rs

@@ -1,42 +0,0 @@
-#[cxx::bridge]
-mod ffi {
-    
-    // Shared structs with fields visible to both languages.
-    struct Results {
-        size: usize,
-        labels: Vec<u32>,
-        distances: Vec<f32>,
-    }
-
-    // C++ types and signatures exposed to Rust.
-    unsafe extern "C++" {
-        include!("rust.h");
-
-        type Index;
-
-        fn new_index() -> UniquePtr<Index>;
-
-        fn dim(&self) -> u64;
-        fn connectivity(&self) -> u64;
-        fn size(&self) -> u64;
-        fn capacity(&self) -> u64;
-
-        fn add(&self, label: u64, vector: &[f32]);
-        fn search(&self, query: &[f32], count: u64) -> Results;
-    }
-}
-
-
-fn main() {
-    let client = ffi::new_index();
-
-    // Upload a blob.
-    let chunks = vec![b"fearless".to_vec(), b"concurrency".to_vec()];
-    let mut buf = MultiBuf { chunks, pos: 0 };
-    let blobid = client.add(&mut buf);
-    println!("blobid = {}", blobid);
-
-    // Read back the tags.
-    let search = client.search(blobid);
-    println!("tags = {:?}", search.tags);
-}

package/src/rust.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "rust/cxx.h"
-
-struct Results;
-
-class Index {
-  public:
-    Index();
-    void add(uint64_t label, rust::Slice<float const> vector) const;
-    Results search(rust::Slice<float const> vector, uint64_t count) const;
-
-    uint64_t dim() const;
-    uint64_t connectivity() const;
-    uint64_t size() const;
-    uint64_t capacity() const;
-
-  private:
-    class impl;
-    std::shared_ptr<impl> impl;
-};
-
-std::unique_ptr<Index> new_index();