Updates: svs-vamana version capability validation

Author: Nitin Kanukolanu

redisvl/exceptions.py

@@ -31,3 +31,29 @@ class QueryValidationError(RedisVLError):
     """Error when validating a query."""
 
     pass
+
+
+class RedisModuleVersionError(RedisVLError):
+    """Error when Redis or module versions are incompatible with requested features."""
+
+    @classmethod
+    def for_svs_vamana(cls, capabilities, min_redis_version: str):
+        """Create error for unsupported SVS-VAMANA.
+
+        Args:
+            capabilities: VectorSupport instance with version info
+            min_redis_version: Minimum required Redis version
+
+        Returns:
+            RedisModuleVersionError with formatted message
+        """
+        message = (
+            f"SVS-VAMANA requires Redis >= {min_redis_version} with RediSearch >= 2.8.10. "
+            f"Current: Redis {capabilities.redis_version}, "
+            f"RediSearch {capabilities.search_version_str}, "
+            f"SearchLight {capabilities.searchlight_version_str}. "
+            f"Options: 1) Upgrade Redis Stack, "
+            f"2) Use algorithm='hnsw' or 'flat', "
+            f"3) Remove compression parameters"
+        )
+        return cls(message)

redisvl/index/index.py

@@ -67,6 +67,7 @@
 
 from redisvl.exceptions import (
     QueryValidationError,
+    RedisModuleVersionError,
     RedisSearchError,
     RedisVLError,
     SchemaValidationError,
@@ -82,11 +83,15 @@
 from redisvl.query.filter import FilterExpression
 from redisvl.redis.connection import (
     RedisConnectionFactory,
+    check_vector_capabilities,
+    check_vector_capabilities_async,
     convert_index_info_to_schema,
 )
+from redisvl.redis.constants import SVS_MIN_REDIS_VERSION
 from redisvl.schema import IndexSchema, StorageType
 from redisvl.schema.fields import (
     VECTOR_NORM_MAP,
+    SVSVectorField,
     VectorDistanceMetric,
     VectorIndexAlgorithm,
 )
@@ -228,6 +233,12 @@ def _storage(self) -> BaseStorage:
             index_schema=self.schema
         )
 
+    def _uses_svs_vamana(self) -> bool:
+        """Check if schema contains any SVS-VAMANA vector fields."""
+        return any(
+            isinstance(field, SVSVectorField) for field in self.schema.fields.values()
+        )
+
     def _validate_query(self, query: BaseQuery) -> None:
         """Validate a query."""
         if isinstance(query, VectorQuery):
@@ -535,6 +546,17 @@ def set_client(self, redis_client: SyncRedisClient, **kwargs):
         self.__redis_client = redis_client
         return self
 
+    def _check_svs_support(self) -> None:
+        """Validate SVS-VAMANA support.
+
+        Raises:
+            RedisModuleVersionError: If SVS-VAMANA requirements are not met.
+        """
+        caps = check_vector_capabilities(self._redis_client)
+
+        if not caps.svs_vamana_supported:
+            raise RedisModuleVersionError.for_svs_vamana(caps, SVS_MIN_REDIS_VERSION)
+
     def create(self, overwrite: bool = False, drop: bool = False) -> None:
         """Create an index in Redis with the current schema and properties.
 
@@ -566,6 +588,10 @@ def create(self, overwrite: bool = False, drop: bool = False) -> None:
         if not isinstance(overwrite, bool):
             raise TypeError("overwrite must be of type bool")
 
+        # Check if schema uses SVS-VAMANA and validate Redis capabilities
+        if self._uses_svs_vamana():
+            self._check_svs_support()
+
         if self.exists():
             if not overwrite:
                 logger.info("Index already exists, not overwriting.")
@@ -1302,6 +1328,18 @@ async def _info(name: str, redis_client: AsyncRedisClient) -> Dict[str, Any]:
                 f"Error while fetching {name} index info: {str(e)}"
             ) from e
 
+    async def _check_svs_support_async(self) -> None:
+        """Validate SVS-VAMANA support.
+
+        Raises:
+            RedisModuleVersionError: If SVS-VAMANA requirements are not met.
+        """
+        client = await self._get_client()
+        caps = await check_vector_capabilities_async(client)
+
+        if not caps.svs_vamana_supported:
+            raise RedisModuleVersionError.for_svs_vamana(caps, SVS_MIN_REDIS_VERSION)
+
     async def create(self, overwrite: bool = False, drop: bool = False) -> None:
         """Asynchronously create an index in Redis with the current schema
             and properties.
@@ -1335,6 +1373,10 @@ async def create(self, overwrite: bool = False, drop: bool = False) -> None:
         if not isinstance(overwrite, bool):
             raise TypeError("overwrite must be of type bool")
 
+        # Check if schema uses SVS-VAMANA and validate Redis capabilities
+        if self._uses_svs_vamana():
+            await self._check_svs_support_async()
+
         if await self.exists():
             if not overwrite:
                 logger.info("Index already exists, not overwriting.")

redisvl/redis/connection.py

@@ -1,4 +1,5 @@
 import os
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union, overload
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 from warnings import warn
@@ -15,7 +16,11 @@
 from redis.sentinel import Sentinel
 
 from redisvl import __version__
-from redisvl.redis.constants import REDIS_URL_ENV_VAR
+from redisvl.redis.constants import (
+    REDIS_URL_ENV_VAR,
+    SVS_MIN_REDIS_VERSION,
+    SVS_REQUIRED_MODULES,
+)
 from redisvl.redis.utils import convert_bytes, is_cluster_url
 from redisvl.types import AsyncRedisClient, RedisClient, SyncRedisClient
 from redisvl.utils.utils import deprecated_function
