improve imports, tests, and rename things

Author: tylerhutcherson

README.md

@@ -238,7 +238,7 @@ We're excited to announce the support for **RedisVL Extensions**. These modules
 Increase application throughput and reduce the cost of using LLM models in production by leveraging previously generated knowledge with the [`SemanticCache`](https://docs.redisvl.com/en/stable/api/cache.html#semanticcache).
 
 ```python
-from redisvl.extensions.llmcache import SemanticCache
+from redisvl.extensions.cache.llm import SemanticCache
 
 # init cache with TTL and semantic distance threshold
 llmcache = SemanticCache(

docs/user_guide/03_llmcache.ipynb

@@ -88,7 +88,7 @@
     }
    ],
    "source": [
-    "from redisvl.extensions.llmcache import SemanticCache\n",
+    "from redisvl.extensions.cache.llm import SemanticCache\n",
     "\n",
     "llmcache = SemanticCache(\n",
     "    name=\"llmcache\",                     # underlying search index name\n",

docs/user_guide/04_vectorizers.ipynb

@@ -609,7 +609,7 @@
          "metadata": {},
          "outputs": [],
          "source": [
-            "from redisvl.extensions.llmcache import SemanticCache\n",
+            "from redisvl.extensions.cache.llm import SemanticCache\n",
             "\n",
             "cache = SemanticCache(name=\"custom_cache\", vectorizer=custom_vectorizer)\n",
             "\n",

docs/user_guide/09_threshold_optimization.ipynb

@@ -24,7 +24,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from redisvl.extensions.llmcache import SemanticCache\n",
+    "from redisvl.extensions.cache.llm import SemanticCache\n",
     "\n",
     "sem_cache = SemanticCache(\n",
     "    name=\"sem_cache\",                    # underlying search index name\n",

docs/user_guide/release_guide/0_5_0_release.ipynb

@@ -248,7 +248,7 @@
    ],
    "source": [
     "from redisvl.utils.optimize import CacheThresholdOptimizer\n",
-    "from redisvl.extensions.llmcache import SemanticCache\n",
+    "from redisvl.extensions.cache.llm import SemanticCache\n",
     "\n",
     "sem_cache = SemanticCache(\n",
     "    name=\"sem_cache\",                    # underlying search index name\n",

redisvl/extensions/__init__.py

@@ -1,6 +1 @@
-"""
-Redis Vector Library Extensions
 
-These extensions provide additional functionality on top of the
-core RedisVL functionality.
-"""

redisvl/extensions/cache/base.py

@@ -17,6 +17,9 @@ class BaseCache:
     including TTL management, connection handling, and basic cache operations.
     """
 
+    _redis_client: Optional[Redis]
+    _async_redis_client: Optional[AsyncRedis]
+
     def __init__(
         self,
         name: str,
@@ -47,12 +50,15 @@ def __init__(
             "connection_kwargs": connection_kwargs,
         }
 
+        # Initialize Redis clients
+        self._async_redis_client = None
+
         if redis_client:
             self._owns_redis_client = False
             self._redis_client = redis_client
         else:
             self._owns_redis_client = True
-            self._redis_client = None
+            self._redis_client = None  # type: ignore
 
     def _get_prefix(self) -> str:
         """Get the key prefix for Redis keys.
@@ -102,9 +108,10 @@ def _get_redis_client(self) -> Redis:
             Redis: A Redis client instance.
         """
         if self._redis_client is None:
-            self._redis_client = Redis.from_url(
-                self.redis_kwargs["redis_url"], **self.redis_kwargs["connection_kwargs"]
-            )
+            # Create new Redis client
+            url = self.redis_kwargs["redis_url"]
+            kwargs = self.redis_kwargs["connection_kwargs"]
+            self._redis_client = Redis.from_url(url, **kwargs)  # type: ignore
         return self._redis_client
 
     async def _get_async_redis_client(self) -> AsyncRedis:
@@ -114,9 +121,10 @@ async def _get_async_redis_client(self) -> AsyncRedis:
             AsyncRedis: An async Redis client instance.
         """
         if not hasattr(self, "_async_redis_client") or self._async_redis_client is None:
-            self._async_redis_client = AsyncRedis.from_url(
-                self.redis_kwargs["redis_url"], **self.redis_kwargs["connection_kwargs"]
-            )
+            # Create new async Redis client
+            url = self.redis_kwargs["redis_url"]
+            kwargs = self.redis_kwargs["connection_kwargs"]
+            self._async_redis_client = AsyncRedis.from_url(url, **kwargs)  # type: ignore
         return self._async_redis_client
 
     def expire(self, key: str, ttl: Optional[int] = None) -> None:
@@ -161,25 +169,29 @@ def clear(self) -> None:
         prefix = self._get_prefix()
 
         # Scan for all keys with our prefix
-        cursor = "0"
-        while cursor != 0:
-            cursor, keys = client.scan(cursor=cursor, match=f"{prefix}*", count=100)
+        cursor = 0  # Start with cursor 0
+        while True:
+            cursor_int, keys = client.scan(cursor=cursor, match=f"{prefix}*", count=100)  # type: ignore
             if keys:
                 client.delete(*keys)
+            if cursor_int == 0:  # Redis returns 0 when scan is complete
+                break
+            cursor = cursor_int  # Update cursor for next iteration
 
     async def aclear(self) -> None:
         """Async clear the cache of all keys."""
         client = await self._get_async_redis_client()
         prefix = self._get_prefix()
 
         # Scan for all keys with our prefix
-        cursor = "0"
-        while cursor != 0:
-            cursor, keys = await client.scan(
-                cursor=cursor, match=f"{prefix}*", count=100
-            )
+        cursor = 0  # Start with cursor 0
+        while True:
+            cursor_int, keys = await client.scan(cursor=cursor, match=f"{prefix}*", count=100)  # type: ignore
             if keys:
                 await client.delete(*keys)
+            if cursor_int == 0:  # Redis returns 0 when scan is complete
+                break
+            cursor = cursor_int  # Update cursor for next iteration
 
     def disconnect(self) -> None:
         """Disconnect from Redis."""
@@ -188,11 +200,12 @@ def disconnect(self) -> None:
 
         if self._redis_client:
             self._redis_client.close()
-            self._redis_client = None
+            self._redis_client = None  # type: ignore
 
         if hasattr(self, "_async_redis_client") and self._async_redis_client:
-            self._async_redis_client.close()
-            self._async_redis_client = None
+            # Use synchronous close for async client in synchronous context
+            self._async_redis_client.close()  # type: ignore
+            self._async_redis_client = None  # type: ignore
 
     async def adisconnect(self) -> None:
         """Async disconnect from Redis."""
@@ -201,8 +214,9 @@ async def adisconnect(self) -> None:
 
         if self._redis_client:
             self._redis_client.close()
-            self._redis_client = None
+            self._redis_client = None  # type: ignore
 
         if hasattr(self, "_async_redis_client") and self._async_redis_client:
-            await self._async_redis_client.aclose()
-            self._async_redis_client = None
+            # Use proper async close method
+            await self._async_redis_client.aclose()  # type: ignore
+            self._async_redis_client = None  # type: ignore

redisvl/extensions/cache/embeddings/__init__.py

@@ -4,8 +4,7 @@
 This module provides embedding caching functionality for RedisVL.
 """
 
-from redisvl.extensions.cache.embeddings.base import BaseEmbeddingsCache
 from redisvl.extensions.cache.embeddings.embeddings import EmbeddingsCache
 from redisvl.extensions.cache.embeddings.schema import CacheEntry
 
-__all__ = ["BaseEmbeddingsCache", "EmbeddingsCache", "CacheEntry"]
+__all__ = ["EmbeddingsCache", "CacheEntry"]

redisvl/extensions/cache/embeddings/embeddings.py

@@ -1,10 +1,6 @@
-"""Embeddings cache implementation for RedisVL.
+"""Embeddings cache implementation for RedisVL."""
 
-This module provides a concrete implementation of the BaseEmbeddingsCache that
-stores and retrieves embedding vectors with exact key matching.
-"""
-
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
 
 from redis import Redis
 
@@ -83,8 +79,18 @@ def _prepare_entry_data(
         model_name: str,
         embedding: List[float],
         metadata: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Prepare data for storage in Redis"""
+    ) -> Tuple[str, Dict[str, Any]]:
+        """Prepare data for storage in Redis
+
+        Args:
+            text (str): The text input that was embedded.
+            model_name (str): The name of the embedding model.
+            embedding (List[float]): The embedding vector.
+            metadata (Optional[Dict[str, Any]]): Optional metadata.
+
+        Returns:
+            Tuple[str, Dict[str, Any]]: A tuple of (key, entry_data)
+        """
         # Create cache entry with entry_id
         entry_id = self._make_entry_id(text, model_name)
         key = self._make_key(entry_id)
@@ -97,46 +103,6 @@ def _prepare_entry_data(
         )
         return key, entry.to_dict()
 
-    def clear(self) -> None:
-        """Clear the cache of all keys.
-
-        Removes all entries from the cache that match the cache prefix.
-
-        .. code-block:: python
-
-            cache.clear()
-        """
-        client = self._get_redis_client()
-
-        # Scan for all keys with our prefix
-        cursor = "0"
-        while cursor != 0:
-            cursor, keys = client.scan(
-                cursor=cursor, match=f"{self.prefix}*", count=100
-            )
-            if keys:
-                client.delete(*keys)
-
-    async def aclear(self) -> None:
-        """Async clear the cache of all keys.
-
-        Asynchronously removes all entries from the cache that match the cache prefix.
-
-        .. code-block:: python
-
-            await cache.aclear()
-        """
-        client = await self._get_async_redis_client()
-
-        # Scan for all keys with our prefix
-        cursor = "0"
-        while cursor != 0:
-            cursor, keys = await client.scan(
-                cursor=cursor, match=f"{self.prefix}*", count=100
-            )
-            if keys:
-                await client.delete(*keys)
-
     def get(
         self,
         text: str,
@@ -284,7 +250,7 @@ def set(
 
         # Store in Redis
         client = self._get_redis_client()
-        client.hset(name=key, mapping=cache_entry)
+        client.hset(name=key, mapping=cache_entry)  # type: ignore
 
         # Set TTL if specified
         self.expire(key, ttl)
@@ -329,7 +295,7 @@ async def aset(
 
         # Store in Redis
         client = await self._get_async_redis_client()
-        await client.hset(name=key, mapping=cache_entry)
+        await client.hset(name=key, mapping=cache_entry)  # type: ignore
 
         # Set TTL if specified
         await self.aexpire(key, ttl)

redisvl/extensions/cache/embeddings/schema.py

@@ -23,8 +23,6 @@ class CacheEntry(BaseModel):
     """The name of the embedding model used"""
     embedding: List[float]
     """The embedding vector representation"""
-    dimensions: int
-    """Number of dimensions in the embedding"""
     inserted_at: float = Field(default_factory=current_timestamp)
     """Timestamp of when the entry was added to the cache"""
     metadata: Optional[Dict[str, Any]] = Field(default=None)
@@ -44,6 +42,8 @@ def deserialize_cache_entry(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         ):
             values[EMBEDDING_FIELD_NAME] = deserialize(values[EMBEDDING_FIELD_NAME])
 
+        return values
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert the cache entry to a dictionary for storage"""
         data = self.model_dump(exclude_none=True)