fix: apply score_threshold filtering after fusion queries in local mode (#1138)

* fix: apply score_threshold filtering after fusion queries in local mode

The local/memory client was not applying score_threshold filtering after
RRF and DBSF fusion operations. This caused query_points with prefetch
and fusion queries to return results below the specified score_threshold.

This fix adds score_threshold filtering after fusion results are computed,
matching the behavior of the remote Qdrant server.

* tests: simplify score threshold tests, add formula threshold test

---------

Co-authored-by: George Panchuk <george.panchuk@qdrant.tech>

Author: cbcoutinho

qdrant_client/local/local_collection.py

@@ -823,6 +823,10 @@ def _merge_sources(
                 else:
                     raise ValueError(f"Fusion method {query.fusion} does not exist")
 
+            # Apply score_threshold filtering (matching server behavior)
+            if score_threshold is not None:
+                fused = [p for p in fused if p.score >= score_threshold]
+
             # Fetch payload and vectors
             ids = [point.id for point in fused]
             fetched_points = self.retrieve(

tests/congruence_tests/test_query.py

@@ -413,6 +413,36 @@ def dense_query_dbsf(self, client: QdrantBase) -> models.QueryResponse:
             limit=10,
         )
 
+    def dense_query_rrf_score_threshold(self, client: QdrantBase) -> list[models.ScoredPoint]:
+        return client.query_points(
+            collection_name=COLLECTION_NAME,
+            prefetch=[
+                models.Prefetch(
+                    query=self.dense_vector_query_text,
+                    using="text",
+                )
+            ],
+            query=models.RrfQuery(rrf=models.Rrf(k=1)),
+            with_payload=True,
+            limit=10,
+            score_threshold=0.25,  # should return 3 results: 1.0, 0.5, 0.3(3)
+        ).points
+
+    def dense_query_formula_score_threshold(self, client: QdrantBase) -> list[models.ScoredPoint]:
+        return client.query_points(
+            collection_name=COLLECTION_NAME,
+            prefetch=[
+                models.Prefetch(
+                    query=self.dense_vector_query_text,
+                    using="text",
+                )
+            ],
+            query=models.FormulaQuery(formula=models.MultExpression(mult=["$score", 1.0])),
+            with_payload=True,
+            limit=10,
+            score_threshold=1.0,  # todo: score threshold is not applied in formula queries in core
+        ).points
+
     def deep_dense_queries_rrf(self, client: QdrantBase) -> models.QueryResponse:
         return client.query_points(
             collection_name=COLLECTION_NAME,
@@ -1297,10 +1327,15 @@ def test_dense_query_fusion():
     compare_clients_results(
         local_client, http_client, grpc_client, searcher.deep_dense_queries_dbsf
     )
-
     compare_clients_results(
         local_client, http_client, grpc_client, searcher.dense_query_parametrized_rrf
     )
+    compare_clients_results(
+        local_client, http_client, grpc_client, searcher.dense_query_rrf_score_threshold
+    )
+    compare_clients_results(
+        local_client, http_client, grpc_client, searcher.dense_query_formula_score_threshold
+    )
 
 
 def test_dense_query_discovery_context():

tests/test_in_memory.py

@@ -118,3 +118,181 @@ def test_sparse_in_memory_key_filter_returns_results(qdrant: QdrantClient):
     ).points
 
     assert [r.id for r in search_result] == [4, 2]
+
+
+def test_fusion_rrf_score_threshold(qdrant: QdrantClient):
+    """Test that RRF fusion with score_threshold correctly filters results.
+
+    RRF scores in local mode are normalized and for 5 points we get roughly:
+    - ID 1: 1.0
+    - ID 2: 0.667
+    - ID 3: 0.5
+    - ID 5: 0.4
+    - ID 4: 0.333
+
+    A threshold of 0.45 should filter out IDs 4 and 5.
+    """
+    qdrant.create_collection(
+        collection_name="test_collection",
+        vectors_config={
+            "text": models.VectorParams(size=4, distance=models.Distance.COSINE),
+            "image": models.VectorParams(size=4, distance=models.Distance.COSINE),
+        },
+    )
+
+    qdrant.upsert(
+        collection_name="test_collection",
+        wait=True,
+        points=[
+            models.PointStruct(
+                id=1,
+                vector={"text": [1.0, 0.0, 0.0, 0.0], "image": [1.0, 0.0, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=2,
+                vector={"text": [0.9, 0.1, 0.0, 0.0], "image": [0.9, 0.1, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=3,
+                vector={"text": [0.5, 0.5, 0.0, 0.0], "image": [0.5, 0.5, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=4,
+                vector={"text": [0.0, 1.0, 0.0, 0.0], "image": [0.0, 1.0, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=5,
+                vector={"text": [0.0, 0.0, 1.0, 0.0], "image": [0.0, 0.0, 1.0, 0.0]},
+            ),
+        ],
+    )
+
+    query_vector = [1.0, 0.0, 0.0, 0.0]
+
+    # Without score_threshold - should return all 5 points
+    result_no_threshold = qdrant.query_points(
+        collection_name="test_collection",
+        prefetch=[
+            models.Prefetch(query=query_vector, using="text", limit=10),
+            models.Prefetch(query=query_vector, using="image", limit=10),
+        ],
+        query=models.FusionQuery(fusion=models.Fusion.RRF),
+        limit=10,
+    )
+    assert len(result_no_threshold.points) == 5
+
+    # Find points with scores below 0.45 - IDs 4 (0.333) and 5 (0.4) should be filtered
+    low_score_count = sum(1 for p in result_no_threshold.points if p.score < 0.45)
+    assert low_score_count == 2, f"Expected 2 low-scoring points, got {low_score_count}"
+
+    # With a threshold of 0.45, points with scores below should be filtered
+    result_with_threshold = qdrant.query_points(
+        collection_name="test_collection",
+        prefetch=[
+            models.Prefetch(query=query_vector, using="text", limit=10),
+            models.Prefetch(query=query_vector, using="image", limit=10),
+        ],
+        query=models.FusionQuery(fusion=models.Fusion.RRF),
+        score_threshold=0.45,
+        limit=10,
+    )
+
+    # Verify all returned points have score >= threshold
+    for point in result_with_threshold.points:
+        assert point.score >= 0.45, f"Score {point.score} is below threshold 0.45"
+
+    # Key assertion: filtering should reduce the count from 5 to 3
+    assert len(result_with_threshold.points) == 3, (
+        f"Expected 3 points after filtering (threshold 0.45), got {len(result_with_threshold.points)}. "
+        f"Scores: {[p.score for p in result_no_threshold.points]}"
+    )
+
+
+def test_fusion_dbsf_score_threshold(qdrant: QdrantClient):
+    """Test that DBSF fusion with score_threshold correctly filters results.
+
+    DBSF scores for the test data:
+    - ID 1: ~1.30
+    - ID 2: ~1.30
+    - ID 3: ~1.11
+    - ID 4: ~0.64
+    - ID 5: ~0.64
+
+    A threshold of 1.0 should filter out IDs 4 and 5.
+    """
+    qdrant.create_collection(
+        collection_name="test_collection",
+        vectors_config={
+            "text": models.VectorParams(size=4, distance=models.Distance.COSINE),
+            "image": models.VectorParams(size=4, distance=models.Distance.COSINE),
+        },
+    )
+
+    qdrant.upsert(
+        collection_name="test_collection",
+        wait=True,
+        points=[
+            models.PointStruct(
+                id=1,
+                vector={"text": [1.0, 0.0, 0.0, 0.0], "image": [1.0, 0.0, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=2,
+                vector={"text": [0.9, 0.1, 0.0, 0.0], "image": [0.9, 0.1, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=3,
+                vector={"text": [0.5, 0.5, 0.0, 0.0], "image": [0.5, 0.5, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=4,
+                vector={"text": [0.0, 1.0, 0.0, 0.0], "image": [0.0, 1.0, 0.0, 0.0]},
+            ),
+            models.PointStruct(
+                id=5,
+                vector={"text": [0.0, 0.0, 1.0, 0.0], "image": [0.0, 0.0, 1.0, 0.0]},
+            ),
+        ],
+    )
+
+    query_vector = [1.0, 0.0, 0.0, 0.0]
+
+    # Without score_threshold - should return all 5 points
+    result_no_threshold = qdrant.query_points(
+        collection_name="test_collection",
+        prefetch=[
+            models.Prefetch(query=query_vector, using="text", limit=10),
+            models.Prefetch(query=query_vector, using="image", limit=10),
+        ],
+        query=models.FusionQuery(fusion=models.Fusion.DBSF),
+        limit=10,
+    )
+    assert len(result_no_threshold.points) == 5
+
+    # Find points with scores below 1.0 - IDs 4 and 5 (~0.64) should be filtered
+    low_score_count = sum(1 for p in result_no_threshold.points if p.score < 1.0)
+    assert low_score_count == 2, f"Expected 2 low-scoring points, got {low_score_count}"
+
+    # With score_threshold of 1.0, points below should be filtered
+    result_with_threshold = qdrant.query_points(
+        collection_name="test_collection",
+        prefetch=[
+            models.Prefetch(query=query_vector, using="text", limit=10),
+            models.Prefetch(query=query_vector, using="image", limit=10),
+        ],
+        query=models.FusionQuery(fusion=models.Fusion.DBSF),
+        score_threshold=1.0,
+        limit=10,
+    )
+
+    # Verify all returned points have score >= threshold
+    for point in result_with_threshold.points:
+        assert point.score >= 1.0, f"Score {point.score} is below threshold 1.0"
+
+    # Key assertion: filtering should reduce the count from 5 to 3
+    assert len(result_with_threshold.points) == 3, (
+        f"Expected 3 points after filtering (threshold 1.0), got {len(result_with_threshold.points)}. "
+        f"Scores: {[p.score for p in result_no_threshold.points]}"
+    )
+
+