zeusdb-vector-database 0.0.1__tar.gz → 0.0.2__tar.gz

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: zeusdb-vector-database
-Version: 0.0.1
+Version: 0.0.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Dist: maturin>=1.8.7 ; extra == 'dev'
+Requires-Dist: numpy>=2.2.6,<3.0.0
+Requires-Dist: maturin>=1.9.0 ; extra == 'dev'
 Requires-Dist: pytest>=8.4.0 ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE
@@ -141,7 +142,7 @@ query_vec = [0.1, 0.2, 0.3, 0.1, 0.4, 0.2, 0.6, 0.7]
 # Query with no filter (all documents)
 print("\n--- Querying without filter (all documents) ---")
 results = index.query(vector=query_vec, filter=None, top_k=2)
-for doc_id, score in results_all:
+for doc_id, score in results:
     print(f"{doc_id} (score={score:.4f})")
 ```
 

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/README.md

@@ -123,7 +123,7 @@ query_vec = [0.1, 0.2, 0.3, 0.1, 0.4, 0.2, 0.6, 0.7]
 # Query with no filter (all documents)
 print("\n--- Querying without filter (all documents) ---")
 results = index.query(vector=query_vec, filter=None, top_k=2)
-for doc_id, score in results_all:
+for doc_id, score in results:
     print(f"{doc_id} (score={score:.4f})")
 ```
 

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zeusdb-vector-database"
-version = "0.0.1"
+version = "0.0.2"
 description = "Blazing-fast vector DB with real-time similarity search and metadata filtering."
 readme = "README.md"
 authors = [
@@ -12,10 +12,12 @@ classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",
 ]
-dependencies = []
+dependencies = [
+    "numpy>=2.2.6,<3.0.0"
+]
 
 [build-system]
-requires = ["maturin>=1.8.7,<2.0"]
+requires = ["maturin>=1.9.0,<2.0"]
 build-backend = "maturin"
 
 [tool.maturin]
@@ -28,7 +30,7 @@ include = ["LICENSE", "NOTICE", "README.md", "src/**"]
 
 [project.optional-dependencies]
 dev = [
-    "maturin >=1.8.7",
+    "maturin >=1.9.0",
     "pytest >=8.4.0",
 ]
 

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/src/zeusdb_vector_database/__init__.py

@@ -1,4 +1,7 @@
-__version__ = "0.0.1"
+"""
+ZeusDB Vector Database Module
+"""
+__version__ = "0.0.2"
 
 from .vector_database import VectorDatabase # imports the VectorDatabase class from the vector_database.py file
 

zeusdb_vector_database-0.0.2/src/zeusdb_vector_database/vector_database.py

@@ -0,0 +1,50 @@
+"""
+vector_database.py
+
+Pure factory for creating vector indexes using Rust backend.
+Currently supports HNSW (Hierarchical Navigable Small World).
+"""
+from .zeusdb_vector_database import HNSWIndex
+
+class VectorDatabase:
+    """
+    Pure factory for creating vector indexes.
+    No state management - just creates and returns indexes.
+    """
+    
+    def __init__(self):
+        """Initialize VectorDatabase factory."""
+        pass
+
+    def create_index_hnsw(
+        self,
+        dim: int = 1536,
+        space: str = "cosine",
+        M: int = 16,
+        ef_construction: int = 200,
+        expected_size: int = 10000
+    ) -> HNSWIndex:
+        """
+        Creates a new HNSW (Hierarchical Navigable Small World) index.
+
+        Args:
+            dim: Vector dimension (default: 1536)
+            space: Distance metric, only 'cosine' supported (default: 'cosine')
+            M: Bidirectional links per node (default: 16, max: 256)
+            ef_construction: Construction candidate list size (default: 200)
+            expected_size: Expected number of vectors (default: 10000)
+
+        Returns:
+            HNSWIndex: Use this index directly for all operations
+
+        Example:
+            vdb = VectorDatabase()
+            index = vdb.create_index_hnsw(dim=1536, expected_size=10000)
+            index.add_point("doc1", vector, metadata)
+            results = index.query(query_vector, k=10)
+        """
+        try:
+            return HNSWIndex(dim, space, M, ef_construction, expected_size)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create HNSW index: {e}") from e
+    

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/vdb-core/Cargo.lock

@@ -301,9 +301,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -375,9 +375,9 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "mach2"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
 dependencies = [
  "libc",
 ]
