cognee-community-vector-adapter-valkey 0.1.1__py3-none-any.whl

cognee_community_vector_adapter_valkey/__init__.py

@@ -0,0 +1,4 @@
+from .exceptions import CollectionNotFoundError, ValkeyVectorEngineInitializationError
+from .valkey_adapter import ValkeyAdapter
+
+__all__ = ["ValkeyAdapter", "ValkeyVectorEngineInitializationError", "CollectionNotFoundError"]

cognee_community_vector_adapter_valkey/exceptions.py

@@ -0,0 +1,10 @@
+class ValkeyVectorEngineInitializationError(Exception):
+    """Exception raised when vector engine initialization fails."""
+
+    pass
+
+
+class CollectionNotFoundError(Exception):
+    """Exception raised when a collection is not found."""
+
+    pass

cognee_community_vector_adapter_valkey/register.py

@@ -0,0 +1,5 @@
+from cognee.infrastructure.databases.vector import use_vector_adapter
+
+from .valkey_adapter import ValkeyAdapter
+
+use_vector_adapter("valkey", ValkeyAdapter)

cognee_community_vector_adapter_valkey/utils.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import json
+import struct
+from functools import singledispatch
+from typing import Any
+from urllib.parse import urlparse
+from uuid import UUID
+
+from cognee.infrastructure.databases.vector.models.ScoredResult import ScoredResult
+
+"""
+Internal helper function. Not part of the public API.
+"""
+
+
+def _parse_host_port(url: str) -> tuple[str, int]:
+    """
+    Parse a url and extract the host and port.
+
+    Args:
+        url (str): The connection URL, e.g., "valkey://localhost:6379".
+
+    Returns:
+        tuple[str, int]: A tuple containing:
+            - host (str): The hostname from the URL, defaults to "localhost" if missing.
+            - port (int): The port number from the URL, defaults to 6379 if missing.
+    """
+
+    parsed = urlparse(url)
+    host = parsed.hostname or "localhost"
+    port = parsed.port or 6379
+    return host, port
+
+
+def _to_float32_bytes(vec) -> bytes:
+    """
+    Convert a sequence of numeric values into a bytes representation using 32-bit floats.
+
+    Args:
+        vec (Iterable[float]): A sequence of numbers (e.g., list, tuple) to be converted.
+
+    Returns:
+        bytes: A binary representation of the input values packed as consecutive 32-bit floats.
+
+    Notes:
+        - Uses `struct.pack` with the format string `"{len(vec)}f"`, which packs all values as
+          IEEE 754 single-precision floats.
+        - Ensures compatibility with vector databases or embedding engines that require raw
+          float32 byte arrays.
+    """
+
+    return struct.pack(f"{len(vec)}f", *map(float, vec))
+
+
+@singledispatch
+def _serialize_for_json(obj: Any) -> Any:
+    """Convert objects to JSON-serializable format.
+    This id default serialization: return the object as-is.
+
+    Args:
+        obj: Object to serialize (UUID, dict, list, or any other type).
+
+    Returns:
+        JSON-serializable representation of the object.
+    """
+    return obj
+
+
+@_serialize_for_json.register
+def _(obj: UUID) -> str:
+    return str(obj)
+
+
+@_serialize_for_json.register
+def _(obj: dict) -> dict:
+    return {k: _serialize_for_json(v) for k, v in obj.items()}
+
+
+@_serialize_for_json.register
+def _(obj: list) -> list:
+    return [_serialize_for_json(item) for item in obj]
+
+
+def _b2s(x: bytes | bytearray | str) -> str:
+    """Convert bytes or bytearray to a UTF-8 string if possible,
+        otherwise return a string representation.
+
+    Args:
+        x (Any): The input value, which may be bytes, bytearray, or any other type.
+
+    Returns:
+        Any: A decoded UTF-8 string if `x` is bytes or bytearray; otherwise, returns `x` unchanged.
+            If decoding fails, returns the string representation of `x`.
+    """
+
+    if isinstance(x, (bytes, bytearray)):
+        try:
+            return x.decode("utf-8")
+        except Exception:
+            return str(x)
+    return x
+
+
+def _build_scored_results_from_ft(
+    raw: Any,
+    *,
+    use_key_suffix_when_missing_id: bool = True,
+) -> list[ScoredResult]:
+    """Build a list of `ScoredResult` objects from raw FT (Full-Text) search response.
+
+    Args:
+        raw (Any): The raw response from Valkey's FT search command, expected to be a list or tuple
+                   where the second element is a mapping of keys to field dictionaries.
+        use_key_suffix_when_missing_id (bool): If True, use the key string as the ID when the `id`
+                   field is missing in the response.
+
+    Returns:
+        list[ScoredResult]: A list of scored results, each containing:
+            - id (str): Extracted from `id` field or fallback to key.
+            - payload (dict): Parsed JSON from `payload_data` field, or raw string if malformed.
+            - score (float | None): Extracted from `__vector_score` field if present.
+
+    Notes:
+        - Handles both byte keys and string keys by decoding them.
+        - Gracefully falls back when fields are missing or payload is invalid JSON.
+    """
+    if not isinstance(raw, (list, tuple)) or len(raw) < 2 or not isinstance(raw[1], dict):
+        return []
+
+    mapping: dict[Any, dict[Any, Any]] = raw[1]  # the { key -> fields } dict
+    scored: list[ScoredResult] = []
+
+    for key_bytes, fields in mapping.items():
+        key_str = _b2s(key_bytes)
+
+        # Extract id
+        raw_id = fields.get(b"id") if b"id" in fields else fields.get("id")
+        if raw_id is not None:
+            result_id = _b2s(raw_id)
+        else:
+            result_id = key_str
+
+        # Extrat score
+        score = (
+            fields.get(b"__vector_score")
+            if b"__vector_score" in fields
+            else fields.get("__vector_score")
+        )
+        if score is not None:
+            score = float(score)
+
+        # Extract and parse payload_data
+        payload_raw = (
+            fields.get(b"payload_data") if b"payload_data" in fields else fields.get("payload_data")
+        )
+        payload: dict[str, Any] = {}
+        if payload_raw is not None:
+            payload_str = _b2s(payload_raw)
+            if isinstance(payload_str, str):
+                try:
+                    obj = json.loads(payload_str)
+                    if isinstance(obj, dict):
+                        payload = obj
+                    else:
+                        # If it's not a dict (e.g., list), wrap it
+                        payload = {"_payload": obj}
+                except json.JSONDecodeError:
+                    # Keep the raw string if malformed
+                    payload = {"_payload_raw": payload_str}
+
+        scored.append(
+            ScoredResult(
+                id=result_id,
+                payload=payload,
+                score=score,
+            )
+        )
+
+    return scored

