Repository: unum-cloud/usearch (language: rust)

Issue:
Bug: Index.vectors returns an error
### Describe the bug

When you do index.vectors it provides a (possibly-deprecated?) "vstack" argument that causes an error.

```
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[3], [line 2](vscode-notebook-cell:?execution_count=3&line=2)
      [1](vscode-notebook-cell:?execution_count=3&line=1) index = Index.restore("[/Users/benjamin/Desktop/topic_indexes/topics_bge-micro.usearch](https://file+.vscode-resource.vscode-cdn.net/Users/benjamin/Desktop/topic_indexes/topics_bge-micro.usearch)")
----> [2](vscode-notebook-cell:?execution_count=3&line=2) X_train = index.vectors
      [3](vscode-notebook-cell:?execution_count=3&line=3) X_train.size

File [~/Desktop/repos/taylor/.venv/lib/python3.10/site-packages/usearch/index.py:1135](https://file+.vscode-resource.vscode-cdn.net/Users/benjamin/Desktop/repos/taylor/~/Desktop/repos/taylor/.venv/lib/python3.10/site-packages/usearch/index.py:1135), in Index.vectors(self)
   [1133](https://file+.vscode-resource.vscode-cdn.net/Users/benjamin/Desktop/repos/taylor/~/Desktop/repos/taylor/.venv/lib/python3.10/site-packages/usearch/index.py:1133) @property
   [1134](https://file+.vscode-resource.vscode-cdn.net/Users/benjamin/Desktop/repos/taylor/~/Desktop/repos/taylor/.venv/lib/python3.10/site-packages/usearch/index.py:1134) def vectors(self) -> np.ndarray:
-> [1135](https://file+.vscode-resource.vscode-cdn.net/Users/benjamin/Desktop/repos/taylor/~/Desktop/repos/taylor/.venv/lib/python3.10/site-packages/usearch/index.py:1135)     return self.get(self.keys, vstack=True)

TypeError: Index.get() got an unexpected keyword argument 'vstack'
```

### Steps to reproduce

Create or load an index and then try to use the Index.vectors property

### Expected behavior

Getting back the vectors

### USearch version

2.8.15

### Operating System

Mac OS

### Hardware architecture

Arm

### Which interface are you using?

Python bindings

### Contact Details

andersonbcdefg@gmail.com

### Is there an existing issue for this?

- [X] I have searched the existing issues

### Code of Conduct

- [X] I agree to follow this project's Code of Conduct


Discussion / hints:
Nice catch, @andersonbcdefg! Would you be open to submitting a patch for that and maybe test, if it's not yet covered by the suite? Thanks ahead 🤗 

Fix patch:
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1af23ede..d094def6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -104,6 +104,13 @@ cppcheck --enable=all --force --suppress=cstyleCast --suppress=unusedFunction \
     include/index_plugins.hpp
 ```
 
+I'd recommend putting the following breakpoints when debugging the code in GDB:
+
+- `__asan::ReportGenericError` - to detect illegal memory accesses.
+- `__ubsan::ScopedReport::~ScopedReport` - to catch undefined behavior.
+- `__GI_exit` - to stop at exit points - the end of running any executable.
+- `__builtin_unreachable` - to catch all the places where the code is expected to be unreachable.
+
 ## Python 3
 
 Python bindings are built using PyBind11 and are available on [PyPi](https://pypi.org/project/usearch/).
@@ -215,10 +222,11 @@ USearch provides both Objective-C and Swift bindings through the [Swift Package
 The compilation settings are controlled by the `Package.swift` and are independent from CMake used for C/C++ builds.
 
 ```sh
