Use a TAG field for instance names

Author: abrookins

redis_sre_agent/core/instances.py

@@ -16,7 +16,7 @@
 
 from pydantic import BaseModel, Field, SecretStr, field_serializer, field_validator
 from redisvl.query import CountQuery, FilterQuery
-from redisvl.query.filter import Tag, Text
+from redisvl.query.filter import Tag
 
 from .encryption import encrypt_secret, get_secret_value
 from .keys import RedisKeys
@@ -414,8 +414,8 @@ async def query_instances(
             filter_expr = user_filter if filter_expr is None else (filter_expr & user_filter)
 
         if search:
-            # Text search on name field (supports prefix matching)
-            name_filter = Text("name") % f"*{search}*"
+            # Tag filter on name field with wildcard for partial matching
+            name_filter = Tag("name") == f"*{search}*"
             filter_expr = name_filter if filter_expr is None else (filter_expr & name_filter)
 
         # Get total count with filter
@@ -787,13 +787,12 @@ async def get_instance_by_name(instance_name: str) -> Optional[RedisInstance]:
         await _ensure_instances_index_exists()
         index = await get_instances_index()
 
-        # Use exact text match on name field
-        # Note: name is indexed as TEXT, so we search for the exact term
+        # Use exact tag match on name field
         fq = FilterQuery(
             return_fields=["data"],
             num_results=1,
         )
-        fq.set_filter(Text("name") % instance_name)
+        fq.set_filter(Tag("name") == instance_name)
 
         results = await index.query(fq)
 

redis_sre_agent/core/redis.py

@@ -188,7 +188,7 @@
         "storage_type": "hash",
     },
     "fields": [
-        {"name": "name", "type": "text"},
+        {"name": "name", "type": "tag"},
         {"name": "environment", "type": "tag"},
         {"name": "usage", "type": "tag"},
         {"name": "instance_type", "type": "tag"},

tests/unit/api/test_instances_api.py

@@ -108,6 +108,73 @@ def test_list_instances_with_filters(self, client, sample_instance):
             assert call_kwargs["limit"] == 50
             assert call_kwargs["offset"] == 10
 
+    def test_list_instances_with_search(self, client, sample_instance):
+        """Test instance listing with search parameter."""
+        mock_result = InstanceQueryResult(
+            instances=[sample_instance],
+            total=1,
+            limit=100,
+            offset=0,
+        )
+
+        with patch("redis_sre_agent.core.instances.query_instances") as mock_query:
+            mock_query.return_value = mock_result
+
+            response = client.get(
+                "/api/v1/instances",
+                params={"search": "test-redis"},
+            )
+
+            assert response.status_code == 200
+            mock_query.assert_called_once()
+            call_kwargs = mock_query.call_args[1]
+            assert call_kwargs["search"] == "test-redis"
+
+    def test_list_instances_with_empty_search(self, client, sample_instance):
+        """Test instance listing with empty search string."""
+        mock_result = InstanceQueryResult(
+            instances=[sample_instance],
+            total=1,
+            limit=100,
+            offset=0,
+        )
+
+        with patch("redis_sre_agent.core.instances.query_instances") as mock_query:
+            mock_query.return_value = mock_result
+
+            response = client.get(
+                "/api/v1/instances",
+                params={"search": ""},
+            )
+
+            assert response.status_code == 200
+            mock_query.assert_called_once()
+            call_kwargs = mock_query.call_args[1]
+            # Empty string should be passed as empty (falsy)
+            assert call_kwargs["search"] == ""
+
+    def test_list_instances_with_instance_type_filter(self, client, sample_instance):
+        """Test instance listing with instance_type filter."""
+        mock_result = InstanceQueryResult(
+            instances=[sample_instance],
+            total=1,
+            limit=100,
+            offset=0,
+        )
+
+        with patch("redis_sre_agent.core.instances.query_instances") as mock_query:
+            mock_query.return_value = mock_result
+
+            response = client.get(
+                "/api/v1/instances",
+                params={"instance_type": "redis_cloud"},
+            )
+
+            assert response.status_code == 200
+            mock_query.assert_called_once()
+            call_kwargs = mock_query.call_args[1]
+            assert call_kwargs["instance_type"] == "redis_cloud"
+
     def test_get_instance_success(self, client, sample_instance):
         """Test successful instance retrieval."""
         with patch("redis_sre_agent.core.instances.get_instances") as mock_get:

tests/unit/mcp_server/test_mcp_server.py

@@ -423,6 +423,43 @@ async def test_list_instances_with_filters(self):
             assert result["total"] == 1
             assert result["instances"][0]["environment"] == "production"
 
+    @pytest.mark.asyncio
+    async def test_list_instances_with_search(self):
+        """Test instance listing with search parameter."""
+        from redis_sre_agent.core.instances import InstanceQueryResult
+
+        mock_instance = MagicMock()
+        mock_instance.id = "redis-prod-1"
+        mock_instance.name = "Production Redis"
+        mock_instance.environment = "production"
+        mock_instance.usage = "cache"
+        mock_instance.description = "Main cache"
+        mock_instance.instance_type = "redis_cloud"
+        mock_instance.repo_url = None
+
+        mock_result = InstanceQueryResult(
+            instances=[mock_instance],
+            total=1,
+            limit=100,
+            offset=0,
+        )
+
+        with patch(
+            "redis_sre_agent.core.instances.query_instances",
+            new_callable=AsyncMock,
+        ) as mock_query:
+            mock_query.return_value = mock_result
+
+            result = await redis_sre_list_instances(search="Production")
+
+            # Verify query_instances was called with the search parameter
+            mock_query.assert_called_once()
+            call_kwargs = mock_query.call_args[1]
+            assert call_kwargs["search"] == "Production"
+
+            assert result["total"] == 1
+            assert result["instances"][0]["name"] == "Production Redis"
+
     @pytest.mark.asyncio
     async def test_list_instances_error(self):
         """Test list instances error handling."""

ui/src/pages/Instances.tsx

@@ -812,7 +812,6 @@ const AddInstanceForm = ({
 
 const Instances = () => {
   const [instances, setInstances] = useState<RedisInstance[]>([]);
-  const [totalCount, setTotalCount] = useState(0);
   const [isLoading, setIsLoading] = useState(true);
   const [isRefreshing, setIsRefreshing] = useState(false);
   const [error, setError] = useState("");
@@ -878,12 +877,10 @@ const Instances = () => {
         response.instances.map(convertToUIInstance);
 
       setInstances(uiInstances);
-      setTotalCount(response.total);
     } catch (err) {
       setError("Failed to load Redis instances. Please try again.");
       console.error("Error loading instances:", err);
       setInstances([]);
-      setTotalCount(0);
     } finally {
       setIsLoading(false);
     }