cognee-community-vector-adapter-redis 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

cognee_community_vector_adapter_redis/redis_adapter.py

@@ -6,35 +6,40 @@ from uuid import UUID
 from redisvl.index import AsyncSearchIndex
 from redisvl.schema import IndexSchema
 from redisvl.query import VectorQuery
+# from redisvl.query import VectorDistanceMetric
 
-from cognee.exceptions import InvalidValueError
 from cognee.shared.logging_utils import get_logger
 
 from cognee.infrastructure.engine import DataPoint
 from cognee.infrastructure.engine.utils import parse_id
+from cognee.infrastructure.databases.exceptions import MissingQueryParameterError
 from cognee.infrastructure.databases.vector import VectorDBInterface
 from cognee.infrastructure.databases.vector.models.ScoredResult import ScoredResult
-from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import EmbeddingEngine
+from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import (
+    EmbeddingEngine,
+)
 
 logger = get_logger("RedisAdapter")
 
 
 class VectorEngineInitializationError(Exception):
     """Exception raised when vector engine initialization fails."""
+
     pass
 
 
 class CollectionNotFoundError(Exception):
     """Exception raised when a collection is not found."""
+
     pass
 
 
 def serialize_for_json(obj: Any) -> Any:
     """Convert objects to JSON-serializable format.
-    
+
     Args:
         obj: Object to serialize (UUID, dict, list, or any other type).
-        
+
     Returns:
         JSON-serializable representation of the object.
     """
@@ -50,40 +55,41 @@ def serialize_for_json(obj: Any) -> Any:
 
 class RedisDataPoint(DataPoint):
     """Redis data point schema for vector index entries.
-    
+
     Attributes:
         text: The text content to be indexed.
         metadata: Metadata containing index field configuration.
     """
+
     text: str
     metadata: dict = {"index_fields": ["text"]}
 
 
 class RedisAdapter(VectorDBInterface):
     """Redis vector database adapter using RedisVL for vector similarity search.
-    
+
     This adapter provides an interface to Redis vector search capabilities,
     supporting embedding generation, vector indexing, and similarity search.
     """
-    
+
     name = "Redis"
     url: Optional[str]
     api_key: Optional[str] = None
     embedding_engine: Optional[EmbeddingEngine] = None
-    
+
     def __init__(
-        self, 
+        self,
         url: str,
         api_key: Optional[str] = None,
-        embedding_engine: Optional[EmbeddingEngine] = None
+        embedding_engine: Optional[EmbeddingEngine] = None,
     ) -> None:
         """Initialize the Redis adapter.
-        
+
         Args:
             url (str): Connection string for your Redis instance like redis://localhost:6379.
             embedding_engine: Engine for generating embeddings.
             api_key: Optional API key. Ignored for Redis.
-            
+
         Raises:
             VectorEngineInitializationError: If required parameters are missing.
         """
@@ -91,31 +97,32 @@ class RedisAdapter(VectorDBInterface):
             raise VectorEngineInitializationError("Redis connnection URL!")
         if not embedding_engine:
             raise VectorEngineInitializationError("Embedding engine is required!")
-        
+
         self.url = url
         self.embedding_engine = embedding_engine
         self._indices = {}
-        
+        self.VECTOR_DB_LOCK = asyncio.Lock()
+
     async def embed_data(self, data: List[str]) -> List[List[float]]:
         """Embed text data using the embedding engine.
-        
+
         Args:
             data: List of text strings to embed.
-            
+
         Returns:
             List of embedding vectors as lists of floats.
-            
+
         Raises:
             Exception: If embedding generation fails.
         """
         return await self.embedding_engine.embed_text(data)
-    
+
     def _create_schema(self, collection_name: str) -> IndexSchema:
         """Create a RedisVL IndexSchema for a collection.
-        
+
         Args:
             collection_name: Name of the collection to create an index schema for.
-            
+
         Returns:
             Redis IndexSchema configured for vector search.
         """
@@ -123,7 +130,7 @@ class RedisAdapter(VectorDBInterface):
             "index": {
                 "name": collection_name,
                 "prefix": f"{collection_name}",
-                "storage_type": "json"
+                "storage_type": "json",
             },
             "fields": [
                 {"name": "id", "type": "tag", "attrs": {"sortable": True}},
@@ -136,133 +143,154 @@ class RedisAdapter(VectorDBInterface):
                         "m": 32,
                         "dims": self.embedding_engine.get_vector_size(),
                         "distance_metric": "cosine",
-                        "datatype": "float32"
-                    }
+                        "datatype": "float32",
+                    },
                 },
