diff --git a/include/svs/index/vamana/dynamic_index.h b/include/svs/index/vamana/dynamic_index.h
index 9336f82e1..a78b212e7 100644
--- a/include/svs/index/vamana/dynamic_index.h
+++ b/include/svs/index/vamana/dynamic_index.h
@@ -94,19 +94,32 @@ inline constexpr std::string_view name(SlotMetadata metadata) {
 
 class ValidBuilder {
   public:
-    ValidBuilder(const std::vector<SlotMetadata>& status)
-        : status_{status} {}
+    // Optional `pred` (with `translator`): an entry is also invalid if `pred(external_id)`
+    // is false. Invalid entries are navigated through but never returned.
+    ValidBuilder(
+        const std::vector<SlotMetadata>& status,
+        const IDTranslator* translator = nullptr,
+        const std::function<bool(size_t)>* pred = nullptr
+    )
+        : status_{status}
+        , translator_{translator}
+        , pred_{pred} {}
 
     template <typename I>
     constexpr PredicatedSearchNeighbor<I> operator()(I i, float distance) const {
         bool invalid = getindex(status_, i) == SlotMetadata::Deleted;
         // This neighbor should be skipped if the metadata corresponding to the given index
         // marks this slot as deleted.
+        if (!invalid && pred_ != nullptr) {
+            invalid = !(*pred_)(translator_->get_external(i));
+        }
         return PredicatedSearchNeighbor<I>(i, distance, !invalid);
     }
 
   private:
     const std::vector<SlotMetadata>& status_;
+    const IDTranslator* translator_;
+    const std::function<bool(size_t)>* pred_;
 };
 
 template <graphs::MemoryGraph Graph, typename Data, typename Dist>
@@ -532,6 +545,9 @@ class MutableVamanaIndex {
             [&](const auto is, uint64_t /*tid*/) {
                 for (auto i : is) {
                     for (size_t j = 0, jmax = getsize<1>(ids); j < jmax; ++j) {
+                        if (ids.at(i, j) == static_cast<size_t>(-1)) {
+                            continue; // Padding from a filtered search.
+                        }
                         auto internal = lib::narrow_cast<Idx>(ids.at(i, j));
                         ids.at(i, j) = translate_internal_id(internal);
                     }
@@ -573,13 +589,17 @@ class MutableVamanaIndex {
 
     // Return a `greedy_search` compatible builder for this index.
     // This is an internal method, mostly used to help implement the batch iterator.
-    ValidBuilder internal_search_builder() const { return ValidBuilder{status_}; }
+    ValidBuilder internal_search_builder(const std::function<bool(size_t)>* pred = nullptr
+    ) const {
+        return ValidBuilder{status_, &translator_, pred};
+    }
 
     auto greedy_search_closure(
         GreedySearchPrefetchParameters prefetch_parameters,
-        const lib::DefaultPredicate& cancel = lib::Returns(lib::Const<false>())
+        const lib::DefaultPredicate& cancel = lib::Returns(lib::Const<false>()),
+        const std::function<bool(size_t)>* pred = nullptr
     ) const {
-        return [&, prefetch_parameters](
+        return [&, prefetch_parameters, pred](
                    const auto& query, auto& accessor, auto& distance, auto& buffer
                ) {
             // Perform the greedy search using the provided resources.
@@ -591,7 +611,7 @@ class MutableVamanaIndex {
                 distance,
                 buffer,
                 vamana::EntryPointInitializer<Idx>{lib::as_const_span(entry_point_)},
-                internal_search_builder(),
+                internal_search_builder(pred),
                 prefetch_parameters,
                 cancel
             );
@@ -623,8 +643,12 @@ class MutableVamanaIndex {
         QueryResultView<I> results,
         const Queries& queries,
         const search_parameters_type& sp,
-        const lib::DefaultPredicate& cancel = lib::Returns(lib::Const<false>())
+        const lib::DefaultPredicate& cancel = lib::Returns(lib::Const<false>()),
+        const std::function<bool(size_t)>* pred = nullptr
     ) {
+        // Optional `pred`: only entries whose external id passes are returned. It is called
+        // from all search threads. Rows with fewer passing entries than requested are
+        // padded with id `size_t(-1)` and the worst score.
         threads::parallel_for(
             threadpool_,
             threads::StaticPartition{queries.size()},
@@ -643,17 +667,25 @@ class MutableVamanaIndex {
 
                 auto scratch = extensions::per_thread_batch_search_setup(data_, distance_);
 
-                extensions::per_thread_batch_search(
-                    data_,
-                    buffer,
-                    scratch,
-                    queries,
-                    results,
-                    threads::UnitRange{is},
-                    greedy_search_closure(prefetch_parameters, cancel),
-                    *this,
-                    cancel
-                );
+                auto run = [&](const auto& search) {
+                    extensions::per_thread_batch_search(
+                        data_,
+                        buffer,
+                        scratch,
+                        queries,
+                        results,
+                        threads::UnitRange{is},
+                        search,
+                        *this,
+                        cancel
+                    );
+                };
+                auto search = greedy_search_closure(prefetch_parameters, cancel, pred);
+                if (pred == nullptr) {
+                    run(search);
+                } else {
+                    run(extensions::FilteredSearch<decltype(search)>{search, pred});
+                }
             }
         );
 
diff --git a/include/svs/index/vamana/extensions.h b/include/svs/index/vamana/extensions.h
index 96ffeaa06..883286b27 100644
--- a/include/svs/index/vamana/extensions.h
+++ b/include/svs/index/vamana/extensions.h
@@ -27,6 +27,9 @@
 #include "svs/lib/preprocessor.h"
 #include "svs/lib/threads.h"
 
+#include <functional>
+#include <limits>
+
 namespace svs::index::vamana::extensions {
 
 /////
@@ -432,12 +435,18 @@ struct VamanaSingleSearchType {
 /// with additional results.
 template <typename Index, typename SearchBuffer, typename Query>
 void check_and_supplement_search_buffer(
-    const Index& index, SearchBuffer& search_buffer, const Query& query
+    const Index& index,
+    SearchBuffer& search_buffer,
+    const Query& query,
+    const std::function<bool(size_t)>* pred = nullptr
 ) {
     if (search_buffer.valid() < search_buffer.target_window() &&
         search_buffer.valid() < index.size()) {
         search_buffer.sort();
         for (auto external_id : index.external_ids()) {
+            if (pred != nullptr && !(*pred)(external_id)) {
+                continue;
+            }
             auto internal_id = index.translate_external_id(external_id);
             auto dist = index.get_distance(external_id, query);
             auto builder = index.internal_search_builder();
@@ -449,6 +458,15 @@ void check_and_supplement_search_buffer(
     }
 }
 
+/// A search closure that also carries the filter of a filtered search.
+template <typename Search> struct FilteredSearch {
+    Search search;
+    const std::function<bool(size_t)>* pred;
+    template <typename... Args> void operator()(Args&&... args) const {
+        search(std::forward<Args>(args)...);
+    }
+};
+
 /// Customization point object for processing single queries.
 inline constexpr VamanaSingleSearchType single_search{};
 
@@ -481,7 +499,11 @@ SVS_FORCE_INLINE void svs_invoke(
     search(query, accessor, distance, search_buffer);
 
     if constexpr (Index::needs_id_translation) {
-        check_and_supplement_search_buffer(index, search_buffer, query);
+        const std::function<bool(size_t)>* pred = nullptr;
+        if constexpr (requires { search.pred; }) {
+            pred = search.pred; // Filtered search: keep filtered-out ids out of the top-up.
+        }
+        check_and_supplement_search_buffer(index, search_buffer, query, pred);
     }
 }
 
@@ -586,6 +608,16 @@ void svs_invoke(
 
         // Copy back results.
         for (size_t j = 0; j < num_neighbors; ++j) {
+            if constexpr (requires { search.pred; }) {
+                if (j >= search_buffer.size()) { // Filtered: fewer than k passed.
+                    result.index(i, j) = static_cast<I>(-1);
+                    result.distance(i, j) =
+                        distance::comparator(distance)(0.0f, 1.0f)
+                            ? std::numeric_limits<float>::infinity()
+                            : -std::numeric_limits<float>::infinity();
+                    continue;
+                }
+            }
             result.set(search_buffer[j], i, j);
         }
     }
diff --git a/include/svs/orchestrators/dynamic_vamana.h b/include/svs/orchestrators/dynamic_vamana.h
index 067c7c486..9619bdc7d 100644
--- a/include/svs/orchestrators/dynamic_vamana.h
+++ b/include/svs/orchestrators/dynamic_vamana.h
@@ -56,8 +56,21 @@ class DynamicVamanaInterface : public VamanaInterface {
 
     // Check if the index has been consolidated - no `Deleted` entries remain.
     virtual bool is_consolidated() const = 0;
+
+    // Filtered search; false if the data type does not support it. Keep last (ABI).
+    virtual bool filtered_search(
+        svs::QueryResultView<size_t> results,
+        AnonymousArray<2> queries,
+        const index::vamana::VamanaSearchParameters& search_parameters,
+        const std::function<bool(size_t)>& filter
+    ) = 0;
 };
 
+// Filtered search is only enabled for uncompressed data.
+template <typename T> inline constexpr bool is_simple_data = false;
+template <typename T, size_t Extent, typename Alloc>
+inline constexpr bool is_simple_data<data::SimpleData<T, Extent, Alloc>> = true;
+
 template <lib::TypeList QueryTypes, typename Impl>
 class DynamicVamanaImpl : public VamanaImpl<QueryTypes, Impl, DynamicVamanaInterface> {
   public:
@@ -109,6 +122,46 @@ class DynamicVamanaImpl : public VamanaImpl<QueryTypes, Impl, DynamicVamanaInter
 
     // Check if the index has been consolidated - no `Deleted` entries remain.
     bool is_consolidated() const override { return impl().is_consolidated(); }
+
+    bool filtered_search(
+        svs::QueryResultView<size_t> results,
+        AnonymousArray<2> queries,
+        const index::vamana::VamanaSearchParameters& search_parameters,
+        const std::function<bool(size_t)>& filter
+    ) override {
+        // Indexes whose `search` has no filter argument (e.g. the concurrent index) report
+        // "unsupported" like other data types.
+        constexpr bool supported =
+            is_simple_data<typename Impl::data_type> &&
+            requires(
+                Impl & idx,
+                svs::QueryResultView<size_t> r,
+                data::ConstSimpleDataView<float> q,
+                const index::vamana::VamanaSearchParameters& sp,
+                const std::function<bool(size_t)>* pred
+            ) { idx.search(r, q, sp, lib::Returns(lib::Const<false>()), pred); };
+        if constexpr (supported) {
+            lib::match(
+                QueryTypes{},
+                queries.type(),
+                [&]<typename T>(lib::Type<T> SVS_UNUSED(type)) {
+                    impl().search(
+                        results,
+                        data::ConstSimpleDataView<T>(queries),
+                        search_parameters,
+                        lib::Returns(lib::Const<false>()),
+                        &filter
+                    );
+                },
+                [&](svs::DataType data_type) {
+                    throw ANNEXCEPTION("Unsupported query datatype! Got: {}.", data_type);
+                }
+            );
+            return true;
+        } else {
+            return false;
+        }
+    }
 };
 
 // Forward Declaractions.
@@ -609,6 +662,20 @@ class DynamicVamana : public manager::IndexManager<DynamicVamanaInterface> {
 
     /// @brief Check if the index has been consolidated - no `Deleted` entries remain.
     bool is_consolidated() const { return impl_->is_consolidated(); }
+
+    /// @brief Filtered search: only ids for which ``filter(id)`` is true are returned.
+    /// Returns false if the data type does not support it.
+    template <typename QueryType>
+    bool filtered_search(
+        QueryResultView<size_t> results,
+        data::ConstSimpleDataView<QueryType> queries,
+        const VamanaSearchParameters& search_parameters,
+        const std::function<bool(size_t)>& filter
+    ) {
+        return impl_->filtered_search(
+            results, AnonymousArray<2>(queries), search_parameters, filter
+        );
+    }
 };
 
 ///
diff --git a/tests/svs/index/vamana/dynamic_index.cpp b/tests/svs/index/vamana/dynamic_index.cpp
index 94daddcf1..44ed215d7 100644
--- a/tests/svs/index/vamana/dynamic_index.cpp
+++ b/tests/svs/index/vamana/dynamic_index.cpp
@@ -23,11 +23,14 @@
 #include <cstdint>
 #include <filesystem>
 #include <iostream>
+#include <limits>
 #include <memory>
 #include <numeric>
+#include <random>
 #include <sstream>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 
 // svs
 #include "svs/core/recall.h"
@@ -464,3 +467,222 @@ CATCH_TEST_CASE("MutableVamana Index Memory Usage", "[graph_index][dynamic_index
     const size_t usage = index.get_memory_breakdown().total();
     CATCH_REQUIRE(usage == expected_total_bytes);
 }
+
+CATCH_TEST_CASE(
+    "MutableVamana Index Filtered Search", "[graph_index][dynamic_index][filtered]"
+) {
+    const size_t num_threads = 2;
+    const size_t n = 3000;
+    const size_t dim = 32;
+    const size_t num_queries = 50;
+    const size_t k = 10;
+    using Distance = svs::distance::DistanceL2;
+
+    std::mt19937 rng(42);
+    std::normal_distribution<float> normal;
+    auto data = svs::data::BlockedData<float>(n, dim);
+    std::vector<std::vector<float>> raw(n, std::vector<float>(dim));
+    for (size_t i = 0; i < n; ++i) {
+        for (auto& x : raw[i]) {
+            x = normal(rng);
+        }
+        data.set_datum(i, raw[i]);
+    }
+    auto queries = svs::data::SimpleData<float>(num_queries, dim);
+    for (size_t i = 0; i < num_queries; ++i) {
+        std::vector<float> q(dim);
+        for (auto& x : q) {
+            x = normal(rng);
+        }
+        queries.set_datum(i, q);
+    }
+
+    // External ids differ from internal ids.
+    std::vector<size_t> ids(n);
+    std::iota(ids.begin(), ids.end(), 7);
+    svs::index::vamana::VamanaBuildParameters parameters{1.2, 32, 64, 64, 32, true};
+    auto index = svs::index::vamana::MutableVamanaIndex(
+        parameters, std::move(data), ids, Distance(), num_threads
+    );
+
+    auto sp = svs::index::vamana::VamanaSearchParameters{};
+    sp.buffer_config_ = svs::index::vamana::SearchBufferConfig{50};
+
+    // Runs the filtered search; `found` = number of non-padding ids per query.
+    auto search_filtered = [&](auto& results,
+                               const std::function<bool(size_t)>& pred,
+                               std::vector<size_t>& found) {
+        index.search(
+            results.view(),
+            queries.cview(),
+            sp,
+            svs::lib::Returns(svs::lib::Const<false>()),
+            &pred
+        );
+        found.assign(num_queries, 0);
+        for (size_t q = 0; q < num_queries; ++q) {
+            for (size_t j = 0; j < k; ++j) {
+                found[q] += results.index(q, j) != static_cast<size_t>(-1);
+            }
+        }
+    };
+
+    // Brute force over live ids passing `pred`.
+    std::unordered_set<size_t> deleted;
+    auto brute_force = [&](size_t q, auto&& pred) {
+        std::vector<std::pair<float, size_t>> all;
+        for (size_t i = 0; i < n; ++i) {
+            size_t e = ids[i];
+            if (deleted.contains(e) || !pred(e)) {
+                continue;
+            }
+            float d = 0;
+            for (size_t j = 0; j < dim; ++j) {
+                float diff = queries.get_datum(q)[j] - raw[i][j];
+                d += diff * diff;
+            }
+            all.emplace_back(d, e);
+        }
+        std::sort(all.begin(), all.end());
+        std::vector<size_t> out;
+        for (size_t i = 0; i < std::min(k, all.size()); ++i) {
+            out.push_back(all[i].second);
+        }
+        return out;
+    };
+
+    auto check = [&](auto&& pred, bool expect_full) {
+        auto results = svs::QueryResult<size_t>(num_queries, k);
+        std::vector<size_t> found;
+        search_filtered(results, pred, found);
+        CATCH_REQUIRE(found.size() == num_queries);
+        size_t hits = 0, total = 0;
+        for (size_t q = 0; q < num_queries; ++q) {
+            auto gt = brute_force(q, pred);
+            CATCH_REQUIRE(found[q] <= k);
+            if (expect_full) {
+                CATCH_REQUIRE(found[q] == k);
+            }
+            for (size_t j = 0; j < found[q]; ++j) {
+                size_t id = results.index(q, j);
+                CATCH_REQUIRE(pred(id));
+                CATCH_REQUIRE(!deleted.contains(id));
+                hits += std::count(gt.begin(), gt.end(), id);
+            }
+            for (size_t j = found[q]; j < k; ++j) {
+                CATCH_REQUIRE(results.index(q, j) == static_cast<size_t>(-1));
+                CATCH_REQUIRE(
+                    results.distance(q, j) == std::numeric_limits<float>::infinity()
+                );
+            }
+            total += gt.size();
+        }
+        return double(hits) / double(total);
+    };
+
+    auto mod10 = [](size_t e) { return e % 10 == 0; };
+
+    CATCH_SECTION("recall against brute force") {
+        CATCH_REQUIRE(check(mod10, true) >= 0.95);
+    }
+
+    CATCH_SECTION("deleted ids are never returned") {
+        std::vector<size_t> to_delete;
+        for (size_t i = 0; i < n; i += 3) {
+            to_delete.push_back(ids[i]);
+        }
+        index.delete_entries(to_delete);
+        deleted.insert(to_delete.begin(), to_delete.end());
+        CATCH_REQUIRE(check(mod10, true) >= 0.9);
+        CATCH_REQUIRE(check([](size_t) { return true; }, true) >= 0.9);
+    }
+
+    CATCH_SECTION("fewer than k passing ids are padded") {
+        auto few = [](size_t e) { return e == 100 || e == 200 || e == 300; };
+        check(few, false);
+        auto results = svs::QueryResult<size_t>(num_queries, k);
+        std::vector<size_t> found;
+        search_filtered(results, few, found);
+        for (size_t q = 0; q < num_queries; ++q) {
+            CATCH_REQUIRE(found[q] == 3);
+        }
+        auto none = [](size_t) { return false; };
+        search_filtered(results, none, found);
+        for (size_t q = 0; q < num_queries; ++q) {
+            CATCH_REQUIRE(found[q] == 0);
+        }
+    }
+
+    CATCH_SECTION("unfiltered search is unchanged by the optional argument") {
+        index.delete_entries(std::vector<size_t>{ids[0], ids[1], ids[2]});
+        auto plain = svs::QueryResult<size_t>(num_queries, k);
+        auto with_null = svs::QueryResult<size_t>(num_queries, k);
+        index.search(plain.view(), queries.cview(), sp);
+        index.search(
+            with_null.view(),
+            queries.cview(),
+            sp,
+            svs::lib::Returns(svs::lib::Const<false>()),
+            nullptr
+        );
+        for (size_t q = 0; q < num_queries; ++q) {
+            for (size_t j = 0; j < k; ++j) {
+                CATCH_REQUIRE(plain.index(q, j) == with_null.index(q, j));
+                CATCH_REQUIRE(plain.distance(q, j) == with_null.distance(q, j));
+            }
+        }
+    }
+
+    CATCH_SECTION("inner product pads with the worst score (-inf)") {
+        auto data_ip = svs::data::BlockedData<float>(n, dim);
+        for (size_t i = 0; i < n; ++i) {
+            data_ip.set_datum(i, raw[i]);
+        }
+        svs::index::vamana::VamanaBuildParameters parameters_ip{0.95, 32, 64, 64, 32, true};
+        auto index_ip = svs::index::vamana::MutableVamanaIndex(
+            parameters_ip, std::move(data_ip), ids, svs::distance::DistanceIP(), num_threads
+        );
+        std::function<bool(size_t)> few = [](size_t e) { return e == 100 || e == 200; };
+        auto results = svs::QueryResult<size_t>(num_queries, k);
+        index_ip.search(
+            results.view(),
+            queries.cview(),
+            sp,
+            svs::lib::Returns(svs::lib::Const<false>()),
+            &few
+        );
+        for (size_t q = 0; q < num_queries; ++q) {
+            for (size_t j = 2; j < k; ++j) {
+                CATCH_REQUIRE(results.index(q, j) == static_cast<size_t>(-1));
+                CATCH_REQUIRE(
+                    results.distance(q, j) == -std::numeric_limits<float>::infinity()
+                );
+            }
+        }
+    }
+
+    CATCH_SECTION("orchestrator entry point") {
+        auto dyn = svs::DynamicVamana::build<float>(
+            parameters,
+            [&] {
+                auto d = svs::data::SimpleData<float>(n, dim);
+                for (size_t i = 0; i < n; ++i) {
+                    d.set_datum(i, raw[i]);
+                }
+                return d;
+            }(),
+            ids,
+            Distance(),
+            num_threads
+        );
+        auto results = svs::QueryResult<size_t>(num_queries, k);
+        CATCH_REQUIRE(dyn.filtered_search(
+            results.view(), queries.cview(), sp, std::function<bool(size_t)>(mod10)
+        ));
+        for (size_t q = 0; q < num_queries; ++q) {
+            for (size_t j = 0; j < k; ++j) {
+                CATCH_REQUIRE(mod10(results.index(q, j)));
+            }
+        }
+    }
+}