-swift build
-swift test -v
+swift build && swift test -v
 ```
 
+Those depend on Apple's `Foundation` library and can only run on Apple devices.
+
 ## GoLang
 
 USearch provides GoLang bindings, that depend on the C library that must be installed beforehand.
diff --git a/README.md b/README.md
index eb8e7847..0f80ed76 100644
--- a/README.md
+++ b/README.md
@@ -30,19 +30,18 @@ Spatial • Binary • Probabilistic • User-Defined Metrics
 <a href="https://unum-cloud.github.io/usearch/swift">Swift</a> •
 <a href="https://unum-cloud.github.io/usearch/csharp">C#</a> •
 <a href="https://unum-cloud.github.io/usearch/golang">GoLang</a> •
-<a href="https://unum-cloud.github.io/usearch/wolfram">Wolfram</a> •
-<a href="https://unum-cloud.github.io/usearch/sqlite">SQLite3</a>
+<a href="https://unum-cloud.github.io/usearch/wolfram">Wolfram</a>
 <br/>
-Linux • MacOS • Windows • iOS • WebAssembly
+Linux • MacOS • Windows • iOS • WebAssembly •
+<a href="https://unum-cloud.github.io/usearch/sqlite">SQLite3</a>
 </p>
 
 <div align="center">
-<a href="https://pepy.tech/project/usearch"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/usearch?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=USearch%20Python%20installs"> </a>
-<a href="https://www.npmjs.com/package/usearch"> <img alt="NPM" src="https://img.shields.io/npm/dy/usearch?label=NPM%20installs"> </a>
-<a href="https://crates.io/crates/usearch"> <img alt="Crate" src="https://img.shields.io/crates/d/usearch?label=Crate%20installs"> </a>
-<a href="https://www.nuget.org/packages/Cloud.Unum.USearch"> <img alt="NuGet" src="https://img.shields.io/nuget/dt/Cloud.Unum.USearch?label=NuGet%20installs"> </a>
-<a href="https://central.sonatype.com/artifact/cloud.unum/usearch/overview"> <img alt="Maven" src="https://img.shields.io/nexus/r/cloud.unum/usearch?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&label=Maven%20version"> </a>
-<a href="https://hub.docker.com/r/unum/usearch"> <img alt="Docker" src="https://img.shields.io/docker/pulls/unum/usearch?label=Docker%20installs"> </a>
+<a href="https://pepy.tech/project/usearch"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/usearch?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=Python%20PyPi%20installs"> </a>
+<a href="https://www.npmjs.com/package/usearch"> <img alt="NPM" src="https://img.shields.io/npm/dy/usearch?label=JavaScript%20NPM%20installs"> </a>
+<a href="https://crates.io/crates/usearch"> <img alt="Crate" src="https://img.shields.io/crates/d/usearch?label=Rust%20Crate%20installs"> </a>
+<a href="https://www.nuget.org/packages/Cloud.Unum.USearch"> <img alt="NuGet" src="https://img.shields.io/nuget/dt/Cloud.Unum.USearch?label=CSharp%20NuGet%20installs"> </a>
+<a href="https://central.sonatype.com/artifact/cloud.unum/usearch/overview"> <img alt="Maven" src="https://img.shields.io/nexus/r/cloud.unum/usearch?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&label=Java%20Maven%20version"> </a>
 <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/unum-cloud/usearch?label=Repo%20size">
 </div>
 
@@ -50,18 +49,16 @@ Linux • MacOS • Windows • iOS • WebAssembly
 
 - ✅ __[10x faster][faster-than-faiss]__ [HNSW][hnsw-algorithm] implementation than [FAISS][faiss].
 - ✅ Simple and extensible [single C++11 header][usearch-header] __library__.
-- ✅ Compatible with a dozen programming languages out of the box.
 - ✅ [Trusted](#integrations) by giants like Google and databases like [ClickHouse][clickhouse-docs].
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
 - ✅ Hardware-agnostic `f16` & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
 - ✅ [View large indexes from disk](#serving-index-from-disk) without loading into RAM.
 - ✅ Heterogeneous lookups, renaming/relabeling, and on-the-fly deletions.
-- ✅ Variable dimensionality vectors for unique applications, including search over compressed data.
 - ✅ Binary Tanimoto and Sorensen coefficients for [Genomics and Chemistry applications](#usearch--rdkit--molecular-search).
 - ✅ Space-efficient point-clouds with `uint40_t`, accommodating 4B+ size.
-- ✅ Compatible with OpenMP and custom "executors" for fine-grained control over CPU utilization.
-- ✅ Near-real-time [clustering and sub-clustering](#clustering) for Tens or Millions of clusters.
+- ✅ Compatible with OpenMP and custom "executors" for fine-grained parallelism.
 - ✅ [Semantic Search](#usearch--ai--multi-modal-semantic-search) and [Joins](#joins-one-to-one-one-to-many-and-many-to-many-mappings).
+- 🔄 Near-real-time [clustering and sub-clustering](#clustering) for Tens or Millions of clusters.
 
 [faiss]: https://github.com/facebookresearch/faiss
 [usearch-header]: https://github.com/unum-cloud/usearch/blob/main/include/usearch/index.hpp
@@ -133,7 +130,7 @@ matches = index.search(vector, 10)
 
 assert matches[0].key == 42
 assert matches[0].distance <= 0.001
-assert np.allclose(index[42], vector)
+assert np.allclose(index[42], vector, atol=0.1) # Ensure high tolerance in mixed-precision comparisons
 ```
 
 More settings are always available, and the API is designed to be as flexible as possible.
