Fix LangCache clear() to raise NotImplementedError instead of sending empty attributes

- Changed delete() and adelete() to raise NotImplementedError
- Added validation to delete_by_attributes() and adelete_by_attributes() to reject empty attributes
- Updated all related tests to verify new behavior
- Added new tests for delete_by_attributes with both valid and empty attributes

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

Author: Copilot

redisvl/extensions/cache/llm/langcache.py

@@ -536,18 +536,34 @@ async def aupdate(self, key: str, **kwargs) -> None:
     def delete(self) -> None:
         """Delete the entire cache.
 
-        This deletes all entries in the cache by calling delete_query
-        with no attributes.
+        Note: LangCache API does not support deleting all entries without
+        specific attributes. Use delete_by_attributes() to delete entries
+        matching specific criteria, or delete_by_id() to delete individual entries.
+
+        Raises:
+            NotImplementedError: LangCache does not support clearing all entries.
         """
-        self._client.delete_query(attributes={})
+        raise NotImplementedError(
+            "LangCache API does not support deleting all entries without attributes. "
+            "Use delete_by_attributes(attributes) to delete entries matching specific "
+            "criteria, or delete_by_id(entry_id) to delete individual entries."
+        )
 
     async def adelete(self) -> None:
         """Async delete the entire cache.
 
-        This deletes all entries in the cache by calling delete_query
-        with no attributes.
+        Note: LangCache API does not support deleting all entries without
+        specific attributes. Use adelete_by_attributes() to delete entries
+        matching specific criteria, or adelete_by_id() to delete individual entries.
+
+        Raises:
+            NotImplementedError: LangCache does not support clearing all entries.
         """
-        await self._client.delete_query_async(attributes={})
+        raise NotImplementedError(
+            "LangCache API does not support deleting all entries without attributes. "
+            "Use adelete_by_attributes(attributes) to delete entries matching specific "
+            "criteria, or adelete_by_id(entry_id) to delete individual entries."
+        )
 
     def clear(self) -> None:
         """Clear the cache of all entries.
@@ -584,10 +600,19 @@ def delete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
 
         Args:
             attributes (Dict[str, Any]): Attributes to match for deletion.
+                Cannot be empty.
 
         Returns:
             Dict[str, Any]: Result of the deletion operation.
+
+        Raises:
+            ValueError: If attributes is empty.
         """
+        if not attributes:
+            raise ValueError(
+                "attributes cannot be empty. Provide specific attributes to match, "
+                "or use delete_by_id(entry_id) to delete individual entries."
+            )
         result = self._client.delete_query(attributes=attributes)
         # Convert DeleteQueryResponse to dict
         return result.model_dump() if hasattr(result, "model_dump") else {}
@@ -597,10 +622,19 @@ async def adelete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, A
 
         Args:
             attributes (Dict[str, Any]): Attributes to match for deletion.
+                Cannot be empty.
 
         Returns:
             Dict[str, Any]: Result of the deletion operation.
