vectlite 0.9.0 → 0.9.2

package/README.md

@@ -138,6 +138,10 @@ products.upsert('p1', embedding, { name: 'Widget', price: 9.99 })
 
 const logs = store.openOrCreateCollection('logs', 128)
 console.log(store.collections()) // ["logs", "products"]
+
+products.close()
+logs.close()
+store.close()
 ```
 
 ### Transactions
@@ -231,20 +235,22 @@ db.dropIndex('score')
 
 ### Vector Quantization
 
-Reduce memory usage and accelerate search with quantized vectors. All methods use a 2-stage pipeline: fast quantized candidate selection followed by exact float32 rescoring.
+Reduce in-memory candidate-index usage and accelerate search with quantized vectors. All methods use a 2-stage pipeline: fast quantized candidate selection followed by exact float32 rescoring.
 
 ```js
-// Scalar quantization (int8) -- 4x memory reduction, minimal recall loss
+// Scalar quantization (int8) -- smaller in-memory candidate index, minimal recall loss
 db.enableQuantization('scalar')
 
-// Binary quantization -- 32x memory reduction, best for normalized embeddings
-db.enableQuantization('binary', JSON.stringify({ rescoreMultiplier: 10 }))
+// Binary quantization -- smallest in-memory candidate index, best for normalized embeddings
+db.enableQuantization('binary', { rescoreMultiplier: 10 })
 
-// Product quantization -- configurable compression for very large datasets
-db.enableQuantization('product', JSON.stringify({ numSubVectors: 16, numCentroids: 256 }))
+// Product quantization -- "pq" and "product" are accepted case-insensitively
+console.log(db.validNumSubVectors()) // valid PQ partitions for this dimension
+db.enableQuantization('pq', { numSubVectors: 16, numCentroids: 256 })
 
 // Search works exactly the same -- quantization accelerates it transparently
 const results = db.search(queryEmbedding, { k: 10 })
+const sameResults = db.search({ query: queryEmbedding, k: 10 })
 
 // Check quantization status
 console.log(db.isQuantized)         // true
@@ -254,7 +260,11 @@ console.log(db.quantizationMethod)  // "scalar", "binary", or "product"
 db.disableQuantization()
 ```
 
-Quantization parameters persist across reopens in a `.vdb.quant` sidecar file. The quantized index auto-rebuilds on inserts and upserts.
+`rescoreMultiplier` controls the number of quantized candidates rescored with exact float32 scoring: `k * rescoreMultiplier`, capped at the collection size. Increase it to trade latency for recall.
+
+For PQ, `numSubVectors` must divide the database dimension. If omitted, Vectlite chooses a compatible default; use `db.validNumSubVectors()` to inspect all valid values.
+
+Quantization does not shrink the `.vdb` file on disk. Vectlite keeps the original float32 vectors for exact rescoring and stores quantization parameters in a `.vdb.quant` sidecar file, so total disk footprint can increase slightly. The quantized index auto-rebuilds on inserts and upserts.
 
 ### Multi-Vector / ColBERT Search
 
@@ -263,14 +273,12 @@ Store token-level embeddings (ColBERT, ColPali) and search with MaxSim late inte
 ```js
 // Upsert with per-token ColBERT embeddings
 db.upsertMultiVectors('doc1', denseVector,
-  JSON.stringify({ colbert: [tokenVec1, tokenVec2] }),
-  JSON.stringify({ metadata: { source: 'paper' } })
+  { colbert: [tokenVec1, tokenVec2] },
+  { metadata: { source: 'paper' } }
 )
 
 // MaxSim search
-const results = JSON.parse(
-  db.searchMultiVector('colbert', JSON.stringify(queryTokenVectors))
-)
+const results = db.searchMultiVector('colbert', queryTokenVectors)
 
 // Enable 2-bit quantization (~16x compression)
 db.enableMultiVectorQuantization('colbert')
@@ -403,7 +411,7 @@ before re-throwing.
 | Method | Description |
 |---|---|
 | `db.get(id, { namespace })` | Get a single record by id |
-| `db.search(query, options)` | Search and return a list of results |
+| `db.search(query, options)` or `db.search({ query, ...options })` | Search and return a list of results |
 | `db.searchWithStats(query, options)` | Search with detailed performance stats |
 | `db.count({ namespace, filter })` | Count records, optionally scoped by namespace/filter |
 | `db.list({ namespace, filter, limit, offset })` | List records without issuing a vector query |
