Update hybrid search usage based on in-practice constraints

Author: vishal-bala

redisvl/index/index.py

@@ -45,8 +45,20 @@
     from redis.commands.search.aggregation import AggregateResult
     from redis.commands.search.document import Document
     from redis.commands.search.result import Result
+
     from redisvl.query.query import BaseQuery
 
+try:
+    from redis.commands.search.hybrid_result import HybridResult
+
+    from redisvl.query.hybrid import HybridQuery
+
+    REDIS_HYBRID_AVAILABLE = True
+except ImportError:
+    REDIS_HYBRID_AVAILABLE = False
+    HybridResult = None  # type: ignore
+    HybridQuery = None  # type: ignore
+
 from redis import __version__ as redis_version
 from redis.client import NEVER_DECODE
 
@@ -215,6 +227,13 @@ def _process(row):
     return [_process(r) for r in results.rows]
 
 
+if REDIS_HYBRID_AVAILABLE:
+
+    def process_hybrid_results(results: HybridResult) -> List[Dict[str, Any]]:
+        """Convert a hybrid result object into a list of document dictionaries."""
+        return [convert_bytes(r) for r in results.results]
+
+
 class BaseSearchIndex:
     """Base search engine class"""
 
@@ -1003,6 +1022,23 @@ def search(self, *args, **kwargs) -> "Result":
         except Exception as e:
             raise RedisSearchError(f"Unexpected error while searching: {str(e)}") from e
 
+    if REDIS_HYBRID_AVAILABLE:
+
+        def hybrid_search(self, query: HybridQuery, **kwargs) -> List[Dict[str, Any]]:
+            results: HybridResult = self._redis_client.ft(
+                self.schema.index.name
+            ).hybrid_search(
+                query=query.query,
+                combine_method=query.combination_method,
+                post_processing=(
+                    query.postprocessing_config
+                    if query.postprocessing_config.build_args()
+                    else None
+                ),
+                **kwargs,
+            )  # type: ignore
+            return process_hybrid_results(results)
+
     def batch_query(
         self, queries: Sequence[BaseQuery], batch_size: int = 10
     ) -> List[List[Dict[str, Any]]]:

redisvl/query/aggregate.py

@@ -235,7 +235,7 @@ def _build_query_string(self) -> str:
         # Add distance field alias
         knn_query += f" AS {self.DISTANCE_ID}"
 
-        return f"{text})=>[{knn_query}]"
+        return f"{text}=>[{knn_query}]"
 
     def __str__(self) -> str:
         """Return the string representation of the query."""

redisvl/query/hybrid.py

@@ -2,14 +2,17 @@
 
 from redis.commands.search.query import Filter
 
