@@ -79,14 +79,17 @@
     "default": Datatype.FLOAT32,
 }
 IN_MEMORY_STRING: Final[str] = ":memory:"
-# The server compares ranges as float64, so larger ints are matched exactly with MatchValue instead.
+# The server compares ranges as float64, which can't tell 2**53 from 2**53 + 1, so ints from 2**53 up
+# are matched exactly with MatchValue instead.
 MAX_EXACT_FLOAT_INT: Final[int] = 2**53
 
 
 def _match_value(key: str, value: Any) -> FieldCondition:
     """Match a single value, numerically for numbers so 5 also matches 5.0 and floats are accepted."""
     # MatchValue only accepts str, int and bool, and an int never matches a float payload
-    if isinstance(value, (int, float)) and not isinstance(value, bool) and abs(value) <= MAX_EXACT_FLOAT_INT:
+    if isinstance(value, float) or (
+        isinstance(value, int) and not isinstance(value, bool) and abs(value) < MAX_EXACT_FLOAT_INT
+    ):
         return FieldCondition(key=key, range=Range(gte=value, lte=value))
     return FieldCondition(key=key, match=MatchValue(value=value))
 
 
@@ -5,7 +5,7 @@
 
 from pytest import fixture, mark
 
-from semantic_kernel.connectors.qdrant import QdrantCollection
+from semantic_kernel.connectors.qdrant import QdrantCollection, _match_value
 from semantic_kernel.data.vector import VectorStoreField, vectorstoremodel
 
 
@@ -92,8 +92,22 @@ async def product_collection():
         ("lambda x: x.price not in [4.5]", [2]),
         ("lambda x: x.in_stock in [True]", [1]),
         ("lambda x: x.in_stock not in [True]", [2]),
+        # Large floats too, which MatchValue would reject
+        ("lambda x: x.price == 1e20", []),
+        ("lambda x: x.price != 1e20", [1, 2]),
     ],
 )
 async def test_local_filter_with_float_and_bool_values(product_collection, filter_str, expected):
     results = await product_collection.search(vector=[1.0, 1.0], filter=filter_str)
     assert sorted([r.record.id async for r in results.results]) == expected
+
+
+@mark.parametrize(
+    ("value", "uses_range"),
+    [(2**53 - 1, True), (-(2**53) + 1, True), (2**53, False), (2**60, False), (1e20, True)],
+)
+def test_match_value_uses_range_only_where_float64_is_exact(value, uses_range):
+    # The server compares ranges as float64, where 2**53 and 2**53 + 1 are the same value
+    condition = _match_value("n", value)
+    assert (condition.range is not None) is uses_range
+    assert (condition.match is None) is uses_range