diff --git a/keyvi/include/keyvi/dictionary/dictionary.h b/keyvi/include/keyvi/dictionary/dictionary.h
index a4438a277..e017d3001 100644
--- a/keyvi/include/keyvi/dictionary/dictionary.h
+++ b/keyvi/include/keyvi/dictionary/dictionary.h
@@ -36,10 +36,10 @@
 #include "keyvi/dictionary/fsa/traverser_types.h"
 #include "keyvi/dictionary/match.h"
 #include "keyvi/dictionary/match_iterator.h"
-#include "keyvi/dictionary/matching/filter.h"
 #include "keyvi/dictionary/matching/fuzzy_matching.h"
 #include "keyvi/dictionary/matching/near_matching.h"
 #include "keyvi/dictionary/matching/prefix_completion_matching.h"
+#include "keyvi/dictionary/util/bounded_priority_queue.h"
 
 // #define ENABLE_TRACING
 #include "keyvi/dictionary/util/trace.h"
@@ -326,40 +326,39 @@ class Dictionary final {
     return MatchIterator::MakeIteratorPair(func, data->FirstMatch());
   }
 
-  MatchIterator::MatchIteratorPair GetPrefixCompletion(const std::string& query,
-                                                       const matching::filter_t filter = matching::accept_all) const {
+  MatchIterator::MatchIteratorPair GetPrefixCompletion(const std::string& query) const {
     auto data = std::make_shared<matching::PrefixCompletionMatching<>>(
-        matching::PrefixCompletionMatching<>::FromSingleFsa(fsa_, query, filter));
+        matching::PrefixCompletionMatching<>::FromSingleFsa(fsa_, query));
 
     auto func = [data]() { return data->NextMatch(); };
-    return MatchIterator::MakeIteratorPair(func, data->FirstMatch());
+    return MatchIterator::MakeIteratorPair(
+        func, data->FirstMatch(),
+        std::bind(&matching::PrefixCompletionMatching<>::SetMinWeight, &(*data), std::placeholders::_1));
   }
 
   MatchIterator::MatchIteratorPair GetPrefixCompletion(const std::string& query, size_t top_n) const {
-    auto top_results = std::make_shared<matching::filter::TopN>(top_n);
-
-    auto data =
-        std::make_shared<matching::PrefixCompletionMatching<>>(matching::PrefixCompletionMatching<>::FromSingleFsa(
-            fsa_, query, std::bind(&matching::filter::TopN::filter, &(*top_results), std::placeholders::_1)));
+    auto data = std::make_shared<matching::PrefixCompletionMatching<>>(
+        matching::PrefixCompletionMatching<>::FromSingleFsa(fsa_, query));
 
-    auto func = [data, top_results]() { return data->NextMatch(); };
-    return MatchIterator::MakeIteratorPair(func, data->FirstMatch());
-  }
+    // TODO(hendrik): C++14, use a unique pointer and move this into func
+    auto best_weights = std::make_shared<util::BoundedPriorityQueue<uint32_t>>(top_n);
 
-  /**
-   * Complete a prefix.
-   */
-  MatchIterator::MatchIteratorPair GetPrefixCompletion(const std::string& query, matching::filter_wrapper_t filter,
-                                                       void* user_data) const {
-    auto filter_wrapper = std::make_shared<matching::filter::FilterWrapper>(filter, user_data);
+    auto func = [data, best_weights]() {
+      auto m = data->NextMatch();
+      while (!m.IsEmpty()) {
+        if (m.GetWeight() >= best_weights->Back()) {
+          best_weights->Put(m.GetWeight());
+          return m;
+        }
 
-    auto data =
-        std::make_shared<matching::PrefixCompletionMatching<>>(matching::PrefixCompletionMatching<>::FromSingleFsa(
-            fsa_, query,
-            std::bind(&matching::filter::FilterWrapper::filter, &(*filter_wrapper), std::placeholders::_1)));
+        m = data->NextMatch();
+      }
+      return Match();
+    };
 
-    auto func = [data, filter_wrapper]() { return data->NextMatch(); };
-    return MatchIterator::MakeIteratorPair(func, data->FirstMatch());
+    return MatchIterator::MakeIteratorPair(
+        func, data->FirstMatch(),
+        std::bind(&matching::PrefixCompletionMatching<>::SetMinWeight, &(*data), std::placeholders::_1));
   }
 
   std::string GetManifest() const { return fsa_->GetManifest(); }
