Use flush() API to delete all entries instead of delete_query with empty attributes

- Changed delete() to use self._client.flush() instead of raising NotImplementedError
- Changed adelete() to use self._client.flush_async()
- Updated error messages in delete_by_attributes to suggest using delete()/clear()
- Updated all tests to verify flush() is called
- This fixes the 400 error by using the proper API endpoint for clearing all entries

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

Author: Copilot

redisvl/extensions/cache/llm/langcache.py

@@ -536,34 +536,16 @@ async def aupdate(self, key: str, **kwargs) -> None:
     def delete(self) -> None:
         """Delete the entire cache.
 
-        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.
+        This deletes all entries in the cache by calling the flush API.
         """
-        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."
-        )
+        self._client.flush()
 
     async def adelete(self) -> None:
         """Async delete the entire cache.
 
-        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.
+        This deletes all entries in the cache by calling the flush API.
         """
-        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."
-        )
+        await self._client.flush_async()
 
     def clear(self) -> None:
         """Clear the cache of all entries.
@@ -611,6 +593,7 @@ def delete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
         if not attributes:
             raise ValueError(
                 "attributes cannot be empty. Provide specific attributes to match, "
+                "use delete() or clear() to delete all entries, "
                 "or use delete_by_id(entry_id) to delete individual entries."
             )
         result = self._client.delete_query(attributes=attributes)
@@ -633,6 +616,7 @@ async def adelete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, A
         if not attributes:
             raise ValueError(
                 "attributes cannot be empty. Provide specific attributes to match, "
+                "use adelete() or aclear() to delete all entries, "
                 "or use adelete_by_id(entry_id) to delete individual entries."
             )
         result = await self._client.delete_query_async(attributes=attributes)

tests/unit/test_langcache_semantic_cache.py

@@ -354,63 +354,71 @@ 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_not_supported(self, mock_langcache_client):
-        """Test that delete() raises NotImplementedError."""
+    def test_delete(self, mock_langcache_client):
+        """Test deleting the entire cache using flush()."""
+        _, mock_client = mock_langcache_client
+
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        with pytest.raises(
-            NotImplementedError, match="does not support deleting all entries"
-        ):
-            cache.delete()
+        cache.delete()
+
+        mock_client.flush.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_adelete_not_supported(self, mock_langcache_client):
-        """Test that async delete() raises NotImplementedError."""
+    async def test_adelete(self, mock_langcache_client):
+        """Test async deleting the entire cache using flush()."""
+        _, mock_client = mock_langcache_client
+
+        mock_client.flush_async = AsyncMock()
+
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        with pytest.raises(
-            NotImplementedError, match="does not support deleting all entries"
-        ):
-            await cache.adelete()
+        await cache.adelete()
+
+        mock_client.flush_async.assert_called_once()
+
+    def test_clear(self, mock_langcache_client):
+        """Test that clear() calls delete() which uses flush()."""
+        _, mock_client = mock_langcache_client
 
-    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",
         )
 
-        with pytest.raises(
-            NotImplementedError, match="does not support deleting all entries"
-        ):
-            cache.clear()
+        cache.clear()
+
+        mock_client.flush.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_aclear_not_supported(self, mock_langcache_client):
-        """Test that async clear() raises NotImplementedError."""
+    async def test_aclear(self, mock_langcache_client):
+        """Test that async clear() calls adelete() which uses flush()."""
+        _, mock_client = mock_langcache_client
+
+        mock_client.flush_async = AsyncMock()
+
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        with pytest.raises(
-            NotImplementedError, match="does not support deleting all entries"
-        ):
-            await cache.aclear()
+        await cache.aclear()
+
+        mock_client.flush_async.assert_called_once()
 
     def test_delete_by_id(self, mock_langcache_client):
         """Test deleting a single entry by ID."""