@@ -426,10 +434,14 @@ before re-throwing.
 
 | Method | Description |
 |---|---|
-| `db.enableQuantization(method, optionsJson)` | Enable quantization (`'scalar'`, `'binary'`, or `'product'`) |
+| `db.enableQuantization(method, options)` | Enable quantization (`'scalar'`, `'binary'`, or `'pq'` / `'product'`) |
 | `db.disableQuantization()` | Disable quantization and remove persisted parameters |
 | `db.isQuantized` | Whether quantization is enabled (property) |
 | `db.quantizationMethod` | Active method name or `null` (property) |
+| `db.validNumSubVectors()` | Valid PQ `numSubVectors` values for this database dimension |
+| `db.enableMultiVectorQuantization(space, options)` | Enable 2-bit quantization for a multi-vector space |
+| `db.disableMultiVectorQuantization(space)` | Disable multi-vector quantization for a space |
+| `db.isMultiVectorQuantized(space)` | Whether multi-vector quantization is enabled for a space |
 
 ### Maintenance Methods
 

package/index.d.ts

@@ -9,6 +9,7 @@ export type MetadataValue =
 export type Metadata = { [key: string]: MetadataValue }
 export type SparseVector = { [term: string]: number }
 export type NamedVectors = { [name: string]: number[] }
+export type MultiVectors = { [space: string]: number[][] }
 export type Filter = { [key: string]: unknown }
 export type TextEmbedding = ArrayLike<number>
 export type TextEmbeddingResult = TextEmbedding | Promise<TextEmbedding>
@@ -130,6 +131,46 @@ export interface SearchOptions {
   vectorWeights?: { [name: string]: number } | null
 }
 