diff --git a/keyvi/include/keyvi/dictionary/fsa/state_traverser.h b/keyvi/include/keyvi/dictionary/fsa/state_traverser.h
index f00164f51..63270fa0d 100644
--- a/keyvi/include/keyvi/dictionary/fsa/state_traverser.h
+++ b/keyvi/include/keyvi/dictionary/fsa/state_traverser.h
@@ -216,6 +216,7 @@ inline uint64_t StateTraverser<traversal::WeightedTransition>::FilterByMinWeight
  */
 template <>
 inline void StateTraverser<traversal::WeightedTransition>::SetMinWeight(uint32_t min_weight) {
+  TRACE("set min weight for weighted transition specialization %d", min_weight);
   stack_.traversal_stack_payload.min_weight = min_weight;
 }
 
diff --git a/keyvi/include/keyvi/dictionary/match_iterator.h b/keyvi/include/keyvi/dictionary/match_iterator.h
index 73fefe78d..d377fd087 100644
--- a/keyvi/include/keyvi/dictionary/match_iterator.h
+++ b/keyvi/include/keyvi/dictionary/match_iterator.h
@@ -55,21 +55,26 @@ class MatchIterator : public boost::iterator_facade<MatchIterator, Match const,
  public:
   typedef util::iterator_pair<MatchIterator> MatchIteratorPair;
 
-  explicit MatchIterator(std::function<Match()> match_functor, const Match& first_match = Match())
-      : match_functor_(match_functor) {
+  explicit MatchIterator(std::function<Match()> match_functor, const Match& first_match = Match(),
+                         std::function<void(uint32_t)> set_min_weight = {})
+      : match_functor_(match_functor), set_min_weight_(set_min_weight) {
     current_match_ = first_match;
     if (first_match.IsEmpty()) {
       increment();
     }
   }
 
-  static MatchIteratorPair MakeIteratorPair(std::function<Match()> f, const Match& first_match = Match()) {
-    return MatchIteratorPair(MatchIterator(f, first_match), MatchIterator());
+  static MatchIteratorPair MakeIteratorPair(std::function<Match()> f, const Match& first_match = Match(),
+                                            std::function<void(uint32_t)> set_min_weight = {}) {
+    return MatchIteratorPair(MatchIterator(f, first_match, set_min_weight), MatchIterator());
   }
 
   static MatchIteratorPair EmptyIteratorPair() { return MatchIteratorPair(MatchIterator(), MatchIterator()); }
 
-  MatchIterator() : match_functor_(0) {}
+  MatchIterator() : match_functor_(0), set_min_weight_({}) {}
+
+  void SetMinWeight(uint32_t min_weight) { set_min_weight_(min_weight); }
+
   // What we implement is determined by the boost::forward_traversal_tag
   // template parameter
  private:
@@ -105,6 +110,7 @@ class MatchIterator : public boost::iterator_facade<MatchIterator, Match const,
  private:
   std::function<Match()> match_functor_;
   Match current_match_;
+  std::function<void(uint32_t)> set_min_weight_;
 };
 
 } /* namespace dictionary */