@@ -101,6 +106,152 @@ def unpack_redis_modules(module_list: List[Dict[str, Any]]) -> Dict[str, Any]:
     return {module["name"]: module["ver"] for module in module_list}
 
 
+@dataclass
+class VectorSupport:
+    """Redis server capabilities for vector operations."""
+
+    redis_version: str
+    search_version: int
+    searchlight_version: int
+    svs_vamana_supported: bool
+
+    @property
+    def search_version_str(self) -> str:
+        """Format search module version as string."""
+        return format_module_version(self.search_version)
+
+    @property
+    def searchlight_version_str(self) -> str:
+        """Format searchlight module version as string."""
+        return format_module_version(self.searchlight_version)
+
+
+def format_module_version(version: int) -> str:
+    """Format module version from integer (20810) to string (2.8.10)."""
+    if version == 0:
+        return "not installed"
+    major = version // 10000
+    minor = (version % 10000) // 100
+    patch = version % 100
+    return f"{major}.{minor}.{patch}"
+
+
+def check_vector_capabilities(client: SyncRedisClient) -> VectorSupport:
+    """Check Redis server capabilities for vector features.
+
+    Args:
+        client: Sync Redis client instance
+
+    Returns:
+        VectorSupport with version info and supported features
+    """
+    info = client.info("server")
+    redis_version = info.get("redis_version", "0.0.0")
+
+    modules = RedisConnectionFactory.get_modules(client)
+    search_ver = modules.get("search", 0)
+    searchlight_ver = modules.get("searchlight", 0)
+
+    # Check if SVS-VAMANA requirements are met
+    redis_ok = compare_versions(redis_version, SVS_MIN_REDIS_VERSION)
+    modules_ok = search_ver >= 20810 or searchlight_ver >= 20810
+
+    return VectorSupport(
+        redis_version=redis_version,
+        search_version=search_ver,
+        searchlight_version=searchlight_ver,
+        svs_vamana_supported=redis_ok and modules_ok,
+    )
+
+
+async def check_vector_capabilities_async(client: AsyncRedisClient) -> VectorSupport:
+    """Async version of check_vector_capabilities.
+
+    Args:
+        client: Async Redis client instance
+
+    Returns:
+        VectorSupport with version info and supported features
+    """
+    info = await client.info("server")
+    redis_version = info.get("redis_version", "0.0.0")
+
+    modules = await RedisConnectionFactory.get_modules_async(client)
+    search_ver = modules.get("search", 0)
+    searchlight_ver = modules.get("searchlight", 0)
+
+    # Check if SVS-VAMANA requirements are met
+    redis_ok = compare_versions(redis_version, SVS_MIN_REDIS_VERSION)
+    modules_ok = search_ver >= 20810 or searchlight_ver >= 20810
+
+    return VectorSupport(
+        redis_version=redis_version,
+        search_version=search_ver,
+        searchlight_version=searchlight_ver,
+        svs_vamana_supported=redis_ok and modules_ok,
+    )
+
+
+def supports_svs_vamana(client: SyncRedisClient) -> bool:
+    """Check if Redis server supports SVS-VAMANA algorithm.
+
+    SVS-Vamana requires:
+    - Redis version >= 8.2.0
+    - RediSearch version >= 2.8.10 (20810)
+
+    Args:
+        client: Sync Redis client instance
+
+    Returns:
+        bool: True if SVS-VAMANA is supported, False otherwise
+    """
+    info = client.info()
+    redis_version = info.get("redis_version", "0.0.0")
+    if not compare_versions(redis_version, SVS_MIN_REDIS_VERSION):
+        return False
+
+    # Check module versions
+    modules = unpack_redis_modules(convert_bytes(client.module_list()))
+    for module in SVS_REQUIRED_MODULES:
+        module_name = module["name"]
+        required_version = module["ver"]
+        if module_name not in modules:
+            return False
+        if modules[module_name] < required_version:
+            return False
+    return True
+
+
+async def async_supports_svs_vamana(client: AsyncRedisClient) -> bool:
+    """Check if Redis server supports SVS-VAMANA algorithm asynchronously.
+
+    SVS-Vamana requires:
+    - Redis version >= 8.2.0
+    - RediSearch version >= 2.8.10 (20810)
+
+    Args:
+        client: Sync Redis client instance
+
+    Returns:
+        bool: True if SVS-VAMANA is supported, False otherwise
+    """
+    info = await client.info()
+    redis_version = info.get("redis_version", "0.0.0")
+    if not compare_versions(redis_version, SVS_MIN_REDIS_VERSION):
+        return False
+
+    # Check module versions
+    modules = unpack_redis_modules(convert_bytes(await client.module_list()))
+    for module in SVS_REQUIRED_MODULES:
+        module_name = module["name"]
+        required_version = module["ver"]
+        if module_name not in modules:
+            return False
+        if modules[module_name] < required_version:
+            return False
+    return True
+
+
 def get_address_from_env() -> str:
     """Get Redis URL from environment variable."""
     redis_url = os.getenv(REDIS_URL_ENV_VAR)

redisvl/redis/constants.py

@@ -4,6 +4,15 @@
     {"name": "searchlight", "ver": 20600},
 ]
 
+# SVS-VAMANA requires Redis 8.2+ with RediSearch 2.8.10+
+SVS_REQUIRED_MODULES = [
+    {"name": "search", "ver": 20810},  # RediSearch 2.8.10+
+    {"name": "searchlight", "ver": 20810},
+]
+
+# Minimum Redis version for SVS-VAMANA
+SVS_MIN_REDIS_VERSION = "8.2.0"
+
 # default tag separator
 REDIS_TAG_SEPARATOR = ","