fix(query)!: Remove epsilon parameter from VectorQuery (#612)

EPSILON is a VECTOR_RANGE-only attribute. So when emitted inside the KNN bracket, Redis responds with:

```
ResponseError: Error parsing vector similarity parameters:
range query attributes were sent for a non-range query
```

- Remove epsilon kwarg, set_epsilon() method, and epsilon property
- Remove EPSILON emission from _build_query_string and params

Does not impact VectorRangeQuery

Author: booleanhunter

redisvl/query/query.py

@@ -421,7 +421,6 @@ class BaseVectorQuery:
     # HNSW runtime parameters
     EF_RUNTIME: str = "EF_RUNTIME"
     EF_RUNTIME_PARAM: str = "EF"
-    EPSILON_PARAM: str = "EPSILON"
 
     # SVS-VAMANA runtime parameters
     SEARCH_WINDOW_SIZE: str = "SEARCH_WINDOW_SIZE"
@@ -457,7 +456,6 @@ def __init__(
         hybrid_policy: str | None = None,
         batch_size: int | None = None,
         ef_runtime: int | None = None,
-        epsilon: float | None = None,
         search_window_size: int | None = None,
         use_search_history: str | None = None,
         search_buffer_capacity: int | None = None,
@@ -505,10 +503,6 @@ def __init__(
             ef_runtime (Optional[int]): Controls the size of the dynamic candidate list for HNSW
                 algorithm at query time. Higher values improve recall at the expense of
                 slower search performance. Defaults to None, which uses the index-defined value.
-            epsilon (Optional[float]): The range search approximation factor for HNSW and SVS-VAMANA
-                indexes. Sets boundaries for candidates within radius * (1 + epsilon). Higher values
-                allow more extensive search and more accurate results at the expense of run time.
-                Defaults to None, which uses the index-defined value (typically 0.01).
             search_window_size (Optional[int]): The size of the search window for SVS-VAMANA KNN searches.
                 Increasing this value generally yields more accurate but slower search results.
                 Defaults to None, which uses the index-defined value (typically 10).
@@ -541,7 +535,6 @@ def __init__(
         self._hybrid_policy: HybridPolicy | None = None
         self._batch_size: int | None = None
         self._ef_runtime: int | None = None
-        self._epsilon: float | None = None
         self._search_window_size: int | None = None
         self._use_search_history: str | None = None
         self._search_buffer_capacity: int | None = None
@@ -578,9 +571,6 @@ def __init__(
         if ef_runtime is not None:
             self.set_ef_runtime(ef_runtime)
 
-        if epsilon is not None:
-            self.set_epsilon(epsilon)
-
         if search_window_size is not None:
             self.set_search_window_size(search_window_size)
 
@@ -613,10 +603,6 @@ def _build_query_string(self) -> str:
         if self._ef_runtime:
             knn_query += f" {self.EF_RUNTIME} ${self.EF_RUNTIME_PARAM}"
 
-        # Add EPSILON parameter if specified (HNSW and SVS-VAMANA)
-        if self._epsilon is not None:
-            knn_query += f" EPSILON ${self.EPSILON_PARAM}"
-
         # Add SEARCH_WINDOW_SIZE parameter if specified (SVS-VAMANA)
         if self._search_window_size is not None:
             knn_query += f" {self.SEARCH_WINDOW_SIZE} ${self.SEARCH_WINDOW_SIZE_PARAM}"
@@ -695,28 +681,6 @@ def set_ef_runtime(self, ef_runtime: int):
         # Invalidate the query string
         self._built_query_string = None
 
-    def set_epsilon(self, epsilon: float):
-        """Set the epsilon parameter for the query.
-
-        Args:
-            epsilon (float): The range search approximation factor for HNSW and SVS-VAMANA
-                indexes. Sets boundaries for candidates within radius * (1 + epsilon).
-                Higher values allow more extensive search and more accurate results at the
-                expense of run time.
-
-        Raises:
-            TypeError: If epsilon is not a float or int
-            ValueError: If epsilon is negative
-        """
-        if not isinstance(epsilon, (float, int)):
-            raise TypeError("epsilon must be of type float or int")
-        if epsilon < 0:
-            raise ValueError("epsilon must be non-negative")
-        self._epsilon = epsilon
-
-        # Invalidate the query string
-        self._built_query_string = None
-
     def set_search_window_size(self, search_window_size: int):
         """Set the SEARCH_WINDOW_SIZE parameter for the query.
 
@@ -808,15 +772,6 @@ def ef_runtime(self) -> int | None:
         """
         return self._ef_runtime
 
-    @property
-    def epsilon(self) -> float | None:
-        """Return the epsilon parameter for the query.
-
-        Returns:
-            Optional[float]: The epsilon value for the query.
-        """
-        return self._epsilon
-
     @property
     def search_window_size(self) -> int | None:
         """Return the SEARCH_WINDOW_SIZE parameter for the query.
@@ -862,10 +817,6 @@ def params(self) -> dict[str, Any]:
         if self._ef_runtime is not None:
             params[self.EF_RUNTIME_PARAM] = self._ef_runtime
 
-        # Add EPSILON parameter if specified (HNSW and SVS-VAMANA)
-        if self._epsilon is not None:
-            params[self.EPSILON_PARAM] = self._epsilon
-
         # Add SEARCH_WINDOW_SIZE parameter if specified (SVS-VAMANA)
         if self._search_window_size is not None:
             params[self.SEARCH_WINDOW_SIZE_PARAM] = self._search_window_size

tests/unit/test_query_types.py

@@ -973,43 +973,6 @@ def test_vector_query_update_ef_runtime():
     assert params2.get(VectorQuery.EF_RUNTIME_PARAM) == 200
 
 
-def test_vector_query_epsilon():
-    """Test that VectorQuery correctly handles epsilon parameter."""
-    # Create a vector query with epsilon
-    vector_query = VectorQuery([0.1, 0.2, 0.3, 0.4], "vector_field", epsilon=0.05)
-
-    # Check properties
-    assert vector_query.epsilon == 0.05
-
-    # Check query string
-    query_string = str(vector_query)
-    assert f"EPSILON ${VectorQuery.EPSILON_PARAM}" in query_string
-
-    # Check params dictionary
-    assert vector_query.params.get(VectorQuery.EPSILON_PARAM) == 0.05
-
-
-def test_vector_query_invalid_epsilon():
-    """Test error handling for invalid epsilon values in VectorQuery."""
-    # Test with invalid epsilon type
-    with pytest.raises(TypeError, match="epsilon must be of type float or int"):
-        VectorQuery([0.1, 0.2, 0.3, 0.4], "vector_field", epsilon="0.05")
-
-    # Test with negative epsilon
-    with pytest.raises(ValueError, match="epsilon must be non-negative"):
-        VectorQuery([0.1, 0.2, 0.3, 0.4], "vector_field", epsilon=-0.05)
-
-    # Create a valid vector query
-    vector_query = VectorQuery([0.1, 0.2, 0.3, 0.4], "vector_field")
-
-    # Test with invalid epsilon via setter
-    with pytest.raises(TypeError, match="epsilon must be of type float or int"):
-        vector_query.set_epsilon("0.05")
-
-    with pytest.raises(ValueError, match="epsilon must be non-negative"):
-        vector_query.set_epsilon(-0.05)
-
-
 def test_vector_query_search_window_size():
     """Test that VectorQuery correctly handles search_window_size parameter (SVS-VAMANA)."""
     # Create a vector query with search_window_size
@@ -1153,31 +1116,27 @@ def test_vector_query_all_runtime_params():
         [0.1, 0.2, 0.3, 0.4],
         "vector_field",
         ef_runtime=100,
-        epsilon=0.05,
         search_window_size=40,
         use_search_history="ON",
         search_buffer_capacity=50,
     )
 
     # Check all properties
     assert vector_query.ef_runtime == 100
-    assert vector_query.epsilon == 0.05
     assert vector_query.search_window_size == 40
     assert vector_query.use_search_history == "ON"
     assert vector_query.search_buffer_capacity == 50
 
     # Check query string contains all parameters
     query_string = str(vector_query)
     assert "EF_RUNTIME $EF" in query_string
-    assert "EPSILON $EPSILON" in query_string
     assert "SEARCH_WINDOW_SIZE $SEARCH_WINDOW_SIZE" in query_string
     assert "USE_SEARCH_HISTORY $USE_SEARCH_HISTORY" in query_string
     assert "SEARCH_BUFFER_CAPACITY $SEARCH_BUFFER_CAPACITY" in query_string
 
     # Check params dictionary contains all parameters
     params = vector_query.params
     assert params["EF"] == 100
-    assert params["EPSILON"] == 0.05
     assert params["SEARCH_WINDOW_SIZE"] == 40
     assert params["USE_SEARCH_HISTORY"] == "ON"
     assert params["SEARCH_BUFFER_CAPACITY"] == 50