Add async-specific cluster mode detection

Author: abrookins

langgraph/store/redis/aio.py

@@ -45,6 +45,7 @@
     _row_to_item,
     _row_to_search_item,
     get_key_with_hash_tag,
+    logger,
 )
 
 from .token_unescaper import TokenUnescaper
@@ -176,6 +177,9 @@ def configure_client(
         else:
             self._redis = redis_client
 
+        # Initialize cluster_mode to False, will be set properly in setup()
+        self.cluster_mode = False
+
     async def setup(self) -> None:
         """Initialize store indices."""
         # Handle embeddings in same way as sync store
@@ -184,11 +188,31 @@ async def setup(self) -> None:
                 self.index_config.get("embed"),
             )
 
+        # Detect if we're connected to a Redis cluster
+        await self.detect_cluster_mode()
+
         # Create indices in Redis
         await self.store_index.create(overwrite=False)
         if self.index_config:
             await self.vector_index.create(overwrite=False)
 
+    async def detect_cluster_mode(self) -> None:
+        """Detect if the Redis client is a cluster client.
+
+        This is the async version of the cluster mode detection logic in BaseRedisStore.__init__.
+        """
+        from redis.exceptions import ResponseError
+
+        try:
+            # Try to run a cluster command
+            # This will succeed for cluster clients and fail for non-cluster clients
+            await self._redis.cluster("info")
+            self.cluster_mode = True
+            logger.info("Redis cluster mode detected")
+        except (ResponseError, AttributeError):
+            self.cluster_mode = False
+            logger.info("Redis standalone mode detected")
+
     # This can't be properly typed due to covariance issues with async methods
     async def _apply_ttl_to_keys(
         self,

langgraph/store/redis/base.py

@@ -25,6 +25,7 @@
 )
 from redis import Redis
 from redis.asyncio import Redis as AsyncRedis
+from redis.exceptions import ResponseError
 from redisvl.index import SearchIndex
 from redisvl.query.filter import Tag, Text
 from redisvl.utils.token_escaper import TokenEscaper
@@ -211,9 +212,6 @@ def __init__(
         self.ttl_config = ttl  # type: ignore
         self.embeddings: Optional[Embeddings] = None
 
-        # Detect if Redis client is a cluster client
-        from redis.exceptions import ResponseError
-
         try:
             # Try to run a cluster command
             # This will succeed for cluster clients and fail for non-cluster clients

tests/test_async_cluster_mode.py

@@ -29,15 +29,6 @@ def __init__(self, *args, **kwargs):
         self.delete_calls = []
         self.json_get_calls = []
 
-    def cluster(self, command, *args, **kwargs):
-        """Mock synchronous cluster command that returns cluster info.
-
-        This is called by BaseRedisStore.__init__ to detect cluster mode.
-        """
-        if command == "info":
-            return {"cluster_state": "ok"}
-        raise ResponseError(f"Unknown cluster command: {command}")
-
     async def cluster(self, command, *args, **kwargs):  # type: ignore
         """Mock asynchronous cluster command that returns cluster info.
 
@@ -125,9 +116,12 @@ async def async_cluster_store(mock_async_redis_cluster):
     # Create a store with the mock Redis client
     # Pass the mock client explicitly as redis_client to avoid URL parsing
     async with AsyncRedisStore(redis_client=mock_async_redis_cluster) as store:
-        # Manually set cluster_mode to True for testing
-        # This bypasses the automatic detection which is hard to mock in async context
-        store.cluster_mode = True
+        # The cluster_mode will be automatically detected during setup
+        # Call setup to ensure cluster mode is detected
+        await store.detect_cluster_mode()
+
+        # Verify that cluster mode was detected
+        assert store.cluster_mode is True
 
         # Mock the store_index and vector_index
         mock_index = AsyncMock()
@@ -145,16 +139,32 @@ async def async_cluster_store(mock_async_redis_cluster):
 
 @pytest.mark.asyncio
 async def test_async_cluster_mode_detection(mock_async_redis_cluster):
-    """Test that cluster mode can be manually set."""
+    """Test that cluster mode is automatically detected."""
     # Pass the mock client explicitly as redis_client to avoid URL parsing
     async with AsyncRedisStore(redis_client=mock_async_redis_cluster) as store:
-        # Manually set cluster_mode for testing
-        store.cluster_mode = True
+        # Cluster mode should be initialized to False
+        assert store.cluster_mode is False
+
+        # Call detect_cluster_mode to detect cluster mode
+        await store.detect_cluster_mode()
+
+        # Cluster mode should be detected as True
         assert store.cluster_mode is True
 
-        # Test with cluster_mode set to False
-        store.cluster_mode = False
-        assert store.cluster_mode is False
+        # Test with a non-cluster Redis client by patching the cluster method
+        with patch.object(
+            mock_async_redis_cluster,
+            "cluster",
+            side_effect=ResponseError("cluster command not allowed"),
+        ):
+            # Reset cluster_mode to False
+            store.cluster_mode = False
+
+            # Call detect_cluster_mode again
+            await store.detect_cluster_mode()
+
+            # Cluster mode should remain False
+            assert store.cluster_mode is False
 
 
 @pytest.mark.asyncio