+
+        Raises:
+            ValueError: If attributes is empty.
         """
+        if not attributes:
+            raise ValueError(
+                "attributes cannot be empty. Provide specific attributes to match, "
+                "or use adelete_by_id(entry_id) to delete individual entries."
+            )
         result = await self._client.delete_query_async(attributes=attributes)
         # Convert DeleteQueryResponse to dict
         return result.model_dump() if hasattr(result, "model_dump") else {}

tests/unit/test_langcache_semantic_cache.py

@@ -354,38 +354,63 @@ def test_check_with_empty_attributes_does_not_send_attributes(
             _, call_kwargs = mock_client.search.call_args
             assert "attributes" not in call_kwargs
 
-    def test_delete(self, mock_langcache_client):
-        """Test deleting the entire cache."""
-        _, mock_client = mock_langcache_client
-
+    def test_delete_not_supported(self, mock_langcache_client):
+        """Test that delete() raises NotImplementedError."""
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        cache.delete()
-
-        mock_client.delete_query.assert_called_once_with(attributes={})
+        with pytest.raises(
+            NotImplementedError, match="does not support deleting all entries"
+        ):
+            cache.delete()
 
     @pytest.mark.asyncio
-    async def test_adelete(self, mock_langcache_client):
-        """Test async deleting the entire cache."""
-        _, mock_client = mock_langcache_client
+    async def test_adelete_not_supported(self, mock_langcache_client):
+        """Test that async delete() raises NotImplementedError."""
+        cache = LangCacheSemanticCache(
+            name="test",
+            server_url="https://api.example.com",
+            cache_id="test-cache",
+            api_key="test-key",
+        )
 
-        mock_client.delete_query_async = AsyncMock()
+        with pytest.raises(
+            NotImplementedError, match="does not support deleting all entries"
+        ):
+            await cache.adelete()
 
+    def test_clear_not_supported(self, mock_langcache_client):
+        """Test that clear() raises NotImplementedError."""
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        await cache.adelete()
+        with pytest.raises(
+            NotImplementedError, match="does not support deleting all entries"
+        ):
+            cache.clear()
+
+    @pytest.mark.asyncio
+    async def test_aclear_not_supported(self, mock_langcache_client):
+        """Test that async clear() raises NotImplementedError."""
+        cache = LangCacheSemanticCache(
+            name="test",
+            server_url="https://api.example.com",
+            cache_id="test-cache",
+            api_key="test-key",
+        )
 
-        mock_client.delete_query_async.assert_called_once_with(attributes={})
+        with pytest.raises(
+            NotImplementedError, match="does not support deleting all entries"
+        ):
+            await cache.aclear()
 
     def test_delete_by_id(self, mock_langcache_client):
         """Test deleting a single entry by ID."""
@@ -402,6 +427,80 @@ def test_delete_by_id(self, mock_langcache_client):
 
         mock_client.delete_by_id.assert_called_once_with(entry_id="entry-123")
 
+    def test_delete_by_attributes_with_valid_attributes(self, mock_langcache_client):
+        """Test deleting entries by attributes with valid attributes."""
+        _, mock_client = mock_langcache_client
+
+        mock_response = MagicMock()
+        mock_response.model_dump.return_value = {"deleted_count": 5}
+        mock_client.delete_query.return_value = mock_response
+
+        cache = LangCacheSemanticCache(
+            name="test",
+            server_url="https://api.example.com",
+            cache_id="test-cache",
+            api_key="test-key",
+        )
+
+        result = cache.delete_by_attributes({"topic": "python"})
+
+        assert result == {"deleted_count": 5}
+        mock_client.delete_query.assert_called_once_with(attributes={"topic": "python"})
+
+    def test_delete_by_attributes_with_empty_attributes_raises_error(
+        self, mock_langcache_client
+    ):
+        """Test that delete_by_attributes raises ValueError with empty attributes."""
+        cache = LangCacheSemanticCache(
+            name="test",
+            server_url="https://api.example.com",
+            cache_id="test-cache",
+            api_key="test-key",
+        )
+
+        with pytest.raises(ValueError, match="attributes cannot be empty"):
+            cache.delete_by_attributes({})
+
+    @pytest.mark.asyncio
+    async def test_adelete_by_attributes_with_valid_attributes(
+        self, mock_langcache_client
+    ):
+        """Test async deleting entries by attributes with valid attributes."""
+        _, mock_client = mock_langcache_client
+
+        mock_response = MagicMock()
+        mock_response.model_dump.return_value = {"deleted_count": 3}
+        mock_client.delete_query_async = AsyncMock(return_value=mock_response)
+
+        cache = LangCacheSemanticCache(
+            name="test",
+            server_url="https://api.example.com",
+            cache_id="test-cache",
+            api_key="test-key",
+        )
+
+        result = await cache.adelete_by_attributes({"language": "python"})
+
+        assert result == {"deleted_count": 3}
+        mock_client.delete_query_async.assert_called_once_with(
+            attributes={"language": "python"}
+        )
+
+    @pytest.mark.asyncio
+    async def test_adelete_by_attributes_with_empty_attributes_raises_error(
+        self, mock_langcache_client
+    ):
+        """Test that async delete_by_attributes raises ValueError with empty attributes."""
+        cache = LangCacheSemanticCache(
+            name="test",
+            server_url="https://api.example.com",
+            cache_id="test-cache",
+            api_key="test-key",
+        )
+
+        with pytest.raises(ValueError, match="attributes cannot be empty"):
+            await cache.adelete_by_attributes({})
+
     def test_update_not_supported(self, mock_langcache_client):
         """Test that update raises NotImplementedError."""
         cache = LangCacheSemanticCache(