nidx-binding 6.6.1.post437__tar.gz → 6.6.1.post439__tar.gz

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/Cargo.lock

@@ -2292,6 +2292,7 @@ dependencies = [
  "nidx_protos",
  "nidx_types",
  "rand 0.8.5",
+ "rayon",
  "rstest",
  "serde",
  "simsimd",

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.6.1.post437
+Version: 6.6.1.post439
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_protos/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.6.1.post437"
+version = "6.6.1.post439"
 license = "AGPL-3.0-or-later"
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [{ name = "Nuclia", email = "nucliadb@nuclia.com" }]

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/Cargo.toml

@@ -23,6 +23,7 @@ stream-vbyte = "0.4.1"
 fst = "0.4.7"
 bit-vec = "0.8.0"
 bincode = "2.0.1"
+rayon = "1.10.0"
 
 [target.'cfg(not(all(target_os="linux",target_arch="aarch64")))'.dependencies]
 simsimd = "4.3.1"

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/config.rs

@@ -65,9 +65,9 @@ impl VectorType {
         }
     }
 
-    pub fn dimension(&self) -> Option<usize> {
+    pub fn dimension(&self) -> usize {
         match self {
-            VectorType::DenseF32 { dimension } => Some(*dimension),
+            VectorType::DenseF32 { dimension } => *dimension,
         }
     }
 
@@ -79,6 +79,13 @@ impl VectorType {
     }
 }
 
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+pub enum VectorCardinality {
+    #[default]
+    Single,
+    Multi,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct VectorConfig {
     #[serde(default)]
@@ -86,6 +93,8 @@ pub struct VectorConfig {
     #[serde(default)]
     pub normalize_vectors: bool,
     pub vector_type: VectorType,
+    #[serde(default)]
+    pub vector_cardinality: VectorCardinality,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub flags: Vec<String>,
 }
@@ -114,11 +123,13 @@ impl TryFrom<VectorIndexConfig> for VectorConfig {
                 dimension: dim as usize,
             },
         };
+        // TODO: Add support for multivectors. It is incompatible with vector normalization for now
         Ok(VectorConfig {
             similarity: proto.similarity().into(),
             normalize_vectors: proto.normalize_vectors,
             vector_type,
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         })
     }
 }

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_point/mod.rs

@@ -30,7 +30,8 @@ use crate::config::{VectorConfig, flags};
 use crate::data_store::{DataStore, DataStoreV1, DataStoreV2, OpenReason, ParagraphRef, VectorRef};
 use crate::formula::Formula;
 use crate::inverted_index::{FilterBitSet, InvertedIndexes, build_indexes};
-use crate::{ParagraphAddr, VectorErr, VectorR, VectorSegmentMeta, VectorSegmentMetadata};
+use crate::{ParagraphAddr, VectorAddr, VectorErr, VectorR, VectorSegmentMeta, VectorSegmentMetadata};
+use core::f32;
 use disk_hnsw::DiskHnsw;
 use io::{BufWriter, Write};
 use memmap2::Mmap;
