usearch 1.2.2 → 1.3.0

package/.github/workflows/prerelease.yml

@@ -17,6 +17,32 @@ permissions:
 
 jobs:
 
+  test_c:
+    name: Test C
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        ref: main-dev
+    - run: git submodule update --init --recursive
+    - name: Prepare Environment
+      run: |
+        sudo apt update && 
+        sudo apt install -y cmake g++-12 build-essential libjemalloc-dev
+    - name: Build
+      run: |
+        cmake -B ./build_release \
+        -DCMAKE_CXX_COMPILER="g++-12" \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DUSEARCH_BUILD_TEST=1 \
+        -DUSEARCH_USE_OPENMP=1 \
+        -DUSEARCH_USE_SIMSIMD=1 \
+        -DUSEARCH_USE_JEMALLOC=1 \
+        -DUSEARCH_BUILD_BENCHMARK=0 &&
+        make -C ./build_release -j
+    - name: Run tests
+      run: ./build_release/test_c
+
   test_cpp:
     name: Test C++
     runs-on: ubuntu-latest

package/.github/workflows/release.yml

@@ -287,7 +287,7 @@ jobs:
         run: |
               sudo apt update && 
               sudo apt install -y doxygen graphviz dia git && 
-              pip install sphinx==7.1.2 sphinx-js breathe furo m2r2 sphinxcontrib-googleanalytics==0.2.dev20220708 sphinxcontrib-jquery && 
+              pip install sphinx==5.3.0 sphinx-js==3.2.1 breathe==4.35.0 furo==2023.3.27 m2r2==0.3.3.post2 sphinxcontrib-googleanalytics==0.2.dev20220708 sphinxcontrib-jquery==4.1 && 
               npm install -g jsdoc
       - name: Install USearch from PyPi
         run: pip install usearch

package/CMakeLists.txt

@@ -113,6 +113,7 @@ if(USEARCH_INSTALL)
 endif()
 
 if(${USEARCH_BUILD_TEST} OR ${USEARCH_BUILD_BENCHMARK})
+    add_subdirectory(c)
     add_subdirectory(cpp)
 endif()
 

package/Cargo.toml

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

package/README.md

@@ -109,10 +109,10 @@ Comparing the performance of FAISS against USearch on 1 Million 96-dimensional v
 
 |              | FAISS, `f32` | USearch, `f32` | USearch, `f16` |     USearch, `i8` |
 | :----------- | -----------: | -------------: | -------------: | ----------------: |
-| Batch Insert |       16 K/s |         73 K/s |        100 K/s | 104 K/s **+550%** |
-| Batch Search |       82 K/s |        103 K/s |        113 K/s |  134 K/s **+63%** |
-| Bulk Insert  |       76 K/s |        105 K/s |        115 K/s | 202 K/s **+165%** |
-| Bulk Search  |      118 K/s |        174 K/s |        173 K/s | 304 K/s **+157%** |
+| Batch Insert |       16 K/s |         73 K/s |        100 K/s | 104 K/s __+550%__ |
+| Batch Search |       82 K/s |        103 K/s |        113 K/s |  134 K/s __+63%__ |
+| Bulk Insert  |       76 K/s |        105 K/s |        115 K/s | 202 K/s __+165%__ |
+| Bulk Search  |      118 K/s |        174 K/s |        173 K/s | 304 K/s __+157%__ |
 | Recall @ 10  |          99% |          99.2% |          99.1% |             99.2% |
 
 > HNSW was configured with identical hyper-parameters:
@@ -152,10 +152,16 @@ Instead, we have focused on high-precision arithmetic over low-precision downcas
 The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f32_t`, `f16_t`, `f64_t`, and `i8_t` representations, even if the hardware doesn't natively support it.
 Continuing the topic of memory efficiency, we provide a `uint40_t` to allow collection with over 4B+ vectors without allocating 8 bytes for every neighbor reference in the proximity graph.
 
-## Serving `Index` from Disk
+## Serialization & Serving `Index` from Disk
 
-With USearch, you can serve indexes from external memory, enabling you to optimize your server choices for indexing speed and serving costs.
-This can result in **20x cost reduction** on AWS and other public clouds.
+USearch supports multiple forms of serialization:
+
+- Into a __file__ defined with a path.
+- Into a __stream__ defined with a callback, serializing or reconstructing incrementally.
+- Into a __buffer__ of fixed length, or a memory-mapped file, that supports random access.
+
+The latter allows you to serve indexes from external memory, enabling you to optimize your server choices for indexing speed and serving costs.
+This can result in __20x cost reduction__ on AWS and other public clouds.
 
 ```py
 index.save("index.usearch")
@@ -186,10 +192,10 @@ many_in_many: BatchMatches = search(vectors, vectors, 50, MetricKind.L2sq, exact
 ```
 
 By passing the `exact=True` argument, the system bypasses indexing altogether and performs a brute-force search through the entire dataset using SIMD-optimized similarity metrics from [SimSIMD](https://github.com/ashvardanian/simsimd).
-When compared to FAISS's `IndexFlatL2` in Google Colab, **[USearch may offer up to a 20x performance improvement](https://github.com/unum-cloud/usearch/issues/176#issuecomment-1666650778)**:
+When compared to FAISS's `IndexFlatL2` in Google Colab, __[USearch may offer up to a 20x performance improvement](https://github.com/unum-cloud/usearch/issues/176#issuecomment-1666650778)__:
 
-- `faiss.IndexFlatL2`: **55.3 ms**.
-- `usearch.index.search`: **2.54 ms**.
+- `faiss.IndexFlatL2`: __55.3 ms__.
+- `usearch.index.search`: __2.54 ms__.
 
 ## `Indexes` for Multi-Index Lookups
 

package/c/lib.cpp

@@ -54,7 +54,7 @@ add_result_t add_(index_dense_t* index, usearch_key_t key, void const* vector, s
     }
 }
 
-bool get_(index_dense_t* index, usearch_key_t key, size_t count, void* vector, scalar_kind_t kind) {
+std::size_t get_(index_dense_t* index, usearch_key_t key, size_t count, void* vector, scalar_kind_t kind) {
     switch (kind) {
     case scalar_kind_t::f32_k: return index->get(key, (f32_t*)vector, count);
     case scalar_kind_t::f64_k: return index->get(key, (f64_t*)vector, count);
@@ -103,6 +103,11 @@ USEARCH_EXPORT void usearch_free(usearch_index_t index, usearch_error_t*) {
     delete reinterpret_cast<index_dense_t*>(index);
 }
 
+USEARCH_EXPORT size_t usearch_serialized_length(usearch_index_t index, usearch_error_t*) {
+    assert(index);
+    return reinterpret_cast<index_dense_t*>(index)->serialized_length();
+}
+
 USEARCH_EXPORT void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
 
     assert(index && path && error);
@@ -127,6 +132,35 @@ USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearc
         *error = result.error.release();
 }
 
+USEARCH_EXPORT void usearch_save_buffer(usearch_index_t index, void* buffer, size_t length, usearch_error_t* error) {
+
+    assert(index && buffer && length && error);
+    memory_mapped_file_t memory_map((byte_t*)buffer, length);
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->save(std::move(memory_map));
+    if (!result)
+        *error = result.error.release();
+}
+
+USEARCH_EXPORT void usearch_load_buffer(usearch_index_t index, void const* buffer, size_t length,
+                                        usearch_error_t* error) {
+
+    assert(index && buffer && length && error);
+    memory_mapped_file_t memory_map((byte_t*)buffer, length);
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->load(std::move(memory_map));
+    if (!result)
+        *error = result.error.release();
+}
+
+USEARCH_EXPORT void usearch_view_buffer(usearch_index_t index, void const* buffer, size_t length,
+                                        usearch_error_t* error) {
+
+    assert(index && buffer && length && error);
+    memory_mapped_file_t memory_map((byte_t*)buffer, length);
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->view(std::move(memory_map));
+    if (!result)
+        *error = result.error.release();
+}
+
 USEARCH_EXPORT size_t usearch_size(usearch_index_t index, usearch_error_t*) { //
     return reinterpret_cast<index_dense_t*>(index)->size();
 }

package/c/test.c

@@ -13,46 +13,18 @@
     }
 
 
-void parse_vectors_from_file(char const* file_path, size_t* count, size_t* dimension, float** data) {
-
-    // Open the file
-    struct stat st = {};
-    ASSERT(stat(file_path, &st) == 0, "Failed to get metadata of the file");
-    FILE* file = fopen(file_path, "rb");
-    ASSERT(file, "Failed to open the file");
-
-    // Read vectors dimension and calculate count
-    int dim = 0;
-    size_t read = fread(&dim, sizeof(int), 1, file);
-    ASSERT(read == 1, "Failed to read from the file");
-    ASSERT(st.st_size % ((dim + 1) * sizeof(float)) == 0, "File does not contain a whole number of vectors");
-    *dimension = (size_t)dim;
-    *count = st.st_size / ((dim + 1) * sizeof(float));
-
-    // Allocate memory for the vectors' data
-    *data = (float*)malloc(*count * *dimension * sizeof(float));
-    ASSERT(*data, "Failed to allocate memory");
-
-    // Read the data
-    for (size_t i = 0; i < *count; ++i) {
-        read = fread(*data + i * *dimension, sizeof(float), *dimension, file);
-        ASSERT(read == *dimension, "Failed to read from the file");
-         if (i == *count - 1)
-            break;
-
-        // Skip
-        float skip;
-        read = fread(&skip, sizeof(float), 1, file);
-        ASSERT(read == 1, "Failed to read from the file");
-    }
-
-    fclose(file);
+float* create_vectors(size_t count, size_t dimensions) {
+    float* data = (float*)malloc(count * dimensions * sizeof(float));
+    ASSERT(data, "Failed to allocate memory");
+    for (size_t idx = 0; idx < count * dimensions; ++idx)
+        data[idx] = (float)rand() / (float)RAND_MAX;
+    return data;
 }
 
-usearch_init_options_t create_options(size_t vector_dimension) {
+usearch_init_options_t create_options(size_t dimensions) {
     usearch_init_options_t opts;
     opts.connectivity = 2; // 32 in faiss
-    opts.dimensions = vector_dimension;
+    opts.dimensions = dimensions;
     opts.expansion_add = 40;    // 40 in faiss
     opts.expansion_search = 16; // 10 in faiss
     opts.metric_kind = usearch_metric_ip_k;
@@ -61,14 +33,13 @@ usearch_init_options_t create_options(size_t vector_dimension) {
     return opts;
 }
 
-void test_init(size_t vectors_count, size_t vector_dimension) {
+void test_init(size_t collection_size, size_t dimensions) {
     printf("Test: Index Initialization...\n");
 
     // Init index
-    usearch_index_t idx = NULL;
     usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(vector_dimension);
-    idx = usearch_init(&opts, &error);
+    usearch_init_options_t opts = create_options(dimensions);
+    usearch_index_t idx = usearch_init(&opts, &error);
     ASSERT(!error, error);
     usearch_free(idx, &error);
     ASSERT(!error, error);
@@ -79,15 +50,15 @@ void test_init(size_t vectors_count, size_t vector_dimension) {
 
     ASSERT(usearch_size(idx, &error) == 0, error);
     ASSERT(usearch_capacity(idx, &error) == 0, error);
-    ASSERT(usearch_dimensions(idx, &error) == vector_dimension, error);
+    ASSERT(usearch_dimensions(idx, &error) == dimensions, error);
     ASSERT(usearch_connectivity(idx, &error) == opts.connectivity, error);
 
     // Reserve
-    usearch_reserve(idx, vectors_count, &error);
+    usearch_reserve(idx, collection_size, &error);
     ASSERT(!error, error);
     ASSERT(usearch_size(idx, &error) == 0, error);
-    ASSERT(usearch_capacity(idx, &error) == vectors_count, error);
-    ASSERT(usearch_dimensions(idx, &error) == vector_dimension, error);
+    ASSERT(usearch_capacity(idx, &error) == collection_size, error);
+    ASSERT(usearch_dimensions(idx, &error) == dimensions, error);
     ASSERT(usearch_connectivity(idx, &error) == opts.connectivity, error);
 
     usearch_free(idx, &error);
@@ -96,110 +67,148 @@ void test_init(size_t vectors_count, size_t vector_dimension) {
     printf("Test: Index Initialization - PASSED\n");
 }
 
-void test_add_vector(size_t vectors_count, size_t vector_dimension, float const* data) {
+void test_add_vector(size_t collection_size, size_t dimensions) {
     printf("Test: Add Vector...\n");
 
-    usearch_index_t idx = NULL;
     usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(vector_dimension);
-    idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, vectors_count, &error);
+    usearch_init_options_t opts = create_options(dimensions);
+    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_reserve(idx, collection_size, &error);
 
     // Add vectors
-    for (size_t i = 0; i < vectors_count; ++i) {
+    float* data = create_vectors(collection_size, dimensions);
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        usearch_add(idx, key, data + i * vector_dimension, usearch_scalar_f32_k, &error);
+        usearch_add(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
-    ASSERT(usearch_size(idx, &error) == vectors_count, error);
-    ASSERT(usearch_capacity(idx, &error) == vectors_count, error);
+    ASSERT(usearch_size(idx, &error) == collection_size, error);
+    ASSERT(usearch_capacity(idx, &error) == collection_size, error);
 
     // Check vectors in the index
-    for (size_t i = 0; i < vectors_count; ++i) {
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         ASSERT(usearch_contains(idx, key, &error), error);
     }
     ASSERT(!usearch_contains(idx, -1, &error), error); // Non existing key
 
+    free(data);
     usearch_free(idx, &error);
     printf("Test: Add Vector - PASSED\n");
 }
 
-void test_find_vector(size_t vectors_count, size_t vector_dimension, float const* data) {
+void test_find_vector(size_t collection_size, size_t dimensions) {
     printf("Test: Find Vector...\n");
 
-    usearch_index_t idx = NULL;
     usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(vector_dimension);
-    idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, vectors_count, &error);
+    usearch_init_options_t opts = create_options(dimensions);
+    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_reserve(idx, collection_size, &error);
 
     // Create result buffers
-    int results_count = 10;
+    int results_count = collection_size;
     usearch_key_t* keys = (usearch_key_t*)malloc(results_count * sizeof(usearch_key_t));
     float* distances = (float*)malloc(results_count * sizeof(float));
     ASSERT(keys && distances, "Failed to allocate memory");
 
     // Add vectors
-    for (size_t i = 0; i < vectors_count; ++i) {
+    float* data = create_vectors(collection_size, dimensions);
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        usearch_add(idx, key, data + i * vector_dimension, usearch_scalar_f32_k, &error);
+        usearch_add(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
     // Find the vectors
-    for (size_t i = 0; i < vectors_count; i++) {
-        const void *query_vector = data + i * vector_dimension;
+    for (size_t i = 0; i < collection_size; i++) {
+        const void *query_vector = data + i * dimensions;
         size_t found_count = usearch_search(idx, query_vector, usearch_scalar_f32_k, results_count, keys, distances, &error);
         ASSERT(!error, error);
         ASSERT(found_count = results_count, "Vector is missing");
     }
 
+    free(data);
+    free(keys);
+    free(distances);
     usearch_free(idx, &error);
     printf("Test: Find Vector - PASSED\n");
 }
 
-void test_remove_vector(size_t vectors_count, size_t vector_dimension, float const* data) {
+void test_get_vector(size_t collection_size, size_t dimensions) {
+    printf("Test: Get Vector...\n");
+
+    usearch_error_t error = NULL;
+    usearch_init_options_t opts = create_options(dimensions);
+    opts.multi = true;
+    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_reserve(idx, collection_size, &error);
+
+    // Create result buffers
+    int results_count = collection_size;
+    float* vectors = (float*)malloc(results_count * dimensions * sizeof(float));
+    ASSERT(vectors, "Failed to allocate memory");
+
+    // Add multiple vectors with SAME key
+    usearch_key_t const key = 1;
+    float* data = create_vectors(collection_size, dimensions);
+    for (size_t i = 0; i < collection_size; i++) {
+        usearch_add(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        ASSERT(!error, error);
+    }
+
+    // Retrieve vectors from index
+    size_t count = usearch_get(idx, key, collection_size, vectors, usearch_scalar_f32_k, &error);
+    ASSERT(count == results_count, "Vector is missing");
+
+    free(vectors);
+    free(data);
+    usearch_free(idx, &error);
+
+    printf("Test: Get Vector - PASSED\n");
+}
+
+void test_remove_vector(size_t collection_size, size_t dimensions) {
     printf("Test: Remove Vector...\n");
 
-    usearch_index_t idx = NULL;
     usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(vector_dimension);
-    idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, vectors_count, &error);
+    usearch_init_options_t opts = create_options(dimensions);
+    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_reserve(idx, collection_size, &error);
 
     // Add vectors
-    for (size_t i = 0; i < vectors_count; ++i) {
+    float* data = create_vectors(collection_size, dimensions);
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        usearch_add(idx, key, data + i * vector_dimension, usearch_scalar_f32_k, &error);
+        usearch_add(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
     // Remove the vectors
-    for (size_t i = 0; i < vectors_count; i++) {
+    for (size_t i = 0; i < collection_size; i++) {
         usearch_key_t key = i;
         usearch_remove(idx, key, &error);
-        ASSERT(error, "Currently, Remove is not supported");
+        ASSERT(!error, "Currently, Remove is not supported");
     }
 
+    free(data);
     usearch_free(idx, &error);
     printf("Test: Remove Vector - PASSED\n");
 }
 
-void test_save_load(size_t vectors_count, size_t vector_dimension, float const* data) {
+void test_save_load(size_t collection_size, size_t dimensions) {
     printf("Test: Save/Load...\n");
 
-    usearch_index_t idx = NULL;
     usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(vector_dimension);
-    idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, vectors_count, &error);
+    usearch_init_options_t opts = create_options(dimensions);
+    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_reserve(idx, collection_size, &error);
 
     // Add vectors
-    for (size_t i = 0; i < vectors_count; ++i) {
+    float* data = create_vectors(collection_size, dimensions);
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        usearch_add(idx, key, data + i * vector_dimension, usearch_scalar_f32_k, &error);
+        usearch_add(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
@@ -217,34 +226,35 @@ void test_save_load(size_t vectors_count, size_t vector_dimension, float const*
     // Load
     usearch_load(idx, "usearch_index.bin", &error);
     ASSERT(!error, error);
-    ASSERT(usearch_size(idx, &error) == vectors_count, error);
-    ASSERT(usearch_capacity(idx, &error) == vectors_count, error);
-    ASSERT(usearch_dimensions(idx, &error) == vector_dimension, error);
+    ASSERT(usearch_size(idx, &error) == collection_size, error);
+    ASSERT(usearch_capacity(idx, &error) == collection_size, error);
+    ASSERT(usearch_dimensions(idx, &error) == dimensions, error);
     ASSERT(usearch_connectivity(idx, &error) == opts.connectivity, error);
 
     // Check vectors in the index
-    for (size_t i = 0; i < vectors_count; ++i) {
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         ASSERT(usearch_contains(idx, key, &error), error);
     }
 
+    free(data);
     usearch_free(idx, &error);
     printf("Test: Save/Load - PASSED\n");
 }
 
-void test_view(size_t vectors_count, size_t vector_dimension, float const* data) {
+void test_view(size_t collection_size, size_t dimensions) {
     printf("Test: View...\n");
 
-    usearch_index_t idx = NULL;
     usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(vector_dimension);
-    idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, vectors_count, &error);
+    usearch_init_options_t opts = create_options(dimensions);
+    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_reserve(idx, collection_size, &error);
 
     // Add vectors
-    for (size_t i = 0; i < vectors_count; ++i) {
+    float* data = create_vectors(collection_size, dimensions);
+    for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        usearch_add(idx, key, data + i * vector_dimension, usearch_scalar_f32_k, &error);
+        usearch_add(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
@@ -262,33 +272,26 @@ void test_view(size_t vectors_count, size_t vector_dimension, float const* data)
     usearch_view(idx, "usearch_index.bin", &error);
     ASSERT(!error, error);
 
+    free(data);
     usearch_free(idx, &error);
     printf("Test: View - PASSED\n");
 }
 
-int main(int argc, char* argv[]) {
-    // Resolve file path
-    char const* filename = "sample.fvecs";
-    if (argc == 2)
-        filename = argv[1];
-
-    // Read data from the file
-    float* data = NULL;
-    size_t vectors_count = 0;
-    size_t vector_dimension = 0;
-    parse_vectors_from_file(filename, &vectors_count, &vector_dimension, &data);
-    vectors_count = vectors_count > 100000 ? 100000 : vectors_count; // Just limit vectors
-
-    // Test
-    test_init(vectors_count, vector_dimension);
-    test_add_vector(vectors_count, vector_dimension, data);
-    test_find_vector(vectors_count, vector_dimension, data);
-    test_remove_vector(vectors_count, vector_dimension, data);
-    test_save_load(vectors_count, vector_dimension, data);
-    test_view(vectors_count, vector_dimension, data);
-
-    // Free vectors' buffer
-    free(data);
+int main() {
+
+    size_t collection_sizes[] = {11, 512};
+    size_t dimensions[] = {83, 1};
+    for (size_t idx = 0; idx < sizeof(collection_sizes) / sizeof(collection_sizes[0]); ++idx) {
+        for (size_t jdx = 0; jdx < sizeof(dimensions) / sizeof(dimensions[0]); ++jdx) {
+            test_init(collection_sizes[idx], dimensions[jdx]);
+            test_add_vector(collection_sizes[idx], dimensions[jdx]);
+            test_find_vector(collection_sizes[idx], dimensions[jdx]);
+            test_get_vector(collection_sizes[idx], dimensions[jdx]);
+            test_remove_vector(collection_sizes[idx], dimensions[jdx]);
+            test_save_load(collection_sizes[idx], dimensions[jdx]);
+            test_view(collection_sizes[idx], dimensions[jdx]);
+        }
+    }
 
     return 0;
 }

package/c/usearch.h

@@ -109,6 +109,12 @@ USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, use
  */
 USEARCH_EXPORT void usearch_free(usearch_index_t, usearch_error_t* error);
 
+/**
+ *  @brief Reports expected file size after serialization.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT size_t usearch_serialized_length(usearch_index_t, usearch_error_t* error);
+
 /**
  *  @brief Saves the index to a file.
  *  @param[in] path The file path where the index will be saved.
@@ -124,12 +130,33 @@ USEARCH_EXPORT void usearch_save(usearch_index_t, char const* path, usearch_erro
 USEARCH_EXPORT void usearch_load(usearch_index_t, char const* path, usearch_error_t* error);
 
 /**
- *  @brief Creates a view of the index from a file without loading it into memory.
+ *  @brief Creates a view of the index from a file without copying it into memory.
  *  @param[in] path The file path from where the view will be created.
  *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
  */
 USEARCH_EXPORT void usearch_view(usearch_index_t, char const* path, usearch_error_t* error);
 
+/**
+ *  @brief Saves the index to an in-memory buffer.
+ *  @param[in] buffer The in-memory continuous buffer where the index will be saved.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_save_buffer(usearch_index_t, void* buffer, size_t length, usearch_error_t* error);
+
+/**
+ *  @brief Loads the index from an in-memory buffer.
+ *  @param[in] buffer The in-memory continuous buffer from where the index will be loaded.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_load_buffer(usearch_index_t, void const* buffer, size_t length, usearch_error_t* error);
+
+/**
+ *  @brief Creates a view of the index from an in-memory buffer without copying it into memory.
+ *  @param[in] buffer The in-memory continuous buffer from where the view will be created.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_view_buffer(usearch_index_t, void const* buffer, size_t length, usearch_error_t* error);
+
 USEARCH_EXPORT size_t usearch_size(usearch_index_t, usearch_error_t* error);
 USEARCH_EXPORT size_t usearch_capacity(usearch_index_t, usearch_error_t* error);
 USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t, usearch_error_t* error);

package/conanfile.py

@@ -4,7 +4,7 @@ from conans import ConanFile
 class USearchConan(ConanFile):
 
     name = 'USearch'
-    version = '1.2.2'
+    version = '1.3.0'
     license = 'Apache 2.0'
     url = 'https://github.com/unum-cloud/usearch'
     description = 'Smaller & Faster Single-File Vector Search Engine from Unum'

package/cpp/test.cpp

@@ -118,7 +118,7 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     }
 
     // Search again over mapped index
-    // file_head_result_t head = index_dense_metadata("tmp.usearch");
+    // file_head_result_t head = index_dense_metadata_from_path("tmp.usearch");
     // expect(head.size == 3);
     index.view("tmp.usearch");
     matched_count = index.search(vector_first, 5, args...).dump_to(matched_keys, matched_distances);
@@ -140,7 +140,7 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
 
     // Check metadata
     if constexpr (punned_ak) {
-        index_dense_metadata_result_t meta = index_dense_metadata("tmp.usearch");
+        index_dense_metadata_result_t meta = index_dense_metadata_from_path("tmp.usearch");
         expect(bool(meta));
     }
 }

package/docs/benchmarks.md

@@ -19,13 +19,13 @@ The default values vary drastically.
 Below are the performance numbers for a benchmark running on the 64 cores of AWS `c7g.metal` "Graviton 3"-based instances.
 The main columns are:
 
-- **Add**: Number of insertion Queries Per Second.
-- **Search**: Number search Queries Per Second.
-- **Recall @1**: How often does approximate search yield the exact best match?
+- __Add__: Number of insertion Queries Per Second.
+- __Search__: Number search Queries Per Second.
+- __Recall @1__: How often does approximate search yield the exact best match?
 
 ### Different "connectivity"
 
-| Vectors    | Connectivity | EF @ A | EF @ S | **Add**, QPS | **Search**, QPS | **Recall @1** |
+| Vectors    | Connectivity | EF @ A | EF @ S | __Add__, QPS | __Search__, QPS | __Recall @1__ |
 | :--------- | :----------: | :----: | :----: | :----------: | :-------------: | ------------: |
 | `f32` x256 |      16      |  128   |   64   |    75'640    |     131'654     |         99.3% |
 | `f32` x256 |      12      |  128   |   64   |    81'747    |     149'728     |         99.0% |
@@ -33,7 +33,7 @@ The main columns are:
 
 ### Different "expansion factors"
 
-| Vectors    | Connectivity | EF @ A | EF @ S | **Add**, QPS | **Search**, QPS | **Recall @1** |
+| Vectors    | Connectivity | EF @ A | EF @ S | __Add__, QPS | __Search__, QPS | __Recall @1__ |
 | :--------- | :----------: | :----: | :----: | :----------: | :-------------: | ------------: |
 | `f32` x256 |      16      |  128   |   64   |    75'640    |     131'654     |         99.3% |
 | `f32` x256 |      16      |   64   |   32   |   128'644    |     228'422     |         97.2% |
@@ -41,7 +41,7 @@ The main columns are:
 
 ### Different vectors "quantization"
 
-| Vectors      | Connectivity | EF @ A | EF @ S | **Add**, QPS | **Search**, QPS | **Recall @1** |
+| Vectors      | Connectivity | EF @ A | EF @ S | __Add__, QPS | __Search__, QPS | __Recall @1__ |
 | :----------- | :----------: | :----: | :----: | :----------: | :-------------: | ------------: |
 | `f32` x256   |      16      |  128   |   64   |    87'995    |     171'856     |         99.1% |
 | `f16` x256   |      16      |  128   |   64   |    87'270    |     153'788     |         98.4% |