@@ -736,9 +736,9 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "syn"
-version = "2.0.103"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4307e30089d6fd6aff212f2da3a1f9e32f3223b1f010fb09b7c95f90f3ca1e8"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1029,7 +1029,7 @@ dependencies = [
 
 [[package]]
 name = "zeusdb-vector-database"
-version = "0.0.1"
+version = "0.0.2"
 dependencies = [
  "hnsw_rs",
  "pyo3",

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/vdb-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zeusdb-vector-database"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2021"
 resolver = "2" # <-- Avoid compiling unnecessary features from dependencies.
 
@@ -10,7 +10,7 @@ name = "zeusdb_vector_database" # <-- This is the name of the compiled Python mo
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.25.0", features = ["extension-module"] }
+pyo3 = { version = "0.25.1", features = ["extension-module"] }
 hnsw_rs = "0.3.2"
 
 [profile.release]

zeusdb_vector_database-0.0.2/vdb-core/src/hnsw_index.rs

@@ -0,0 +1,344 @@
+use pyo3::prelude::*;
+use std::collections::HashMap;
+use hnsw_rs::prelude::{Hnsw, DistCosine};
+
+#[pyclass]
+pub struct HNSWIndex {
+    dim: usize,
+    space: String,
+    m: usize,
+    ef_construction: usize,
+    expected_size: usize,
+
+    // Index-level metadata
+    metadata: HashMap<String, String>,
+
+    // Vector store
+    vectors: HashMap<String, Vec<f32>>,
+    vector_metadata: HashMap<String, HashMap<String, String>>,
+
+    hnsw: Hnsw<'static, f32, DistCosine>,  // Actual graph
+    id_map: HashMap<String, usize>,     // Maps external ID → usize
+    rev_map: HashMap<usize, String>,    // Maps usize → external ID
+    id_counter: usize,
+}
+
+#[pymethods]
+impl HNSWIndex {
+    #[new]
+    fn new(
+        dim: usize, 
+        space: String,
+        m: usize, 
+        ef_construction: usize,
+        expected_size: usize
+    ) -> PyResult<Self> {  // Return PyResult for validation
+        // Validate parameters in Rust
+        if dim == 0 {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                "dim must be positive"
+            ));
+        }
+        if ef_construction == 0 {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                "ef_construction must be positive"
+            ));
+        }
+        if expected_size == 0 {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                "expected_size must be positive"
+            ));
+        }
+        if m > 256 {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                "M must be less than or equal to 256"
+            ));
+        }
+        if space != "cosine" {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                format!("Unsupported space: {}. Only 'cosine' is supported", space)
+            ));
+        }
+
+        // Calculate max_layer as log2(expected_size).ceil()
+        let max_layer = (expected_size as f32).log2().ceil() as usize;
+        let hnsw = Hnsw::<f32, DistCosine>::new(
+            m,                // M
+            expected_size,    // expected number of vectors
+            max_layer,        // number of layers
+            ef_construction,  // ef
+            DistCosine {}
+        );
+        
+        Ok(HNSWIndex {
+            dim,
+            space,
+            m,
+            ef_construction,
+            expected_size,
+            metadata: HashMap::new(),
+            vectors: HashMap::new(),
+            vector_metadata: HashMap::new(),
+            hnsw,
+            id_map: HashMap::new(),
+            rev_map: HashMap::new(),
+            id_counter: 0,
+        })
+    }
+
+    /// Adds a vector to the index. Fails if the ID already exists.
+    pub fn add_point(&mut self, id: String, vector: Vec<f32>, metadata: Option<HashMap<String, String>>) -> PyResult<()> {
+        // Check vector dimension
+        if vector.len() != self.dim {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                "Vector dimension mismatch: expected {}, got {}",
+                self.dim, vector.len()
+            )));
+        }
+
+        // Check for duplicate ID
+        if self.vectors.contains_key(&id) {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                "Duplicate ID: '{}' already exists", id
+            )));
+        }
+
+        // Assign internal index
+        let internal_id = self.id_counter;
+        self.id_counter += 1;
+
+        // Store the vector and mappings
+        self.vectors.insert(id.clone(), vector.clone());
+        self.id_map.insert(id.clone(), internal_id);
+        self.rev_map.insert(internal_id, id.clone());
+
+        // Store metadata if provided
+        if let Some(meta) = metadata {
+            self.vector_metadata.insert(id.clone(), meta);
+        }
+
+        // Insert into HNSW using a reference to the stored vector
+        let stored_vec = self.vectors.get(&id).unwrap();
+        self.hnsw.insert((stored_vec.as_slice(), internal_id));
+
+        Ok(())
+    }
+
+    /// Add multiple vectors in batch for better performance
+    pub fn add_batch(&mut self, 
+        points: Vec<(String, Vec<f32>, Option<HashMap<String, String>>)>
+    ) -> PyResult<HashMap<String, Vec<String>>> {
+        let mut errors = Vec::new();
+        let mut success_count = 0;
+
+        for (id, vector, metadata) in points {
+            match self.add_point(id.clone(), vector, metadata) {
+                Ok(()) => success_count += 1,
+                Err(e) => errors.push(format!("ID '{}': {}", id, e)),
+            }
+        }
+
+        let mut result = HashMap::new();
+        result.insert("success_count".to_string(), vec![success_count.to_string()]);
+        result.insert("error_count".to_string(), vec![errors.len().to_string()]);
+        result.insert("errors".to_string(), errors);
+
+        Ok(result)
+    }
+
+    /// Query the index for the k-nearest neighbors of a vector
+    #[pyo3(signature = (vector, filter=None, top_k=10, ef_search=None))]
+    pub fn query(
+        &self,
+        vector: Vec<f32>,
+        filter: Option<HashMap<String, String>>,
+        top_k: usize,
+        ef_search: Option<usize>,
+    ) -> PyResult<Vec<(String, f32)>> {
+        if vector.len() != self.dim {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                "Query vector dimension mismatch: expected {}, got {}",
+                self.dim, vector.len()
+            )));
+        }
+
+        // Get results from HNSW graph
+        let ef = ef_search.unwrap_or_else(|| std::cmp::max(2 * top_k, 100));
+        let results = self.hnsw.search(&vector, top_k, ef);
+
+        let mut filtered_results = Vec::new();
+
+        for neighbor in results {
+            let score = neighbor.distance;
+            let internal_id = neighbor.get_origin_id();
+            
+            if let Some(ext_id) = self.rev_map.get(&internal_id) {
+                // Apply filtering if provided
+                if let Some(ref filter_map) = filter {
+                    if let Some(meta) = self.vector_metadata.get(ext_id) {
+                        let mut matches = true;
+                        for (k, v) in filter_map {
+                            if meta.get(k) != Some(v) {
+                                matches = false;
+                                break;
+                            }
+                        }
+                        if !matches {
+                            continue;
+                        }
+                    } else {
+                        // No metadata, but filter required - skip
+                        continue;
+                    }
+                }
+                filtered_results.push((ext_id.clone(), score));
+            }
+        }
+
+        Ok(filtered_results)
+    }
+
+    /// Search with metadata included in results
+    #[pyo3(signature = (vector, filter=None, top_k=10, ef_search=None, include_metadata=false))]
+    pub fn search_with_metadata(
+        &self,
+        vector: Vec<f32>,
+        filter: Option<HashMap<String, String>>,
+        top_k: usize,
+        ef_search: Option<usize>,
+        include_metadata: bool,
+    ) -> PyResult<Vec<(String, f32, Option<HashMap<String, String>>)>> {
+        if vector.len() != self.dim {
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                "Query vector dimension mismatch: expected {}, got {}",
+                self.dim, vector.len()
+            )));
+        }
+
+        let ef = ef_search.unwrap_or_else(|| std::cmp::max(2 * top_k, 100));
+        let results = self.hnsw.search(&vector, top_k, ef);
+
+        let mut filtered_results = Vec::new();
+
+        for neighbor in results {
+            let score = neighbor.distance;
+            let internal_id = neighbor.get_origin_id();
+            
+            if let Some(ext_id) = self.rev_map.get(&internal_id) {
+                // Apply filtering if provided
+                if let Some(ref filter_map) = filter {
+                    if let Some(meta) = self.vector_metadata.get(ext_id) {
+                        let mut matches = true;
+                        for (k, v) in filter_map {
+                            if meta.get(k) != Some(v) {
+                                matches = false;
+                                break;
+                            }
+                        }
+                        if !matches {
+                            continue;
+                        }
+                    } else {
+                        continue;
+                    }
+                }
+
+                let metadata = if include_metadata {
+                    self.vector_metadata.get(ext_id).cloned()
+                } else {
+                    None
+                };
+
+                filtered_results.push((ext_id.clone(), score, metadata));
+            }
+        }
+
+        Ok(filtered_results)
+    }
+
+    /// Get vector by ID
+    pub fn get_vector(&self, id: String) -> Option<Vec<f32>> {
+        self.vectors.get(&id).cloned()
+    }
+
+    /// Get metadata by ID
+    pub fn get_vector_metadata(&self, id: String) -> Option<HashMap<String, String>> {
+        self.vector_metadata.get(&id).cloned()
+    }
+
+    /// Get comprehensive statistics
+    pub fn get_stats(&self) -> HashMap<String, String> {
+        let mut stats = HashMap::new();
+        stats.insert("total_vectors".to_string(), self.vectors.len().to_string());
+        stats.insert("dimension".to_string(), self.dim.to_string());
+        stats.insert("space".to_string(), self.space.clone());
+        stats.insert("M".to_string(), self.m.to_string());
+        stats.insert("ef_construction".to_string(), self.ef_construction.to_string());
+        stats.insert("expected_size".to_string(), self.expected_size.to_string());
+        stats.insert("index_type".to_string(), "HNSW".to_string());
+        stats
+    }
+
+    /// List the first `number` records in the index (ID and metadata).
+    #[pyo3(signature = (number=10))]
+    pub fn list(&self, number: usize) -> Vec<(String, Option<HashMap<String, String>>)> {
+        self.vectors
+            .iter()
+            .take(number)
+            .map(|(id, _vec)| {
+                let meta = self.vector_metadata.get(id).cloned();
+                (id.clone(), meta)
+            })
+            .collect()
+    }
+    
+    /// Add multiple key-value pairs to index-level metadata
+    pub fn add_metadata(&mut self, metadata: HashMap<String, String>) {
+        for (key, value) in metadata {
+            self.metadata.insert(key, value);
+        }
+    }
+
+    /// Get a single index-level metadata value
+    pub fn get_metadata(&self, key: String) -> Option<String> {
+        self.metadata.get(&key).cloned()
+    }
+
+    /// Get all index-level metadata
+    pub fn get_all_metadata(&self) -> HashMap<String, String> {
+        self.metadata.clone()
+    }
+
+    /// Returns basic info about the index
+    pub fn info(&self) -> String {
+        format!(
+            "HNSWIndex(dim={}, space={}, M={}, ef_construction={}, expected_size={}, vectors={})",
+            self.dim,
+            self.space,
+            self.m,
+            self.ef_construction,
+            self.expected_size,
+            self.vectors.len()
+        )
+    }
+
+    /// Check if vector ID exists
+    pub fn contains(&self, id: String) -> bool {
+        self.vectors.contains_key(&id)
+    }
+
+    /// Remove vector by ID
+    pub fn remove_point(&mut self, id: String) -> PyResult<bool> {
+        if let Some(internal_id) = self.id_map.remove(&id) {
+            self.vectors.remove(&id);
+            self.vector_metadata.remove(&id);
+            self.rev_map.remove(&internal_id);
+            // Note: HNSW doesn't support removal, so the graph still contains the point
+            // but it won't be accessible via our mappings
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+}
+

{zeusdb_vector_database-0.0.1 → zeusdb_vector_database-0.0.2}/vdb-core/src/lib.rs

@@ -1,10 +1,10 @@
 // lib.rs
-mod create_index_hnsw;
+mod hnsw_index;
 
 use pyo3::prelude::*;
 
 #[pymodule]
 fn zeusdb_vector_database(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<create_index_hnsw::HNSWIndex>()?;
+    m.add_class::<hnsw_index::HNSWIndex>()?;
     Ok(())
 }

zeusdb_vector_database-0.0.1/src/zeusdb_vector_database/create_index_hnsw.py

@@ -1,24 +0,0 @@
-from .zeusdb_vector_database import HNSWIndex
-
-def create_index_hnsw(dim: int, space: str, M: int, ef_construction: int, expected_size: int) -> HNSWIndex:
-    """
-    Create a new HNSW (Hierarchical Navigable Small World) index using the Rust backend with expected capacity.
-
-    Args:
-        dim (int): Dimension of the vectors to be indexed.
-        space (str): Distance metric to use. Only 'cosine' is currently supported.
-        M (int): Number of bi-directional links created for every new element.
-        ef_construction (int): Size of the dynamic list for the nearest neighbors during index construction.
-
-    Returns:
-        HNSWIndex: An instance of the HNSWIndex class representing the created index.
-
-    Raises:
-        ValueError: If an unsupported distance metric is provided.
-    """
-    #if space not in {"cosine", "l2", "dot"}:
-    if space not in {"cosine"}:
-        raise ValueError(f"Unsupported space: {space}")
-    if M > 256:
-        raise ValueError("M (max_nb_connection) must be less than or equal to 256")
-    return HNSWIndex(dim, space, M, ef_construction, expected_size)

zeusdb_vector_database-0.0.1/src/zeusdb_vector_database/vector_database.py

@@ -1,33 +0,0 @@
-from .create_index_hnsw import HNSWIndex, create_index_hnsw
-
-class VectorDatabase:
-    def __init__(self):
-        self.index = None
-
-    def create_index_hnsw(
-            self, 
-            dim: int = 1536, 
-            space: str = "cosine", 
-            M: int = 16, 
-            ef_construction: int = 200,
-            expected_size: int = 10000  # Default capacity
-            ) -> HNSWIndex:
-        """
-        Creates a new HNSW (Hierarchical Navigable Small World) index using the specified configuration.
-
-        This method initializes the index for approximate nearest neighbor search using the HNSW algorithm.
-        It supports configuration of vector dimension, distance metric, connectivity, and construction parameters.
-
-        Args:
-            dim (int): The number of dimensions for each vector in the index (default is 1536).
-            space (str): The distance metric to use for similarity, currently only 'cosine' is supported.
-            M (int): The number of bidirectional links each node maintains in the graph (higher = more accuracy).
-            ef_construction (int): Size of the dynamic candidate list during index construction (higher = better recall).
-            expected_size (int): Estimated number of vectors to store; used to preallocate internal data structures (default is 10,000).
-
-        Returns:
-            HNSWIndex: An initialized HNSWIndex object ready for vector insertion and similarity search.
-        """
-        return create_index_hnsw(dim, space, M, ef_construction, expected_size)
-
-

zeusdb_vector_database-0.0.1/vdb-core/src/create_index_hnsw.rs

@@ -1,199 +0,0 @@
-use pyo3::prelude::*;
-use std::collections::HashMap;
-use hnsw_rs::prelude::{Hnsw, DistCosine};
-
-#[pyclass]
-pub struct HNSWIndex {
-    dim: usize,
-    space: String,
-    m: usize,
-    ef_construction: usize,
-    expected_size: usize,
-
-    // Index-level metadata
-    metadata: HashMap<String, String>,
-
-    // Vector store
-    vectors: HashMap<String, Vec<f32>>,
-    vector_metadata: HashMap<String, HashMap<String, String>>,
-
-    hnsw: Hnsw<'static, f32, DistCosine>,  // Actual graph
-    id_map: HashMap<String, usize>,     // Maps external ID → usize
-    rev_map: HashMap<usize, String>,    // Maps usize → external ID
-    id_counter: usize,
-}
-
-#[pymethods]
-impl HNSWIndex {
-    #[new]
-    fn new(
-        dim: usize, 
-        space: String,
-        m: usize, 
-        ef_construction: usize,
-        expected_size: usize
-    ) -> Self {
-        // Calculate max_layer as log2(expected_size).ceil()
-        let max_layer = (expected_size as f32).log2().ceil() as usize;
-        let hnsw = Hnsw::<f32, DistCosine>::new(
-            m,                // M
-            expected_size,    // expected number of vectors
-            max_layer,        // number of layers
-            ef_construction,  // ef
-            DistCosine {}
-        );
-        // Initialize the HNSW index with the given parameters
-        HNSWIndex {
-            dim,
-            space,
-            m,
-            ef_construction,
-            expected_size,
-            metadata: HashMap::new(),
-            vectors: HashMap::new(),
-            vector_metadata: HashMap::new(),
-            hnsw,
-            id_map: HashMap::new(),
-            rev_map: HashMap::new(),
-            id_counter: 0,
-        }
-    }
-
-    /// Adds a vector to the index. Fails if the ID already exists.
-pub fn add_point(&mut self, id: String, vector: Vec<f32>, metadata: Option<HashMap<String, String>>) -> PyResult<()> {
-    // Check vector dimension
-    if vector.len() != self.dim {
-        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-            "Vector dimension mismatch: expected {}, got {}",
-            self.dim, vector.len()
-        )));
-    }
-
-    // Check for duplicate ID
-    if self.vectors.contains_key(&id) {
-        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-            "Duplicate ID: '{}' already exists", id
-        )));
-    }
-
-    // Assign internal index
-    let internal_id = self.id_counter;
-    self.id_counter += 1;
-
-    // Store the vector and mappings
-    self.vectors.insert(id.clone(), vector.clone());
-    self.id_map.insert(id.clone(), internal_id);
-    self.rev_map.insert(internal_id, id.clone());
-
-    // Store metadata if provided
-    if let Some(meta) = metadata {
-        self.vector_metadata.insert(id.clone(), meta);
-    }
-
-    // Debugging output
-    //println!("Adding vector with external_id = '{}', internal_id = {}", id, internal_id);
-
-    // Insert into HNSW using a reference to the stored vector
-    let stored_vec = self.vectors.get(&id).unwrap();
-    self.hnsw.insert((stored_vec.as_slice(), internal_id));
-
-    Ok(())
-}
-
-    /// Query the index for the k-nearest neighbors of a vector
-    #[pyo3(signature = (vector, filter=None, top_k=10, ef_search=None))]
-    pub fn query(
-        &self,
-        vector: Vec<f32>,
-        filter: Option<HashMap<String, String>>,
-        top_k: usize,
-        ef_search: Option<usize>,
-    ) -> PyResult<Vec<(String, f32)>> {
-        if vector.len() != self.dim {
-            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-                "Query vector dimension mismatch: expected {}, got {}",
-                self.dim, vector.len()
-            )));
-        }
-
-        // Get results from HNSW graph
-        let ef = ef_search.unwrap_or_else(|| std::cmp::max(2 * top_k, 100));
-        let results = self.hnsw.search(&vector, top_k, ef);
-
-        let mut filtered_results = Vec::new();
-
-        for neighbor in results {
-            let score = neighbor.distance;
-            let internal_id = neighbor.get_origin_id();
-
-            // Debugging: resolved internal ID to external ID mapping
-            //println!("Resolved internal_id {} → {:?}", internal_id, self.rev_map.get(&internal_id));
-            
-            if let Some(ext_id) = self.rev_map.get(&internal_id) {
-            if let Some(ref filter_map) = filter {
-                let meta = self.vector_metadata.get(ext_id);
-                if meta.is_none() {
-                    continue;
-                }
-                let meta = meta.unwrap();
-                let mut matches = true;
-                for (k, v) in filter_map {
-                    if meta.get(k) != Some(v) {
-                        matches = false;
-                        break;
-                    }
-                }
-                if !matches {
-                    continue;
-                }
-            }
-            filtered_results.push((ext_id.clone(), score));
-        }
-    }
-
-    Ok(filtered_results)
-    }
-
-    /// List the first `number` records in the index (ID and metadata).
-    #[pyo3(signature = (number=10))]
-    pub fn list(&self, number: usize) -> Vec<(String, Option<HashMap<String, String>>)> {
-        self.vectors
-            .iter()
-            .take(number)
-            .map(|(id, _vec)| {
-                let meta = self.vector_metadata.get(id).cloned();
-                (id.clone(), meta)
-            })
-            .collect()
-    }
-    
-    /// Add multiple key-value pairs to index-level metadata
-    pub fn add_metadata(&mut self, metadata: HashMap<String, String>) {
-        for (key, value) in metadata {
-            self.metadata.insert(key, value);
-        }
-    }
-
-    /// Get a single index-level metadata value
-    pub fn get_metadata(&self, key: String) -> Option<String> {
-        self.metadata.get(&key).cloned()
-    }
-
-    /// Get all index-level metadata
-    pub fn get_all_metadata(&self) -> HashMap<String, String> {
-        self.metadata.clone()
-    }
-
-    /// Returns basic info about the index
-    pub fn info(&self) -> String {
-        format!(
-            "HNSWIndex(dim={}, space={}, M={}, ef_construction={}, expected_size={}, vectors={})",
-            self.dim,
-            self.space,
-            self.m,
-            self.ef_construction,
-            self.expected_size,
-            self.vectors.len()
-        )
-    }
-}