diff --git a/keyvi/include/keyvi/dictionary/matching/filter.h b/keyvi/include/keyvi/dictionary/matching/filter.h
deleted file mode 100644
index eec831c72..000000000
--- a/keyvi/include/keyvi/dictionary/matching/filter.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/* keyvi - A key value store.
- *
- * Copyright 2024 Hendrik Muhs<hendrik.muhs@gmail.com>
- *
- * 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.
- */
-
-/*
- * filter.h
- */
-
-#ifndef KEYVI_DICTIONARY_MATCHING_FILTER_H_
-#define KEYVI_DICTIONARY_MATCHING_FILTER_H_
-
-#include <utility>
-
-#include "keyvi/dictionary/match.h"
-#include "keyvi/dictionary/util/bounded_priority_queue.h"
-
-// #define ENABLE_TRACING
-#include "keyvi/dictionary/util/trace.h"
-
-namespace keyvi {
-namespace dictionary {
-namespace matching {
-
-using filter_result_t = std::pair<bool, uint32_t>;
-using filter_t = std::function<filter_result_t(const Match&)>;
-using filter_wrapper_t = std::function<filter_result_t(const Match&, void*)>;
-
-inline filter_result_t accept_all(const Match& m) {
-  return filter_result_t(true, 0);
-}
-namespace filter {
-class TopN final {
- public:
-  TopN(size_t n) : priority_queue_(n) {}
-
-  filter_result_t filter(const Match& m) {
-    if (m.GetWeight() < priority_queue_.Back()) {
-      return filter_result_t(false, priority_queue_.Back());
-    }
-
-    priority_queue_.Put(m.GetWeight());
-    return filter_result_t(true, priority_queue_.Back());
-  }
-
- private:
-  util::BoundedPriorityQueue<uint32_t> priority_queue_;
-};
-
-/**
- * A wrapper around a filter that can hold an object internally.
- * Used for interfacing with bindings, e.g. to implement filter code in python.
- */
-class FilterWrapper final {
- public:
-  FilterWrapper(filter_wrapper_t filter, void* user_data) : inner_filter_(filter), user_data_(user_data) {}
-
-  filter_result_t filter(const Match& m) { return (inner_filter_(m, user_data_)); }
-
- private:
-  filter_wrapper_t inner_filter_;
-  void* user_data_;
-};
-
-} /* namespace filter */
-} /* namespace matching */
-} /* namespace dictionary */
-} /* namespace keyvi */
-#endif  // KEYVI_DICTIONARY_MATCHING_FILTER_H_
diff --git a/keyvi/include/keyvi/dictionary/matching/prefix_completion_matching.h b/keyvi/include/keyvi/dictionary/matching/prefix_completion_matching.h
index 55d1eff5e..ad7093d66 100644
--- a/keyvi/include/keyvi/dictionary/matching/prefix_completion_matching.h
+++ b/keyvi/include/keyvi/dictionary/matching/prefix_completion_matching.h
@@ -33,7 +33,6 @@
 #include "keyvi/dictionary/fsa/traverser_types.h"
 #include "keyvi/dictionary/fsa/zip_state_traverser.h"
 #include "keyvi/dictionary/match.h"
-#include "keyvi/dictionary/matching/filter.h"
 #include "keyvi/dictionary/util/utf8_utils.h"
 #include "keyvi/stringdistance/levenshtein.h"
 #include "utf8.h"
