faiss 0.6.0 → 0.6.2

data/vendor/faiss/faiss/svs/IndexSVSIVFLeanVec.cpp

@@ -0,0 +1,225 @@
+/*
+ * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/*
+ * Portions Copyright 2026 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <faiss/svs/IndexSVSFaissUtils.h>
+#include <faiss/svs/IndexSVSIVFLeanVec.h>
+
+#include <svs/runtime/dynamic_ivf_index.h>
+#include <svs/runtime/ivf_index.h>
+#include <svs/runtime/training.h>
+
+#include <memory>
+#include <numeric>
+
+namespace faiss {
+
+IndexSVSIVFLeanVec::IndexSVSIVFLeanVec() : IndexSVSIVF() {
+    is_trained = false;
+    storage_kind = SVSStorageKind::SVS_LeanVec4x4;
+}
+
+IndexSVSIVFLeanVec::IndexSVSIVFLeanVec(
+        idx_t d,
+        size_t nlist,
+        MetricType metric,
+        size_t leanvec_dims,
+        SVSStorageKind storage_kind,
+        bool is_static)
+        : IndexSVSIVF(d, nlist, metric, storage_kind, is_static) {
+    is_trained = false;
+    leanvec_d = leanvec_dims == 0 ? d / 2 : leanvec_dims;
+}
+
+IndexSVSIVFLeanVec::~IndexSVSIVFLeanVec() {
+    if (training_data) {
+        auto status = svs_runtime::LeanVecTrainingData::destroy(training_data);
+        FAISS_ASSERT(status.ok());
+        training_data = nullptr;
+    }
+    // Base class destructor handles impl cleanup
+}
+
+void IndexSVSIVFLeanVec::train(idx_t n, const float* x) {
+    train_with_queries(n, x, 0, nullptr);
+}
+
+void IndexSVSIVFLeanVec::train_with_queries(
+        idx_t n,
+        const float* x,
+        idx_t n_train_q,
+        const float* xq_train) {
+    FAISS_THROW_IF_MSG(
+            training_data || impl, "Index already trained or contains data.");
+
+    FAISS_THROW_IF_NOT_MSG(
+            IndexSVSIVF::is_lvq_leanvec_enabled(),
+            "LVQ/LeanVec support not available on this platform or build");
+
+    // Build LeanVec training data
+    auto status = svs_runtime::LeanVecTrainingData::build(
+            &training_data, d, n, x, n_train_q, xq_train, leanvec_d);
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+    FAISS_THROW_IF_NOT_MSG(
+            training_data, "Failed to build leanvec training info.");
+
+    // Now build the IVF index with the training data
+    create_impl(n, x);
+    is_trained = true;
+}
+
+void IndexSVSIVFLeanVec::reset() {
+    if (training_data) {
+        auto status = svs_runtime::LeanVecTrainingData::destroy(training_data);
+        FAISS_ASSERT(status.ok());
+        training_data = nullptr;
+    }
+    IndexSVSIVF::reset();
+}
+
+void IndexSVSIVFLeanVec::serialize_training_data(std::ostream& out) const {
+    FAISS_THROW_IF_NOT_MSG(
+            training_data, "Cannot serialize: Training data not initialized.");
+
+    auto status = training_data->save(out);
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+}
+
+void IndexSVSIVFLeanVec::deserialize_training_data(std::istream& in) {
+    svs_runtime::LeanVecTrainingData* tdata = nullptr;
+    auto status = svs_runtime::LeanVecTrainingData::load(&tdata, in);
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+    FAISS_THROW_IF_NOT_MSG(tdata, "Failed to load leanvec training data.");
+    training_data = tdata;
+}
+
+void IndexSVSIVFLeanVec::create_impl(idx_t n, const float* x) {
+    FAISS_THROW_IF_NOT(!impl);
+    ntotal = 0;
+    auto svs_metric = to_svs_metric(metric_type);
+    auto svs_storage_kind = to_svs_storage_kind(storage_kind);
+    auto build_params = svs_runtime::IVFIndex::BuildParams{
+            .num_centroids = num_centroids,
+            .minibatch_size = minibatch_size,
+            .num_iterations = num_iterations,
+            .is_hierarchical = is_hierarchical,
+            .training_fraction = training_fraction,
+            .hierarchical_level1_clusters = hierarchical_level1_clusters,
+            .seed = seed,
+    };
+    auto search_params = svs_runtime::IVFIndex::SearchParams{
+            .n_probes = n_probes,
+            .k_reorder = k_reorder,
+    };
+
+    auto status = svs_runtime::Status_Ok;
+    if (is_static) {
+        if (training_data) {
+            status = svs_runtime::IVFIndexLeanVec::build(
+                    &impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    static_cast<size_t>(n),
+                    x,
+                    training_data,
+                    build_params,
+                    search_params,
+                    num_threads,
+                    intra_query_threads);
+        } else {
+            status = svs_runtime::IVFIndexLeanVec::build(
+                    &impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    static_cast<size_t>(n),
+                    x,
+                    leanvec_d,
+                    build_params,
+                    search_params,
+                    num_threads,
+                    intra_query_threads);
+        }
+    } else {
+        std::vector<size_t> labels(n);
+        std::iota(labels.begin(), labels.end(), 0);
+
+        svs_runtime::DynamicIVFIndex* dyn_impl = nullptr;
+        if (training_data) {
+            status = svs_runtime::DynamicIVFIndexLeanVec::build(
+                    &dyn_impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    static_cast<size_t>(n),
+                    x,
+                    labels.data(),
+                    training_data,
+                    build_params,
+                    search_params,
+                    num_threads,
+                    intra_query_threads);
+        } else {
+            status = svs_runtime::DynamicIVFIndexLeanVec::build(
+                    &dyn_impl,
+                    d,
+                    svs_metric,
+                    svs_storage_kind,
+                    static_cast<size_t>(n),
+                    x,
+                    labels.data(),
+                    leanvec_d,
+                    build_params,
+                    search_params,
+                    num_threads,
+                    intra_query_threads);
+        }
+        impl = dyn_impl;
+    }
+
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+    FAISS_THROW_IF_NOT(impl);
+
+    // Force reinitialization of SVS search infrastructure after build.
+    // Same workaround as in IndexSVSIVF::create_impl — the move chain through
+    // the orchestrator wrappers can leave matmul_results_ inconsistent
+    // when threads > centroids.
+    size_t current_threads = 0;
+    impl->get_num_threads(&current_threads);
+    auto st = impl->set_num_threads(current_threads);
+    if (!st.ok()) {
+        FAISS_THROW_MSG(st.message());
+    }
+
+    ntotal = n;
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSIVFLeanVec.h

@@ -0,0 +1,71 @@
+/*
+ * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/*
+ * Portions Copyright 2026 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <faiss/svs/IndexSVSIVF.h>
+
+namespace faiss {
+
+struct IndexSVSIVFLeanVec : IndexSVSIVF {
+    IndexSVSIVFLeanVec();
+
+    IndexSVSIVFLeanVec(
+            idx_t d,
+            size_t nlist,
+            MetricType metric = METRIC_L2,
+            size_t leanvec_dims = 0,
+            SVSStorageKind storage = SVSStorageKind::SVS_LeanVec4x4,
+            bool is_static = false);
+
+    ~IndexSVSIVFLeanVec() override;
+
+    /* Default train assumes in-distribution data */
+    void train(idx_t n, const float* x) override;
+
+    /* Generic train with out-of-distribution parameters.
+     * Out-of-distribution (OOD) means database vectors and queries _can_ be
+     * sampled from different distributions (e.g., cross-modal). More details in
+     * the original publication, arXiv:2312.16335.
+     */
+    void train_with_queries(
+            idx_t n,
+            const float* x,
+            idx_t n_train_q,
+            const float* xq_train) override;
+
+    void reset() override;
+
+    void serialize_training_data(std::ostream& out) const;
+    void deserialize_training_data(std::istream& in);
+
+    size_t leanvec_d = 0;
+
+    /* Training information */
+    svs_runtime::LeanVecTrainingData* training_data{nullptr};
+
+   protected:
+    void create_impl(idx_t n, const float* x) override;
+};
+
+} // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamana.cpp