-                {"name": "payload", "type": "text", "attrs": {"sortable": True}}
-            ]
+                {"name": "payload_data", "type": "text", "attrs": {"sortable": True}},
+            ],
         }
         return IndexSchema.from_dict(schema_dict)
-    
+
     def _get_index(self, collection_name: str) -> AsyncSearchIndex:
         """Get or create an AsyncSearchIndex for a collection.
-        
+
         Args:
             collection_name: Name of the collection.
-            
+
         Returns:
             AsyncSearchIndex instance for the collection.
         """
         if collection_name not in self._indices:
             schema = self._create_schema(collection_name)
             self._indices[collection_name] = AsyncSearchIndex(
-                schema=schema,
-                redis_url=self.url,
-                validate_on_load=True
+                schema=schema, redis_url=self.url, validate_on_load=True
             )
         return self._indices[collection_name]
-    
+
     async def has_collection(self, collection_name: str) -> bool:
         """Check if a collection (index) exists.
-        
+
         Args:
             collection_name: Name of the collection to check.
-            
+
         Returns:
             True if collection exists, False otherwise.
         """
         try:
             index = self._get_index(collection_name)
-            return await index.exists()
+            result = await index.exists()
+            await index.disconnect()
+            return result
         except Exception:
             return False
-    
+
     async def create_collection(
         self,
         collection_name: str,
         payload_schema: Optional[Any] = None,
     ) -> None:
         """Create a new collection (Redis index) with vector search capabilities.
-        
+
         Args:
             collection_name: Name of the collection to create.
             payload_schema: Schema for payload data (not used).
-            
+
         Raises:
             Exception: If collection creation fails.
         """
-        try:
-            if await self.has_collection(collection_name):
-                logger.info(f"Collection {collection_name} already exists")
-                return
-            
+        async with self.VECTOR_DB_LOCK:
             index = self._get_index(collection_name)
-            await index.create(overwrite=False)
-            
-            logger.info(f"Created collection {collection_name}")
-            
-        except Exception as e:
-            logger.error(f"Error creating collection {collection_name}: {str(e)}")
-            raise e
-    
-    async def create_data_points(self, collection_name: str, data_points: List[DataPoint]) -> None:
+            try:
+                if await self.has_collection(collection_name):
+                    logger.info(f"Collection {collection_name} already exists")
+                    return
+
+                index = self._get_index(collection_name)
+                await index.create(overwrite=False)
+
+                logger.info(f"Created collection {collection_name}")
+
+            except Exception as e:
+                logger.error(f"Error creating collection {collection_name}: {str(e)}")
+                raise e
+            finally:
+                await index.disconnect()
+
+    async def create_data_points(
+        self, collection_name: str, data_points: List[DataPoint]
+    ) -> None:
         """Create data points in the collection.
-        
+
         Args:
             collection_name: Name of the target collection.
             data_points: List of DataPoint objects to insert.
-            
+
         Raises:
             CollectionNotFoundError: If the collection doesn't exist.
             Exception: If data point creation fails.
         """
+        index = self._get_index(collection_name)
         try:
             if not await self.has_collection(collection_name):
-                raise CollectionNotFoundError(f"Collection {collection_name} not found!")
-            
+                raise CollectionNotFoundError(
+                    f"Collection {collection_name} not found!"
+                )
+
             # Embed the data points
             data_vectors = await self.embed_data(
-                [DataPoint.get_embeddable_data(data_point) for data_point in data_points]
+                [
+                    DataPoint.get_embeddable_data(data_point)
+                    for data_point in data_points
+                ]
             )
-            
+
             # Prepare documents for RedisVL
             documents = []
             for data_point, embedding in zip(data_points, data_vectors):
                 # Serialize the payload to handle UUIDs and other non-JSON types
                 payload = serialize_for_json(data_point.model_dump())
-                
+
                 doc_data = {
                     "id": str(data_point.id),
-                    "text": getattr(data_point, data_point.metadata.get("index_fields", ["text"])[0], ""),
+                    "text": getattr(
+                        data_point,
+                        data_point.metadata.get("index_fields", ["text"])[0],
+                        "",
+                    ),
                     "vector": embedding,
-                    "payload": json.dumps(payload)  # Store as JSON string
+                    "payload_data": json.dumps(payload),  # Store as JSON string
                 }
                 documents.append(doc_data)
