Use AggregateHybridQuery instead of HybridQuery for backward compatibility

Replace HybridQuery with AggregateHybridQuery to preserve existing functionality that works with older Redis versions. The new HybridQuery in redisvl 0.14.0 requires Redis 8.4.0+ and uses a different API, while AggregateHybridQuery maintains compatibility with the original implementation.

Co-authored-by: TaoChenOSU <[email protected]>

Author: Copilot

python/CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- **agent-framework-redis**: Fix `RedisContextProvider` compatibility with redisvl 0.14.0 by using `linear_alpha` parameter ([#3954](https://github.com/microsoft/agent-framework/pull/3954))
+- **agent-framework-redis**: Fix `RedisContextProvider` compatibility with redisvl 0.14.0 by using `AggregateHybridQuery` ([#3954](https://github.com/microsoft/agent-framework/pull/3954))
 
 ## [1.0.0b260212] - 2026-02-12
 

python/packages/redis/agent_framework_redis/_context_provider.py

@@ -23,7 +23,7 @@
     ServiceInvalidRequestError,
 )
 from redisvl.index import AsyncSearchIndex
-from redisvl.query import HybridQuery, TextQuery
+from redisvl.query import AggregateHybridQuery, TextQuery
 from redisvl.query.filter import FilterExpression, Tag
 from redisvl.utils.token_escaper import TokenEscaper
 from redisvl.utils.vectorize import BaseVectorizer
@@ -366,14 +366,14 @@ async def _redis_search(
         try:
             if self.redis_vectorizer and self.vector_field_name:
                 vector = await self.redis_vectorizer.aembed(q)
-                query = HybridQuery(
+                query = AggregateHybridQuery(
                     text=q,
                     text_field_name="content",
                     vector=vector,
                     vector_field_name=self.vector_field_name,
                     text_scorer=text_scorer,
                     filter_expression=combined_filter,
-                    linear_alpha=alpha,
+                    alpha=alpha,
                     dtype=self.redis_vectorizer.dtype,
                     num_results=num_results,
                     return_fields=return_fields,

python/packages/redis/tests/test_providers.py

@@ -241,14 +241,14 @@ async def test_aenter_returns_self(self, patch_index_from_dict: MagicMock):  # n
 
 
 class TestRedisContextProviderHybridQuery:
-    """Test for HybridQuery parameter compatibility with redisvl 0.14.0."""
+    """Test for AggregateHybridQuery parameter compatibility with redisvl 0.14.0."""
 
-    async def test_hybrid_query_uses_linear_alpha(
+    async def test_aggregate_hybrid_query_uses_alpha(
         self,
         mock_index: AsyncMock,
         patch_index_from_dict: MagicMock,  # noqa: ARG002 - fixture modifies behavior via side effects
     ):
-        """Ensure HybridQuery is called with linear_alpha parameter for redisvl 0.14.0+."""
+        """Ensure AggregateHybridQuery is called with alpha parameter for backward compatibility."""
         from redisvl.utils.vectorize import BaseVectorizer
 
         # Create a mock vectorizer that inherits from BaseVectorizer
@@ -267,16 +267,17 @@ async def test_hybrid_query_uses_linear_alpha(
         )
 
         # Call _redis_search with custom alpha
-        with patch("agent_framework_redis._context_provider.HybridQuery") as mock_hybrid_query:
+        with patch("agent_framework_redis._context_provider.AggregateHybridQuery") as mock_hybrid_query:
             mock_hybrid_query.return_value = MagicMock()
             await provider._redis_search(text="test query", alpha=0.5)
 
-            # Verify HybridQuery was called with linear_alpha, not alpha
+            # Verify AggregateHybridQuery was called with alpha parameter
             mock_hybrid_query.assert_called_once()
             call_kwargs = mock_hybrid_query.call_args.kwargs
-            assert "linear_alpha" in call_kwargs
-            assert call_kwargs["linear_alpha"] == 0.5
-            assert "alpha" not in call_kwargs
+            assert "alpha" in call_kwargs
+            assert call_kwargs["alpha"] == 0.5
+            # linear_alpha should NOT be in the call (that's for the new HybridQuery)
+            assert "linear_alpha" not in call_kwargs
 
 
 # ===========================================================================