Pin redisvl to 0.11.1

Author: abrookins

libs/redis/langchain_redis/cache.py

@@ -720,37 +720,6 @@ async def aclear(self, **kwargs: Any) -> None:
         await self.cache.aclear()
 
 
-_LLM_STRING_ENCODE_TRANS = str.maketrans(
-    {
-        ",": "，",  # FULLWIDTH COMMA, U+FF0C
-        "/": "∕",  # DIVISION SLASH, U+2215
-    }
-)
-
-
-def _encode_llm_string_for_attributes(llm_string: str) -> str:
-    """Encode an llm_string for use as a LangCache attribute value.
-
-    LangCache enforces validation rules on the ``llm_string`` attribute:
-
-    - It cannot contain commas (",") – attempts to store such values
-      result in ``400 Bad Request`` responses from the LangCache API.
-    - Attribute filtering on ``llm_string`` does not reliably match values
-      containing slashes ("/") even though they can be stored.
-
-    To ensure round-trippable, attribute-filterable values, we replace these
-    characters with visually similar Unicode variants that are accepted by
-    LangCache and precompute a translation table so we only scan the string
-    once.
-
-    The encoded value is only used for attribute storage and filtering; the
-    original ``llm_string`` is preserved inside the serialized Generation
-    payload, so no decoding step is required.
-    """
-
-    return llm_string.translate(_LLM_STRING_ENCODE_TRANS)
-
-
 class LangCacheSemanticCache(BaseCache):
     """Managed LangCache-backed semantic cache.
 
@@ -851,12 +820,11 @@ def __init__(
 
     def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
         """Lookup using LangCache's check API."""
-        safe_llm_string = _encode_llm_string_for_attributes(llm_string)
         results = self.cache.check(
             prompt=prompt,
             num_results=1,
             distance_threshold=self._distance_threshold,
-            attributes={"llm_string": safe_llm_string},
+            attributes={"llm_string": llm_string},
         )
         return self._process_lookup_results(results, llm_string)
 
