Method insert

nodedb-vector/src/codec_index/build.rs:45–127

Insert a vector with the given caller-supplied `id`. Encodes `v` via `codec.encode`, assigns a random layer, and runs the standard HNSW neighbour-selection algorithm.

(&mut self, id: u32, v: &[f32])

    /// Encodes `v` via `codec.encode`, assigns a random layer, and runs the
    /// standard HNSW neighbour-selection algorithm.
    pub fn insert(&mut self, id: u32, v: &[f32]) {
        let quantized = self.codec.encode(v);
        let node_layer = self.random_layer();

        // Allocate the node first so we can use its index in the graph wiring.
        let new_idx = self.nodes.len() as u32;

        // Build empty neighbor lists: one per layer 0..=node_layer.
        let neighbors = vec![Vec::new(); node_layer + 1];

        self.nodes.push(NodeC {
            id,
            deleted: false,
            layer: node_layer,
            quantized,
            neighbors,
        });

        let Some(ep) = self.entry_point else {
            // First node: it becomes the entry point.
            self.entry_point = Some(new_idx);
            self.max_layer = node_layer;
            return;
        };

        // Phase 1: greedy descent from max_layer down to node_layer + 1.
        // Carry a single nearest candidate per layer (ef = 1).
        let mut cur_ep = ep;
        for layer in (node_layer + 1..=self.max_layer).rev() {
            cur_ep = self.greedy_nearest(new_idx, cur_ep, layer);
        }

        // Phase 2: ef_construction search from node_layer down to 0.
        let ef = self.ef_construction;
        for layer in (0..=node_layer.min(self.max_layer)).rev() {
            let candidates = self.search_layer_build(new_idx, cur_ep, ef, layer);

            // Choose the m (or m0 at layer 0) nearest as neighbours.
            let max_nb = self.max_neighbors(layer);
            let chosen: Vec<u32> = candidates
                .iter()
                .filter(|c| c.idx != new_idx)
                .take(max_nb)
                .map(|c| c.idx)
                .collect();

            // Set new node's neighbours at this layer.
            self.nodes[new_idx as usize].neighbors[layer] = chosen.clone();

            // Update chosen neighbours reciprocally.
            for &nb_idx in &chosen {
                let new_dist = {
                    let nb_q = &self.nodes[nb_idx as usize].quantized as *const C::Quantized;
                    let new_q = &self.nodes[new_idx as usize].quantized as *const C::Quantized;
                    // SAFETY: we hold exclusive access to `self`; the two
                    // borrows are to distinct nodes.
                    unsafe { self.codec.fast_symmetric_distance(&*nb_q, &*new_q) }
                };