Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

examples/data/framework/src/hnsw.rs

@@ -0,0 +1,757 @@
+//! HNSW (Hierarchical Navigable Small World) Index
+//!
+//! Production-quality implementation of the HNSW algorithm for approximate
+//! nearest neighbor search in high-dimensional vector spaces.
+//!
+//! ## Algorithm Overview
+//!
+//! HNSW builds a multi-layer graph structure where:
+//! - Layer 0 contains all vectors
+//! - Higher layers contain progressively fewer vectors (exponentially decaying)
+//! - Each layer is a navigable small world graph with bounded degree
+//! - Search proceeds from top layer down, greedy navigating to nearest neighbors
+//!
+//! ## Performance Characteristics
+//!
+//! - **Search**: O(log n) approximate nearest neighbor queries
+//! - **Insert**: O(log n) amortized insertion time
+//! - **Space**: O(n * M) where M is max connections per layer
+//! - **Accuracy**: Configurable via ef_construction and ef_search parameters
+//!
+//! ## References
+//!
+//! - Malkov, Y. A., & Yashunin, D. A. (2018). "Efficient and robust approximate
+//!   nearest neighbor search using Hierarchical Navigable Small World graphs"
+//!   IEEE Transactions on Pattern Analysis and Machine Intelligence.
+
+use std::cmp::Reverse;
+use std::collections::{BinaryHeap, HashSet};
+use std::sync::{Arc, RwLock};
+
+use chrono::{DateTime, Utc};
+use rand::Rng;
+use serde::{Deserialize, Serialize};
+
+use crate::ruvector_native::SemanticVector;
+use crate::FrameworkError;
+
+/// HNSW index configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HnswConfig {
+    /// Maximum number of bi-directional links per node per layer (M)
+    /// Higher values improve recall but increase memory and search time
+    /// Typical range: 8-64, default: 16
+    pub m: usize,
+
+    /// Maximum connections for layer 0 (typically M * 2)
+    pub m_max_0: usize,
+
+    /// Size of dynamic candidate list during construction (ef_construction)
+    /// Higher values improve graph quality but slow construction
+    /// Typical range: 100-500, default: 200
+    pub ef_construction: usize,
+
+    /// Size of dynamic candidate list during search (ef_search)
+    /// Higher values improve recall but slow search
+    /// Typical range: 50-200, default: 50
+    pub ef_search: usize,
+
+    /// Layer generation probability parameter (ml)
+    /// 1/ln(ml) determines layer assignment probability
+    /// Default: 1.0 / ln(m) ≈ 0.36 for m=16
+    pub ml: f64,
+
+    /// Vector dimension (must be consistent)
+    pub dimension: usize,
+
+    /// Distance metric
+    pub metric: DistanceMetric,
+}
+
+impl Default for HnswConfig {
+    fn default() -> Self {
+        let m = 16;
+        Self {
+            m,
+            m_max_0: m * 2,
+            ef_construction: 200,
+            ef_search: 50,
+            ml: 1.0 / (m as f64).ln(),
+            dimension: 128,
+            metric: DistanceMetric::Cosine,
+        }
+    }
+}
+
+/// Distance metrics supported by HNSW
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum DistanceMetric {
+    /// Cosine similarity (converted to angular distance)
+    /// Distance = arccos(similarity) / π
+    /// Range: [0, 1] where 0 = identical, 1 = opposite
+    Cosine,
+
+    /// Euclidean (L2) distance
+    Euclidean,
+
+    /// Manhattan (L1) distance
+    Manhattan,
+}
+
+/// A node in the HNSW graph
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct HnswNode {
+    /// Vector data
+    vector: Vec<f32>,
+
+    /// External identifier from SemanticVector
+    external_id: String,
+
+    /// Timestamp when added
+    timestamp: DateTime<Utc>,
+
+    /// Maximum layer this node appears in
+    level: usize,
+
+    /// Connections per layer: connections[layer] = set of neighbor node IDs
+    /// Layer 0 can have up to m_max_0 connections, others up to m
+    connections: Vec<Vec<usize>>,
+}
+
+/// Search result with distance and metadata
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HnswSearchResult {
+    /// Node ID in the index
+    pub node_id: usize,
+
+    /// External identifier
+    pub external_id: String,
+
+    /// Distance to query vector (lower is more similar)
+    pub distance: f32,
+
+    /// Cosine similarity score (if using cosine metric)
+    pub similarity: Option<f32>,
+
+    /// Timestamp when vector was added
+    pub timestamp: DateTime<Utc>,
+}
+
+/// Statistics about the HNSW index structure
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HnswStats {
+    /// Total number of nodes
+    pub node_count: usize,
+
+    /// Number of layers in the graph
+    pub layer_count: usize,
+
+    /// Nodes per layer
+    pub nodes_per_layer: Vec<usize>,
+
+    /// Average connections per node per layer
+    pub avg_connections_per_layer: Vec<f64>,
+
+    /// Total edges in the graph
+    pub total_edges: usize,
+
+    /// Entry point node ID
+    pub entry_point: Option<usize>,
+
+    /// Memory usage estimate in bytes
+    pub estimated_memory_bytes: usize,
+}
+
+/// HNSW index for approximate nearest neighbor search
+///
+/// Thread-safe implementation using Arc<RwLock<>> for concurrent reads.
+pub struct HnswIndex {
+    /// Configuration
+    config: HnswConfig,
+
+    /// All nodes in the index
+    nodes: Vec<HnswNode>,
+
+    /// Entry point for search (node with highest layer)
+    entry_point: Option<usize>,
+
+    /// Maximum layer currently in use
+    max_layer: usize,
+
+    /// Random number generator for layer assignment
+    rng: Arc<RwLock<rand::rngs::StdRng>>,
+}
+
+impl HnswIndex {
+    /// Create a new HNSW index with default configuration
+    pub fn new() -> Self {
+        Self::with_config(HnswConfig::default())
+    }
+
+    /// Create a new HNSW index with custom configuration
+    pub fn with_config(config: HnswConfig) -> Self {
+        use rand::SeedableRng;
+        Self {
+            config,
+            nodes: Vec::new(),
+            entry_point: None,
+            max_layer: 0,
+            rng: Arc::new(RwLock::new(rand::rngs::StdRng::from_entropy())),
+        }
+    }
+
+    /// Insert a vector into the index
+    ///
+    /// ## Arguments
+    ///
+    /// - `vector`: The SemanticVector to insert
+    ///
+    /// ## Returns
+    ///
+    /// The assigned node ID
+    pub fn insert(&mut self, vector: SemanticVector) -> Result<usize, FrameworkError> {
+        if vector.embedding.len() != self.config.dimension {
+            return Err(FrameworkError::Config(format!(
+                "Vector dimension mismatch: expected {}, got {}",
+                self.config.dimension,
+                vector.embedding.len()
+            )));
+        }
+
+        let node_id = self.nodes.len();
+        let level = self.random_level();
+
+        // Create new node
+        let mut new_node = HnswNode {
+            vector: vector.embedding,
+            external_id: vector.id,
+            timestamp: vector.timestamp,
+            level,
+            connections: vec![Vec::new(); level + 1],
+        };
+
+        // Insert into graph
+        if self.entry_point.is_none() {
+            // First node - becomes entry point
+            self.nodes.push(new_node);
+            self.entry_point = Some(node_id);
+            self.max_layer = level;
+            return Ok(node_id);
+        }
+
+        // Search for nearest neighbors at insertion point
+        let entry_point = self.entry_point.unwrap();
+        let mut current_nearest = vec![entry_point];
+
+        // Traverse from top layer down to level+1
+        for lc in (level + 1..=self.max_layer).rev() {
+            current_nearest = self.search_layer(&new_node.vector, &current_nearest, 1, lc);
+        }
+
+        // Insert from level down to 0
+        for lc in (0..=level).rev() {
+            let candidates = self.search_layer(&new_node.vector, &current_nearest, self.config.ef_construction, lc);
+
+            // Select M neighbors
+            let m = if lc == 0 { self.config.m_max_0 } else { self.config.m };
+            let neighbors = self.select_neighbors(&new_node.vector, candidates, m);
+
+            // Add bidirectional links
+            for &neighbor_id in &neighbors {
+                // Add link from new node to neighbor
+                new_node.connections[lc].push(neighbor_id);
+            }
+
+            current_nearest = neighbors.clone();
+        }
+
+        self.nodes.push(new_node);
+
+        // Add reverse links and prune if necessary
+        for lc in 0..=level {
+            let neighbors: Vec<usize> = self.nodes[node_id].connections[lc].clone();
+            for neighbor_id in neighbors {
+                // Only add reverse link if neighbor has this layer
+                if lc < self.nodes[neighbor_id].connections.len() {
+                    self.nodes[neighbor_id].connections[lc].push(node_id);
+
+                    // Prune if exceeded max connections
+                    let m_max = if lc == 0 { self.config.m_max_0 } else { self.config.m };
+                    if self.nodes[neighbor_id].connections[lc].len() > m_max {
+                        let neighbor_vec = self.nodes[neighbor_id].vector.clone();
+                        let candidates = self.nodes[neighbor_id].connections[lc].clone();
+                        let pruned = self.select_neighbors(&neighbor_vec, candidates, m_max);
+                        self.nodes[neighbor_id].connections[lc] = pruned;
+                    }
+                }
+            }
+        }
+
+        // Update entry point if new node is at higher layer
+        if level > self.max_layer {
+            self.max_layer = level;
+            self.entry_point = Some(node_id);
+        }
+
+        Ok(node_id)
+    }
+
+    /// Insert a batch of vectors
+    ///
+    /// More efficient than inserting one at a time for large batches.
+    pub fn insert_batch(&mut self, vectors: Vec<SemanticVector>) -> Result<Vec<usize>, FrameworkError> {
+        let mut ids = Vec::with_capacity(vectors.len());
+        for vector in vectors {
+            ids.push(self.insert(vector)?);
+        }
+        Ok(ids)
+    }
+
+    /// Search for k nearest neighbors
+    ///
+    /// ## Arguments
+    ///
+    /// - `query`: Query vector (must match index dimension)
+    /// - `k`: Number of neighbors to return
+    ///
+    /// ## Returns
+    ///
+    /// Up to k nearest neighbors, sorted by distance (ascending)
+    pub fn search_knn(&self, query: &[f32], k: usize) -> Result<Vec<HnswSearchResult>, FrameworkError> {
+        if query.len() != self.config.dimension {
+            return Err(FrameworkError::Config(format!(
+                "Query dimension mismatch: expected {}, got {}",
+                self.config.dimension,
+                query.len()
+            )));
+        }
+
+        if self.entry_point.is_none() {
+            return Ok(Vec::new());
+        }
+
+        let entry_point = self.entry_point.unwrap();
+        let mut current_nearest = vec![entry_point];
+
+        // Traverse from top layer down to layer 1
+        for lc in (1..=self.max_layer).rev() {
+            current_nearest = self.search_layer(query, &current_nearest, 1, lc);
+        }
+
+        // Search layer 0 with ef_search
+        let ef = self.config.ef_search.max(k);
+        let candidates = self.search_layer(query, &current_nearest, ef, 0);
+
+        // Convert to search results
+        let results: Vec<HnswSearchResult> = candidates
+            .iter()
+            .take(k)
+            .map(|&node_id| {
+                let node = &self.nodes[node_id];
+                let distance = self.distance(query, &node.vector);
+                let similarity = if self.config.metric == DistanceMetric::Cosine {
+                    Some(self.cosine_similarity(query, &node.vector))
+                } else {
+                    None
+                };
+
+                HnswSearchResult {
+                    node_id,
+                    external_id: node.external_id.clone(),
+                    distance,
+                    similarity,
+                    timestamp: node.timestamp,
+                }
+            })
+            .collect();
+
+        Ok(results)
+    }
+
+    /// Search for all neighbors within a distance threshold
+    ///
+    /// ## Arguments
+    ///
+    /// - `query`: Query vector
+    /// - `threshold`: Maximum distance (exclusive)
+    /// - `max_results`: Maximum number of results to return (None for unlimited)
+    ///
+    /// ## Returns
+    ///
+    /// All neighbors within threshold, sorted by distance
+    pub fn search_threshold(
+        &self,
+        query: &[f32],
+        threshold: f32,
+        max_results: Option<usize>,
+    ) -> Result<Vec<HnswSearchResult>, FrameworkError> {
+        // Search with large k first
+        let k = max_results.unwrap_or(1000).max(100);
+        let mut results = self.search_knn(query, k)?;
+
+        // Filter by threshold
+        results.retain(|r| r.distance < threshold);
+
+        // Limit results
+        if let Some(max) = max_results {
+            results.truncate(max);
+        }
+
+        Ok(results)
+    }
+
+    /// Get statistics about the index structure
+    pub fn stats(&self) -> HnswStats {
+        let node_count = self.nodes.len();
+        let layer_count = self.max_layer + 1;
+
+        let mut nodes_per_layer = vec![0; layer_count];
+        let mut connections_per_layer = vec![0; layer_count];
+
+        for node in &self.nodes {
+            for layer in 0..=node.level {
+                nodes_per_layer[layer] += 1;
+                connections_per_layer[layer] += node.connections[layer].len();
+            }
+        }
+
+        let avg_connections_per_layer: Vec<f64> = connections_per_layer
+            .iter()
+            .zip(&nodes_per_layer)
+            .map(|(conn, nodes)| {
+                if *nodes > 0 {
+                    *conn as f64 / *nodes as f64
+                } else {
+                    0.0
+                }
+            })
+            .collect();
+
+        let total_edges: usize = connections_per_layer.iter().sum();
+
+        // Estimate memory: each node stores vector + metadata + connections
+        let estimated_memory_bytes = node_count
+            * (self.config.dimension * 4 // vector (f32)
+                + 100 // metadata overhead
+                + self.config.m * 8 * layer_count); // connections (usize)
+
+        HnswStats {
+            node_count,
+            layer_count,
+            nodes_per_layer,
+            avg_connections_per_layer,
+            total_edges,
+            entry_point: self.entry_point,
+            estimated_memory_bytes,
+        }
+    }
+
+    // ===== Private helper methods =====
+
+    /// Search a single layer for nearest neighbors
+    fn search_layer(&self, query: &[f32], entry_points: &[usize], ef: usize, layer: usize) -> Vec<usize> {
+        let mut visited = HashSet::new();
+        let mut candidates = BinaryHeap::new();
+        let mut nearest = BinaryHeap::new();
+
+        for &ep in entry_points {
+            let dist = self.distance(query, &self.nodes[ep].vector);
+            candidates.push((Reverse(OrderedFloat(dist)), ep));
+            nearest.push((OrderedFloat(dist), ep));
+            visited.insert(ep);
+        }
+
+        while let Some((Reverse(OrderedFloat(dist)), current)) = candidates.pop() {
+            // Check if we should continue searching
+            if let Some(&(OrderedFloat(max_dist), _)) = nearest.peek() {
+                if dist > max_dist {
+                    break;
+                }
+            }
+
+            // Explore neighbors
+            if current < self.nodes.len() && layer <= self.nodes[current].level {
+                for &neighbor in &self.nodes[current].connections[layer] {
+                    if visited.insert(neighbor) {
+                        let neighbor_dist = self.distance(query, &self.nodes[neighbor].vector);
+
+                        if let Some(&(OrderedFloat(max_dist), _)) = nearest.peek() {
+                            if neighbor_dist < max_dist || nearest.len() < ef {
+                                candidates.push((Reverse(OrderedFloat(neighbor_dist)), neighbor));
+                                nearest.push((OrderedFloat(neighbor_dist), neighbor));
+
+                                if nearest.len() > ef {
+                                    nearest.pop();
+                                }
+                            }
+                        } else {
+                            candidates.push((Reverse(OrderedFloat(neighbor_dist)), neighbor));
+                            nearest.push((OrderedFloat(neighbor_dist), neighbor));
+                        }
+                    }
+                }
+            }
+        }
+
+        // Extract node IDs sorted by distance (ascending)
+        let mut sorted_nearest: Vec<_> = nearest.into_iter().collect();
+        sorted_nearest.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
+        sorted_nearest.into_iter().map(|(_, id)| id).collect()
+    }
+
+    /// Select M neighbors from candidates using heuristic
+    fn select_neighbors(&self, base: &[f32], candidates: Vec<usize>, m: usize) -> Vec<usize> {
+        if candidates.len() <= m {
+            return candidates;
+        }
+
+        // Simple heuristic: keep nearest M by distance
+        let mut with_distances: Vec<_> = candidates
+            .into_iter()
+            .map(|id| {
+                let dist = self.distance(base, &self.nodes[id].vector);
+                (OrderedFloat(dist), id)
+            })
+            .collect();
+
+        with_distances.sort_by_key(|(dist, _)| *dist);
+        with_distances.into_iter().take(m).map(|(_, id)| id).collect()
+    }
+
+    /// Compute distance between two vectors
+    fn distance(&self, a: &[f32], b: &[f32]) -> f32 {
+        match self.config.metric {
+            DistanceMetric::Cosine => {
+                let similarity = self.cosine_similarity(a, b);
+                // Convert to angular distance: arccos(sim) / π ∈ [0, 1]
+                similarity.max(-1.0).min(1.0).acos() / std::f32::consts::PI
+            }
+            DistanceMetric::Euclidean => {
+                a.iter()
+                    .zip(b.iter())
+                    .map(|(x, y)| (x - y).powi(2))
+                    .sum::<f32>()
+                    .sqrt()
+            }
+            DistanceMetric::Manhattan => {
+                a.iter()
+                    .zip(b.iter())
+                    .map(|(x, y)| (x - y).abs())
+                    .sum()
+            }
+        }
+    }
+
+    /// Compute cosine similarity between two vectors
+    fn cosine_similarity(&self, a: &[f32], b: &[f32]) -> f32 {
+        let dot: f32 = a.iter().zip(b.iter()).map(|(x, y)| x * y).sum();
+        let norm_a: f32 = a.iter().map(|x| x * x).sum::<f32>().sqrt();
+        let norm_b: f32 = b.iter().map(|x| x * x).sum::<f32>().sqrt();
+
+        if norm_a == 0.0 || norm_b == 0.0 {
+            return 0.0;
+        }
+
+        (dot / (norm_a * norm_b)).max(-1.0).min(1.0)
+    }
+
+    /// Randomly assign a layer to a new node
+    fn random_level(&self) -> usize {
+        let mut rng = self.rng.write().unwrap();
+        let uniform: f64 = rng.gen();
+        (-uniform.ln() * self.config.ml).floor() as usize
+    }
+
+    /// Get the underlying vector for a node
+    pub fn get_vector(&self, node_id: usize) -> Option<&Vec<f32>> {
+        self.nodes.get(node_id).map(|n| &n.vector)
+    }
+
+    /// Get the external ID for a node
+    pub fn get_external_id(&self, node_id: usize) -> Option<&str> {
+        self.nodes.get(node_id).map(|n| n.external_id.as_str())
+    }
+
+    /// Get total number of nodes in the index
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+
+    /// Check if index is empty
+    pub fn is_empty(&self) -> bool {
+        self.nodes.is_empty()
+    }
+}
+
+impl Default for HnswIndex {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Wrapper for f32 that implements Ord for use in BinaryHeap
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+struct OrderedFloat(f32);
+
+impl Eq for OrderedFloat {}
+
+impl Ord for OrderedFloat {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.partial_cmp(&other.0).unwrap_or(std::cmp::Ordering::Equal)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+    use crate::ruvector_native::Domain;
+
+    fn create_test_vector(id: &str, embedding: Vec<f32>) -> SemanticVector {
+        SemanticVector {
+            id: id.to_string(),
+            embedding,
+            domain: Domain::Climate,
+            timestamp: Utc::now(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    #[test]
+    fn test_hnsw_basic_insert_search() {
+        let config = HnswConfig {
+            dimension: 3,
+            ..Default::default()
+        };
+        let mut index = HnswIndex::with_config(config);
+
+        // Insert vectors
+        let v1 = create_test_vector("v1", vec![1.0, 0.0, 0.0]);
+        let v2 = create_test_vector("v2", vec![0.0, 1.0, 0.0]);
+        let v3 = create_test_vector("v3", vec![0.9, 0.1, 0.0]);
+
+        index.insert(v1).unwrap();
+        index.insert(v2).unwrap();
+        index.insert(v3).unwrap();
+
+        assert_eq!(index.len(), 3);
+
+        // Search for nearest to v1
+        let query = vec![1.0, 0.0, 0.0];
+        let results = index.search_knn(&query, 2).unwrap();
+
+        assert_eq!(results.len(), 2);
+        assert_eq!(results[0].external_id, "v1"); // Exact match
+        assert_eq!(results[1].external_id, "v3"); // Close match
+    }
+
+    #[test]
+    fn test_hnsw_batch_insert() {
+        let config = HnswConfig {
+            dimension: 2,
+            ..Default::default()
+        };
+        let mut index = HnswIndex::with_config(config);
+
+        let vectors = vec![
+            create_test_vector("v1", vec![1.0, 0.0]),
+            create_test_vector("v2", vec![0.0, 1.0]),
+            create_test_vector("v3", vec![1.0, 1.0]),
+        ];
+
+        let ids = index.insert_batch(vectors).unwrap();
+        assert_eq!(ids.len(), 3);
+        assert_eq!(index.len(), 3);
+    }
+
+    #[test]
+    fn test_hnsw_threshold_search() {
+        let config = HnswConfig {
+            dimension: 2,
+            ..Default::default()
+        };
+        let mut index = HnswIndex::with_config(config);
+
+        // Insert vectors at different distances
+        index.insert(create_test_vector("close", vec![1.0, 0.1])).unwrap();
+        index.insert(create_test_vector("medium", vec![0.7, 0.7])).unwrap();
+        index.insert(create_test_vector("far", vec![0.0, 1.0])).unwrap();
+
+        let query = vec![1.0, 0.0];
+        let results = index.search_threshold(&query, 0.3, None).unwrap();
+
+        // Should find only close vectors
+        assert!(results.len() >= 1);
+        assert!(results.iter().all(|r| r.distance < 0.3));
+    }
+
+    #[test]
+    fn test_hnsw_cosine_similarity() {
+        let config = HnswConfig {
+            dimension: 3,
+            metric: DistanceMetric::Cosine,
+            ..Default::default()
+        };
+        let mut index = HnswIndex::with_config(config);
+
+        let v1 = create_test_vector("identical", vec![1.0, 0.0, 0.0]);
+        let v2 = create_test_vector("orthogonal", vec![0.0, 1.0, 0.0]);
+        let v3 = create_test_vector("opposite", vec![-1.0, 0.0, 0.0]);
+
+        index.insert(v1).unwrap();
+        index.insert(v2).unwrap();
+        index.insert(v3).unwrap();
+
+        let query = vec![1.0, 0.0, 0.0];
+        let results = index.search_knn(&query, 3).unwrap();
+
+        // Identical should be closest
+        assert_eq!(results[0].external_id, "identical");
+        assert!(results[0].distance < 0.01);
+
+        // Opposite should be farthest
+        assert_eq!(results[2].external_id, "opposite");
+    }
+
+    #[test]
+    fn test_hnsw_stats() {
+        let config = HnswConfig {
+            dimension: 2,
+            m: 4,
+            ..Default::default()
+        };
+        let mut index = HnswIndex::with_config(config);
+
+        for i in 0..10 {
+            let vec = create_test_vector(&format!("v{}", i), vec![i as f32, i as f32]);
+            index.insert(vec).unwrap();
+        }
+
+        let stats = index.stats();
+        assert_eq!(stats.node_count, 10);
+        assert!(stats.layer_count > 0);
+        assert_eq!(stats.nodes_per_layer[0], 10); // All nodes in layer 0
+        assert!(stats.total_edges > 0);
+    }
+
+    #[test]
+    fn test_dimension_mismatch() {
+        let config = HnswConfig {
+            dimension: 3,
+            ..Default::default()
+        };
+        let mut index = HnswIndex::with_config(config);
+
+        let bad_vector = create_test_vector("bad", vec![1.0, 2.0]); // Wrong dimension
+        let result = index.insert(bad_vector);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_empty_index_search() {
+        let index = HnswIndex::new();
+        let query = vec![1.0; 128];
+        let results = index.search_knn(&query, 5).unwrap();
+        assert!(results.is_empty());
+    }
+}