LangCache: avoid sending empty attributes/metadata; add tests; ignore .ai

Author: abrookins

redisvl/extensions/cache/llm/langcache.py

@@ -47,7 +47,7 @@ class LangCacheSemanticCache(BaseLLMCache):
     def __init__(
         self,
         name: str = "langcache",
-        server_url: str = "https://api.langcache.com",
+        server_url: str = "https://aws-us-east-1.langcache.redis.io",
         cache_id: str = "",
         api_key: str = "",
         ttl: Optional[int] = None,
@@ -56,7 +56,7 @@ def __init__(
         distance_scale: Literal["normalized", "redis"] = "normalized",
         **kwargs,
     ):
-        """Initialize a LangCache wrapper.
+        """Initialize a LangCache semantic cache.
 
         Args:
             name (str): The name of the cache. Defaults to "langcache".
@@ -108,20 +108,20 @@ def _create_client(self):
         Initialize the LangCache client.
 
         Returns:
-            LangCacheClient: The LangCache client.
+            LangCache: The LangCache client.
 
         Raises:
             ImportError: If the langcache package is not installed.
         """
         try:
-            from langcache import LangCacheClient
+            from langcache import LangCache
         except ImportError as e:
             raise ImportError(
                 "The langcache package is required to use LangCacheSemanticCache. "
                 "Install it with: pip install langcache"
             ) from e
 
-        return LangCacheClient(
+        return LangCache(
             server_url=self._server_url,
             cache_id=self._cache_id,
             api_key=self._api_key,
@@ -155,6 +155,8 @@ def _build_search_kwargs(
             SearchStrategy.EXACT if "exact" in self._search_strategies else None,
             SearchStrategy.SEMANTIC if "semantic" in self._search_strategies else None,
         ]
+        # Filter out Nones to avoid sending invalid enum values
+        search_strategies = [s for s in search_strategies if s is not None]
         kwargs: Dict[str, Any] = {
             "prompt": prompt,
             "search_strategies": search_strategies,
@@ -253,15 +255,31 @@ def check(
         if distance_threshold is not None:
             similarity_threshold = self._similarity_threshold(distance_threshold)
 
-        # Search using the LangCache client
-        # The client itself is the context manager
+        # Build kwargs
         search_kwargs = self._build_search_kwargs(
             prompt=prompt,
             similarity_threshold=similarity_threshold,
             attributes=attributes,
         )
 
-        response = self._client.search(**search_kwargs)
+        try:
+            response = self._client.search(**search_kwargs)
+        except Exception as e:
+            try:
+                from langcache.errors import BadRequestErrorResponseContent
+            except Exception:
+                raise
+            if (
+                isinstance(e, BadRequestErrorResponseContent)
+                and "no attributes are configured" in str(e).lower()
+                and attributes
+            ):
+                raise RuntimeError(
+                    "LangCache reported attributes are not configured for this cache, "
+                    "but attributes were provided to check(). Remove attributes or configure them on the cache."
+                ) from e
+            else:
+                raise
 
         # Convert results to cache hits
         return self._hits_from_response(response, num_results)
@@ -321,7 +339,24 @@ async def acheck(
 
         # Add attributes if provided (already handled by builder)
 
-        response = await self._client.search_async(**search_kwargs)
+        try:
+            response = await self._client.search_async(**search_kwargs)
+        except Exception as e:
+            try:
+                from langcache.errors import BadRequestErrorResponseContent
+            except Exception:
+                raise
+            if (
+                isinstance(e, BadRequestErrorResponseContent)
+                and "no attributes are configured" in str(e).lower()
+                and attributes
+            ):
+                raise RuntimeError(
+                    "LangCache reported attributes are not configured for this cache, "
+                    "but attributes were provided to acheck(). Remove attributes or configure them on the cache."
+                ) from e
+            else:
+                raise
 
         # Convert results to cache hits
         return self._hits_from_response(response, num_results)
@@ -365,16 +400,30 @@ def store(
         if ttl is not None:
             logger.warning("LangCache does not support per-entry TTL")
 
-        # Store using the LangCache client
-        # The client itself is the context manager
-        # Only pass attributes if metadata is provided
-        # Some caches may not have attributes configured
-        if metadata:
-            result = self._client.set(
-                prompt=prompt, response=response, attributes=metadata
-            )
-        else:
-            result = self._client.set(prompt=prompt, response=response)
+        # Store using the LangCache client; only send attributes if provided (non-empty)
+        try:
+            if metadata:
+                result = self._client.set(
+                    prompt=prompt, response=response, attributes=metadata
+                )
+            else:
+                result = self._client.set(prompt=prompt, response=response)
+        except Exception as e:  # narrow for known SDK error when possible
+            try:
+                from langcache.errors import BadRequestErrorResponseContent
+            except Exception:
+                raise
+            if (
+                isinstance(e, BadRequestErrorResponseContent)
+                and "no attributes are configured" in str(e).lower()
+                and metadata
+            ):
+                raise RuntimeError(
+                    "LangCache reported attributes are not configured for this cache, "
+                    "but metadata was provided to store(). Remove metadata or configure attributes on the cache."
+                ) from e
+            else:
+                raise
 
         # Return the entry ID
         # Result is a SetResponse Pydantic model with entry_id attribute
@@ -419,16 +468,30 @@ async def astore(
         if ttl is not None:
             logger.warning("LangCache does not support per-entry TTL")
 
-        # Store using the LangCache client (async)
-        # The client itself is the context manager
-        # Only pass attributes if metadata is provided
-        # Some caches may not have attributes configured
-        if metadata:
-            result = await self._client.set_async(
-                prompt=prompt, response=response, attributes=metadata
-            )
-        else:
-            result = await self._client.set_async(prompt=prompt, response=response)
+        # Store using the LangCache client (async); only send attributes if provided (non-empty)
+        try:
+            if metadata:
+                result = await self._client.set_async(
+                    prompt=prompt, response=response, attributes=metadata
+                )
+            else:
+                result = await self._client.set_async(prompt=prompt, response=response)
+        except Exception as e:
+            try:
+                from langcache.errors import BadRequestErrorResponseContent
+            except Exception:
+                raise
+            if (
+                isinstance(e, BadRequestErrorResponseContent)
+                and "no attributes are configured" in str(e).lower()
+                and metadata
+            ):
+                raise RuntimeError(
+                    "LangCache reported attributes are not configured for this cache, "
+                    "but metadata was provided to astore(). Remove metadata or configure attributes on the cache."
+                ) from e
+            else:
+                raise
 
         # Return the entry ID
         # Result is a SetResponse Pydantic model with entry_id attribute

tests/unit/test_langcache_semantic_cache.py

@@ -292,6 +292,68 @@ def test_check_with_attributes(self, mock_langcache_client):
             "topic": "programming",
         }
 
+        def test_store_with_empty_metadata_does_not_send_attributes(
+            self, mock_langcache_client
+        ):
+            """Empty metadata {} should not be forwarded as attributes to the SDK."""
+            _, mock_client = mock_langcache_client
+
+            mock_response = MagicMock()
+            mock_response.entry_id = "entry-empty"
+            mock_client.set.return_value = mock_response
+
+            cache = LangCacheSemanticCache(
+                name="test",
+                server_url="https://api.example.com",
+                cache_id="test-cache",
+                api_key="test-key",
+            )
+
+            entry_id = cache.store(
+                prompt="Q?",
+                response="A",
+                metadata={},  # should be ignored
+            )
+
+            assert entry_id == "entry-empty"
+            # Ensure attributes kwarg was NOT sent when metadata is {}
+            _, call_kwargs = mock_client.set.call_args
+            assert "attributes" not in call_kwargs
+
+        def test_check_with_empty_attributes_does_not_send_attributes(
+            self, mock_langcache_client
+        ):
+            """Empty attributes {} should not be forwarded to the SDK search call."""
+            _, mock_client = mock_langcache_client
+
+            mock_entry = MagicMock()
+            mock_entry.model_dump.return_value = {
+                "id": "e1",
+                "prompt": "Q?",
+                "response": "A",
+                "similarity": 1.0,
+                "created_at": 0.0,
+                "updated_at": 0.0,
+                "attributes": {},
+            }
+            mock_response = MagicMock()
+            mock_response.data = [mock_entry]
+            mock_client.search.return_value = mock_response
+
+            cache = LangCacheSemanticCache(
+                name="test",
+                server_url="https://api.example.com",
+                cache_id="test-cache",
+                api_key="test-key",
+            )
+
+            results = cache.check(prompt="Q?", attributes={})  # should be ignored
+            assert results and results[0]["entry_id"] == "e1"
+
+            # Ensure attributes kwarg was NOT sent when attributes is {}
+            _, 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