+from redisvl.redis.utils import array_to_buffer
 from redisvl.utils.full_text_query_helper import FullTextQueryHelper
 
 try:
     from redis.commands.search.hybrid_query import (
         CombinationMethods,
         CombineResultsMethod,
         HybridPostProcessingConfig,
-        HybridQuery as RedisHybridQuery,
+    )
+    from redis.commands.search.hybrid_query import HybridQuery as RedisHybridQuery
+    from redis.commands.search.hybrid_query import (
         HybridSearchQuery,
         HybridVsimQuery,
         VectorSearchMethods,
@@ -41,22 +44,26 @@ def __init__(
         range_epsilon: Optional[float] = None,
         yield_vsim_score_as: Optional[str] = None,
         vector_filter_expression: Optional[Union[str, FilterExpression]] = None,
-        stopwords: Optional[Union[str, Set[str]]] = "english",
-        text_weights: Optional[Dict[str, float]] = None,
         combination_method: Optional[Literal["RRF", "LINEAR"]] = None,
         rrf_window: Optional[int] = None,
         rrf_constant: Optional[float] = None,
         linear_alpha: Optional[float] = None,
         linear_beta: Optional[float] = None,
         yield_combined_score_as: Optional[str] = None,
+        dtype: str = "float32",
+        num_results: Optional[int] = None,
+        return_fields: Optional[List[str]] = None,
+        stopwords: Optional[Union[str, Set[str]]] = "english",
+        text_weights: Optional[Dict[str, float]] = None,
     ):
         """
         Instantiates a HybridQuery object.
 
         Args:
             text: The text to search for.
             text_field_name: The text field name to search in.
-            vector: The vector to perform vector similarity search.
+            vector: The vector to perform vector similarity search, converted to bytes (e.g.
+                using `redisvl.redis.utils.array_to_buffer`).
             vector_field_name: The vector field name to search in.
             text_scorer: The text scorer to use. Options are {TFIDF, TFIDF.DOCNORM,
                 BM25STD, BM25STD.NORM, BM25STD.TANH, DISMAX, DOCSCORE, HAMMING}. Defaults to "BM25STD". For more
@@ -72,6 +79,17 @@ def __init__(
                 accuracy of the search.
             yield_vsim_score_as: The name of the field to yield the vector similarity score as.
             vector_filter_expression: The filter expression to use for the vector similarity search. Defaults to None.
+            combination_method: The combination method to use. Options are {RRF, LINEAR}. Defaults to None.
+            rrf_window: The window size to use for the reciprocal rank fusion (RRF) combination method. Limits
+                fusion scope.
+            rrf_constant: The constant to use for the reciprocal rank fusion (RRF) combination method. Controls decay
+                of rank influence.
+            linear_alpha: The weight of the first query for the linear combination method (LINEAR).
+            linear_beta: The weight of the second query for the linear combination method (LINEAR).
+            yield_combined_score_as: The name of the field to yield the combined score as.
+            dtype: The data type of the vector. Defaults to "float32".
+            num_results: The number of results to return. If not specified, the server default will be used (10).
+            return_fields: The fields to return. Defaults to None.
             stopwords (Optional[Union[str, Set[str]]], optional): The stopwords to remove from the
                 provided text prior to search-use. If a string such as "english" "german" is
                 provided then a default set of stopwords for that language will be used. if a list,
@@ -84,14 +102,6 @@ def __init__(
             text_weights (Optional[Dict[str, float]]): The importance weighting of individual words
                 within the query text. Defaults to None, as no modifications will be made to the
                 text_scorer score.
-            combination_method: The combination method to use. Options are {RRF, LINEAR}. Defaults to None.
-            rrf_window: The window size to use for the reciprocal rank fusion (RRF) combination method. Limits
-                fusion scope.
-            rrf_constant: The constant to use for the reciprocal rank fusion (RRF) combination method. Controls decay
-                of rank influence.
-            linear_alpha: The weight of the first query for the linear combination method (LINEAR).
-            linear_beta: The weight of the second query for the linear combination method (LINEAR).
-            yield_combined_score_as: The name of the field to yield the combined score as.
 
         Notes:
             If RRF combination method is used, then at least one of `rrf_window` or `rrf_constant` must be provided.
@@ -101,11 +111,16 @@ def __init__(
             TypeError: If the stopwords are not a set, list, or tuple of strings.
             ValueError: If the text string is empty, or if the text string becomes empty after
                 stopwords are removed.
-            ValueError: If `vector_search_method` is not one of {KNN, RANGE} (or None).
+            ValueError: If `vector_search_method` is defined and isn't one of {KNN, RANGE}.
             ValueError: If `vector_search_method` is "KNN" and `knn_k` is not provided.
             ValueError: If `vector_search_method` is "RANGE" and `range_radius` is not provided.
         """
         self.postprocessing_config = HybridPostProcessingConfig()
+        if num_results:
+            self.postprocessing_config.limit(offset=0, num=num_results)
+        if return_fields:
+            self.postprocessing_config.load(*(f"@{f}" for f in return_fields))
+
         self._ft_helper = FullTextQueryHelper(
             stopwords=stopwords,
             text_weights=text_weights,
@@ -128,6 +143,7 @@ def __init__(
             range_epsilon=range_epsilon,
             yield_vsim_score_as=yield_vsim_score_as,
             vector_filter_expression=vector_filter_expression,
+            dtype=dtype,
         )
 
         if combination_method:
@@ -147,7 +163,7 @@ def __init__(
     @staticmethod
     def build_query(
         text_query: str,
-        vector: Union[bytes, List[float]],
+        vector: bytes | List[float],
         vector_field_name: str,
         text_scorer: str = "BM25STD",
         yield_text_score_as: Optional[str] = None,
@@ -158,6 +174,7 @@ def build_query(
         range_epsilon: Optional[float] = None,
         yield_vsim_score_as: Optional[str] = None,
         vector_filter_expression: Optional[Union[str, FilterExpression]] = None,
+        dtype: str = "float32",
     ) -> RedisHybridQuery:
         """Build a Redis HybridQuery for the hybrid search."""
 
@@ -168,11 +185,10 @@ def build_query(
             yield_score_as=yield_text_score_as,
         )
 
-        # If the vector isn't already bytes, it needs to be represented as a string
-        if not isinstance(vector, bytes):
-            vector_data: Union[str, bytes] = str(vector)
-        else:
+        if isinstance(vector, bytes):
             vector_data = vector
+        else:
+            vector_data = array_to_buffer(vector, dtype)
 
         # Serialize vector similarity search method and params, if specified
         vsim_search_method: Optional[VectorSearchMethods] = None
@@ -205,7 +221,7 @@ def build_query(
 
         # Serialize the vector similarity query
         vsim_query = HybridVsimQuery(
-            vector_field_name=vector_field_name,
+            vector_field_name="@" + vector_field_name,
             vector_data=vector_data,
             vsim_search_method=vsim_search_method,
             vsim_search_method_params=vsim_search_method_params,
@@ -240,15 +256,27 @@ def build_combination_method(
             method = CombinationMethods.LINEAR
             if linear_alpha:
                 method_params["ALPHA"] = linear_alpha
+                if not linear_beta:
+                    method_params["BETA"] = 1 - linear_alpha
+
             if linear_beta:
+                if not linear_alpha:  # Defined first to preserve consistent ordering
+                    method_params["ALPHA"] = 1 - linear_beta
                 method_params["BETA"] = linear_beta
 
+            # TODO: Warn if alpha + beta != 1
+
         else:
             raise ValueError(f"Unknown combination method: {combination_method}")
 
         if yield_score_as:
             method_params["YIELD_SCORE_AS"] = yield_score_as
 
+        if not method_params:
+            raise ValueError(
+                "No parameters provided for combination method - must provide at least one parameter."
+            )
+
         return CombineResultsMethod(
             method=method,
             **method_params,

redisvl/utils/full_text_query_helper.py

@@ -69,7 +69,7 @@ def build_query_string(
         if filter_expression and filter_expression != "*":
             query += f" AND {filter_expression}"
 
-        return query
+        return query + ")"
 
     def _get_stopwords(
         self, stopwords: Optional[Union[str, Set[str]]] = "english"