@@ -187,7 +188,7 @@ fn merge_indexes<DS: DataStore + 'static>(
 
     let metadata = VectorSegmentMetadata {
         path: data_point_path.to_path_buf(),
-        records: merged_vectors_count,
+        records: data_store.stored_paragraph_count(),
         index_metadata: VectorSegmentMeta {
             tags: operants[0].metadata.index_metadata.tags.clone(),
         },
@@ -208,12 +209,15 @@ fn merge_indexes<DS: DataStore + 'static>(
 
 pub fn create(path: &Path, elems: Vec<Elem>, config: &VectorConfig, tags: HashSet<String>) -> VectorR<OpenDataPoint> {
     // Check dimensions
-    if let Some(dim) = config.vector_type.dimension() {
-        if let Some(elem) = elems.iter().find(|elem| elem.vector.len() != dim) {
-            return Err(crate::VectorErr::InconsistentDimensions {
-                index_config: dim,
-                vector: elem.vector.len(),
-            });
+    let dim = config.vector_type.dimension();
+    for e in &elems {
+        for v in &e.vectors {
+            if v.len() != dim {
+                return Err(crate::VectorErr::InconsistentDimensions {
+                    index_config: dim,
+                    vector: v.len(),
+                });
+            }
         }
     }
 
@@ -229,6 +233,12 @@ pub fn create(path: &Path, elems: Vec<Elem>, config: &VectorConfig, tags: HashSe
             tags,
         )
     } else {
+        // Double check vector cardinality
+        if elems.iter().any(|e| e.vectors.len() != 1) {
+            return Err(crate::VectorErr::InvalidConfiguration(
+                "DataStore v1 not supported with multi-vectors",
+            ));
+        }
         DataStoreV1::create(path, elems, &config.vector_type)?;
         create_indexes(
             path,
@@ -280,7 +290,7 @@ fn create_indexes<DS: DataStore + 'static>(
 
     let metadata = VectorSegmentMetadata {
         path: path.to_path_buf(),
-        records: vector_count,
+        records: data_store.stored_paragraph_count(),
         index_metadata: VectorSegmentMeta { tags },
     };
 
@@ -360,7 +370,7 @@ impl<DS: DataStore> DataRetriever for Retriever<'_, DS> {
 #[derive(Clone, Debug)]
 pub struct Elem {
     pub key: String,
-    pub vector: Vec<f32>,
+    pub vectors: Vec<Vec<f32>>,
     pub metadata: Option<Vec<u8>>,
     pub labels: Vec<String>,
 }
@@ -370,7 +380,21 @@ impl Elem {
             labels,
             metadata,
             key,
-            vector,
+            vectors: vec![vector],
+        }
+    }
+
+    pub fn new_multivector(
+        key: String,
+        vectors: Vec<Vec<f32>>,
+        labels: Vec<String>,
+        metadata: Option<Vec<u8>>,
+    ) -> Elem {
+        Elem {
+            labels,
+            metadata,
+            key,
+            vectors,
         }
     }
 }
@@ -440,6 +464,10 @@ impl OpenDataPoint {
         self.data_store.get_paragraph(id)
     }
 
+    pub fn get_vector(&self, id: VectorAddr) -> VectorRef {
+        self.data_store.get_vector(id)
+    }
+
     pub fn search(
         &self,
         query: &[f32],
@@ -490,12 +518,20 @@ impl OpenDataPoint {
             let mut scored_results = Vec::new();
             for paragraph_addr in bitset.iter() {
                 let paragraph = data_store.get_paragraph(paragraph_addr);
-                for vector_addr in paragraph.vectors(&paragraph_addr) {
-                    let address = vector_addr.into();
-                    let score = retriever.similarity(query_address, address);
-                    if score >= min_score {
-                        scored_results.push(Reverse(Cnx(address, score)));
-                    }
+
+                // Only return the best vector match per paragraph
+                let best_vector_score = paragraph
+                    .vectors(&paragraph_addr)
+                    .map(|va| {
+                        let address = va.into();
+                        let score = retriever.similarity(query_address, address);
+                        Cnx(address, score)
+                    })
+                    .max_by(|v, w| v.1.total_cmp(&w.1))
+                    .unwrap();
+
+                if best_vector_score.1 >= min_score {
+                    scored_results.push(Reverse(best_vector_score));
                 }
             }
             scored_results.sort();
@@ -528,7 +564,7 @@ mod test {
 
     use crate::{
         ParagraphAddr, VectorAddr,
-        config::{Similarity, VectorConfig},
+        config::{Similarity, VectorCardinality, VectorConfig},
         formula::Formula,
         vector_types::dense_f32::{dot_similarity, encode_vector},
     };
@@ -612,6 +648,7 @@ mod test {
             vector_type: crate::config::VectorType::DenseF32 { dimension: DIMENSION },
             normalize_vectors: false,
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         };
         let mut rng = SmallRng::seed_from_u64(1234567890);
         let temp_dir = tempdir()?;
@@ -628,7 +665,7 @@ mod test {
 
         for (i, (elem, mut labels)) in elems.into_iter().enumerate() {
             let vector = dp.data_store.get_vector(VectorAddr(i as u32));
-            assert_eq!(config.vector_type.encode(&elem.vector), vector.vector());
+            assert_eq!(config.vector_type.encode(&elem.vectors[0]), vector.vector());
 
             let paragraph = dp.data_store.get_paragraph(ParagraphAddr(i as u32));
             assert_eq!(elem.key, paragraph.id());
@@ -657,6 +694,7 @@ mod test {
             vector_type: crate::config::VectorType::DenseF32 { dimension: DIMENSION },
             normalize_vectors: false,
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         };
         let mut rng = SmallRng::seed_from_u64(1234567890);
 
@@ -684,7 +722,7 @@ mod test {
 
         for (i, (elem, mut labels)) in elems1.into_iter().chain(elems2.into_iter()).enumerate() {
             let vector = merged_dp.data_store.get_vector(VectorAddr(i as u32));
-            assert_eq!(config.vector_type.encode(&elem.vector), vector.vector());
+            assert_eq!(config.vector_type.encode(&elem.vectors[0]), vector.vector());
 
             let paragraph = merged_dp.data_store.get_paragraph(ParagraphAddr(i as u32));
             assert_eq!(elem.key, paragraph.id());
@@ -734,6 +772,7 @@ mod test {
             vector_type: crate::config::VectorType::DenseF32 { dimension: DIMENSION },
             normalize_vectors: false,
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         };
 
         // Create a data point

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_point/ops_hnsw.rs

@@ -82,7 +82,7 @@ pub type Neighbours = Vec<(Address, f32)>;
 struct NodeFilter<'a, DR> {
     retriever: &'a DR,
     filter: &'a FilterBitSet,
-    blocked_addresses: &'a FxHashSet<Address>,
+    paragraphs: FxHashSet<ParagraphAddr>,
     vec_counter: RepCounter<'a>,
 }
 
@@ -93,11 +93,18 @@ impl<DR: DataRetriever> NodeFilter<'_, DR> {
 
     pub fn is_valid(&self, n: Address, score: f32) -> bool {
         !score.is_nan()
-        // The vector is blocked, meaning that its key is part of the current version of the solution
-        && !self.blocked_addresses.contains(&n)
-        // The number of times this vector appears is 0
+        // Reject the candidate if we already have a result for the same paragraph
+        && !self.paragraphs.contains(&self.retriever.paragraph(n))
+        // Reject the candidate if we already have a result with an identical vector
         && self.vec_counter.get(self.retriever.get_vector(n)) == 0
     }
+
+    /// Adds a result so that further candidates with the same vector
+    /// or paragraph will get rejected.
+    pub fn add_result(&mut self, n: Address) {
+        self.paragraphs.insert(self.retriever.paragraph(n));
+        self.vec_counter.add(self.retriever.get_vector(n));
+    }
 }
 
 pub struct HnswOps<'a, DR> {
@@ -194,8 +201,7 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
 
             let paragraph_addr = self.retriever.paragraph(candidate);
             if filter.is_valid(candidate, candidate_similarity) && filter.passes_formula(paragraph_addr) {
-                let candidate_vector = self.retriever.get_vector(candidate);
-                filter.vec_counter.add(candidate_vector);
+                filter.add_result(candidate);
                 results.push((candidate, candidate_similarity));
             }
 
@@ -354,7 +360,7 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
         let filter = NodeFilter {
             filter: with_filter,
             retriever: self.retriever,
-            blocked_addresses: &Default::default(),
+            paragraphs: Default::default(),
             vec_counter: RepCounter::new(!with_duplicates),
         };
         let layer_zero = hnsw.get_layer(0);

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_point/tests.rs

@@ -24,7 +24,7 @@ use std::time::Instant;
 use tempfile::tempdir;
 
 use crate::VectorR;
-use crate::config::{Similarity, VectorConfig, flags};
+use crate::config::{Similarity, VectorCardinality, VectorConfig, flags};
 use crate::data_point::{self, Elem};
 use crate::data_store::{DataStoreV1, DataStoreV2};
 use crate::formula::{AtomClause, Clause, Formula};
@@ -34,6 +34,7 @@ const CONFIG: VectorConfig = VectorConfig {
     normalize_vectors: false,
     vector_type: crate::config::VectorType::DenseF32 { dimension: 178 },
     flags: vec![],
+    vector_cardinality: VectorCardinality::Single,
 };
 
 fn create_query() -> Vec<f32> {

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_point_provider/reader.rs

@@ -18,10 +18,14 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
 
+use crate::ParagraphAddr;
+use crate::config::VectorCardinality;
 use crate::data_point::OpenDataPoint;
 use crate::data_point_provider::SearchRequest;
 use crate::data_point_provider::VectorConfig;
 use crate::data_store::ParagraphRef;
+use crate::multivector::extract_multi_vectors;
+use crate::multivector::maxsim_similarity;
 use crate::request_types::VectorSearchRequest;
 use crate::utils;
 use crate::{VectorErr, VectorR};
@@ -30,6 +34,7 @@ use nidx_protos::prost::*;
 use nidx_protos::{DocumentScored, DocumentVectorIdentifier, SentenceMetadata, VectorSearchResponse};
 use nidx_types::prefilter::PrefilterResult;
 use nidx_types::query_language::*;
+use rayon::prelude::*;
 use std::cmp::Ordering;
 use std::collections::HashSet;
 use std::time::Instant;
@@ -39,6 +44,8 @@ use tracing::*;
 pub struct ScoredParagraph<'a> {
     score: f32,
     paragraph: ParagraphRef<'a>,
+    address: ParagraphAddr,
+    data_point: &'a OpenDataPoint,
 }
 impl Eq for ScoredParagraph<'_> {}
 impl std::hash::Hash for ScoredParagraph<'_> {
@@ -72,8 +79,13 @@ impl PartialEq for ScoredParagraph<'_> {
 }
 
 impl<'a> ScoredParagraph<'a> {
-    pub fn new(paragraph: ParagraphRef<'a>, score: f32) -> Self {
-        Self { paragraph, score }
+    pub fn new(data_point: &'a OpenDataPoint, address: ParagraphAddr, paragraph: ParagraphRef<'a>, score: f32) -> Self {
+        Self {
+            data_point,
+            paragraph,
+            score,
+            address,
+        }
     }
     pub fn score(&self) -> f32 {
         self.score
@@ -88,6 +100,12 @@ impl<'a> ScoredParagraph<'a> {
         let metadata = self.paragraph.metadata();
         (!metadata.is_empty()).then_some(metadata)
     }
+    pub fn vectors(&self) -> Vec<&[u8]> {
+        self.paragraph
+            .vectors(&self.address)
+            .map(|va| self.data_point.get_vector(va).vector())
+            .collect()
+    }
 }
 
 // Fixed-sized sorted collection
@@ -251,8 +269,9 @@ impl Reader {
                 open_data_point.search(query, filter, with_duplicates, no_results, &self.config, min_score);
 
             for candidate in partial_solution {
-                let paragraph = open_data_point.get_paragraph(candidate.paragraph());
-                let scored_paragraph = ScoredParagraph::new(paragraph, candidate.score());
+                let addr = candidate.paragraph();
+                let paragraph = open_data_point.get_paragraph(addr);
+                let scored_paragraph = ScoredParagraph::new(open_data_point, addr, paragraph, candidate.score());
                 ffsv.add(scored_paragraph, candidate.vector());
             }
         }
@@ -293,14 +312,72 @@ impl Reader {
             formula.operator = BooleanOperator::Or;
         }
 
-        let search_request = (total_to_get, request, formula);
         let v = time.elapsed().as_millis();
-        debug!("{id:?} - Searching: starts at {v} ms");
-
-        let result = self._search(&search_request, &request.segment_filtering_formula)?;
+        let result = match self.config.vector_cardinality {
+            VectorCardinality::Single => {
+                let search_request = (total_to_get, request, formula);
+                debug!("{id:?} - Searching: starts at {v} ms");
+                self._search(&search_request, &request.segment_filtering_formula)?
+            }
+            VectorCardinality::Multi => {
+                let search_vectors = extract_multi_vectors(&request.vector, &self.config.vector_type)?;
+                debug!(
+                    "{id:?} - Multi-vector searching: starts at {v} ms with {} requests",
+                    search_vectors.len()
+                );
+                let encoded_query = search_vectors
+                    .iter()
+                    .map(|v| self.config.vector_type.encode(v))
+                    .collect::<Vec<_>>();
+
+                // Search for each vector in the query
+                let results = search_vectors
+                    .into_par_iter()
+                    .map(|v| {
+                        let mut subreq = request.clone();
+
+                        subreq.vector = v;
+                        // We are OK with duplicate individual vectors. We always deduplicate by paragraphs anyway (NodeFilter.paragraphs)
+                        subreq.with_duplicates = true;
+                        // We don't care about min_score in this first pass, we apply min_score on top of maxsim similarity
+                        subreq.min_score = f32::MIN;
+                        // Request at least a few vectors, since the rerank may offer different results later
+                        let total_to_get = total_to_get.max(10);
+
+                        let search_request = (total_to_get, &subreq, formula.clone());
+                        self._search(&search_request, &request.segment_filtering_formula)
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                let v = time.elapsed().as_millis();
+                debug!("{id:?} - Multi-vector reranking: starts at {v} ms");
+
+                // Remove duplicates, we only want each paragraph once
+                let mut result_paragraphs = results.into_iter().flatten().collect::<Vec<_>>();
+                result_paragraphs.sort_unstable_by_key(|rp| rp.address);
+                result_paragraphs.dedup_by_key(|rp| rp.address);
+
+                // Score each paragraph using maxsim
+                let similarity_function = self.config.similarity_function();
+                let mut results = result_paragraphs
+                    .into_par_iter()
+                    .filter_map(|mut sp| {
+                        sp.score = maxsim_similarity(similarity_function, &encoded_query, &sp.vectors());
+                        (sp.score() > request.min_score).then_some(sp)
+                    })
+                    .collect::<Vec<_>>();
+
+                // Select top_k
+                results.sort_unstable_by(|a, b| b.score().partial_cmp(&a.score()).unwrap());
+                results.truncate(total_to_get);
+
+                results
+            }
+        };
 
         let v = time.elapsed().as_millis();
         debug!("{id:?} - Searching: ends at {v} ms");
+
         debug!("{id:?} - Creating results: starts at {v} ms");
 
         let documents = result
@@ -335,7 +412,7 @@ mod tests {
     use tempfile::TempDir;
 
     use super::*;
-    use crate::config::{Similarity, VectorConfig, VectorType};
+    use crate::config::{Similarity, VectorCardinality, VectorConfig, VectorType};
     use crate::data_point;
     use crate::indexer::{ResourceWrapper, index_resource};
 
@@ -348,6 +425,7 @@ mod tests {
             normalize_vectors: false,
             vector_type: VectorType::DenseF32 { dimension: 3 },
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         };
         let raw_sentences = [
             (
@@ -444,6 +522,7 @@ mod tests {
             normalize_vectors: false,
             vector_type: VectorType::DenseF32 { dimension: 3 },
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         };
         let raw_sentences = [
             (
@@ -565,6 +644,7 @@ mod tests {
             normalize_vectors: false,
             vector_type: VectorType::DenseF32 { dimension: 3 },
             flags: vec![],
+            vector_cardinality: VectorCardinality::Single,
         };
         let raw_sentences = [
             (

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_store/v1/store.rs

@@ -211,13 +211,14 @@ pub fn merge(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::data_point::Elem;
+    use crate::{config::VectorCardinality, data_point::Elem};
 
     const VECTOR_CONFIG: VectorConfig = VectorConfig {
         vector_type: VectorType::DenseF32 { dimension: 3 },
         similarity: crate::config::Similarity::Dot,
         normalize_vectors: false,
         flags: vec![],
+        vector_cardinality: VectorCardinality::Single,
     };
 
     #[test]

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_store/v1.rs

@@ -137,10 +137,12 @@ impl store::IntoBuffer for Elem {
         let ram_trie = trie_ram::create_trie(&self.labels);
         let trie_bytes = trie::serialize(ram_trie);
 
+        debug_assert!(self.vectors.len() == 1);
+
         Node::serialize_into(
             w,
             self.key,
-            vector_type.encode(&self.vector),
+            vector_type.encode(&self.vectors[0]),
             vector_type.vector_alignment(),
             trie_bytes,
             self.metadata.as_ref(),

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_store/v2/paragraph_store.rs

@@ -59,7 +59,7 @@ impl<'a> StoredParagraph<'a> {
             labels: elem.labels.iter().map(String::as_str).collect(),
             metadata: elem.metadata.as_ref().map_or(&[], |x| x),
             first_vector,
-            num_vectors: 1,
+            num_vectors: elem.vectors.len() as u32,
         }
     }
 

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_store/v2/vector_store.rs

@@ -133,16 +133,20 @@ impl VectorStoreWriter {
         })
     }
 
-    pub fn write(&mut self, paragraph_id: u32, vectors: &[&[u8]]) -> std::io::Result<(u32, u32)> {
+    pub fn write(
+        &mut self,
+        paragraph_id: u32,
+        vectors: impl Iterator<Item = impl AsRef<[u8]>>,
+    ) -> std::io::Result<(u32, u32)> {
         let first_addr = self.addr;
         for v in vectors {
-            self.output.write_all(v)?;
+            self.output.write_all(v.as_ref())?;
             self.output.write_all(paragraph_id.to_le_bytes().as_slice())?;
             if self.padding_bytes > 0 {
                 self.output.seek(SeekFrom::Current(self.padding_bytes as i64))?;
             }
+            self.addr += 1;
         }
-        self.addr += vectors.len() as u32;
         let last_addr = self.addr - 1;
         Ok((first_addr, last_addr))
     }

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/data_store/v2.rs

@@ -47,7 +47,7 @@ impl DataStoreV2 {
         let mut vectors = VectorStoreWriter::new(path, vector_type)?;
 
         for (idx, elem) in (0..).zip(entries.into_iter()) {
-            let (first_vector, _) = vectors.write(idx, &[&vector_type.encode(&elem.vector)])?;
+            let (first_vector, _) = vectors.write(idx, elem.vectors.iter().map(|v| vector_type.encode(v)))?;
             paragraphs.write(StoredParagraph::from_elem(&elem, first_vector))?;
         }
 
@@ -70,13 +70,10 @@ impl DataStoreV2 {
             for paragraph_addr in alive {
                 // Retrieve paragraph and vectors
                 let paragraph = store.get_paragraph(paragraph_addr);
-                let p_vectors: Vec<_> = paragraph
-                    .vectors(&paragraph_addr)
-                    .map(|v| store.get_vector(v).vector())
-                    .collect();
+                let p_vectors = paragraph.vectors(&paragraph_addr).map(|v| store.get_vector(v).vector());
 
                 // Write to new store
-                let (first_vector, last_vector) = vectors.write(p_idx, p_vectors.as_slice())?;
+                let (first_vector, last_vector) = vectors.write(p_idx, p_vectors)?;
                 paragraphs.write_paragraph_ref(paragraph, first_vector, last_vector - first_vector + 1)?;
                 p_idx += 1;
             }

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/formula/mod.rs

@@ -96,3 +96,9 @@ impl Formula {
         self.clauses.push(clause.into())
     }
 }
+
+impl Default for Formula {
+    fn default() -> Self {
+        Self::new()
+    }
+}

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/indexer.rs

@@ -17,8 +17,9 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-use crate::config::VectorConfig;
+use crate::config::{VectorCardinality, VectorConfig};
 use crate::data_point::{self, Elem};
+use crate::multivector::extract_multi_vectors;
 use crate::{VectorSegmentMetadata, utils};
 use nidx_protos::{noderesources, prost::*};
 use std::collections::HashMap;
@@ -124,7 +125,19 @@ pub fn index_resource(
                     sentence.vector.clone()
                 };
                 let metadata = sentence.metadata.as_ref().map(|m| m.encode_to_vec());
-                elems.push(Elem::new(key, vector, paragraph.labels.clone(), metadata));
+
+                match config.vector_cardinality {
+                    VectorCardinality::Single => elems.push(Elem::new(key, vector, paragraph.labels.clone(), metadata)),
+                    VectorCardinality::Multi => {
+                        let vectors = extract_multi_vectors(&vector, &config.vector_type)?;
+                        elems.push(Elem::new_multivector(
+                            key.clone(),
+                            vectors,
+                            paragraph.labels.clone(),
+                            metadata.clone(),
+                        ));
+                    }
+                };
             }
         }
     }

{nidx_binding-6.6.1.post437 → nidx_binding-6.6.1.post439}/nidx_vector/src/lib.rs

@@ -26,6 +26,7 @@ mod data_types;
 mod formula;
 mod indexer;
 mod inverted_index;
+mod multivector;
 mod query_io;
 mod request_types;
 mod utils;
@@ -47,7 +48,7 @@ use tracing::instrument;
 pub use indexer::SEGMENT_TAGS;
 pub use request_types::VectorSearchRequest;
 
-#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq, Hash)]
 pub struct ParagraphAddr(u32);
 pub struct VectorAddr(u32);