handle old versions of redis

Author: tylerhutcherson

redisvl/extensions/router/semantic.py

@@ -5,6 +5,7 @@
 from pydantic.v1 import BaseModel, Field, PrivateAttr
 from redis import Redis
 from redis.commands.search.aggregation import AggregateRequest, AggregateResult, Reducer
+from redis.exceptions import ResponseError
 
 from redisvl.extensions.router.schema import (
     DistanceAggregationMethod,
@@ -275,10 +276,19 @@ def _classify(
         aggregate_request = self._build_aggregate_request(
             vector_range_query, aggregation_method, max_k=1
         )
-        route_matches: AggregateResult = self._index.client.ft(  # type: ignore
-            self._index.name
-        ).aggregate(aggregate_request, vector_range_query.params)
-        return [self._process_route(route_match) for route_match in route_matches.rows]
+        try:
+            route_matches: AggregateResult = self._index.client.ft(  # type: ignore
+                self._index.name
+            ).aggregate(aggregate_request, vector_range_query.params)
+            return [
+                self._process_route(route_match) for route_match in route_matches.rows
+            ]
+        except ResponseError as e:
+            if "VSS is not yet supported on FT.AGGREGATE" in str(e):
+                raise RuntimeError(
+                    "Semantic routing is only available on Redis version 7.x.x or greater"
+                )
+            raise e
 
     def _classify_many(
         self,
@@ -307,10 +317,19 @@ def _classify_many(
         aggregate_request = self._build_aggregate_request(
             vector_range_query, aggregation_method, max_k
         )
-        route_matches: AggregateResult = self._index.client.ft(  # type: ignore
-            self._index.name
-        ).aggregate(aggregate_request, vector_range_query.params)
-        return [self._process_route(route_match) for route_match in route_matches.rows]
+        try:
+            route_matches: AggregateResult = self._index.client.ft(  # type: ignore
+                self._index.name
+            ).aggregate(aggregate_request, vector_range_query.params)
+            return [
+                self._process_route(route_match) for route_match in route_matches.rows
+            ]
+        except ResponseError as e:
+            if "VSS is not yet supported on FT.AGGREGATE" in str(e):
+                raise RuntimeError(
+                    "Semantic routing is only available on Redis version 7.x.x or greater"
+                )
+            raise e
 
     def _pass_threshold(self, route_match: Optional[RouteMatch]) -> bool:
         """Check if a route match passes the distance threshold.

redisvl/redis/connection.py

@@ -18,6 +18,35 @@
 from redisvl.version import __version__
 
 
+def compare_versions(version1, version2):
+    """
+    Compare two Redis version strings numerically.
+
+    Parameters:
+    version1 (str): The first version string (e.g., "7.2.4").
+    version2 (str): The second version string (e.g., "6.2.1").
+
+    Returns:
+    int: -1 if version1 < version2, 0 if version1 == version2, 1 if version1 > version2.
+    """
+    v1_parts = list(map(int, version1.split(".")))
+    v2_parts = list(map(int, version2.split(".")))
+
+    for v1, v2 in zip(v1_parts, v2_parts):
+        if v1 < v2:
+            return False
+        elif v1 > v2:
+            return True
+
+    # If the versions are equal so far, compare the lengths of the version parts
+    if len(v1_parts) < len(v2_parts):
+        return False
+    elif len(v1_parts) > len(v2_parts):
+        return True
+
+    return True
+
+
 def unpack_redis_modules(module_list: List[Dict[str, Any]]) -> Dict[str, Any]:
     """Unpack a list of Redis modules pulled from the MODULES LIST command."""
     return {module["name"]: module["ver"] for module in module_list}

tests/integration/test_connection.py

@@ -7,6 +7,7 @@
 
 from redisvl.redis.connection import (
     RedisConnectionFactory,
+    compare_versions,
     convert_index_info_to_schema,
     get_address_from_env,
     unpack_redis_modules,
@@ -18,35 +19,6 @@
 EXPECTED_LIB_NAME = f"redis-py(redisvl_v{__version__})"
 
 
-def compare_versions(version1, version2):
-    """
-    Compare two Redis version strings numerically.
-
-    Parameters:
-    version1 (str): The first version string (e.g., "7.2.4").
-    version2 (str): The second version string (e.g., "6.2.1").
-
-    Returns:
-    int: -1 if version1 < version2, 0 if version1 == version2, 1 if version1 > version2.
-    """
-    v1_parts = list(map(int, version1.split(".")))
-    v2_parts = list(map(int, version2.split(".")))
-
-    for v1, v2 in zip(v1_parts, v2_parts):
-        if v1 < v2:
-            return False
-        elif v1 > v2:
-            return True
-
-    # If the versions are equal so far, compare the lengths of the version parts
-    if len(v1_parts) < len(v2_parts):
-        return False
-    elif len(v1_parts) > len(v2_parts):
-        return True
-
-    return True
-
-
 def test_get_address_from_env(redis_url):
     assert get_address_from_env() == redis_url
 

tests/integration/test_semantic_router.py

@@ -2,6 +2,7 @@
 
 from redisvl.extensions.router import SemanticRouter
 from redisvl.extensions.router.schema import Route, RoutingConfig
+from redisvl.redis.connection import compare_versions
 
 
 @pytest.fixture
@@ -65,18 +66,30 @@ def test_get_non_existing_route(semantic_router):
 
 
 def test_single_query(semantic_router):
+    redis_version = semantic_router._index.client.info()["redis_version"]
+    if not compare_versions(redis_version, "7.0.0"):
+        pytest.skip("Not using a late enough version of Redis")
+
     match = semantic_router("hello")
     assert match.route is not None
     assert match.route.name == "greeting"
     assert match.distance <= semantic_router.route_thresholds["greeting"]
 
 
 def test_single_query_no_match(semantic_router):
+    redis_version = semantic_router._index.client.info()["redis_version"]
+    if not compare_versions(redis_version, "7.0.0"):
+        pytest.skip("Not using a late enough version of Redis")
+
     match = semantic_router("unknown_phrase")
     assert match.route is None
 
 
 def test_multiple_query(semantic_router):
+    redis_version = semantic_router._index.client.info()["redis_version"]
+    if not compare_versions(redis_version, "7.0.0"):
+        pytest.skip("Not using a late enough version of Redis")
+
     matches = semantic_router.route_many("hello", max_k=2)
     assert len(matches) > 0
     assert matches[0].route.name == "greeting"
@@ -90,13 +103,21 @@ def test_update_routing_config(semantic_router):
 
 
 def test_vector_query(semantic_router):
+    redis_version = semantic_router._index.client.info()["redis_version"]
+    if not compare_versions(redis_version, "7.0.0"):
+        pytest.skip("Not using a late enough version of Redis")
+
     vector = semantic_router.vectorizer.embed("goodbye")
     match = semantic_router(vector=vector)
     assert match.route is not None
     assert match.route.name == "farewell"
 
 
 def test_vector_query_no_match(semantic_router):
+    redis_version = semantic_router._index.client.info()["redis_version"]
+    if not compare_versions(redis_version, "7.0.0"):
+        pytest.skip("Not using a late enough version of Redis")
+
     vector = [
         0.0
     ] * semantic_router.vectorizer.dims  # Random vector unlikely to match any route
@@ -123,7 +144,9 @@ def test_additional_route(semantic_router):
     assert route.name == "politics"
     assert "political speech" in route.references
 
-    match = semantic_router("political speech")
-    print(match, flush=True)
-    assert match is not None
-    assert match.route.name == "politics"
+    redis_version = semantic_router._index.client.info()["redis_version"]
+    if compare_versions(redis_version, "7.0.0"):
+        match = semantic_router("political speech")
+        print(match, flush=True)
+        assert match is not None
+        assert match.route.name == "politics"