diff --git a/include/usearch/index_plugins.hpp b/include/usearch/index_plugins.hpp
index 0f9c3739..065795ef 100644
--- a/include/usearch/index_plugins.hpp
+++ b/include/usearch/index_plugins.hpp
@@ -926,7 +926,7 @@ class i8_converted_t {
     std::int8_t int8_{};
 
   public:
-    constexpr static float divisor_k = 100.f;
+    constexpr static f32_t divisor_k = 100.f;
     constexpr static std::int8_t min_k = -100;
     constexpr static std::int8_t max_k = 100;
 
@@ -938,9 +938,9 @@ class i8_converted_t {
     inline i8_converted_t(i8_converted_t const&) = default;
     inline i8_converted_t& operator=(i8_converted_t const&) = default;
 
-    inline operator float() const noexcept { return float(int8_) / divisor_k; }
-    inline operator f16_t() const noexcept { return float(int8_) / divisor_k; }
-    inline operator double() const noexcept { return double(int8_) / divisor_k; }
+    inline operator f16_t() const noexcept { return static_cast<f16_t>(f32_t(int8_) / divisor_k); }
+    inline operator f32_t() const noexcept { return f32_t(int8_) / divisor_k; }
+    inline operator f64_t() const noexcept { return f64_t(int8_) / divisor_k; }
     inline explicit operator bool() const noexcept { return int8_ > (max_k / 2); }
     inline explicit operator std::int8_t() const noexcept { return int8_; }
     inline explicit operator std::int16_t() const noexcept { return int8_; }
@@ -949,9 +949,9 @@ class i8_converted_t {
 
     inline i8_converted_t(f16_t v)
         : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
-    inline i8_converted_t(float v)
+    inline i8_converted_t(f32_t v)
         : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
-    inline i8_converted_t(double v)
+    inline i8_converted_t(f64_t v)
         : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
 };
 
@@ -1165,13 +1165,20 @@ template <typename scalar_at = std::int32_t, typename result_at = float> struct
 };
 
 /**
- *  @brief  Measures Pearson Correlation between two sequences.
+ *  @brief  Measures Pearson Correlation between two sequences in a single pass.
  */
 template <typename scalar_at = float, typename result_at = float> struct metric_pearson_gt {
     using scalar_t = scalar_at;
     using result_t = result_at;
 
     inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t dim) const noexcept {
+        // The correlation coefficient can't be defined for one or zero-dimensional data.
+        if (dim <= 1)
+            return 0;
+        // Conventional Pearson Correlation Coefficient definiton subtracts the mean value of each
+        // sequence from each element, before dividing them. WikiPedia article suggests a convenient
+        // single-pass algorithm for calculating sample correlations, though depending on the numbers
+        // involved, it can sometimes be numerically unstable.
         result_t a_sum{}, b_sum{}, ab_sum{};
         result_t a_sq_sum{}, b_sq_sum{};
 #if USEARCH_USE_OPENMP
@@ -1190,9 +1197,12 @@ template <typename scalar_at = float, typename result_at = float> struct metric_
             a_sq_sum += ai * ai;
             b_sq_sum += bi * bi;
         }
-        result_t denom = std::sqrt((dim * a_sq_sum - a_sum * a_sum) * (dim * b_sq_sum - b_sum * b_sum));
-        result_t corr = (dim * ab_sum - a_sum * b_sum) / denom;
-        return -corr;
+        result_t denom = (dim * a_sq_sum - a_sum * a_sum) * (dim * b_sq_sum - b_sum * b_sum);
+        if (denom == 0)
+            return 0;
+        result_t corr = dim * ab_sum - a_sum * b_sum;
+        denom = std::sqrt(denom);
+        return -corr / denom;
     }
 };
 