-            
+
             # Load using RedisVL
-            index = self._get_index(collection_name)
             await index.load(documents, id_field="id")
-            
-            logger.info(f"Created {len(data_points)} data points in collection {collection_name}")
-            
+
+            logger.info(
+                f"Created {len(data_points)} data points in collection {collection_name}"
+            )
+
         except Exception as e:
             logger.error(f"Error creating data points: {str(e)}")
             raise e
-    
-    async def create_vector_index(self, index_name: str, index_property_name: str) -> None:
+        finally:
+            await index.disconnect()
+
+    async def create_vector_index(
+        self, index_name: str, index_property_name: str
+    ) -> None:
         """Create a vector index for a specific property.
-        
+
         Args:
             index_name: Base name for the index.
             index_property_name: Property name to index.
         """
         await self.create_collection(f"{index_name}_{index_property_name}")
-    
+
     async def index_data_points(
         self, index_name: str, index_property_name: str, data_points: list[DataPoint]
     ) -> None:
         """Index data points for a specific property.
-        
+
         Args:
             index_name: Base name for the index.
             index_property_name: Property name to index.
@@ -273,44 +301,50 @@ class RedisAdapter(VectorDBInterface):
             [
                 RedisDataPoint(
                     id=data_point.id,
-                    text=getattr(data_point, data_point.metadata.get("index_fields", ["text"])[0]),
+                    text=getattr(
+                        data_point, data_point.metadata.get("index_fields", ["text"])[0]
+                    ),
                 )
                 for data_point in data_points
             ],
         )
-    
-    async def retrieve(self, collection_name: str, data_point_ids: List[str]) -> List[Dict[str, Any]]:
+
+    async def retrieve(
+        self, collection_name: str, data_point_ids: List[str]
+    ) -> List[Dict[str, Any]]:
         """Retrieve data points by their IDs.
-        
+
         Args:
             collection_name: Name of the collection to retrieve from.
             data_point_ids: List of data point IDs to retrieve.
-            
+
         Returns:
             List of retrieved data point payloads.
         """
+        index = self._get_index(collection_name)
         try:
-            index = self._get_index(collection_name)
             results = []
-            
+
             for data_id in data_point_ids:
                 doc = await index.fetch(data_id)
                 if doc:
                     # Parse the stored payload JSON
-                    payload_str = doc.get("payload", "{}")
+                    payload_str = doc.get("payload_data", "{}")
                     try:
                         payload = json.loads(payload_str)
                         results.append(payload)
                     except json.JSONDecodeError:
                         # Fallback to the document itself if payload parsing fails
                         results.append(doc)
-            
+
             return results
-            
+
         except Exception as e:
             logger.error(f"Error retrieving data points: {str(e)}")
             return []
-    
+        finally:
+            await index.disconnect()
+
     async def search(
         self,
         collection_name: str,
@@ -320,78 +354,89 @@ class RedisAdapter(VectorDBInterface):
         with_vector: bool = False,
     ) -> List[ScoredResult]:
         """Search for similar vectors in the collection.
-        
+
         Args:
             collection_name: Name of the collection to search.
             query_text: Text query to search for (will be embedded).
             query_vector: Pre-computed query vector.
             limit: Maximum number of results to return.
             with_vector: Whether to include vectors in results.
-            
+
         Returns:
             List of ScoredResult objects sorted by similarity.
-            
+
         Raises:
-            InvalidValueError: If neither query_text nor query_vector is provided.
+            MissingQueryParameterError: If neither query_text nor query_vector is provided.
             Exception: If search execution fails.
         """
         if query_text is None and query_vector is None:
-            raise InvalidValueError("One of query_text or query_vector must be provided!")
-        
-        if limit <= 0:
-            return []
-        
+            raise MissingQueryParameterError()
+
         if not await self.has_collection(collection_name):
-            logger.warning(f"Collection '{collection_name}' not found in RedisAdapter.search; returning [].")
+            logger.warning(
+                f"Collection '{collection_name}' not found in RedisAdapter.search; returning []."
+            )
             return []
-        
+
+        index = self._get_index(collection_name)
+
+        if limit == 0:
+            info = await index.info()
+            limit = info["num_docs"]
+
+        if limit == 0:
+            return []
+
         try:
             # Get the query vector
             if query_vector is None:
                 query_vector = (await self.embed_data([query_text]))[0]
-            
+
             # Create the vector query
             vector_query = VectorQuery(
                 vector=query_vector,
                 vector_field_name="vector",
                 num_results=limit,
                 return_score=True,
-                normalize_vector_distance=True
+                normalize_vector_distance=False,
             )
-            
+
             # Set return fields
-            return_fields = ["id", "text", "payload"]
+            return_fields = ["id", "text", "payload_data"]
             if with_vector:
                 return_fields.append("vector")
             vector_query = vector_query.return_fields(*return_fields)
-            
+
             # Execute the search
-            index = self._get_index(collection_name)
             results = await index.query(vector_query)
-            
+
             # Convert results to ScoredResult objects
             scored_results = []
             for doc in results:
                 # Parse the stored payload - it's stored as JSON string
-                payload_str = doc.get("payload", "{}")
+                payload_str = doc.get("payload_data", "{}")
                 try:
                     payload = json.loads(payload_str)
                 except json.JSONDecodeError:
                     payload = doc
-                
+
                 scored_results.append(
                     ScoredResult(
-                        id=parse_id(doc["id"]),
+                        id=parse_id(doc["id"].split(":", 1)[1]),
                         payload=payload,
-                        score=float(doc.get("vector_distance", 0.0))  # RedisVL returns distance
+                        score=float(
+                            doc.get("vector_distance", 0.0)
+                        ),  # RedisVL returns distance
                     )
                 )
             return scored_results
-            
+
         except Exception as e:
             logger.error(f"Error during search: {str(e)}")
             raise e
-    
+        finally:
+            await index.disconnect()
+
     async def batch_search(
         self,
         collection_name: str,
@@ -400,19 +445,19 @@ class RedisAdapter(VectorDBInterface):
         with_vectors: bool = False,
     ) -> List[List[ScoredResult]]:
         """Perform batch search for multiple queries.
-        
+
         Args:
             collection_name: Name of the collection to search.
             query_texts: List of text queries to search for.
             limit: Maximum number of results per query.
             with_vectors: Whether to include vectors in results.
-            
+
         Returns:
             List of search results for each query, filtered by score threshold.
         """
         # Embed all queries at once
         vectors = await self.embed_data(query_texts)
-        
+
         # Execute searches in parallel
         # TODO: replace with index.batch_query() in the future
         search_tasks = [
@@ -420,46 +465,52 @@ class RedisAdapter(VectorDBInterface):
                 collection_name=collection_name,
                 query_vector=vector,
                 limit=limit,
-                with_vector=with_vectors
+                with_vector=with_vectors,
             )
             for vector in vectors
         ]
-        
+
         results = await asyncio.gather(*search_tasks)
-        
+
         # Filter results by score threshold (Redis uses distance, so lower is better)
         return [
             [result for result in result_group if result.score < 0.1]
             for result_group in results
         ]
-    
-    async def delete_data_points(self, collection_name: str, data_point_ids: List[str]) -> Dict[str, int]:
+
+    async def delete_data_points(
+        self, collection_name: str, data_point_ids: List[str]
+    ) -> Dict[str, int]:
         """Delete data points by their IDs.
-        
+
         Args:
             collection_name: Name of the collection to delete from.
             data_point_ids: List of data point IDs to delete.
-            
+
         Returns:
             Dictionary containing the number of deleted documents.
-            
+
         Raises:
             Exception: If deletion fails.
         """
+        index = self._get_index(collection_name)
         try:
-            index = self._get_index(collection_name)
             deleted_count = await index.drop_documents(data_point_ids)
-            logger.info(f"Deleted {deleted_count} data points from collection {collection_name}")
+            logger.info(
+                f"Deleted {deleted_count} data points from collection {collection_name}"
+            )
             return {"deleted": deleted_count}
         except Exception as e:
             logger.error(f"Error deleting data points: {str(e)}")
             raise e
-    
+        finally:
+            await index.disconnect()
+
     async def prune(self) -> None:
         """Remove all collections and data from Redis.
-        
+
         This method drops all existing indices and clears the internal cache.