@@ -879,12 +847,11 @@ def _process_lookup_results(
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
         """Store using LangCache's store API via redisvl wrapper."""
         serialized_response = json.dumps([dumps(gen) for gen in return_val])
-        safe_llm_string = _encode_llm_string_for_attributes(llm_string)
         # LangCacheSemanticCache ignores per-entry TTL; it uses cache-level TTL if set
         self.cache.store(
             prompt=prompt,
             response=serialized_response,
-            metadata={"llm_string": safe_llm_string},
+            metadata={"llm_string": llm_string},
             ttl=self.ttl,
         )
 
@@ -897,12 +864,11 @@ def name(self) -> str:
 
     async def alookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
         """Async lookup through LangCache's acheck API."""
-        safe_llm_string = _encode_llm_string_for_attributes(llm_string)
         results = await self.cache.acheck(
             prompt=prompt,
             num_results=1,
             distance_threshold=self._distance_threshold,
-            attributes={"llm_string": safe_llm_string},
+            attributes={"llm_string": llm_string},
         )
         return self._process_lookup_results(results, llm_string)
 
@@ -911,11 +877,10 @@ async def aupdate(
     ) -> None:
         """Async store using LangCache's astore API via redisvl wrapper."""
         serialized_response = json.dumps([dumps(gen) for gen in return_val])
-        safe_llm_string = _encode_llm_string_for_attributes(llm_string)
         await self.cache.astore(
             prompt=prompt,
             response=serialized_response,
-            metadata={"llm_string": safe_llm_string},
+            metadata={"llm_string": llm_string},
             ttl=self.ttl,
         )
 

libs/redis/poetry.lock

@@ -13,7 +13,7 @@ license = "MIT"
 [tool.poetry.dependencies]
 python = ">=3.10,<3.14"
 langchain-core = "^1.0"
-redisvl = ">=0.11.0,<1.0.0"
+redisvl = ">=0.11.1"
 jinja2 = "^3.1.6"
 typing-extensions = "^4.13.2"
 anyio = "^4.9.0"

libs/redis/pyproject.toml

@@ -156,7 +156,6 @@ async def test_async_update_and_lookup_roundtrip(
         assert len(hits) == 1
         assert hits[0].text == "Redis is an in-memory data store (async)."
 
-    @pytest.mark.skip("Waiting on upstream RedisVL release to fix")
     def test_clear_removes_entries(
         self, langcache_with_attrs: LangCacheSemanticCache
     ) -> None:
@@ -189,118 +188,25 @@ async def test_aclear_removes_entries(
         await langcache_with_attrs.aclear()
         assert await langcache_with_attrs.alookup(prompt, llm_string) is None
 
-    def test_llm_string_with_comma_roundtrip(
-        self, langcache_with_attrs: LangCacheSemanticCache
-    ) -> None:
-        """llm_string values containing commas should still round-trip.
-
-        The client encodes commas as a fullwidth comma when sending attributes
-        to LangCache for validation/filtering, but lookup() should continue to
-        work when called with the original llm_string containing commas.
-        """
 
-        prompt = "Comma llm_string (sync)"
-        llm_string = "openai/gpt-4o,temperature=0.2,max_tokens=128"
-        result = [Generation(text="Response for llm_string with commas (sync).")]
-
-        langcache_with_attrs.update(prompt, llm_string, result)
-        hits = langcache_with_attrs.lookup(prompt, llm_string)
+    @pytest.mark.requires_api_keys
+    class TestLangCacheSemanticCacheIntegrationWithoutAttributes:
+        def test_update_errors_when_no_attributes_configured(
+            self, langcache_no_attrs: LangCacheSemanticCache
+        ) -> None:
+            """update() should raise if attributes are not configured on the cache."""
 
-        assert hits is not None
-        assert len(hits) == 1
-        assert hits[0].text == "Response for llm_string with commas (sync)."
-
-    @pytest.mark.asyncio
-    async def test_llm_string_with_comma_roundtrip_async(
-        self, langcache_with_attrs: LangCacheSemanticCache
-    ) -> None:
-        """Async variant of the comma llm_string round-trip test."""
+            prompt = "Attributes not configured (sync)"
+            llm_string = "langchain-redis/tests:no-attributes:sync"
 
-        prompt = "Comma llm_string (async)"
-        llm_string = "openai/gpt-4o,temperature=0.3,max_tokens=256"
-        result = [Generation(text="Response for llm_string with commas (async).")]
-
-        await langcache_with_attrs.aupdate(prompt, llm_string, result)
-        hits = await langcache_with_attrs.alookup(prompt, llm_string)
-
-        assert hits is not None
-        assert len(hits) == 1
-        assert hits[0].text == "Response for llm_string with commas (async)."
-
-
-@pytest.mark.requires_api_keys
-class TestRedisVLLangCacheDirectWithoutAttributes:
-    """Direct redisvl client behavior without llm_string attribute filters.
-
-    These tests verify that the underlying LangCache instance used for
-    "with attributes" scenarios can successfully round-trip entries when
-    we do *not* send any attributes in the search request. This helps
-    distinguish adapter-level issues (llm_string attribute handling) from
-    underlying LangCache behavior.
-    """
-
-    def test_direct_store_and_check_without_attributes(
-        self, rv_langcache_with_attrs: "RedisVLLangCacheSemanticCache"
-    ) -> None:
-        """Store and retrieve using the redisvl client, no attributes filter."""
+            with pytest.raises(RuntimeError) as exc:
+                langcache_no_attrs.update(
+                    prompt,
+                    llm_string,
+                    [Generation(text="This should not be stored.")],
+                )
 
-        prompt = "RedisVL direct no-attrs (sync)"
-        response = "Direct response without attributes filter."
-
-        entry_id = rv_langcache_with_attrs.store(prompt=prompt, response=response)
-        assert entry_id
-
-        hits = rv_langcache_with_attrs.check(prompt=prompt, num_results=1)
-
-        assert hits
-        assert hits[0]["prompt"] == prompt
-        assert hits[0]["response"] == response
-
-    def test_direct_store_with_metadata_and_check_without_attributes(
-        self, rv_langcache_with_attrs: "RedisVLLangCacheSemanticCache"
-    ) -> None:
-        """Store with metadata but still retrieve without attributes filter.
-
-        This ensures that even when we provide metadata (attributes) at
-        write-time, we can still successfully retrieve the entry without
-        sending any attributes filter to LangCache.
-        """
-
-        prompt = "RedisVL direct metadata no-attrs (sync)"
-        response = "Direct response with metadata but no attributes filter."
-
-        entry_id = rv_langcache_with_attrs.store(
-            prompt=prompt,
-            response=response,
-            metadata={"llm_string": "redisvl-direct:no-attrs"},
-        )
-        assert entry_id
-
-        hits = rv_langcache_with_attrs.check(prompt=prompt, num_results=1)
-
-        assert hits
-        assert hits[0]["prompt"] == prompt
-        assert hits[0]["response"] == response
-
-
-@pytest.mark.requires_api_keys
-class TestLangCacheSemanticCacheIntegrationWithoutAttributes:
-    def test_update_errors_when_no_attributes_configured(
-        self, langcache_no_attrs: LangCacheSemanticCache
-    ) -> None:
-        """update() should raise if attributes are not configured on the cache."""
-
-        prompt = "Attributes not configured (sync)"
-        llm_string = "langchain-redis/tests:no-attributes:sync"
-
-        with pytest.raises(RuntimeError) as exc:
-            langcache_no_attrs.update(
-                prompt,
-                llm_string,
-                [Generation(text="This should not be stored.")],
-            )
-
-        assert "attributes are not configured for this cache" in str(exc.value).lower()
+            assert "attributes are not configured for this cache" in str(exc.value).lower()
 
     def test_lookup_errors_when_no_attributes_configured(
         self, langcache_no_attrs: LangCacheSemanticCache