Harrison/redis cache (#3766)

Co-authored-by: Tyler Hutcherson <tyler.hutcherson@redis.com>

tests/integration_tests/cache/test_redis_cache.py

@@ -0,0 +1,55 @@
+"""Test Redis cache functionality."""
+import redis
+
+import langchain
+from langchain.cache import RedisCache, RedisSemanticCache
+from langchain.schema import Generation, LLMResult
+from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
+from tests.unit_tests.llms.fake_llm import FakeLLM
+
+REDIS_TEST_URL = "redis://localhost:6379"
+
+
+def test_redis_cache() -> None:
+    langchain.llm_cache = RedisCache(redis_=redis.Redis.from_url(REDIS_TEST_URL))
+    llm = FakeLLM()
+    params = llm.dict()
+    params["stop"] = None
+    llm_string = str(sorted([(k, v) for k, v in params.items()]))
+    langchain.llm_cache.update("foo", llm_string, [Generation(text="fizz")])
+    output = llm.generate(["foo"])
+    print(output)
+    expected_output = LLMResult(
+        generations=[[Generation(text="fizz")]],
+        llm_output={},
+    )
+    print(expected_output)
+    assert output == expected_output
+    langchain.llm_cache.redis.flushall()
+
+
+def test_redis_semantic_cache() -> None:
+    langchain.llm_cache = RedisSemanticCache(
+        embedding=FakeEmbeddings(), redis_url=REDIS_TEST_URL, score_threshold=0.1
+    )
+    llm = FakeLLM()
+    params = llm.dict()
+    params["stop"] = None
+    llm_string = str(sorted([(k, v) for k, v in params.items()]))
+    langchain.llm_cache.update("foo", llm_string, [Generation(text="fizz")])
+    output = llm.generate(
+        ["bar"]
+    )  # foo and bar will have the same embedding produced by FakeEmbeddings
+    expected_output = LLMResult(
+        generations=[[Generation(text="fizz")]],
+        llm_output={},
+    )
+    assert output == expected_output
+    # clear the cache
+    langchain.llm_cache.clear(llm_string=llm_string)
+    output = llm.generate(
+        ["bar"]
+    )  # foo and bar will have the same embedding produced by FakeEmbeddings
+    # expect different output now without cached result
+    assert output != expected_output
+    langchain.llm_cache.clear(llm_string=llm_string)

tests/integration_tests/vectorstores/test_redis.py

@@ -1,26 +1,60 @@
 """Test Redis functionality."""
-
 from langchain.docstore.document import Document
 from langchain.vectorstores.redis import Redis
 from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
 
+TEST_INDEX_NAME = "test"
+TEST_REDIS_URL = "redis://localhost:6379"
+TEST_SINGLE_RESULT = [Document(page_content="foo")]
+TEST_RESULT = [Document(page_content="foo"), Document(page_content="foo")]
+
+
+def drop(index_name: str) -> bool:
+    return Redis.drop_index(
+        index_name=index_name, delete_documents=True, redis_url=TEST_REDIS_URL
+    )
+
 
 def test_redis() -> None:
     """Test end to end construction and search."""
     texts = ["foo", "bar", "baz"]
-    docsearch = Redis.from_texts(
-        texts, FakeEmbeddings(), redis_url="redis://localhost:6379"
-    )
+    docsearch = Redis.from_texts(texts, FakeEmbeddings(), redis_url=TEST_REDIS_URL)
     output = docsearch.similarity_search("foo", k=1)
-    assert output == [Document(page_content="foo")]
+    assert output == TEST_SINGLE_RESULT
+    assert drop(docsearch.index_name)
 
 
 def test_redis_new_vector() -> None:
     """Test adding a new document"""
     texts = ["foo", "bar", "baz"]
-    docsearch = Redis.from_texts(
-        texts, FakeEmbeddings(), redis_url="redis://localhost:6379"
+    docsearch = Redis.from_texts(texts, FakeEmbeddings(), redis_url=TEST_REDIS_URL)
+    docsearch.add_texts(["foo"])
+    output = docsearch.similarity_search("foo", k=2)
+    assert output == TEST_RESULT
+    assert drop(docsearch.index_name)
+
+
+def test_redis_from_existing() -> None:
+    """Test adding a new document"""
+    texts = ["foo", "bar", "baz"]
+    Redis.from_texts(
+        texts, FakeEmbeddings(), index_name=TEST_INDEX_NAME, redis_url=TEST_REDIS_URL
+    )
+    # Test creating from an existing
+    docsearch2 = Redis.from_existing_index(
+        FakeEmbeddings(), index_name=TEST_INDEX_NAME, redis_url=TEST_REDIS_URL
+    )
+    output = docsearch2.similarity_search("foo", k=1)
+    assert output == TEST_SINGLE_RESULT
+
+
+def test_redis_add_texts_to_existing() -> None:
+    """Test adding a new document"""
+    # Test creating from an existing
+    docsearch = Redis.from_existing_index(
+        FakeEmbeddings(), index_name=TEST_INDEX_NAME, redis_url=TEST_REDIS_URL
     )
     docsearch.add_texts(["foo"])
     output = docsearch.similarity_search("foo", k=2)
-    assert output == [Document(page_content="foo"), Document(page_content="foo")]
+    assert output == TEST_RESULT
+    assert drop(TEST_INDEX_NAME)