+export interface SearchRequest extends SearchOptions {
+  query?: number[] | null
+}
+
+export type QuantizationMethod = 'scalar' | 'int8' | 'binary' | 'product' | 'pq'
+export interface QuantizationOptions {
+  rescoreMultiplier?: number
+  rescore_multiplier?: number
+  numSubVectors?: number
+  num_sub_vectors?: number
+  numCentroids?: number
+  num_centroids?: number
+  trainingIterations?: number
+  training_iterations?: number
+}
+
+export interface MultiVectorWriteOptions {
+  namespace?: string | null
+  metadata?: Metadata | null
+}
+
+export interface MultiVectorSearchOptions {
+  k?: number
+  filter?: Filter | null
+  namespace?: string | null
+}
+
+export interface MultiVectorSearchResult {
+  namespace: string
+  id: string
+  score: number
+  metadata: Metadata
+}
+
+export interface MultiVectorQuantizationOptions {
+  method?: 'two_bit'
+  rescoreMultiplier?: number
+  rescore_multiplier?: number
+}
+
 export type DistanceMetric = 'cosine' | 'euclidean' | 'dotproduct' | 'manhattan' | 'l2' | 'dot' | 'ip' | 'l1'
 
 export interface OpenOptions {
@@ -181,13 +222,31 @@ export class Database {
   createIndex(field: string, indexType: 'keyword' | 'numeric'): boolean
   dropIndex(field: string): boolean
   listIndexes(): Array<{ field: string; type: 'keyword' | 'numeric' }>
+  readonly isQuantized: boolean
+  readonly quantizationMethod: 'scalar' | 'binary' | 'product' | null
+  enableQuantization(method?: QuantizationMethod, options?: QuantizationOptions | string): void
+  disableQuantization(): void
+  validNumSubVectors(): number[]
+  upsertMultiVectors(id: string, vector: number[], multiVectors: MultiVectors, options?: MultiVectorWriteOptions): void
+  searchMultiVector(space: string, queryTokens: number[][], options?: MultiVectorSearchOptions): MultiVectorSearchResult[]
+  enableMultiVectorQuantization(space: string, options?: MultiVectorQuantizationOptions | string): void
+  disableMultiVectorQuantization(space: string): void
+  isMultiVectorQuantized(space: string): boolean
   flush(): void
   compact(): void
   snapshot(dest: string): void
   backup(dest: string): void
+  search(request: SearchRequest): SearchResult[]
+  search(query: number[], k: number): SearchResult[]
   search(query?: number[] | null, options?: SearchOptions): SearchResult[]
+  searchWithStats(request: SearchRequest): SearchResponse
+  searchWithStats(query: number[], k: number): SearchResponse
   searchWithStats(query?: number[] | null, options?: SearchOptions): SearchResponse
+  searchAsync(request: SearchRequest): Promise<SearchResult[]>
+  searchAsync(query: number[], k: number): Promise<SearchResult[]>
   searchAsync(query?: number[] | null, options?: SearchOptions): Promise<SearchResult[]>
+  searchWithStatsAsync(request: SearchRequest): Promise<SearchResponse>
+  searchWithStatsAsync(query: number[], k: number): Promise<SearchResponse>
   searchWithStatsAsync(query?: number[] | null, options?: SearchOptions): Promise<SearchResponse>
   flushAsync(): Promise<void>
   compactAsync(): Promise<void>
@@ -202,6 +261,7 @@ export class Store {
   openCollectionReadOnly(name: string): Database
   dropCollection(name: string): boolean
   collections(): string[]
+  close(): void
 }
 
 export function open(path: string, options?: OpenOptions): Database

package/index.js

@@ -182,9 +182,64 @@ function withSearchSpan(query, options, fn) {
 }
 
 function asArray(values) {
+  if (
+    values != null &&
+    typeof values === 'object' &&
+    !Array.isArray(values) &&
+    !ArrayBuffer.isView(values) &&
+    typeof values[Symbol.iterator] !== 'function' &&
+    typeof values.length !== 'number'
+  ) {
+    throw new TypeError('vector must be an array-like or iterable of numbers')
+  }
   return Array.from(values)
 }
 
+function encodeNativeOptions(value) {
+  return typeof value === 'string' ? value : encode(value)
+}
+
+const SEARCH_OPTION_KEYS = new Set([
+  'query',
+  'k',
+  'filter',
+  'namespace',
+  'allNamespaces',
+  'sparse',
+  'denseWeight',
+  'sparseWeight',
+  'fetchK',
+  'mmrLambda',
+  'vectorName',
+  'fusion',
+  'rrfK',
+  'truncateDim',
+  'explain',
+  'queryVectors',
+  'vectorWeights',
+])
+
+function isSearchRequestObject(value) {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    !ArrayBuffer.isView(value) &&
+    [...SEARCH_OPTION_KEYS].some((key) => Object.prototype.hasOwnProperty.call(value, key))
+  )
+}
+
+function normalizeSearchArgs(query, options) {
+  if (isSearchRequestObject(query) && (options == null || Object.keys(options).length === 0)) {
+    const { query: normalizedQuery = null, ...normalizedOptions } = query
+    return { query: normalizedQuery, options: normalizedOptions }
+  }
+  if (typeof options === 'number') {
+    return { query, options: { k: options } }
+  }
+  return { query, options: options ?? {} }
+}
+
 function isPromiseLike(value) {
   return value != null && typeof value.then === 'function'
 }
@@ -406,6 +461,52 @@ class Database {
     return wrapError(() => decode(this._native.listIndexes()))
   }
 
+  enableQuantization(method = 'scalar', options = {}) {
+    return wrapError(() => this._native.enableQuantization(method, encodeNativeOptions(options)))
+  }
+
+  disableQuantization() {
+    return wrapError(() => this._native.disableQuantization())
+  }
+
+  get isQuantized() {
+    return wrapError(() => this._native.isQuantized)
+  }
+
+  get quantizationMethod() {
+    return wrapError(() => this._native.quantizationMethod)
+  }
+
+  validNumSubVectors() {
+    return wrapError(() => this._native.validNumSubVectors())
+  }
+
+  upsertMultiVectors(id, vector, multiVectors, options = {}) {
+    return wrapError(() =>
+      this._native.upsertMultiVectors(id, asArray(vector), encode(multiVectors), encode(options)),
+    )
+  }
+
+  searchMultiVector(space, queryTokens, options = {}) {
+    return wrapError(() =>
+      decode(this._native.searchMultiVector(space, encode(queryTokens), encode(options))),
+    )
+  }
+
+  enableMultiVectorQuantization(space, options = {}) {
+    return wrapError(() =>
+      this._native.enableMultiVectorQuantization(space, encodeNativeOptions(options)),
+    )
+  }
+
+  disableMultiVectorQuantization(space) {
+    return wrapError(() => this._native.disableMultiVectorQuantization(space))
+  }
+
+  isMultiVectorQuantized(space) {
+    return wrapError(() => this._native.isMultiVectorQuantized(space))
+  }
+
   flush() {
     return wrapError(() => this._native.flush())
   }
@@ -423,31 +524,53 @@ class Database {
   }
 
   search(query = null, options = {}) {
-    return withSearchSpan(query, options, () =>
-      wrapError(() => decode(this._native.search(query == null ? null : asArray(query), encode(options)))),
+    const normalized = normalizeSearchArgs(query, options)
+    return withSearchSpan(normalized.query, normalized.options, () =>
+      wrapError(() =>
+        decode(
+          this._native.search(
+            normalized.query == null ? null : asArray(normalized.query),
+            encode(normalized.options),
+          ),
+        ),
+      ),
     )
   }
 
   searchWithStats(query = null, options = {}) {
-    return withSearchSpan(query, options, () =>
+    const normalized = normalizeSearchArgs(query, options)
+    return withSearchSpan(normalized.query, normalized.options, () =>
       wrapError(() =>
-        decode(this._native.searchWithStats(query == null ? null : asArray(query), encode(options))),
+        decode(
+          this._native.searchWithStats(
+            normalized.query == null ? null : asArray(normalized.query),
+            encode(normalized.options),
+          ),
+        ),
       ),
     )
   }
 
   searchAsync(query = null, options = {}) {
-    return withSearchSpan(query, options, () =>
+    const normalized = normalizeSearchArgs(query, options)
+    return withSearchSpan(normalized.query, normalized.options, () =>
       wrapAsync(
-        this._native.searchAsync(query == null ? null : asArray(query), encode(options)),
+        this._native.searchAsync(
+          normalized.query == null ? null : asArray(normalized.query),
+          encode(normalized.options),
+        ),
       ).then(decode),
     )
   }
 
   searchWithStatsAsync(query = null, options = {}) {
-    return withSearchSpan(query, options, () =>
+    const normalized = normalizeSearchArgs(query, options)
+    return withSearchSpan(normalized.query, normalized.options, () =>
       wrapAsync(
-        this._native.searchWithStatsAsync(query == null ? null : asArray(query), encode(options)),
+        this._native.searchWithStatsAsync(
+          normalized.query == null ? null : asArray(normalized.query),
+          encode(normalized.options),
+        ),
       ).then(decode),
     )
   }
@@ -499,6 +622,10 @@ class Store {
   collections() {
     return wrapError(() => this._native.collections())
   }
+
+  close() {
+    return wrapError(() => this._native.close())
+  }
 }
 
 function open(path, options = {}) {

package/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vectlite-node"
-version = "0.9.0"
+version = "0.9.2"
 edition = "2024"
 license = "MIT"
 description = "Node.js bindings for vectlite."

package/native/src/lib.rs

@@ -9,6 +9,7 @@ use serde_json::{Map, Number, Value, json};
 use vectlite::quantization::{
     BinaryQuantizationConfig, MultiVectorQuantizationConfig, ProductQuantizationConfig,
     QuantizationConfig, ScalarQuantizationConfig, TwoBitQuantizationConfig,
+    default_product_num_sub_vectors,
 };
 use vectlite::{
     Database as CoreDatabase, DistanceMetric, FusionStrategy, HybridSearchOptions, Metadata,
@@ -109,6 +110,13 @@ impl NativeStore {
     pub fn collections(&self) -> Result<Vec<String>> {
         self.inner.collections().map_err(to_napi_error)
     }
+
+    /// Close the store. This is a no-op (the store holds no open file handles)
+    /// but is provided for symmetry with `Database.close()`.
+    #[napi]
+    pub fn close(&self) -> Result<()> {
+        Ok(())
+    }
 }
 
 #[napi]
@@ -303,9 +311,7 @@ impl NativeDatabase {
         let indexes = database.list_indexes();
         let arr: Vec<Value> = indexes
             .into_iter()
-            .map(|(field, index_type)| {
-                json!({ "field": field, "type": index_type.name() })
-            })
+            .map(|(field, index_type)| json!({ "field": field, "type": index_type.name() }))
             .collect();
         serde_json::to_string(&arr).map_err(|e| err(format!("JSON serialize: {e}")))
     }
@@ -479,14 +485,15 @@ impl NativeDatabase {
         let method = method.as_deref().unwrap_or("scalar");
         let (rescore_multiplier, num_sub_vectors, num_centroids, training_iterations) =
             parse_quantization_options(options_json.as_deref())?;
+        let mut database = self.write_open()?;
         let config = build_quantization_config(
             method,
             rescore_multiplier,
             num_sub_vectors,
             num_centroids,
             training_iterations,
+            database.dimension(),
         )?;
-        let mut database = self.write_open()?;
         database.enable_quantization(config).map_err(to_napi_error)
     }
 
@@ -515,6 +522,23 @@ impl NativeDatabase {
         }))
     }
 
+    /// Returns valid Product Quantization num_sub_vectors values for this database.
+    #[napi(js_name = "validNumSubVectors")]
+    pub fn valid_num_sub_vectors(&self) -> Result<Vec<u32>> {
+        let database = self.read()?;
+        database
+            .valid_num_sub_vectors()
+            .into_iter()
+            .map(|value| {
+                u32::try_from(value).map_err(|_| {
+                    to_napi_error(vectlite::VectLiteError::InvalidFormat(
+                        "num_sub_vectors value exceeds u32".to_owned(),
+                    ))
+                })
+            })
+            .collect()
+    }
+
     // ---- Multi-vector / ColBERT-style late interaction ----
 
     /// Upsert a record with multi-vector token embeddings (ColBERT-style).
@@ -535,8 +559,9 @@ impl NativeDatabase {
         let mv = json_to_multi_vectors(&mv_value)?;
 
         let (metadata, namespace) = if let Some(opts) = options_json {
-            let opts: Value = serde_json::from_str(&opts)
-                .map_err(|e| to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string())))?;
+            let opts: Value = serde_json::from_str(&opts).map_err(|e| {
+                to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string()))
+            })?;
             let metadata = opts
                 .get("metadata")
                 .map(|v| json_to_metadata(v))
@@ -570,11 +595,11 @@ impl NativeDatabase {
     ) -> Result<String> {
         let qt_value: Value = serde_json::from_str(&query_tokens_json)
             .map_err(|e| to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string())))?;
-        let qt_arr = qt_value
-            .as_array()
-            .ok_or_else(|| to_napi_error(vectlite::VectLiteError::InvalidFormat(
+        let qt_arr = qt_value.as_array().ok_or_else(|| {
+            to_napi_error(vectlite::VectLiteError::InvalidFormat(
                 "query_tokens must be a JSON array of arrays".to_owned(),
-            )))?;
+            ))
+        })?;
         let query_tokens: Vec<Vec<f32>> = qt_arr
             .iter()
             .map(|v| {
@@ -586,26 +611,22 @@ impl NativeDatabase {
                     })?
                     .iter()
                     .map(|n| {
-                        n.as_f64()
-                            .map(|f| f as f32)
-                            .ok_or_else(|| {
-                                to_napi_error(vectlite::VectLiteError::InvalidFormat(
-                                    "token values must be numbers".to_owned(),
-                                ))
-                            })
+                        n.as_f64().map(|f| f as f32).ok_or_else(|| {
+                            to_napi_error(vectlite::VectLiteError::InvalidFormat(
+                                "token values must be numbers".to_owned(),
+                            ))
+                        })
                     })
                     .collect::<Result<Vec<f32>>>()
             })
             .collect::<Result<Vec<Vec<f32>>>>()?;
 
         let (top_k, filter, namespace) = if let Some(opts) = options_json {
-            let opts: Value = serde_json::from_str(&opts)
-                .map_err(|e| to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string())))?;
+            let opts: Value = serde_json::from_str(&opts).map_err(|e| {
+                to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string()))
+            })?;
             let top_k = opts.get("k").and_then(|v| v.as_u64()).unwrap_or(10) as usize;