@@ -31,6 +31,7 @@
 #include <svs/runtime/vamana_index.h>
 
 #include <cstddef>
+#include <cstring>
 #include <numeric>
 #include <span>
 #include <type_traits>
@@ -64,8 +65,12 @@ IndexSVSVamana::IndexSVSVamana(
         idx_t d,
         size_t degree,
         MetricType metric,
-        SVSStorageKind storage)
-        : Index(d, metric), graph_max_degree{degree}, storage_kind{storage} {
+        SVSStorageKind storage,
+        bool is_static)
+        : Index(d, metric),
+          graph_max_degree{degree},
+          is_static{is_static},
+          storage_kind{storage} {
     prune_to = graph_max_degree < 4 ? graph_max_degree : graph_max_degree - 4;
     alpha = metric == METRIC_L2 ? 1.2f : 0.95f;
 
@@ -73,8 +78,9 @@ IndexSVSVamana::IndexSVSVamana(
     // NB: LVQ/LeanVec are only available on Intel(R) hardware AND when using
     //     a build based on LVQ/LeanVec-enabled SVS.
     auto svs_storage = to_svs_storage_kind(storage_kind);
-    auto status =
-            svs_runtime::DynamicVamanaIndex::check_storage_kind(svs_storage);
+    auto status = is_static
+            ? svs_runtime::VamanaIndex::check_storage_kind(svs_storage)
+            : svs_runtime::DynamicVamanaIndex::check_storage_kind(svs_storage);
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
@@ -82,11 +88,19 @@ IndexSVSVamana::IndexSVSVamana(
 
 bool IndexSVSVamana::is_lvq_leanvec_enabled() {
     auto lvq = to_svs_storage_kind(SVS_LVQ4x0);
-    auto status = svs_runtime::DynamicVamanaIndex::check_storage_kind(lvq);
+    auto status = svs_runtime::VamanaIndex::check_storage_kind(lvq);
+    if (!status.ok()) {
+        return false;
+    }
+    status = svs_runtime::DynamicVamanaIndex::check_storage_kind(lvq);
     if (!status.ok()) {
         return false;
     }
     auto leanvec = to_svs_storage_kind(SVS_LeanVec4x4);
+    status = svs_runtime::VamanaIndex::check_storage_kind(leanvec);
+    if (!status.ok()) {
+        return false;
+    }
     status = svs_runtime::DynamicVamanaIndex::check_storage_kind(leanvec);
     if (!status.ok()) {
         return false;
@@ -96,31 +110,83 @@ bool IndexSVSVamana::is_lvq_leanvec_enabled() {
 
 IndexSVSVamana::~IndexSVSVamana() {
     if (impl) {
-        auto status = svs_runtime::DynamicVamanaIndex::destroy(impl);
+        svs_runtime::Status status;
+        if (is_static) {
+            status = svs_runtime::VamanaIndex::destroy(impl);
+        } else {
+            status = svs_runtime::DynamicVamanaIndex::destroy(
+                    static_cast<svs_runtime::DynamicVamanaIndex*>(impl));
+        }
         FAISS_ASSERT(status.ok());
         impl = nullptr;
     }
 }
 
 void IndexSVSVamana::add(idx_t n, const float* x) {
+    if (is_static) {
+        FAISS_THROW_IF_MSG(
+                impl,
+                "Static Vamana index does not support add() after initial "
+                "build. All data must be provided in a single add() call.");
+        create_impl(n, x);
+        if (stored_vectors_valid) {
+            stored_vectors.resize(static_cast<size_t>(n) * d);
+            std::memcpy(stored_vectors.data(), x, sizeof(float) * n * d);
+        }
+        ntotal = n;
+        is_trained = true;
+        return;
+    }
+
     if (!impl) {
-        create_impl();
+        create_impl(0, nullptr);
     }
 
     std::vector<size_t> labels(n);
     std::iota(labels.begin(), labels.end(), ntotal);
 
-    auto status = impl->add(n, labels.data(), x);
+    auto* dyn = dynamic_impl();
+    auto status = dyn->add(n, labels.data(), x);
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
+
+    if (stored_vectors_valid) {
+        size_t prev = static_cast<size_t>(ntotal) * d;
+        stored_vectors.resize(prev + static_cast<size_t>(n) * d);
+        std::memcpy(stored_vectors.data() + prev, x, sizeof(float) * n * d);
+    }
     ntotal += n;
 }
 
+void IndexSVSVamana::reconstruct(idx_t key, float* recons) const {
+    FAISS_THROW_IF_NOT_MSG(
+            key >= 0 && key < ntotal,
+            "IndexSVSVamana::reconstruct: key out of range");
+    FAISS_THROW_IF_NOT_MSG(
+            stored_vectors_valid && !stored_vectors.empty(),
+            "IndexSVSVamana::reconstruct: stored_vectors unavailable "
+            "(invalidated by remove_ids or not restored after deserialization)");
+    std::memcpy(recons, stored_vectors.data() + key * d, sizeof(float) * d);
+}
+
 void IndexSVSVamana::reset() {
     if (impl) {
-        impl->reset();
+        if (is_static) {
+            // Static index: destroy the impl so the next add() rebuilds from
+            // scratch. The static SVS backend has no in-place reset that
+            // permits a follow-up add().
+            auto status = svs_runtime::VamanaIndex::destroy(impl);
+            FAISS_ASSERT(status.ok());
+            impl = nullptr;
+        } else {
+            // Dynamic index: in-place reset preserves the impl and avoids
+            // tearing down its allocated state.
+            impl->reset();
+        }
     }
+    stored_vectors.clear();
+    stored_vectors_valid = true;
     is_trained = false;
     ntotal = 0;
 }
@@ -184,15 +250,22 @@ void IndexSVSVamana::range_search(
 }
 
 size_t IndexSVSVamana::remove_ids(const IDSelector& sel) {
+    FAISS_THROW_IF_MSG(
+            is_static,
+            "Static Vamana index does not support remove_ids(). "
+            "The index is immutable after creation.");
     FAISS_THROW_IF_NOT(impl);
+    auto* dyn = dynamic_impl();
     auto id_filter = FaissIDFilter{sel};
     size_t removed = 0;
-    auto Status = impl->remove_selected(&removed, id_filter);
+    auto Status = dyn->remove_selected(&removed, id_filter);
     ntotal -= removed;
+    stored_vectors.clear();
+    stored_vectors_valid = false;
     return removed;
 }
 
-void IndexSVSVamana::create_impl() {
+void IndexSVSVamana::create_impl(idx_t n, const float* x) {
     FAISS_THROW_IF_NOT(!impl);
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
@@ -209,15 +282,45 @@ void IndexSVSVamana::create_impl() {
             .search_window_size = search_window_size,
             .search_buffer_capacity = search_buffer_capacity,
     };
-    auto Status = svs_runtime::DynamicVamanaIndex::build(
-            &impl,
-            d,
-            svs_metric,
-            svs_storage_kind,
-            build_params,
-            search_params);
-    if (!Status.ok()) {
-        FAISS_THROW_MSG(Status.message());
+
+    svs_runtime::Status Status;
+    if (is_static) {
+        FAISS_THROW_IF_NOT_MSG(
+                n > 0 && x != nullptr,
+                "Static Vamana index requires data at build time.");
+        Status = svs_runtime::VamanaIndex::build(
+                &impl,
+                d,
+                svs_metric,
+                svs_storage_kind,
+                build_params,
+                search_params);
+        if (!Status.ok()) {
+            FAISS_THROW_MSG(Status.message());
+        }
+        FAISS_THROW_IF_NOT(impl);
+        // Populate the static index with the full dataset (one-shot add).
+        Status = impl->add(static_cast<size_t>(n), x);
+        if (!Status.ok()) {
+            // Best-effort cleanup before propagating the error.
+            auto destroy_status = svs_runtime::VamanaIndex::destroy(impl);
+            FAISS_ASSERT(destroy_status.ok());
+            impl = nullptr;
+            FAISS_THROW_MSG(Status.message());
+        }
+    } else {
+        svs_runtime::DynamicVamanaIndex* dyn_impl = nullptr;
+        Status = svs_runtime::DynamicVamanaIndex::build(
+                &dyn_impl,
+                d,
+                svs_metric,
+                svs_storage_kind,
+                build_params,
+                search_params);
+        if (!Status.ok()) {
+            FAISS_THROW_MSG(Status.message());
+        }
+        impl = dyn_impl;
     }
     FAISS_THROW_IF_NOT(impl);
 }
@@ -236,10 +339,28 @@ void IndexSVSVamana::deserialize_impl(std::istream& in) {
     FAISS_THROW_IF_MSG(impl, "Cannot deserialize: SVS index already loaded.");
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);
-    auto status = impl->load(&impl, in, svs_metric, svs_storage_kind);
+
+    svs_runtime::Status status;
+    if (is_static) {
+        status = svs_runtime::VamanaIndex::load(
+                &impl, in, svs_metric, svs_storage_kind);
+    } else {
+        svs_runtime::DynamicVamanaIndex* dyn_impl = nullptr;
+        status = svs_runtime::DynamicVamanaIndex::load(
+                &dyn_impl, in, svs_metric, svs_storage_kind);
+        impl = dyn_impl;
+    }
     if (!status.ok()) {
         FAISS_THROW_MSG(status.message());
     }
+    FAISS_THROW_IF_NOT_MSG(impl, "Failed to load SVS Vamana index.");
+}
+
+svs_runtime::DynamicVamanaIndex* IndexSVSVamana::dynamic_impl() const {
+    FAISS_THROW_IF_MSG(
+            is_static, "Operation not supported on a static Vamana index.");
+    FAISS_THROW_IF_NOT(impl);
+    return static_cast<svs_runtime::DynamicVamanaIndex*>(impl);
 }
 
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamana.h

@@ -30,6 +30,8 @@
 #include <svs/runtime/dynamic_vamana_index.h>
 
 #include <iostream>
+#include <type_traits>
+#include <vector>
 
 namespace faiss {
 
@@ -46,9 +48,11 @@ enum SVSStorageKind {
     SVS_LVQ4x0,
     SVS_LVQ4x4,
     SVS_LVQ4x8,
+    SVS_LVQ8x0,
     SVS_LeanVec4x4,
     SVS_LeanVec4x8,
     SVS_LeanVec8x8,
+    SVS_count,
 };
 
 inline svs_runtime::StorageKind to_svs_storage_kind(SVSStorageKind kind) {
@@ -65,6 +69,8 @@ inline svs_runtime::StorageKind to_svs_storage_kind(SVSStorageKind kind) {
             return svs_runtime::StorageKind::LVQ4x4;
         case SVS_LVQ4x8:
             return svs_runtime::StorageKind::LVQ4x8;
+        case SVS_LVQ8x0:
+            return svs_runtime::StorageKind::LVQ8x0;
         case SVS_LeanVec4x4:
             return svs_runtime::StorageKind::LeanVec4x4;
         case SVS_LeanVec4x8:
@@ -72,7 +78,9 @@ inline svs_runtime::StorageKind to_svs_storage_kind(SVSStorageKind kind) {
         case SVS_LeanVec8x8:
             return svs_runtime::StorageKind::LeanVec8x8;
         default:
-            FAISS_ASSERT(false && "not supported SVS storage kind");
+            FAISS_THROW_FMT(
+                    "SVSStorageKind (%d) not supported",
+                    static_cast<std::underlying_type_t<SVSStorageKind>>(kind));
     }
 }
 
@@ -86,7 +94,10 @@ struct IndexSVSVamana : Index {
     size_t max_candidate_pool_size = 200;
     bool use_full_search_history = true;
 
-    SVSStorageKind storage_kind;
+    /// Whether this is a static (immutable) Vamana index
+    bool is_static = false;
+
+    SVSStorageKind storage_kind = SVS_FP32;
 
     IndexSVSVamana();
 
@@ -94,7 +105,8 @@ struct IndexSVSVamana : Index {
             idx_t d,
             size_t degree,
             MetricType metric = METRIC_L2,
-            SVSStorageKind storage = SVSStorageKind::SVS_FP32);
+            SVSStorageKind storage = SVSStorageKind::SVS_FP32,
+            bool is_static = false);
 
     ~IndexSVSVamana() override;
 
@@ -104,6 +116,8 @@ struct IndexSVSVamana : Index {
 
     void add(idx_t n, const float* x) override;
 
+    void reconstruct(idx_t key, float* recons) const override;
+
     void search(
             idx_t n,
             const float* x,
@@ -127,12 +141,24 @@ struct IndexSVSVamana : Index {
     void serialize_impl(std::ostream& out) const;
     virtual void deserialize_impl(std::istream& in);
 
-    /* The actual SVS implementation */
-    svs_runtime::DynamicVamanaIndex* impl{nullptr};
+    /* The actual SVS implementation (VamanaIndex is the base for both
+       static and dynamic variants) */
+    svs_runtime::VamanaIndex* impl{nullptr};
+
+    // The SVS runtime API does not expose vector retrieval, so we keep a copy
+    // of added vectors to support reconstruct(). When used as a coarse
+    // quantizer this holds only nlist centroids.
+    std::vector<float> stored_vectors;
+    bool stored_vectors_valid{true};
 
    protected:
-    /* Initializes the implementation*/
-    virtual void create_impl();
+    /* Initializes the implementation. For static indexes the data is consumed
+       at build time; for dynamic indexes n/x are ignored and add() populates
+       the index afterwards. */
+    virtual void create_impl(idx_t n, const float* x);
+
+    /* Returns the dynamic impl pointer, throwing if static */
+    svs_runtime::DynamicVamanaIndex* dynamic_impl() const;
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamanaLVQ.cpp

@@ -33,7 +33,8 @@ IndexSVSVamanaLVQ::IndexSVSVamanaLVQ(
         idx_t d,
         size_t degree,
         MetricType metric,
-        SVSStorageKind storage)
-        : IndexSVSVamana(d, degree, metric, storage) {}
+        SVSStorageKind storage,
+        bool is_static)
+        : IndexSVSVamana(d, degree, metric, storage, is_static) {}
 
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSVamanaLVQ.h

@@ -34,7 +34,8 @@ struct IndexSVSVamanaLVQ : IndexSVSVamana {
             idx_t d,
             size_t degree,
             MetricType metric = METRIC_L2,
-            SVSStorageKind storage = SVSStorageKind::SVS_LVQ4x4);
+            SVSStorageKind storage = SVSStorageKind::SVS_LVQ4x0,
+            bool is_static = false);
 
     ~IndexSVSVamanaLVQ() override = default;
 };