@@ -62,9 +61,9 @@ class PrefixCompletionMatching final {
    * @param fsa the fsa
    * @param query the query
    */
-  static PrefixCompletionMatching FromSingleFsa(const fsa::automata_t& fsa, const std::string& query,
-                                                const filter_t filter = accept_all) {
-    return FromSingleFsa(fsa, fsa->GetStartState(), query, filter);
+  static PrefixCompletionMatching FromSingleFsa(const fsa::automata_t& fsa, const std::string& query
+                                                ) {
+    return FromSingleFsa(fsa, fsa->GetStartState(), query);
   }
 
   /**
@@ -75,7 +74,7 @@ class PrefixCompletionMatching final {
    * @param query the query
    */
   static PrefixCompletionMatching FromSingleFsa(const fsa::automata_t& fsa, const uint64_t start_state,
-                                                const std::string& query, const filter_t filter = accept_all) {
+                                                const std::string& query) {
     if (start_state == 0) {
       return PrefixCompletionMatching();
     }
@@ -115,7 +114,7 @@ class PrefixCompletionMatching final {
 
     TRACE("create matcher");
     return PrefixCompletionMatching(std::move(traverser), std::move(first_match), std::move(traversal_stack),
-                                    query_length, filter);
+                                    query_length);
   }
 
   /**
@@ -124,8 +123,8 @@ class PrefixCompletionMatching final {
    * @param fsas a vector of fsas
    * @param query the query
    */
-  static PrefixCompletionMatching FromMulipleFsas(const std::vector<fsa::automata_t>& fsas, const std::string& query,
-                                                  const filter_t filter = accept_all) {
+  static PrefixCompletionMatching FromMulipleFsas(const std::vector<fsa::automata_t>& fsas, const std::string& query
+                                                  ) {
     const size_t query_length = query.size();
     std::vector<std::pair<fsa::automata_t, uint64_t>> fsa_start_state_pairs;
 
@@ -170,17 +169,11 @@ class PrefixCompletionMatching final {
     traverser.reset(new innerTraverserType(fsa_start_state_pairs));
 
     return PrefixCompletionMatching(std::move(traverser), std::move(first_match), std::move(traversal_stack),
-                                    query_length, filter);
+                                    query_length);
   }
 
   Match FirstMatch() const {
-    if (first_match_.IsEmpty()) {
-      return first_match_;
-    }
-
-    filter_result_t fr = filter_(first_match_);
-    traverser_ptr_->SetMinWeight(fr.second);
-    return fr.first ? first_match_ : Match();
+    return first_match_;
   }
 
   Match NextMatch() {
@@ -196,15 +189,6 @@ class PrefixCompletionMatching final {
         Match m(0, prefix_length_ + traverser_ptr_->GetDepth(), match_str, 0, traverser_ptr_->GetFsa(),
                 traverser_ptr_->GetStateValue(), traverser_ptr_->GetInnerWeight());
 
-        filter_result_t fr = filter_(m);
-
-        TRACE("filter result: %s, min weight: %d", fr.first ? "true" : "false", fr.second);
-
-        traverser_ptr_->SetMinWeight(fr.second);
-        if (!fr.first) {
-          continue;
-        }
-
         (*traverser_ptr_)++;
         return m;
       }
@@ -213,15 +197,18 @@ class PrefixCompletionMatching final {
     return Match();
   }
 
+  void SetMinWeight(uint32_t min_weight) {
+    traverser_ptr_->SetMinWeight(min_weight);
+  }
+
  private:
   PrefixCompletionMatching(std::unique_ptr<innerTraverserType>&& traverser, Match&& first_match,
-                           std::unique_ptr<std::vector<unsigned char>>&& traversal_stack, const size_t prefix_length,
-                           const filter_t filter)
+                           std::unique_ptr<std::vector<unsigned char>>&& traversal_stack, const size_t prefix_length
+                           )
       : traverser_ptr_(std::move(traverser)),
         first_match_(std::move(first_match)),
         traversal_stack_(std::move(traversal_stack)),
-        prefix_length_(prefix_length),
-        filter_(filter) {}
+        prefix_length_(prefix_length) {}
 
   PrefixCompletionMatching() {}
 
@@ -230,7 +217,6 @@ class PrefixCompletionMatching final {
   const Match first_match_;
   std::unique_ptr<std::vector<unsigned char>> traversal_stack_;
   const size_t prefix_length_ = 0;
-  const filter_t filter_;
 
   // reset method for the index in the special case the match is deleted
   template <class MatcherT, class DeletedT>
diff --git a/keyvi/tests/keyvi/dictionary/dictionary_test.cpp b/keyvi/tests/keyvi/dictionary/dictionary_test.cpp
index dee879484..4e5009381 100644
--- a/keyvi/tests/keyvi/dictionary/dictionary_test.cpp
+++ b/keyvi/tests/keyvi/dictionary/dictionary_test.cpp
@@ -263,6 +263,7 @@ BOOST_AUTO_TEST_CASE(DictGetPrefixCompletion) {
   }
 }
 
+/*
 BOOST_AUTO_TEST_CASE(DictGetPrefixCompletionCustomFilter) {
   std::vector<std::pair<std::string, uint32_t>> test_data = {
       {"mr. eric a", 331},  {"mr. eric b", 1331}, {"mr. max b", 1431},   {"mr. stefan b", 231}, {"mr. stefan e", 431},
@@ -286,7 +287,7 @@ BOOST_AUTO_TEST_CASE(DictGetPrefixCompletionCustomFilter) {
   }
 
   BOOST_CHECK_EQUAL(expected_matches.size(), i);
-}
+}*/
 
 BOOST_AUTO_TEST_SUITE_END()
 
diff --git a/keyvi/tests/keyvi/dictionary/matching/prefix_completion_matching_test.cpp b/keyvi/tests/keyvi/dictionary/matching/prefix_completion_matching_test.cpp
index 9f8200971..c9ff675e0 100644
--- a/keyvi/tests/keyvi/dictionary/matching/prefix_completion_matching_test.cpp
+++ b/keyvi/tests/keyvi/dictionary/matching/prefix_completion_matching_test.cpp
@@ -21,7 +21,6 @@
 #include <boost/test/unit_test.hpp>
 
 #include "keyvi/dictionary/dictionary.h"
-#include "keyvi/dictionary/matching/filter.h"
 #include "keyvi/testing/temp_dictionary.h"
 
 namespace keyvi {
@@ -114,6 +113,7 @@ void test_prefix_completion_matching(std::vector<std::pair<std::string, uint32_t
   BOOST_CHECK(expected_it == expected_sorted.end());
 }
 
+/*
 void test_prefix_completion_matching_with_filter(std::vector<std::pair<std::string, uint32_t>>* test_data,
                                                  const std::string& query, const std::vector<std::string> expected,
                                                  const filter_t filter) {
@@ -170,7 +170,7 @@ void test_prefix_completion_matching_with_filter_multi_fsa(std::vector<std::pair
     BOOST_CHECK_EQUAL(*expected_it++, m.GetMatchedString());
   }
   BOOST_CHECK(expected_it == expected.end());
-}
+}*/
 
 BOOST_AUTO_TEST_CASE(prefix_0) {
   std::vector<std::pair<std::string, uint32_t>> test_data = {
@@ -205,6 +205,8 @@ BOOST_AUTO_TEST_CASE(prefix_completion_cjk) {
                                   std::vector<std::string>{"あsだ", "あsだs", "あsだsっd", "あsaだsっdさ"});
 }
 
+/*
+
 BOOST_AUTO_TEST_CASE(prefix_top_3) {
   std::vector<std::pair<std::string, uint32_t>> test_data = {
       {"eric a", 331}, {"eric b", 1331}, {"eric c", 1431}, {"eric d", 231}, {"eric e", 431},
@@ -212,6 +214,9 @@ BOOST_AUTO_TEST_CASE(prefix_top_3) {
   };
 
   filter::TopN top3(3);
+
+
+
   test_prefix_completion_matching_with_filter(&test_data, "eric",
                                               std::vector<std::string>{"eric c", "eric b", "eric i"},
                                               std::bind(&filter::TopN::filter, &top3, std::placeholders::_1));
@@ -227,7 +232,7 @@ BOOST_AUTO_TEST_CASE(prefix_top_3) {
   test_prefix_completion_matching_with_filter(&test_data, "steven", std::vector<std::string>{},
                                               std::bind(&filter::TopN::filter, &top3_3, std::placeholders::_1));
 }
-
+*/
 BOOST_AUTO_TEST_SUITE_END()
 
 } /* namespace matching */
diff --git a/python/src/addons/autwrap_workarounds.pyx b/python/src/addons/autwrap_workarounds.pyx
index 0b85d060a..52a42f1ac 100644
--- a/python/src/addons/autwrap_workarounds.pyx
+++ b/python/src/addons/autwrap_workarounds.pyx
@@ -22,16 +22,6 @@ import warnings
 cdef void progress_compiler_callback(size_t a, size_t b, void* py_callback) noexcept with gil:
     (<object>py_callback)(a, b)
 
-cdef libcpp_pair[bool, uint32_t] filter_callback(_Match m, void* py_callback) noexcept with gil:
-    cdef shared_ptr[_Match] _r = shared_ptr[_Match](new _Match(m))
-
-    cdef Match py_match = Match.__new__(Match)
-    py_match.inst = _r
-
-    accept, min_weight = (<object>py_callback)(py_match)
-    cdef libcpp_pair[bool, uint32_t] c_result = libcpp_pair[bool, uint32_t](accept, min_weight)
-    return c_result
-
 def get_package_root():
     module_location = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(keyvi._pycore.__file__)), ".."))
 
diff --git a/python/src/addons/match_iterator.pyx b/python/src/addons/match_iterator.pyx
index 70c45a160..83b30b257 100644
--- a/python/src/addons/match_iterator.pyx
+++ b/python/src/addons/match_iterator.pyx
@@ -41,3 +41,6 @@ cdef class MatchIterator:
         py_result.inst = shared_ptr[_Match](_r)
 
         return py_result
+
+    def set_min_weight(self, w):
+        self.it.SetMinWeight(w)
\ No newline at end of file
diff --git a/python/src/converters/__init__.py b/python/src/converters/__init__.py
index 68654921e..6dbfa9ec4 100644
--- a/python/src/converters/__init__.py
+++ b/python/src/converters/__init__.py
@@ -1,8 +1,6 @@
 from .match_iterator_converter import *
-from .match_filter_converter import *
 from autowrap.ConversionProvider import special_converters
 
 
 def register_converters():
     special_converters.append(MatchIteratorPairConverter())
-    special_converters.append(MatchFilterConverter())
diff --git a/python/src/converters/match_filter_converter.py b/python/src/converters/match_filter_converter.py
deleted file mode 100644
index 31d4076ce..000000000
--- a/python/src/converters/match_filter_converter.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from typing import Tuple
-from autowrap.Types import CppType
-from autowrap.ConversionProvider import TypeConverterBase
-
-
-class MatchFilterConverter(TypeConverterBase):
-    def get_base_types(self):
-        return ("match_filter",)
-
-    def matches(self, cpp_type):
-        return not cpp_type.is_ptr
-
-    def matching_python_type(self, cpp_type):
-        return ""
-
-    def type_check_expression(self, cpp_type: CppType, argument_var: str) -> str:
-        return "isinstance(%s, object)" % (argument_var,)
-
-    def input_conversion(
-        self, cpp_type: CppType, argument_var: str, arg_num: int
-    ) -> Tuple[str, str, str]:
-        return "", "filter_callback, <void*> %s" % argument_var, ""
diff --git a/python/src/pxds/dictionary.pxd b/python/src/pxds/dictionary.pxd
index 7446cc7bc..6f5f69a3c 100644
--- a/python/src/pxds/dictionary.pxd
+++ b/python/src/pxds/dictionary.pxd
@@ -10,8 +10,6 @@ from libcpp.pair cimport pair as libcpp_pair
 from match cimport Match as _Match
 from match_iterator cimport MatchIteratorPair as _MatchIteratorPair
 
-ctypedef libcpp_pair[bool, uint32_t] (*match_filter)(_Match m, void* user_data)
-
 cdef extern from "keyvi/dictionary/dictionary.h" namespace "keyvi::dictionary":
     ctypedef enum loading_strategy_types:
         default_os, # no special treatment, use whatever the OS/Boost has as default
@@ -56,24 +54,6 @@ cdef extern from "keyvi/dictionary/dictionary.h" namespace "keyvi::dictionary":
         #  neither in order nor limited to n. It is up to the caller to resort
         #  and truncate the lists of results.
         #  Only the number of top completions is guaranteed.
-        _MatchIteratorPair GetPrefixCompletion (libcpp_utf8_string key, match_filter filter, void* filter_data) # wrap-ignore
-        _MatchIteratorPair GetPrefixCompletion (libcpp_utf8_string key, match_filter filter) # wrap-as:complete_prefix
-        # wrap-doc:
-        #  complete the given key to full matches by matching the given key as
-        #  prefix. This version of prefix completions allows the definition of a
-        #  custom filter method. The filter method retrieves the match and must
-        #  return a tuple of bool and int:
-        #  
-        #  def my_filter(match):
-        #      ...
-        #      accept_match = True
-        #      min_weight = 42
-        #      return accept_match, min_weight
-        #  
-        #  Only if the filter accepts the match, it is passed downstream.
-        #  min_weight controls the internal traverser. Only branches with a
-        #  weight greater or equal than min_weight are visited, others are
-        #  skipped.
         _MatchIteratorPair GetAllItems () # wrap-ignore
         _MatchIteratorPair Lookup(libcpp_utf8_string  key) # wrap-as:search
         _MatchIteratorPair LookupText(libcpp_utf8_string text) # wrap-as:search_tokenized
diff --git a/python/src/pxds/match_iterator.pxd b/python/src/pxds/match_iterator.pxd
index b4e0b94ac..7a297d055 100644
--- a/python/src/pxds/match_iterator.pxd
+++ b/python/src/pxds/match_iterator.pxd
@@ -1,5 +1,6 @@
 # same import style as autowrap
 from match cimport Match as _Match
+from libc.stdint cimport uint32_t
 
 cdef extern from "keyvi/dictionary/match_iterator.h" namespace "keyvi::dictionary":
     cdef cppclass MatchIterator:
@@ -9,6 +10,7 @@ cdef extern from "keyvi/dictionary/match_iterator.h" namespace "keyvi::dictionar
         MatchIterator& operator++()
         bint operator==(MatchIterator)
         bint operator!=(MatchIterator)
+        void SetMinWeight(uint32_t) # wrap-ignore
 
 cdef extern from "keyvi/dictionary/match_iterator.h" namespace "keyvi::dictionary::MatchIterator":
     cdef cppclass MatchIteratorPair:
diff --git a/python/tests/dictionary/prefix_completion_test.py b/python/tests/dictionary/prefix_completion_test.py
index 40c538faf..3b8d8cce7 100644
--- a/python/tests/dictionary/prefix_completion_test.py
+++ b/python/tests/dictionary/prefix_completion_test.py
@@ -36,14 +36,28 @@ def test_prefix_simple():
         assert [m.matched_string for m in d.complete_prefix("eric", 2)] == [
             "eric",
             "eric ble",
+            "eric bla",
         ]
 
         def my_filter(m):
             return m.matched_string.endswith("x"), 40
 
-        assert [m.matched_string for m in d.complete_prefix("eric", my_filter)] == [
+       # assert [m.matched_string for m in d.complete_prefix("eric", my_filter)] == [
+       ##     "eric blx",
+        #    "eric bllllx",
+        #    "eric boox",
+        #]
+        # same with lambda, not working yet: assert [m.matched_string for m in d.complete_prefix("eric", lambda m: (m.matched_string.endswith('x'), 40))] ==  ['eric blx', 'eric bllllx', 'eric boox']
+
+        def filter(completer):
+            for m in completer:
+                print(m.matched_string)
+                if m.matched_string.endswith("x"):
+                    completer.set_min_weight(40)
+                    yield m
+        
+        assert [m.matched_string for m in filter(d.complete_prefix("eric"))] == [
             "eric blx",
             "eric bllllx",
             "eric boox",
-        ]
-        # same with lambda, not working yet: assert [m.matched_string for m in d.complete_prefix("eric", lambda m: (m.matched_string.endswith('x'), 40))] ==  ['eric blx', 'eric bllllx', 'eric boox']
+        ]
\ No newline at end of file