-            let filter = opts
-                .get("filter")
-                .map(|v| json_to_filter(v))
-                .transpose()?;
+            let filter = opts.get("filter").map(|v| json_to_filter(v)).transpose()?;
             let namespace = opts
                 .get("namespace")
                 .and_then(|v| v.as_str())
@@ -650,8 +671,9 @@ impl NativeDatabase {
         options_json: Option<String>,
     ) -> Result<()> {
         let (method, rescore_multiplier) = if let Some(opts) = options_json {
-            let opts: Value = serde_json::from_str(&opts)
-                .map_err(|e| to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string())))?;
+            let opts: Value = serde_json::from_str(&opts).map_err(|e| {
+                to_napi_error(vectlite::VectLiteError::InvalidFormat(e.to_string()))
+            })?;
             let method = opts
                 .get("method")
                 .and_then(|v| v.as_str())
@@ -659,6 +681,7 @@ impl NativeDatabase {
                 .to_string();
             let rescore = opts
                 .get("rescoreMultiplier")
+                .or_else(|| opts.get("rescore_multiplier"))
                 .and_then(|v| v.as_u64())
                 .map(|v| v as usize);
             (method, rescore)
@@ -672,7 +695,9 @@ impl NativeDatabase {
             }),
             other => {
                 return Err(to_napi_error(vectlite::VectLiteError::InvalidFormat(
-                    format!("unknown multi-vector quantization method: {other}. Supported: two_bit"),
+                    format!(
+                        "unknown multi-vector quantization method: {other}. Supported: two_bit"
+                    ),
                 )));
             }
         };