cognee_community_vector_adapter_valkey/valkey_adapter.py

@@ -0,0 +1,535 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+from cognee.infrastructure.databases.exceptions import MissingQueryParameterError
+from cognee.infrastructure.databases.vector import VectorDBInterface
+from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import (
+    EmbeddingEngine,
+)
+from cognee.infrastructure.databases.vector.models.ScoredResult import ScoredResult
+from cognee.infrastructure.engine import DataPoint
+from cognee.shared.logging_utils import get_logger
+from glide import (
+    BackoffStrategy,
+    GlideClient,
+    GlideClientConfiguration,
+    NodeAddress,
+    ft,
+    glide_json,
+)
+from glide_shared.commands.server_modules.ft_options.ft_create_options import (
+    DataType,
+    DistanceMetricType,
+    FtCreateOptions,
+    TagField,
+    VectorAlgorithm,
+    VectorField,
+    VectorFieldAttributesHnsw,
+    VectorType,
+)
+from glide_shared.commands.server_modules.ft_options.ft_search_options import (
+    FtSearchOptions,
+    ReturnField,
+)
+from glide_shared.exceptions import RequestError
+
+from .exceptions import CollectionNotFoundError, ValkeyVectorEngineInitializationError
+from .utils import (
+    _build_scored_results_from_ft,
+    _parse_host_port,
+    _serialize_for_json,
+    _to_float32_bytes,
+)
+
+logger = get_logger("ValkeyAdapter")
+
+
+class ValkeyAdapter(VectorDBInterface):
+    """Valkey vector database adapter using ValkeyGlide for vector similarity search.
+
+    This adapter provides an implementation of the `VectorDBInterface` for Valkey,
+    enabling vector storage, retrieval, and similarity search using Valkey's
+    full-text and vector indexing capabilities.
+    """
+
+    name = "Valkey"
+    url: str | None
+    api_key: str | None = None
+    embedding_engine: EmbeddingEngine | None = None
+
+    def __init__(
+        self,
+        url: str | None,
+        api_key: str | None = None,
+        database_name: str = "cognee",
+        embedding_engine: EmbeddingEngine | None = None,
+    ) -> None:
+        """Initialize the Valkey adapter.
+
+        Args:
+            url (str): Connection string for your Valkey instance like valkey://localhost:6379.
+            embedding_engine: Engine for generating embeddings.
+            api_key: Optional API key. Ignored for Valkey.
+
+        Raises:
+            ValkeyVectorEngineInitializationError: If required parameters are missing.
+        """
+
+        if not embedding_engine:
+            raise ValkeyVectorEngineInitializationError(
+                "Embedding engine is required. Provide 'embedding_engine' to the Valkey adapter."
+            )
+
+        self.url = url
+        self._host, self._port = _parse_host_port(url)
+        self.database_name = database_name
+        self.embedding_engine = embedding_engine
+        self._client: GlideClient | None = None
+        self._connected = False
+        self.VECTOR_DB_LOCK = asyncio.Lock()
+
+    # -------------------- lifecycle --------------------
+
+    async def get_connection(self) -> GlideClient:
+        """Establish and return an asynchronous Glide client connection to the Valkey server.
+
+        If a connection already exists and is marked as active, it will be reused.
+        Otherwise, a new connection is created using the configured host and port.
+
+        Returns:
+            GlideClient: An active Glide client instance for executing Valkey commands.
+
+        Behavior:
+            - Uses a backoff reconnect strategy with 3 retries and exponential delay.
+            - Disables TLS by default (set `use_tls=True` in configuration if needed).
+            - Sets a request timeout of 5000 ms.
+        """
+
+        if self._connected and self._client is not None:
+            return self._client
+
+        cfg = GlideClientConfiguration(
+            [NodeAddress(self._host, self._port)],
+            use_tls=False,
+            request_timeout=5000,
+            reconnect_strategy=BackoffStrategy(num_of_retries=3, factor=1000, exponent_base=2),
+        )
+        self._client = await GlideClient.create(cfg)
+        self._connected = True
+
+        return self._client
+
+    async def close(self) -> None:
+        """Close the active Glide client connection to the Valkey server.
+
+        If a client connection exists, attempts to close it gracefully.
+        Any exceptions during closure are suppressed to avoid breaking cleanup logic.
+
+        After closing:
+            - The internal client reference is set to None.
+            - The connection state flag (`_connected`) is reset to False.
+
+        Returns:
+            None
+
+        """
+
+        if self._client is not None:
+            try:
+                await self._client.close()
+            except Exception as e:
+                logger.error("Failed to close Valkey client: %e", e)
+                pass
+        self._client = None
+        self._connected = False
+
+    # -------------------- helpers --------------------
+
+    def _index_name(self, collection: str) -> str:
+        return f"index:{collection}"
+
+    def _key_prefix(self, collection: str) -> str:
+        return f"vdb:{collection}:"
+
+    def _key(self, collection: str, pid: str) -> str:
+        return f"{self._key_prefix(collection)}{pid}"
+
+    def _ensure_dims(self) -> int:
+        dims = self.embedding_engine.get_dimensions()
+        return int(dims)
+
+    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)
+
+    # -------------------- VectorDBInterface methods --------------------
+
+    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.
+        """
+        client = await self.get_connection()
+        try:
+            await ft.info(client, self._index_name(collection_name))
+            return True
+        except Exception as e:
+            logger.warning("Valkey index check failed for '%s': %s", collection_name, e)
+            return False
+
+    async def create_collection(
+        self,
+        collection_name: str,
+        payload_schema: Any | None = None,
+    ) -> None:
+        """Create a new collection (Valkey 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.
+        """
+        async with self.VECTOR_DB_LOCK:
+            try:
+                if await self.has_collection(collection_name):
+                    logger.info(f"Collection {collection_name} already exists")
+                    return
+
+                fields = [
+                    TagField("id"),
+                    VectorField(
+                        name="vector",
+                        algorithm=VectorAlgorithm.HNSW,
+                        attributes=VectorFieldAttributesHnsw(
+                            dimensions=self.embedding_engine.get_vector_size(),
+                            distance_metric=DistanceMetricType.COSINE,
+                            type=VectorType.FLOAT32,
+                        ),
+                    ),
+                ]
+                prefixes = [self._key_prefix(collection_name)]
+                options = FtCreateOptions(DataType.JSON, prefixes)
+                index = self._index_name(collection_name)
+
+                ok = await ft.create(self._client, index, fields, options)
+                if ok not in (b"OK", "OK"):
+                    raise Exception(f"FT.CREATE failed for index '{index}': {ok!r}")
+
+            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:
+        """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.
+        """
+        client = await self.get_connection()
+        assert self._client is not None
+
+        try:
+            if not await self.has_collection(collection_name):
+                raise CollectionNotFoundError(f"Collection {collection_name} not found!")
+
+            # Embed the data points
+            data_to_embed = [
+                DataPoint.get_embeddable_data(data_point) for data_point in data_points
+            ]
+            data_vectors = await self.embed_data(data_to_embed)
+
+            documents = []
+            for data_point, embedding in zip(data_points, data_vectors, strict=False):
+                payload = _serialize_for_json(data_point.model_dump())
+
+                doc_data = {
+                    "id": str(data_point.id),
+                    "vector": embedding,
+                    "payload_data": json.dumps(payload),  # Store as JSON string
+                }
+
+                documents.append(
+                    glide_json.set(
+                        client,
+                        self._key(collection_name, str(data_point.id)),
+                        "$",
+                        json.dumps(doc_data),
+                    )
+                )
+
+            await asyncio.gather(*documents)
+
+        except RequestError as e:
+            # Helpful guidance if JSON vector arrays aren't supported by the deployed module
+            logger.error(f"JSON.SET failed: {e}")
+            raise e
+
+        except Exception as e:
+            logger.error(f"Error creating data points: {str(e)}")
+            raise e
+
+    # TODO: Add this and fix issues
+    # async def create_vector_index(self, index_name: str, index_property_name: str):
+    #     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]
+    # ):
+    #     """Index data points in the collection."""
+    #
+    #     await self.create_data_points(f"{index_name}_{index_property_name}", data_points)
+
+    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.
+        """
+        client = await self.get_connection()
+        assert self._client is not None
+
+        try:
+            results = []
+            for data_id in data_point_ids:
+                key = self._key(collection_name, data_id)
+                raw_doc = await glide_json.get(client, key, "$")
+                if raw_doc:
+                    doc = json.loads(raw_doc)
+                    payload_str = doc[0]["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(raw_doc)
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Error retrieving data points: {str(e)}")
+            return []
+
+    async def search(
+        self,
+        collection_name: str,
+        query_text: str | None = None,
+        query_vector: list[float] | None = None,
+        limit: int | None = 15,
+        with_vector: bool = False,
+        include_payload: 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.
+            include_payload: Whether to include payloads in results.
+
+        Returns:
+            List of ScoredResult objects sorted by similarity.
+
+        Raises:
+            MissingQueryParameterError: If neither query_text nor query_vector is provided.
+            Exception: If search execution fails.
+        """
+        client = await self.get_connection()
+        assert self._client is not None
+
+        if query_text is None and query_vector is None:
+            raise MissingQueryParameterError()
+
+        if not await self.has_collection(collection_name):
+            logger.warning(
+                f"Collection '{collection_name}' not found in ValkeyAdapter.search; returning []."
+            )
+            return []
+
+        if limit is None:
+            info = await ft.info(client, self._index_name(collection_name))
+            limit = info["num_docs"]
+
+        if limit <= 0:
+            return []
+
+        try:
+            # Get the query vector
+            if query_vector is None:
+                [vec] = await self.embed_data([query_text])
+            else:
+                vec = query_vector
+            vec_bytes = _to_float32_bytes(vec)
+
+            # Set return fields
+            return_fields = [
+                ReturnField("$.id", alias="id"),
+                ReturnField("__vector_score", alias="score"),
+            ]
+            if include_payload:
+                return_fields.append(ReturnField("$.payload_data", alias="payload_data"))
+            if with_vector:
+                return_fields.append(ReturnField("$.vector", alias="vector"))
+
+            vector_param_name = "query_vector"
+            query = f"*=>[KNN {limit} @vector ${vector_param_name}]"
+            query_options = FtSearchOptions(
+                params={vector_param_name: vec_bytes}, return_fields=return_fields
+            )
+
+            # Execute the search
+            raw_results = await ft.search(
+                client=client,
+                index_name=self._index_name(collection_name),
+                query=query,
+                options=query_options,
+            )
+
+            scored_results = _build_scored_results_from_ft(raw_results)
+            return scored_results
+
+        except Exception as e:
+            logger.error(f"Error during search: {str(e)}")
+            raise e
+
+    async def batch_search(
+        self,
+        collection_name: str,
+        query_texts: list[str],
+        limit: int | None,
+        with_vectors: bool = False,
+        score_threshold: float | None = 0.1,
+        max_concurrency: int = 10,
+        include_payload: 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.
+            score_threshold: threshold for filtering scores.
+            max_concurrency: maximum number of concurrent searches.
+            include_payload: Whether to include payloads in results.
+
+        Returns:
+            List of search results for each query, filtered by score threshold.
+        """
+        if not await self.has_collection(collection_name):
+            logger.warning(
+                f"Collection '{collection_name}' not found in ValkeyAdapter.search; returning []."
+            )
+            return []
+
+        # Embed all queries at once
+        vectors = await self.embed_data(query_texts)
+
+        # Execute searches in parallel
+        semaphore = asyncio.Semaphore(max_concurrency)
+
+        async def limited_search(vector):
+            async with semaphore:
+                return await self.search(
+                    collection_name=collection_name,
+                    query_vector=vector,
+                    limit=limit,
+                    with_vector=with_vectors,
+                    include_payload=include_payload,
+                )
+
+        tasks = [limited_search(vector) for vector in vectors]
+        results = await asyncio.gather(*tasks)
+
+        # Filter results by a score threshold
+        return [
+            [result for result in result_group if result.score < score_threshold]
+            for result_group in results
+        ]
+
+    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.
+        """
+        client = await self.get_connection()
+        assert self._client is not None
+
+        ids = [self._key(collection_name, id) for id in data_point_ids]
+
+        try:
+            deleted_count = await client.delete(ids)
+            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
+
+    async def prune(self):
+        """Remove all collections and data from Valkey.
+
+        This method drops all existing indices and clears the internal cache.
+
+        Raises:
+            Exception: If pruning fails.
+        """
+        client = await self.get_connection()
+        assert self._client is not None
+        try:
+            all_indexes = await ft.list(client)
+            for index in all_indexes:
+                await ft.dropindex(client, index)
+                logger.info(f"Dropped index {index}")
+
+        except Exception as e:
+            logger.error(f"Error during prune: {str(e)}")
+            raise e

cognee_community_vector_adapter_valkey-0.1.1.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: cognee-community-vector-adapter-valkey
+Version: 0.1.1
+Summary: Valkey vector database adapter for cognee
+Requires-Python: <=3.13,>=3.11
+Requires-Dist: cognee==0.5.2
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: valkey-glide>=2.1.0
+Provides-Extra: dev
+Requires-Dist: anyio>=4.0; extra == 'dev'
+Requires-Dist: mypy>=1.17.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=7.4; extra == 'test'
+Requires-Dist: valkey-glide>=2.1.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Cognee Valkey Vector Adapter
+
+A Valkey vector database adapter for Cognee using Valkey Glide, providing high-performance vector storage and retrieval for AI memory applications. Compared to the Redis adapter, Valkey offers a fully open-source, community-driven architecture without the licensing restrictions of Redis. Using Valkey Glide ensures efficient async operations and native support for Valkey’s enhancements, providing optimal compatibility and performance when running on Valkey, making it the best choice for teams adopting Valkey as their primary in-memory vector solution.
+
+## Features
+
+- Full support for vector embeddings storage and retrieval
+- Batch / pipeline operations for efficient processing
+- Automatic embedding generation via configurable embedding engines
+- Comprehensive error handling
+
+## Installation
+
+If published, the package can be simply installed via pip:
+
+```bash
+pip install cognee-community-vector-adapter-valkey
+```
+
+In case it is not published yet, you can use poetry to locally build the adapter package:
+
+```bash
+pip install uv
+uv sync --all-extras
+```
+
+## Prerequisites
+
+You need a Valkey instance with the Valkey Search module enabled. You can use:
+
+1. **Valkey**:
+   ```bash
+   docker run -d --name valkey -p 6379:6379 valkey/valkey-bundle
+   ```
+   
+## Examples
+Checkout the `examples/` folder!
+
+```bash
+uv run examples/example.py
+```
+
+>You will need an OpenAI API key to run the example script.
+
+## Configuration
+
+Configure Valkey as your vector database in cognee:
+
+- `vector_db_provider`: Set to "valkey"
+- `vector_db_url`: Valkey connection URL (e.g., "valkey://localhost:6379")
+
+### Environment Variables
+
+Set the following environment variables or pass them directly in the config:
+
+```bash
+export VECTOR_DB_URL="valkey://localhost:6379"
+```
+
+### Connection URL Examples
+
+```python
+# Local Valkey
+config.set_vector_db_config({
+    "vector_db_provider": "valkey",
+    "vector_db_url": "valkey://localhost:6379"
+})
+
+# Valkey with authentication
+config.set_vector_db_config({
+    "vector_db_provider": "valkey", 
+    "vector_db_url": "valkey://user:password@localhost:6379"
+})
+```
+
+## Requirements
+
+- Python >= 3.11, <= 3.13
+- valkey-glide >= 2.1.0
+- cognee >= 0.4.0
+
+## Advanced Usage
+
+For direct adapter usage (advanced users only):
+
+```python
+from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import EmbeddingEngine
+from cognee_community_vector_adapter_valkey import ValkeyAdapter
+from cognee.infrastructure.engine import DataPoint
+
+# Initialize embedding engine and adapter
+embedding_engine = EmbeddingEngine(model="your-model")
+valkey_adapter = ValkeyAdapter(
+    url="valkey://localhost:6379",
+    embedding_engine=embedding_engine
+)
+
+# Direct adapter operations
+await valkey_adapter.create_collection("my_collection")
+data_points = [DataPoint(id="1", text="Hello", metadata={"index_fields": ["text"]})]
+await valkey_adapter.create_data_points("my_collection", data_points)
+results = await valkey_adapter.search("my_collection", query_text="Hello", limit=10)
+```
+
+## Error Handling
+
+The adapter includes comprehensive error handling:
+
+- `VectorEngineInitializationError`: Raised when required parameters are missing
+- `CollectionNotFoundError`: Raised when attempting operations on non-existent collections
+- `InvalidValueError`: Raised for invalid query parameters
+- Graceful handling of connection failures and embedding errors
+
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Errors**: Ensure Valkey is running and accessible at the specified URL
+2. **Search Module Missing**: Make sure Valkey has the Search module enabled
+3. **Embedding Dimension Mismatch**: Verify embedding engine dimensions match index configuration
+4. **Collection Not Found**: Always create collections before adding data points
+
+### Debug Logging
+
+The adapter uses Cognee's logging system. Enable debug logging to see detailed operation logs:
+
+```python
+import logging
+logging.getLogger("ValkeyAdapter").setLevel(logging.DEBUG)
+```
+
+## Development
+
+To contribute or modify the adapter:
+
+1. Clone the repository and `cd` into the `valkey` folder
+2. Install dependencies: `uv sync --all-extras`
+3. Make sure a Valkey instance is running (see above)
+5. Make your changes, test, and submit a PR

cognee_community_vector_adapter_valkey-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+cognee_community_vector_adapter_valkey/__init__.py,sha256=jEC7tJHqvrLazHCBOU22molo1p_FkjMjUItxEEoxTZA,226
+cognee_community_vector_adapter_valkey/exceptions.py,sha256=mMxiVP0eOTwrrwtPVPWJFKv7Ur4Oky2_6qAeaEeB5g0,247
+cognee_community_vector_adapter_valkey/register.py,sha256=Eh4lgm6TISLw3dfq2RuNpcMubvo9Kf5-wRvJ6VxClWU,158
+cognee_community_vector_adapter_valkey/utils.py,sha256=dFiXNsd8WaX3gDf5o25Dz6lS0FtqnACYyOGSdIg0Lx4,5664
+cognee_community_vector_adapter_valkey/valkey_adapter.py,sha256=BAzMXboHX7nRdHCHENlrJ29sP7gKWs1qUo3psPzqyhk,18481
+cognee_community_vector_adapter_valkey-0.1.1.dist-info/METADATA,sha256=vRe5w9-vXTF0ZsLBTQE0yCwbEI91ELapKpCtyO6nxUY,4975
+cognee_community_vector_adapter_valkey-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cognee_community_vector_adapter_valkey-0.1.1.dist-info/RECORD,,

cognee_community_vector_adapter_valkey-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any