diff --git a/javascript/usearch.js b/javascript/usearch.js
index 7150608f..a6bc59b7 100644
--- a/javascript/usearch.js
+++ b/javascript/usearch.js
@@ -158,7 +158,10 @@ class Index {
             throw new Error("Invalid arguments. Expected either individual arguments or a single object argument.");
         }
 
-        if (!Number.isInteger(dimensions) || !Number.isInteger(connectivity) || !Number.isInteger(expansion_add) || !Number.isInteger(expansion_search) || dimensions <= 0 || connectivity < 0 || expansion_add < 0 || expansion_search < 0) {
+        if ((typeof dimensions !== 'bigint' && (!Number.isInteger(dimensions) || dimensions <= 0)) || 
+            (typeof connectivity !== 'bigint' && (!Number.isInteger(connectivity) || connectivity < 0)) ||
+            (typeof expansion_add !== 'bigint' && (!Number.isInteger(expansion_add) || expansion_add < 0)) ||
+            (typeof expansion_search !== 'bigint' && (!Number.isInteger(expansion_search) || expansion_search < 0))) {
             throw new Error("`dimensions`, `connectivity`, `expansion_add`, and `expansion_search` must be non-negative integers, with `dimensions` being positive.");
         }
 
diff --git a/python/usearch/__init__.py b/python/usearch/__init__.py
index 7e263b3f..befac518 100644
--- a/python/usearch/__init__.py
+++ b/python/usearch/__init__.py
@@ -1,4 +1,5 @@
 import importlib
+import importlib.util
 
 from usearch.compiled import (
     VERSION_MAJOR,
diff --git a/python/usearch/index.py b/python/usearch/index.py
index 39b31671..f3e26f56 100644
--- a/python/usearch/index.py
+++ b/python/usearch/index.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 from inspect import signature
+from collections.abc import Sequence
 
 # The purpose of this file is to provide Pythonic wrapper on top
 # the native precompiled CPython module. It improves compatibility
@@ -313,7 +314,7 @@ def __repr__(self) -> str:
 
 
 @dataclass
-class BatchMatches:
+class BatchMatches(Sequence):
     """This class contains information about multiple retrieved vectors for multiple queries,
     i.e it is a set of `Matches` instances."""
 
@@ -422,7 +423,7 @@ def network(self):
         return g
 
 
-class IndexedKeys:
+class IndexedKeys(Sequence):
     """Smart-reference for the range of keys present in a specific `Index`"""
 
     def __init__(self, index: Index) -> None:
@@ -1136,7 +1137,7 @@ def keys(self) -> IndexedKeys:
 
     @property
     def vectors(self) -> np.ndarray:
-        return self.get(self.keys, vstack=True)
+        return self.get(self.keys)
 
     @property
     def max_level(self) -> int:
diff --git a/simsimd b/simsimd
index a833dd2b..02665027 160000
--- a/simsimd
+++ b/simsimd
@@ -1,1 +1,1 @@
-Subproject commit a833dd2b0caf741ea0587b84dd6a788105641e12
+Subproject commit 02665027985a578bd91514011c31a0bbe302304d
diff --git a/stringzilla b/stringzilla
index ec8abc26..662b66e9 160000
--- a/stringzilla
+++ b/stringzilla
@@ -1,1 +1,1 @@
-Subproject commit ec8abc262114e551fd9337727fd4cc0d234c5209
+Subproject commit 662b66e97eb3bee017e3aae167d6121cb8ab156e


Test patch:
diff --git a/c/test.c b/c/test.c
index 919ee117..1f086a9a 100644
--- a/c/test.c
+++ b/c/test.c
@@ -35,6 +35,7 @@ usearch_init_options_t create_options(size_t const dimensions) {
     opts.metric_kind = usearch_metric_ip_k;
     opts.metric = NULL;
     opts.quantization = usearch_scalar_f32_k;
+    opts.multi = false;
     return opts;
 }
 
@@ -45,7 +46,7 @@ usearch_init_options_t create_options(size_t const dimensions) {
  *  dimensions, and connectivity after each operation.
  */
 void test_init(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Index Initialization...\n");
+    printf("Test: Index Initialization... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     // Init index
     usearch_error_t error = NULL;
@@ -84,7 +85,7 @@ void test_init(size_t const collection_size, size_t const dimensions) {
  *  size, capacity, and presence of each vector in the index.
  */
 void test_add_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Add Vector...\n");
+    printf("Test: Add Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -120,7 +121,7 @@ void test_add_vector(size_t const collection_size, size_t const dimensions) {
  *  found in the index, validating the count of found vectors.
  */
 void test_find_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Find Vector...\n");
+    printf("Test: Find Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -161,7 +162,7 @@ void test_find_vector(size_t const collection_size, size_t const dimensions) {
  *  retrieves vectors associated with the key from the index and checks the count of retrieved vectors.
  */
 void test_get_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Get Vector...\n");
+    printf("Test: Get Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -198,7 +199,7 @@ void test_get_vector(size_t const collection_size, size_t const dimensions) {
  *  the assert in this test expects an error, indicating that the remove functionality is not currently supported.
  */
 void test_remove_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Remove Vector...\n");
+    printf("Test: Remove Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -232,7 +233,8 @@ void test_remove_vector(size_t const collection_size, size_t const dimensions) {
  *  from the saved index.
  */
 void test_save_load(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Save/Load...\n");
+    printf("Test: Save/Load... %zu vectors, %zu dimensions \n", collection_size, dimensions);
+    float* data = create_vectors(collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -242,23 +244,26 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
     weird_ops.expansion_search = 19;
     weird_ops.metric_kind = usearch_metric_pearson_k;
     weird_ops.quantization = usearch_scalar_f64_k;
-    usearch_index_t index = usearch_init(&weird_ops, &error);
-    usearch_reserve(index, collection_size, &error);
 
-    // Add vectors
-    float* data = create_vectors(collection_size, dimensions);
-    for (size_t i = 0; i < collection_size; ++i) {
-        usearch_key_t key = i;
-        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+    {
+
+        usearch_index_t index = usearch_init(&weird_ops, &error);
+        usearch_reserve(index, collection_size, &error);
+
+        // Add vectors
+        for (size_t i = 0; i < collection_size; ++i) {
+            usearch_key_t key = i;
+            usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+            ASSERT(!error, error);
+        }
+
+        // Save and free the index
+        usearch_save(index, "tmp.usearch", &error);
+        ASSERT(!error, error);
+        usearch_free(index, &error);
         ASSERT(!error, error);
     }
 
-    // Save and free the index
-    usearch_save(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
-    usearch_free(index, &error);
-    ASSERT(!error, error);
-
     // Reset the options
     opts.connectivity = 0;
     opts.dimensions = 0;
@@ -269,45 +274,48 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
     opts.metric_kind = usearch_metric_unknown_k;
 
     // Reinit
-    index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == 0, error);
+    {
 
-    // Load
-    usearch_load(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == collection_size, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
+        usearch_index_t index = usearch_init(&opts, &error);
+        ASSERT(!error, error);
+        ASSERT(usearch_size(index, &error) == 0, error);
 
-    // Check vectors in the index
-    for (size_t i = 0; i < collection_size; ++i) {
-        usearch_key_t key = i;
-        ASSERT(usearch_contains(index, key, &error), error);
-    }
+        // Load
+        usearch_load(index, "tmp.usearch", &error);
+        ASSERT(!error, error);
+        ASSERT(usearch_size(index, &error) == collection_size, error);
+        ASSERT(usearch_capacity(index, &error) == collection_size, error);
+        ASSERT(usearch_dimensions(index, &error) == dimensions, error);
+        ASSERT(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
+
+        // Check vectors in the index
+        for (size_t i = 0; i < collection_size; ++i) {
+            usearch_key_t key = i;
+            ASSERT(usearch_contains(index, key, &error), error);
+        }
 
-    // Create result buffers
-    usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
-    float* distances = (float*)malloc(collection_size * sizeof(float));
-    ASSERT(keys && distances, "Failed to allocate memory");
+        // Create result buffers
+        usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
+        float* distances = (float*)malloc(collection_size * sizeof(float));
+        ASSERT(keys && distances, "Failed to allocate memory");
+
+        // Find the vectors
+        for (size_t i = 0; i < collection_size; i++) {
+            size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size,
+                                                keys, distances, &error);
+            ASSERT(!error, error);
+            ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+        }
 
-    // Find the vectors
-    for (size_t i = 0; i < collection_size; i++) {
-        size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size, keys,
-                                            distances, &error);
-        ASSERT(!error, error);
-        ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+        free(keys);
+        free(distances);
+        usearch_free(index, &error);
     }
 
     free(data);
-    free(keys);
-    free(distances);
-    usearch_free(index, &error);
 
     // Remove the file from disk
     remove("tmp.usearch");
-
     printf("Test: Save/Load - PASSED\n");
 }
 
@@ -318,7 +326,7 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
  *  not verify the properties or contents of the viewed index.
  */
 void test_view(size_t const collection_size, size_t const dimensions) {
-    printf("Test: View...\n");
+    printf("Test: View... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -355,7 +363,7 @@ void test_view(size_t const collection_size, size_t const dimensions) {
 int main(int argc, char const* argv[]) {
 
     size_t collection_sizes[] = {11, 512};
-    size_t dimensions[] = {83, 1};
+    size_t dimensions[] = {83, 2}; // Not all distance functions make sense for 1 dimensional data
     for (size_t index = 0; index < sizeof(collection_sizes) / sizeof(collection_sizes[0]); ++index) {
         for (size_t jdx = 0; jdx < sizeof(dimensions) / sizeof(dimensions[0]); ++jdx) {
             test_init(collection_sizes[index], dimensions[jdx]);
diff --git a/python/scripts/test_index.py b/python/scripts/test_index.py
index be88b643..6988bbd8 100644
--- a/python/scripts/test_index.py
+++ b/python/scripts/test_index.py
@@ -69,6 +69,19 @@ def test_index_retrieval(ndim, metric, quantization, dtype, batch_size):
     vectors_retrived = np.vstack(index.get(keys, dtype))
     assert np.allclose(vectors_retrived, vectors, atol=0.1)
 
+    # Try retrieving all the keys
+    keys_retrived = index.keys
+    keys_retrived = np.array(keys_retrived)
+    assert np.all(np.sort(keys_retrived) == keys)
+
+    # Try retrieving all of them
+    if quantization != ScalarKind.I8:
+        # The returned vectors can be in a different order
+        vectors_batch_retrived = index.vectors
+        vectors_reordering = np.argsort(keys_retrived)
+        vectors_batch_retrived = vectors_batch_retrived[vectors_reordering]
+        assert np.allclose(vectors_batch_retrived, vectors, atol=0.1)
+
 
 @pytest.mark.parametrize("ndim", [3, 97, 256])
 @pytest.mark.parametrize("metric", [MetricKind.Cos, MetricKind.L2sq])
diff --git a/python/scripts/test_tooling.py b/python/scripts/test_tooling.py
index aef7367c..c7a52afb 100644
--- a/python/scripts/test_tooling.py
+++ b/python/scripts/test_tooling.py
@@ -57,6 +57,8 @@ def test_exact_search(rows: int, cols: int, k: int, reordered: bool):
     :param int rows: The number of rows in the matrix.
     :param int cols: The number of columns in the matrix.
     """
+    if cols < 10:
+        pytest.skip("In low dimensions collisions are likely.")
     original = np.random.rand(rows, cols)
     keys = np.arange(rows)
     k = min(k, rows)