faiss 0.6.2 → 0.6.4

data/vendor/faiss/faiss/index_factory.cpp

@@ -21,11 +21,13 @@
 #include <faiss/Index2Layer.h>
 #include <faiss/IndexAdditiveQuantizer.h>
 #include <faiss/IndexAdditiveQuantizerFastScan.h>
+#include <faiss/IndexEDEN.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexHNSW.h>
 #include <faiss/IndexIVF.h>
 #include <faiss/IndexIVFAdditiveQuantizer.h>
 #include <faiss/IndexIVFAdditiveQuantizerFastScan.h>
+#include <faiss/IndexIVFEDEN.h>
 #include <faiss/IndexIVFFlat.h>
 #include <faiss/IndexIVFFlatPanorama.h>
 #include <faiss/IndexIVFPQ.h>
@@ -315,8 +317,8 @@ Index* parse_coarse_quantizer(
         SVSStorageKind storage = SVSStorageKind::SVS_FP32;
         if (sm[3].matched) {
             std::string s = sm[3].str().substr(1);
-            if (s == "SQI8") {
-                storage = SVSStorageKind::SVS_SQI8;
+            if (s == "SQ8") {
+                storage = SVSStorageKind::SVS_SQ8;
             } else if (s == "FP16") {
                 storage = SVSStorageKind::SVS_FP16;
             } else if (s == "FP32") {
@@ -383,7 +385,7 @@ IndexIVF* parse_IndexIVF(
     }
     if (match("FlatPanorama([0-9]+)?(_([0-9]+))?")) {
         int nlevels = mres_to_int(sm[1], 8); // default to 8 levels
-        int bs = mres_to_int(sm[3], 128);
+        int bs = mres_to_int(sm[3], Panorama::kDefaultBatchSize);
         return new IndexIVFFlatPanorama(
                 get_q(), d, nlist, nlevels, mt, own_il, bs);
     }
@@ -514,6 +516,18 @@ IndexIVF* parse_IndexIVF(
         uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
         return new IndexIVFRaBitQ(get_q(), d, nlist, mt, own_il, nb_bits);
     }
+    // IndexIVFEDEN with optional nb_bits (1-8) and scale type.
+    // Accepts: "EDEN" (default 1-bit), "EDEN{nb_bits}" (e.g., "EDEN4"),
+    //          or "EDEN{nb_bits}BIASED" for the MSE-minimizing scale.
+    if (match("EDEN([1-8])?(BIASED|BIAS)?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        EDENScaleType scale_type =
+                sm[2].str() == "BIASED" || sm[2].str() == "BIAS"
+                ? EDENScaleType_BIASED
+                : EDENScaleType_UNBIASED;
+        return new IndexIVFEDEN(
+                get_q(), d, nlist, mt, own_il, nb_bits, scale_type);
+    }
     // Accepts: "RaBitQfs" (default 1-bit, batch size 32)
     //          "RaBitQfs{nb_bits}" (e.g., "RaBitQfs4")
     //          "RaBitQfs_64" (1-bit, batch size 64)
@@ -561,6 +575,13 @@ IndexHNSW* parse_IndexHNSW(
     if (match(sq_pattern)) {
         return new IndexHNSWSQ(d, sq_types[sm[1].str()], hnsw_M, mt);
     }
+    // Keep the bare RaBitQ token consistent with Flat and IVF: it means 1 bit.
+    // Use an explicit width such as RaBitQ4 to enable staged refinement.
+    if (match("RaBitQ([1-9])?")) {
+        // the capture is the bare digit, so no substr offset here
+        int nb_bits = mres_to_int(sm[1], 1);
+        return new IndexHNSWRaBitQ(d, hnsw_M, nb_bits, mt);
+    }
     if (match("([0-9]+)\\+PQ([0-9]+)?")) {
         int ncent = mres_to_int(sm[1]);
         int pq_m = mres_to_int(sm[2]);
@@ -681,16 +702,16 @@ Index* parse_svs_datatype(
         }
         FAISS_ASSERT(false && "Unsupported SVS index type for Float16");
     }
-    if (re_match(datatype_string, "SQI8", sm)) {
+    if (re_match(datatype_string, "SQ8", sm)) {
         if (index_type == "Vamana") {
             return new IndexSVSVamana(
-                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQ8);
         }
         if (index_type == "IVF") {
             return new IndexSVSIVF(
-                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQI8);
+                    d, std::stoul(arg_string), mt, SVSStorageKind::SVS_SQ8);
         }
-        FAISS_ASSERT(false && "Unsupported SVS index type for SQI8");
+        FAISS_ASSERT(false && "Unsupported SVS index type for SQ8");
     }
     if (re_match(datatype_string, "(LVQ[0-9]+x[0-9]+)", sm)) {
         if (index_type == "Vamana") {
@@ -917,6 +938,18 @@ Index* parse_other_indexes(
         return new IndexRaBitQ(d, metric, nb_bits);
     }
 
+    // IndexEDEN with optional nb_bits (1-8) and scale type.
+    // Accepts: "EDEN" (default 1-bit), "EDEN{nb_bits}" (e.g., "EDEN4"),
+    //          or "EDEN{nb_bits}BIASED" for the MSE-minimizing scale.
+    if (match("EDEN([1-8])?(BIASED|BIAS)?")) {
+        uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
+        EDENScaleType scale_type =
+                sm[2].str() == "BIASED" || sm[2].str() == "BIAS"
+                ? EDENScaleType_BIASED
+                : EDENScaleType_UNBIASED;
+        return new IndexEDEN(d, metric, nb_bits, scale_type);
+    }
+
     if (match("RaBitQfs([1-9])?(_[0-9]+)?")) {
         uint8_t nb_bits = sm[1].length() > 0 ? std::stoi(sm[1].str()) : 1;
         int bbs = mres_to_int(sm[2], 32, 1);

data/vendor/faiss/faiss/invlists/DirectMap.cpp

@@ -80,7 +80,7 @@ idx_t DirectMap::get(idx_t key) const {
         return lo;
     } else if (type == Hashtable) {
         auto res = hashtable.find(key);
-        FAISS_THROW_IF_NOT_MSG(res != hashtable.end(), "key not found");
+        FAISS_THROW_IF_MSG(res == hashtable.end(), "key not found");
         return res->second;
     } else {
         FAISS_THROW_MSG("direct map not initialized");

data/vendor/faiss/faiss/invlists/InvertedLists.cpp

@@ -371,8 +371,8 @@ ArrayInvertedListsPanorama::ArrayInvertedListsPanorama(
           pano(code_size_in, n_levels_in, batch_size) {
     FAISS_THROW_IF_NOT(n_levels_in > 0);
     FAISS_THROW_IF_NOT(code_size_in % sizeof(float) == 0);
-    FAISS_THROW_IF_NOT_MSG(
-            !use_iterator,
+    FAISS_THROW_IF_MSG(
+            use_iterator,
             "IndexIVFFlatPanorama does not support iterators, use vanilla IndexIVFFlat instead");
     FAISS_ASSERT(level_width % sizeof(float) == 0);
 
@@ -440,8 +440,11 @@ void ArrayInvertedListsPanorama::resize(size_t list_no, size_t new_size) {
 const uint8_t* ArrayInvertedListsPanorama::get_single_code(
         size_t list_no,
         size_t offset) const {
-    assert(list_no < nlist);
-    assert(offset < ids[list_no].size());
+    // Throw rather than assert: Panorama::reconstruct takes an unsized
+    // pointer, so these are the only bounds available and they must hold
+    // in opt builds too.
+    FAISS_THROW_IF_NOT(list_no < nlist);
+    FAISS_THROW_IF_NOT(offset < ids[list_no].size());
 
     uint8_t* recons_buffer = new uint8_t[code_size];
 
@@ -669,10 +672,10 @@ namespace {
 int translate_list_no(const VStackInvertedLists* vil, idx_t list_no) {
     FAISS_THROW_IF_NOT(
             list_no >= 0 && static_cast<size_t>(list_no) < vil->nlist);
-    int i0 = 0, i1 = vil->ils.size();
+    size_t i0 = 0, i1 = vil->ils.size();
     const idx_t* cumsz = vil->cumsz.data();
     while (i0 + 1 < i1) {
-        int imed = (i0 + i1) / 2;
+        size_t imed = i0 + (i1 - i0) / 2;
         if (list_no >= cumsz[imed]) {
             i0 = imed;
         } else {

data/vendor/faiss/faiss/invlists/OnDiskInvertedLists.cpp

@@ -11,6 +11,7 @@
 
 #include <pthread.h>
 
+#include <memory>
 #include <unordered_set>
 
 #include <sys/mman.h>
@@ -405,7 +406,8 @@ void OnDiskInvertedLists::update_entries(
         size_t n_entry,
         const idx_t* ids_in,
         const uint8_t* codes_in) {
-    FAISS_THROW_IF_NOT(!read_only);
+    FAISS_THROW_IF_MSG(
+            read_only, "cannot modify a read-only OnDiskInvertedLists");
     if (n_entry == 0) {
         return;
     }
@@ -422,7 +424,8 @@ size_t OnDiskInvertedLists::add_entries(
         size_t n_entry,
         const idx_t* ids,
         const uint8_t* code) {
-    FAISS_THROW_IF_NOT(!read_only);
+    FAISS_THROW_IF_MSG(
+            read_only, "cannot modify a read-only OnDiskInvertedLists");
     locks->lock_1(list_no);
     size_t o = list_size(list_no);
     resize_locked(list_no, n_entry + o);
@@ -432,7 +435,8 @@ size_t OnDiskInvertedLists::add_entries(
 }
 
 void OnDiskInvertedLists::resize(size_t list_no, size_t new_size) {
-    FAISS_THROW_IF_NOT(!read_only);
+    FAISS_THROW_IF_MSG(
+            read_only, "cannot modify a read-only OnDiskInvertedLists");
     locks->lock_1(list_no);
     resize_locked(list_no, new_size);
     locks->unlock_1(list_no);
@@ -711,12 +715,17 @@ void OnDiskInvertedListsIOHook::write(const InvertedLists* ils, IOWriter* f)
 
 InvertedLists* OnDiskInvertedListsIOHook::read(IOReader* f, int io_flags)
         const {
-    OnDiskInvertedLists* od = new OnDiskInvertedLists();
+    auto od = std::make_unique<OnDiskInvertedLists>();
     od->read_only = io_flags & IO_FLAG_READ_ONLY;
     READ1(od->nlist);
     READ1(od->code_size);
     // this is a POD object
     READVECTOR(od->lists);
+    FAISS_THROW_IF_NOT_FMT(
+            od->lists.size() == od->nlist,
+            "OnDisk inverted lists: read %zu lists for nlist %zu",
+            od->lists.size(),
+            od->nlist);
     {
         std::vector<OnDiskInvertedLists::Slot> v;
         READVECTOR(v);
@@ -756,7 +765,7 @@ InvertedLists* OnDiskInvertedListsIOHook::read(IOReader* f, int io_flags)
     if (!(io_flags & IO_FLAG_SKIP_IVF_DATA)) {
         od->do_mmap();
     }
-    return od;
+    return od.release();
 }
 
 /** read from a ArrayInvertedLists into this invertedlist type */
@@ -766,7 +775,7 @@ InvertedLists* OnDiskInvertedListsIOHook::read_ArrayInvertedLists(
         size_t nlist,
         size_t code_size,
         const std::vector<size_t>& sizes) const {
-    auto ails = new OnDiskInvertedLists();
+    auto ails = std::make_unique<OnDiskInvertedLists>();
     ails->nlist = nlist;
     ails->code_size = code_size;
     ails->read_only = true;
@@ -799,12 +808,24 @@ InvertedLists* OnDiskInvertedListsIOHook::read_ArrayInvertedLists(
         OnDiskInvertedLists::List& l = ails->lists[i];
         l.size = l.capacity = sizes[i];
         l.offset = o;
-        o += l.size * (sizeof(idx_t) + ails->code_size);
+        size_t elem_size = add_no_overflow(
+                sizeof(idx_t), ails->code_size, "OnDisk inverted list element");
+        size_t list_bytes =
+                mul_no_overflow(l.size, elem_size, "OnDisk inverted list");
+        o = add_no_overflow(o, list_bytes, "OnDisk inverted list offset");
+        FAISS_THROW_IF_NOT_FMT(
+                o <= ails->totsize,
+                "inverted list %zu at offset %zu with %zu bytes exceeds "
+                "mapped file size %zu",
+                i,
+                l.offset,
+                list_bytes,
+                ails->totsize);
     }
     // resume normal reading of file
     fseek(fdesc, o, SEEK_SET);
 
-    return ails;
+    return ails.release();
 }
 
 } // namespace faiss

data/vendor/faiss/faiss/python/python_callbacks.cpp

@@ -151,7 +151,9 @@ int64_t PyCallbackShardingFunction::operator()(int64_t i, int64_t shard_count) {
     if (shard_id == nullptr) {
         FAISS_THROW_MSG("propagate py error");
     }
-    return PyLong_AsLongLong(shard_id);
+    int64_t rv = PyLong_AsLongLong(shard_id);
+    Py_DECREF(shard_id);
+    return rv;
 }
 
 PyCallbackShardingFunction::~PyCallbackShardingFunction() {

data/vendor/faiss/faiss/svs/IndexSVSFaissUtils.h

@@ -30,6 +30,7 @@
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/IDSelector.h>
+#include <faiss/impl/mapped_io.h>
 
 #include <algorithm>
 #include <concepts>
@@ -248,4 +249,63 @@ struct FaissResultsAllocator : public svs_runtime::ResultsAllocator {
     using LabelsConverter = OutputBufferConverter<size_t, faiss::idx_t>;
     mutable LabelsConverter labels_converter;
 };
+
+// Helper for memory-mapped SVS index loading.
+// Acquires a pointer to the remaining mapped region and returns the data
+// pointer, size in bytes, and starting position. Validates that mmap returns
+// expected byte count. MappedFileIOReader::mmap returns number of items (not
+// bytes); we always request size=1 so items == bytes, but we name variables
+// explicitly to avoid confusion.
+struct MmapSpan {
+    void* data = nullptr;
+    size_t size_bytes = 0;
+    size_t start_pos = 0;
+};
+
+inline MmapSpan acquire_mmap_span(MappedFileIOReader* mf) {
+    FAISS_THROW_IF_NOT(mf);
+    FAISS_THROW_IF_NOT(mf->mmap_owner);
+    size_t pos = mf->pos;
+    size_t size_to_end = mf->mmap_owner->size() - pos;
+    // Reject an empty span: MappedFileIOReader::mmap() returns 0 without
+    // writing *ptr when no bytes remain, which would otherwise pass the
+    // size check below and hand a nullptr / zero size to the SVS runtime
+    // (e.g. for a truncated or corrupt file).
+    FAISS_THROW_IF_NOT_FMT(
+            size_to_end > 0,
+            "acquire_mmap_span: no mapped bytes remain at reader position %zu",
+            pos);
+    void* data = nullptr;
+    // mmap returns actual_nitems; with size=1 this equals bytes
+    size_t actual_nitems = mf->mmap(&data, 1, size_to_end);
+    FAISS_THROW_IF_NOT_FMT(
+            actual_nitems == size_to_end,
+            "mmap() returned unexpected size: %zu items (expected %zu bytes)",
+            actual_nitems,
+            size_to_end);
+    return {data, size_to_end, pos};
+}
+
+// Adjusts MappedFileIOReader position after SVS consumes read_bytes,
+// storing mmap_owner reference to keep mapping alive.
+inline void finalize_mmap_span(
+        MappedFileIOReader* mf,
+        const MmapSpan& span,
+        size_t read_bytes,
+        std::shared_ptr<MmappedFileMappingOwner>& mmap_owner_out) {
+    // Take ownership of the mapping BEFORE validating read_bytes. By this point
+    // the caller's impl already holds pointers into the mapped region, so the
+    // index must keep the mapping alive even on the throw path. Otherwise the
+    // index would be left with a live impl but no mmap_owner, and once the
+    // reader's mapping reference is released the index destructor (which calls
+    // destroy(impl)) would touch unmapped memory.
+    mmap_owner_out = mf->mmap_owner;
+    FAISS_THROW_IF_NOT_FMT(
+            read_bytes > 0 && read_bytes <= span.size_bytes,
+            "map_to_memory returned invalid read_bytes: %zu (span size %zu)",
+            read_bytes,
+            span.size_bytes);
+    mf->pos = span.start_pos + read_bytes;
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSFlat.cpp

@@ -22,6 +22,7 @@
  */
 
 #include <faiss/Index.h>
+#include <faiss/impl/mapped_io.h>
 #include <faiss/svs/IndexSVSFaissUtils.h>
 #include <faiss/svs/IndexSVSFlat.h>
 
@@ -55,11 +56,16 @@ void IndexSVSFlat::add(idx_t n, const float* x) {
 
 void IndexSVSFlat::reset() {
     if (impl) {
-        auto status = impl->reset();
+        // Destroy impl to ensure no dangling pointers to mmap region remain.
+        // FlatIndex::reset may retain views; destroy guarantees clean state
+        // matching Vamana static behavior.
+        auto status = svs_runtime::FlatIndex::destroy(impl);
         if (!status.ok()) {
             FAISS_THROW_MSG(status.message());
         }
+        impl = nullptr;
     }
+    mmap_owner.reset(); // Release the memory mapping
     ntotal = 0;
 }
 
@@ -114,4 +120,23 @@ void IndexSVSFlat::deserialize_impl(std::istream& in) {
     FAISS_THROW_IF_NOT_MSG(impl, "Failed to load SVS Flat index.");
 }
 
+void IndexSVSFlat::map_to(MappedFileIOReader* mf) {
+    FAISS_THROW_IF_MSG(impl, "Cannot map_to: SVS index already loaded.");
+    FAISS_THROW_IF_NOT(mf);
+
+    MmapSpan span = acquire_mmap_span(mf);
+
+    auto svs_metric = to_svs_metric(metric_type);
+
+    size_t read_bytes = 0;
+    auto status = svs_runtime::FlatIndex::map_to_memory(
+            &impl, span.data, span.size_bytes, svs_metric, &read_bytes);
+
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+
+    finalize_mmap_span(mf, span, read_bytes, mmap_owner);
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/svs/IndexSVSFlat.h

@@ -29,9 +29,14 @@
 #include <svs/runtime/flat_index.h>
 
 #include <iostream>
+#include <memory>
 
 namespace faiss {
 
+// Forward declarations
+struct MappedFileIOReader;
+struct MmappedFileMappingOwner;
+
 struct IndexSVSFlat : Index {
     // sequential labels
     size_t nlabels{0};
@@ -56,10 +61,18 @@ struct IndexSVSFlat : Index {
     /* The actual SVS implementation */
     svs_runtime::FlatIndex* impl{nullptr};
 
+    // Holds a reference to the memory-mapped file owner to keep the memory
+    // mapping alive for the lifetime of this index. Only used when index is
+    // loaded via map_to() with memory-mapped I/O.
+    std::shared_ptr<MmappedFileMappingOwner> mmap_owner{nullptr};
+
     /* Serialization */
     void serialize_impl(std::ostream& out) const;
     void deserialize_impl(std::istream& in);
 
+    /* Memory-mapped deserialization */
+    void map_to(MappedFileIOReader* mf);
+
    protected:
     /* Initializes the implementation*/
     virtual void create_impl();

data/vendor/faiss/faiss/svs/IndexSVSIVF.cpp

@@ -222,7 +222,7 @@ size_t IndexSVSIVF::remove_ids(const IDSelector& sel) {
 }
 
 void IndexSVSIVF::create_impl(idx_t n, const float* x) {
-    FAISS_THROW_IF_NOT(!impl);
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);

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

@@ -119,7 +119,7 @@ void IndexSVSIVFLeanVec::deserialize_training_data(std::istream& in) {
 }
 
 void IndexSVSIVFLeanVec::create_impl(idx_t n, const float* x) {
-    FAISS_THROW_IF_NOT(!impl);
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);

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

@@ -25,6 +25,7 @@
 #include <faiss/svs/IndexSVSVamana.h>
 
 #include <faiss/Index.h>
+#include <faiss/impl/mapped_io.h>
 
 #include <svs/runtime/api_defs.h>
 #include <svs/runtime/dynamic_vamana_index.h>
@@ -66,11 +67,13 @@ IndexSVSVamana::IndexSVSVamana(
         size_t degree,
         MetricType metric,
         SVSStorageKind storage,
-        bool is_static)
+        bool is_static,
+        bool store_vectors)
         : Index(d, metric),
           graph_max_degree{degree},
           is_static{is_static},
-          storage_kind{storage} {
+          storage_kind{storage},
+          store_vectors{store_vectors} {
     prune_to = graph_max_degree < 4 ? graph_max_degree : graph_max_degree - 4;
     alpha = metric == METRIC_L2 ? 1.2f : 0.95f;
 
@@ -123,6 +126,14 @@ IndexSVSVamana::~IndexSVSVamana() {
 }
 
 void IndexSVSVamana::add(idx_t n, const float* x) {
+    // Opting out after data has been added would leave stored_vectors
+    // misaligned with the ids in the index, so release it instead of growing.
+    if (!store_vectors && stored_vectors_valid) {
+        stored_vectors.clear();
+        stored_vectors.shrink_to_fit();
+        stored_vectors_valid = false;
+    }
+
     if (is_static) {
         FAISS_THROW_IF_MSG(
                 impl,
@@ -166,7 +177,8 @@ void IndexSVSVamana::reconstruct(idx_t key, float* recons) const {
     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)");
+            "(store_vectors disabled, invalidated by remove_ids, or not "
+            "restored after deserialization)");
     std::memcpy(recons, stored_vectors.data() + key * d, sizeof(float) * d);
 }
 
@@ -186,7 +198,9 @@ void IndexSVSVamana::reset() {
         }
     }
     stored_vectors.clear();
-    stored_vectors_valid = true;
+    stored_vectors.shrink_to_fit();
+    stored_vectors_valid = store_vectors;
+    mmap_owner.reset(); // Release the memory mapping
     is_trained = false;
     ntotal = 0;
 }
@@ -266,7 +280,7 @@ size_t IndexSVSVamana::remove_ids(const IDSelector& sel) {
 }
 
 void IndexSVSVamana::create_impl(idx_t n, const float* x) {
-    FAISS_THROW_IF_NOT(!impl);
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);
@@ -363,4 +377,32 @@ svs_runtime::DynamicVamanaIndex* IndexSVSVamana::dynamic_impl() const {
     return static_cast<svs_runtime::DynamicVamanaIndex*>(impl);
 }
 
+void IndexSVSVamana::map_to(MappedFileIOReader* mf) {
+    FAISS_THROW_IF_MSG(
+            !is_static,
+            "map_to() is only supported for static Vamana indices.");
+    FAISS_THROW_IF_MSG(impl, "Cannot map_to: SVS index already loaded.");
+    FAISS_THROW_IF_NOT(mf);
+
+    MmapSpan span = acquire_mmap_span(mf);
+
+    auto svs_metric = to_svs_metric(metric_type);
+    auto svs_storage_kind = to_svs_storage_kind(storage_kind);
+
+    size_t read_bytes = 0;
+    auto status = svs_runtime::VamanaIndex::map_to_memory(
+            &impl,
+            span.data,
+            span.size_bytes,
+            svs_metric,
+            svs_storage_kind,
+            &read_bytes);
+
+    if (!status.ok()) {
+        FAISS_THROW_MSG(status.message());
+    }
+
+    finalize_mmap_span(mf, span, read_bytes, mmap_owner);
+}
+
 } // namespace faiss

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

@@ -30,11 +30,16 @@
 #include <svs/runtime/dynamic_vamana_index.h>
 
 #include <iostream>
+#include <memory>
 #include <type_traits>
 #include <vector>
 
 namespace faiss {
 
+// Forward declarations
+struct MappedFileIOReader;
+struct MmappedFileMappingOwner;
+
 struct SearchParametersSVSVamana : public SearchParameters {
     size_t search_window_size = 0;
     size_t search_buffer_capacity = 0;
@@ -44,7 +49,7 @@ struct SearchParametersSVSVamana : public SearchParameters {
 enum SVSStorageKind {
     SVS_FP32,
     SVS_FP16,
-    SVS_SQI8,
+    SVS_SQ8,
     SVS_LVQ4x0,
     SVS_LVQ4x4,
     SVS_LVQ4x8,
@@ -61,7 +66,7 @@ inline svs_runtime::StorageKind to_svs_storage_kind(SVSStorageKind kind) {
             return svs_runtime::StorageKind::FP32;
         case SVS_FP16:
             return svs_runtime::StorageKind::FP16;
-        case SVS_SQI8:
+        case SVS_SQ8:
             return svs_runtime::StorageKind::SQI8;
         case SVS_LVQ4x0:
             return svs_runtime::StorageKind::LVQ4x0;
@@ -106,7 +111,8 @@ struct IndexSVSVamana : Index {
             size_t degree,
             MetricType metric = METRIC_L2,
             SVSStorageKind storage = SVSStorageKind::SVS_FP32,
-            bool is_static = false);
+            bool is_static = false,
+            bool store_vectors = true);
 
     ~IndexSVSVamana() override;
 
@@ -141,16 +147,30 @@ struct IndexSVSVamana : Index {
     void serialize_impl(std::ostream& out) const;
     virtual void deserialize_impl(std::istream& in);
 
+    /* Memory-mapped deserialization for static indices */
+    virtual void map_to(MappedFileIOReader* mf);
+
     /* The actual SVS implementation (VamanaIndex is the base for both
        static and dynamic variants) */
     svs_runtime::VamanaIndex* impl{nullptr};
 
+    // Holds a reference to the memory-mapped file owner to keep the memory
+    // mapping alive for the lifetime of this index. Only used when index is
+    // loaded via map_to() with memory-mapped I/O.
+    std::shared_ptr<MmappedFileMappingOwner> mmap_owner{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};
 
+    // Set to false before the first add() to skip the stored_vectors copy,
+    // saving ntotal * d * 4 bytes at the cost of reconstruct() support and
+    // hence of use as an IVF coarse quantizer. Clearing it after vectors have
+    // been added drops the copy, which can no longer be aligned with the ids.
+    bool store_vectors{true};
+
    protected:
     /* Initializes the implementation. For static indexes the data is consumed
        at build time; for dynamic indexes n/x are ignored and add() populates

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

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

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

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

data/vendor/faiss/faiss/svs/IndexSVSVamanaLeanVec.cpp

@@ -29,7 +29,6 @@
 #include <svs/runtime/vamana_index.h>
 
 #include <memory>
-#include <span>
 #include "faiss/svs/IndexSVSVamana.h"
 
 namespace faiss {
@@ -45,8 +44,15 @@ IndexSVSVamanaLeanVec::IndexSVSVamanaLeanVec(
         MetricType metric,
         size_t leanvec_dims,
         SVSStorageKind storage_kind,
-        bool is_static)
-        : IndexSVSVamana(d, degree, metric, storage_kind, is_static) {
+        bool is_static,
+        bool store_vectors)
+        : IndexSVSVamana(
+                  d,
+                  degree,
+                  metric,
+                  storage_kind,
+                  is_static,
+                  store_vectors) {
     is_trained = false;
     leanvec_d = leanvec_dims == 0 ? d / 2 : leanvec_dims;
 }
@@ -122,7 +128,7 @@ void IndexSVSVamanaLeanVec::deserialize_training_data(std::istream& in) {
 }
 
 void IndexSVSVamanaLeanVec::create_impl(idx_t n, const float* x) {
-    FAISS_THROW_IF_NOT(!impl);
+    FAISS_THROW_IF_MSG(impl, "impl already created");
     ntotal = 0;
     auto svs_metric = to_svs_metric(metric_type);
     auto svs_storage_kind = to_svs_storage_kind(storage_kind);