@@ -1622,9 +1647,7 @@ fn json_to_record(object: &Map<String, Value>, default_namespace: Option<&str>)
         .transpose()?
         .unwrap_or_default();
 
-    let ttl = object
-        .get("ttl")
-        .and_then(|v| v.as_f64());
+    let ttl = object.get("ttl").and_then(|v| v.as_f64());
     let expires_at = ttl_to_expires_at(ttl)?;
 
     Ok(Record {
@@ -1910,9 +1933,7 @@ fn value_to_f32(value: &Value, label: &str) -> Result<f32> {
 fn ttl_to_expires_at(ttl: Option<f64>) -> Result<Option<f64>> {
     match ttl {
         None => Ok(None),
-        Some(t) if t < 0.0 || t.is_nan() => {
-            Err(err("ttl must be a non-negative finite number"))
-        }
+        Some(t) if t < 0.0 || t.is_nan() => Err(err("ttl must be a non-negative finite number")),
         Some(t) => {
             let now = std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
@@ -2004,22 +2025,34 @@ fn build_quantization_config(
     num_sub_vectors: Option<usize>,
     num_centroids: Option<usize>,
     training_iterations: Option<usize>,
+    dimension: usize,
 ) -> Result<QuantizationConfig> {
-    match method {
-        "scalar" | "int8" => Ok(QuantizationConfig::Scalar(ScalarQuantizationConfig {
-            rescore_multiplier: rescore_multiplier.unwrap_or(5),
-        })),
-        "binary" => Ok(QuantizationConfig::Binary(BinaryQuantizationConfig {
-            rescore_multiplier: rescore_multiplier.unwrap_or(10),
-        })),
-        "product" | "pq" => Ok(QuantizationConfig::Product(ProductQuantizationConfig {
-            num_sub_vectors: num_sub_vectors.unwrap_or(16),
-            num_centroids: num_centroids.unwrap_or(256),
-            training_iterations: training_iterations.unwrap_or(20),
-            rescore_multiplier: rescore_multiplier.unwrap_or(10),
-        })),
-        other => Err(err(format!(
-            "unknown quantization method '{other}'. Expected: 'scalar', 'binary', or 'product'"
+    let normalized = method.to_ascii_lowercase();
+    match normalized.as_str() {
+        "scalar" | "int8" => {
+            let default = ScalarQuantizationConfig::default();
+            Ok(QuantizationConfig::Scalar(ScalarQuantizationConfig {
+                rescore_multiplier: rescore_multiplier.unwrap_or(default.rescore_multiplier),
+            }))
+        }
+        "binary" => {
+            let default = BinaryQuantizationConfig::default();
+            Ok(QuantizationConfig::Binary(BinaryQuantizationConfig {
+                rescore_multiplier: rescore_multiplier.unwrap_or(default.rescore_multiplier),
+            }))
+        }
+        "product" | "pq" => {
+            let default = ProductQuantizationConfig::default();
+            Ok(QuantizationConfig::Product(ProductQuantizationConfig {
+                num_sub_vectors: num_sub_vectors
+                    .unwrap_or_else(|| default_product_num_sub_vectors(dimension)),
+                num_centroids: num_centroids.unwrap_or(default.num_centroids),
+                training_iterations: training_iterations.unwrap_or(default.training_iterations),
+                rescore_multiplier: rescore_multiplier.unwrap_or(default.rescore_multiplier),
+            }))
+        }
+        _ => Err(err(format!(
+            "unknown quantization method '{method}'. Expected: 'scalar', 'binary', or 'pq' (alias: 'product')"
         ))),
     }
 }

package/native/vectlite-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vectlite-core"
-version = "0.9.0"
+version = "0.9.2"
 edition = "2024"
 license = "MIT"
 description = "Core storage engine for vectlite."