-        
+
         Raises:
             Exception: If pruning fails.
         """
@@ -473,12 +524,13 @@ class RedisAdapter(VectorDBInterface):
                         await index.disconnect()
                 except Exception as e:
                     logger.warning(f"Failed to drop index {collection_name}: {str(e)}")
-            
+                    await index.disconnect()
+
             # Clear the indices cache
             self._indices.clear()
-            
+
             logger.info("Pruned all Redis vector collections")
-            
+
         except Exception as e:
             logger.error(f"Error during prune: {str(e)}")
             raise e

{cognee_community_vector_adapter_redis-0.0.1.dist-info → cognee_community_vector_adapter_redis-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee-community-vector-adapter-redis
-Version: 0.0.1
+Version: 0.0.3
 Summary: Redis vector database adapter for cognee
 Requires-Python: <=3.13,>=3.11
 Requires-Dist: cognee>=0.2.0.dev0
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
     <br />
 
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-![Language](https://img.shields.io/badge/python-3.8+-blue.svg)
+![Language](https://img.shields.io/badge/python-3.11+-blue.svg)
 
 [![Powered by RedisVL](https://img.shields.io/badge/Powered%20by-RedisVL-red.svg)](https://github.com/redis/redis-vl-python)
 
@@ -44,10 +44,19 @@ Description-Content-Type: text/markdown
 
 ## Installation
 
+If published, the package can be simply installed via pip:
+
 ```bash
 pip install cognee-community-vector-adapter-redis
 ```
 
+In case it is not published yet, you can use poetry to locally build the adapter package:
+
+```bash
+pip install poetry
+poetry install # run this command in the directory containing the pyproject.toml file
+```
+
 ## Prerequisites
 
 You need a Redis instance with the Redis Search module enabled. You can use:
@@ -71,96 +80,115 @@ uv run examples/example.py
 ## Usage
 
 ```python
-from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import EmbeddingEngine
-from cognee_community_vector_adapter_redis import RedisAdapter
-
-# Initialize your embedding engine
-embedding_engine = EmbeddingEngine(
-    model="your-model",
-    # ... other config
-)
-
-# Create Redis adapter
-redis_adapter = RedisAdapter(
-    url="redis://localhost:6379",  # Redis connection URL
-    embedding_engine=embedding_engine,
-    api_key=None  # Optional, not used for Redis but part of interface
-)
+import os
+import asyncio
+from cognee import config, prune, add, cognify, search, SearchType
+
+# Import the register module to enable Redis support
+from cognee_community_vector_adapter_redis import register
+
+async def main():
+    # Configure Redis as vector database
+    config.set_vector_db_config({
+        "vector_db_provider": "redis",
+        "vector_db_url": os.getenv("VECTOR_DB_URL", "redis://localhost:6379"),
+        "vector_db_key": os.getenv("VECTOR_DB_KEY", "your-api-key"),  # Optional
+    })
+    
+    # Optional: Clean previous data
+    await prune.prune_data()
+    await prune.prune_system()
+    
+    # Add your content
+    await add("""
+    Natural language processing (NLP) is an interdisciplinary
+    subfield of computer science and information retrieval.
+    """)
+    
+    # Process with cognee
+    await cognify()
+    
+    # Search
+    search_results = await search(
+        query_type=SearchType.GRAPH_COMPLETION, 
+        query_text="Tell me about NLP"
+    )
+    
+    for result in search_results:
+        print("Search result:", result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
 
-# Create a collection
-await redis_adapter.create_collection("my_collection")
+## Configuration
 
-# Add data points
-from cognee.infrastructure.engine import DataPoint
+Configure Redis as your vector database in cognee:
 
-data_points = [
-    DataPoint(id="1", text="Hello world", metadata={"index_fields": ["text"]}),
-    DataPoint(id="2", text="Redis vector search", metadata={"index_fields": ["text"]})
-]
+- `vector_db_provider`: Set to "redis"
+- `vector_db_url`: Redis connection URL (e.g., "redis://localhost:6379")
+- `vector_db_key`: Optional API key parameter (for compatibility, not used by Redis)
 
-await redis_adapter.create_data_points("my_collection", data_points)
+### Environment Variables
 
-# Search for similar vectors
-results = await redis_adapter.search(
-    collection_name="my_collection",
-    query_text="Hello Redis",
-    limit=10
-)
+Set the following environment variables or pass them directly in the config:
 
-# Search with pre-computed vector
-query_vector = await redis_adapter.embed_data(["Hello Redis"])
-results = await redis_adapter.search(
-    collection_name="my_collection",
-    query_vector=query_vector[0],
-    limit=10,
-    with_vector=True  # Include vectors in results
-)
+```bash
+export VECTOR_DB_URL="redis://localhost:6379"
+export VECTOR_DB_KEY="optional-key"  # Not used by Redis
+```
 
-# Batch search
-results = await redis_adapter.batch_search(
-    collection_name="my_collection", 
-    query_texts=["query1", "query2"],
-    limit=5
-)
+### Connection URL Examples
 
-# Retrieve specific data points
-retrieved = await redis_adapter.retrieve(
-    collection_name="my_collection",
-    data_point_ids=["1", "2"]
-)
+```python
+# Local Redis
+config.set_vector_db_config({
+    "vector_db_provider": "redis",
+    "vector_db_url": "redis://localhost:6379"
+})
 
-# Delete data points
-await redis_adapter.delete_data_points(
-    collection_name="my_collection",
-    data_point_ids=["1"]
-)
+# Redis with authentication
+config.set_vector_db_config({
+    "vector_db_provider": "redis", 
+    "vector_db_url": "redis://user:password@localhost:6379"
+})
 
-# Check if collection exists
-exists = await redis_adapter.has_collection("my_collection")
+# Redis with SSL
+config.set_vector_db_config({
+    "vector_db_provider": "redis",
+    "vector_db_url": "rediss://localhost:6380"
+})
 ```
 
-## Configuration
+## Requirements
 
-The Redis adapter supports the following configuration options:
+- Python >= 3.11, <= 3.13
+- redisvl >= 0.6.0, <= 1.0.0
+- cognee >= 0.2.0.dev0
 
-- `url`: Redis connection URL (e.g., "redis://localhost:6379", "redis://user:pass@host:port")
-- `embedding_engine`: The `EmbeddingEngine` to use for text vectorization (required)
-- `api_key`: Optional API key parameter (not used for Redis but part of the interface)
+## Advanced Usage
 
-### Connection URL Examples
+For direct adapter usage (advanced users only):
 
 ```python
-# Local Redis
-redis_adapter = RedisAdapter(url="redis://localhost:6379", embedding_engine=engine)
+from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import EmbeddingEngine
+from cognee_community_vector_adapter_redis import RedisAdapter
+from cognee.infrastructure.engine import DataPoint
 
-# Redis with authentication
-redis_adapter = RedisAdapter(url="redis://user:password@localhost:6379", embedding_engine=engine)
+# Initialize embedding engine and adapter
+embedding_engine = EmbeddingEngine(model="your-model")
+redis_adapter = RedisAdapter(
+    url="redis://localhost:6379",
+    embedding_engine=embedding_engine
+)
 
-# Redis with SSL
-redis_adapter = RedisAdapter(url="rediss://localhost:6380", embedding_engine=engine)
+# Direct adapter operations
+await redis_adapter.create_collection("my_collection")
+data_points = [DataPoint(id="1", text="Hello", metadata={"index_fields": ["text"]})]
+await redis_adapter.create_data_points("my_collection", data_points)
+results = await redis_adapter.search("my_collection", query_text="Hello", limit=10)
 ```
 
-
 ## Error Handling
 
 The adapter includes comprehensive error handling:

cognee_community_vector_adapter_redis-0.0.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+cognee_community_vector_adapter_redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognee_community_vector_adapter_redis/redis_adapter.py,sha256=YXLW4s631NMqsubAxTqOTQ5etNsNmwjOWu4U3EnZ7VM,18055
+cognee_community_vector_adapter_redis/register.py,sha256=0LdEifYQuIu9OkXNV8PxOPOg2gKCL-9Lq4FL0nmUCxo,154
+cognee_community_vector_adapter_redis-0.0.3.dist-info/METADATA,sha256=ntPwag-uykrHOEKPCki0d_l1EUulh910847MHRWlc6Q,6647
+cognee_community_vector_adapter_redis-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognee_community_vector_adapter_redis-0.0.3.dist-info/RECORD,,

cognee_community_vector_adapter_redis-0.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-cognee_community_vector_adapter_redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognee_community_vector_adapter_redis/redis_adapter.py,sha256=c4D2GLkiZ11nIJ7rk30OW0kSN78rep7T05mJT0wSN0o,17576
-cognee_community_vector_adapter_redis/register.py,sha256=0LdEifYQuIu9OkXNV8PxOPOg2gKCL-9Lq4FL0nmUCxo,154
-cognee_community_vector_adapter_redis-0.0.1.dist-info/METADATA,sha256=g55O7nqOsjqVPdBp649zGoa39fy1gZZDBjCH_ULDvqI,5966
-cognee_community_vector_adapter_redis-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognee_community_vector_adapter_redis-0.0.1.dist-info/RECORD,,