cognee-community-vector-adapter-qdrant 0.0.2__tar.gz → 0.1.0__tar.gz

cognee_community_vector_adapter_qdrant-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: cognee-community-vector-adapter-qdrant
+Version: 0.1.0
+Summary: Qdrant vector database adapter for cognee
+Requires-Python: >=3.11,<=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: cognee (>=0.4.0)
+Requires-Dist: instructor (>=1.11)
+Requires-Dist: qdrant-client (>=1.16.0)
+Requires-Dist: starlette (>=0.48.0)
+Description-Content-Type: text/markdown
+
+# Cognee Qdrant Adapter
+
+## Installation
+
+If published, the package can be simply installed via pip:
+
+```bash
+pip install cognee-community-vector-adapter-qdrant
+```
+
+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
+```
+
+## Connection Setup
+
+For a quick local setup, you can run a docker container that qdrant provides (https://qdrant.tech/documentation/quickstart/). 
+After this, you will be able to connect to the Qdrant DB through the appropriate ports. The command for running the docker 
+container looks something like the following:
+
+```
+docker run -p 6333:6333 -p 6334:6334 \
+    -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
+    qdrant/qdrant
+```
+
+## Usage
+
+Import and register the adapter in your code:
+```python
+from cognee_community_vector_adapter_qdrant import register
+```
+
+## Example
+See example in `example.py` file.
+

cognee_community_vector_adapter_qdrant-0.1.0/README.md

@@ -0,0 +1,38 @@
+# Cognee Qdrant Adapter
+
+## Installation
+
+If published, the package can be simply installed via pip:
+
+```bash
+pip install cognee-community-vector-adapter-qdrant
+```
+
+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
+```
+
+## Connection Setup
+
+For a quick local setup, you can run a docker container that qdrant provides (https://qdrant.tech/documentation/quickstart/). 
+After this, you will be able to connect to the Qdrant DB through the appropriate ports. The command for running the docker 
+container looks something like the following:
+
+```
+docker run -p 6333:6333 -p 6334:6334 \
+    -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
+    qdrant/qdrant
+```
+
+## Usage
+
+Import and register the adapter in your code:
+```python
+from cognee_community_vector_adapter_qdrant import register
+```
+
+## Example
+See example in `example.py` file.

{cognee_community_vector_adapter_qdrant-0.0.2 → cognee_community_vector_adapter_qdrant-0.1.0}/cognee_community_vector_adapter_qdrant/__init__.py

@@ -1,3 +1,3 @@
 from .qdrant_adapter import QDrantAdapter
 
-__all__ = ["QDrantAdapter"] 
+__all__ = ["QDrantAdapter"]

{cognee_community_vector_adapter_qdrant-0.0.2 → cognee_community_vector_adapter_qdrant-0.1.0}/cognee_community_vector_adapter_qdrant/qdrant_adapter.py

@@ -1,16 +1,16 @@
 import asyncio
-from typing import Dict, List, Optional
-from qdrant_client import AsyncQdrantClient, models
-
-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,
+)
 from cognee.infrastructure.databases.vector.exceptions import CollectionNotFoundError
+from cognee.infrastructure.databases.vector.models.ScoredResult import ScoredResult
+from cognee.infrastructure.engine import DataPoint
+from cognee.infrastructure.engine.utils import parse_id
+from cognee.shared.logging_utils import get_logger
+from qdrant_client import AsyncQdrantClient, models
 
 logger = get_logger("QDrantAdapter")
 
@@ -21,20 +21,19 @@ class IndexSchema(DataPoint):
     metadata: dict = {"index_fields": ["text"]}
 
 
-
-def create_hnsw_config(hnsw_config: Dict):
+def create_hnsw_config(hnsw_config: dict):
     if hnsw_config is not None:
         return models.HnswConfig()
     return None
 
 
-def create_optimizers_config(optimizers_config: Dict):
+def create_optimizers_config(optimizers_config: dict):
     if optimizers_config is not None:
         return models.OptimizersConfig()
     return None
 
 
-def create_quantization_config(quantization_config: Dict):
+def create_quantization_config(quantization_config: dict):
     if quantization_config is not None:
         return models.QuantizationConfig()
     return None
@@ -64,7 +63,7 @@ class QDrantAdapter(VectorDBInterface):
 
         return AsyncQdrantClient(location=":memory:")
 
-    async def embed_data(self, data: List[str]) -> List[float]:
+    async def embed_data(self, data: list[str]) -> list[float]:
         return await self.embedding_engine.embed_text(data)
 
     async def has_collection(self, collection_name: str) -> bool:
@@ -86,14 +85,15 @@ class QDrantAdapter(VectorDBInterface):
                     collection_name=collection_name,
                     vectors_config={
                         "text": models.VectorParams(
-                            size=self.embedding_engine.get_vector_size(), distance="Cosine"
+                            size=self.embedding_engine.get_vector_size(),
+                            distance="Cosine",
                         )
                     },
                 )
 
             await client.close()
 
-    async def create_data_points(self, collection_name: str, data_points: List[DataPoint]):
+    async def create_data_points(self, collection_name: str, data_points: list[DataPoint]):
         from qdrant_client.http.exceptions import UnexpectedResponse
 
         client = self.get_qdrant_client()
@@ -112,7 +112,8 @@ class QDrantAdapter(VectorDBInterface):
         points = [convert_to_qdrant_point(point) for point in data_points]
 
         try:
-            client.upload_points(collection_name=collection_name, points=points)
+            # Use upsert for AsyncQdrantClient (upload_points doesn't exist or is sync)
+            await client.upsert(collection_name=collection_name, points=points)
         except UnexpectedResponse as error:
             if "Collection not found" in str(error):
                 raise CollectionNotFoundError(
@@ -152,15 +153,13 @@ class QDrantAdapter(VectorDBInterface):
     async def search(
         self,
         collection_name: str,
-        query_text: Optional[str] = None,
-        query_vector: Optional[List[float]] = None,
-        limit: int = 15,
+        query_text: str | None = None,
+        query_vector: list[float] | None = None,
+        limit: int | None = 15,
         with_vector: bool = False,
-    ) -> List[ScoredResult]:
-        from qdrant_client.http.exceptions import UnexpectedResponse
-
+    ) -> list[ScoredResult]:
         if query_text is None and query_vector is None:
-            raise InvalidValueError(message="One of query_text or query_vector must be provided!")
+            raise MissingQueryParameterError()
 
         if not await self.has_collection(collection_name):
             return []
@@ -168,44 +167,53 @@ class QDrantAdapter(VectorDBInterface):
         if query_vector is None:
             query_vector = (await self.embed_data([query_text]))[0]
 
+        client = None
         try:
             client = self.get_qdrant_client()
-            if limit == 0:
+            if limit is None:
                 collection_size = await client.count(collection_name=collection_name)
+                limit = collection_size.count
+            if limit == 0:
+                await client.close()
+                return []
 
-            results = await client.search(
+            # Use query_points instead of search (API change in qdrant-client)
+            # query_points is the correct method for AsyncQdrantClient
+            query_result = await client.query_points(
                 collection_name=collection_name,
-                query_vector=models.NamedVector(
-                    name="text",
-                    vector=query_vector
-                    if query_vector is not None
-                    else (await self.embed_data([query_text]))[0],
-                ),
-                limit=limit if limit > 0 else collection_size.count,
+                query=query_vector,
+                using="text",
+                limit=limit,
                 with_vectors=with_vector,
             )
 
             await client.close()
 
+            # Extract points from query_result
+            results = query_result.points
+
             return [
                 ScoredResult(
-                    id=parse_id(result.id),
+                    id=parse_id(str(result.id)),
                     payload={
                         **result.payload,
-                        "id": parse_id(result.id),
+                        "id": parse_id(str(result.id)),
                     },
-                    score=1 - result.score,
+                    score=1 - result.score if hasattr(result, 'score') else 1.0,
                 )
                 for result in results
             ]
-        finally:
-            await client.close()
+        except Exception as e:
+            logger.error(f"Error in Qdrant search: {e}", exc_info=True)
+            if client:
+                await client.close()
+            return []
 
     async def batch_search(
         self,
         collection_name: str,
-        query_texts: List[str],
-        limit: int = None,
+        query_texts: list[str],
+        limit: int | None = None,
         with_vectors: bool = False,
     ):
         """
@@ -215,32 +223,50 @@ class QDrantAdapter(VectorDBInterface):
         - collection_name (str): Name of the collection to search in.
         - query_texts (List[str]): List of query texts to search for.
         - limit (int): List of result limits for search requests.
-        - with_vectors (bool, optional): Bool indicating whether to return vectors for search requests.
+        - with_vectors (bool, optional): Bool indicating whether to return
+                                         vectors for search requests.
 
         Returns:
         - results: The search results from Qdrant.
         """
 
-        vectors = await self.embed_data(query_texts)
-
-        # Generate dynamic search requests based on the provided embeddings
-        requests = [
-            models.SearchRequest(
-                vector=models.NamedVector(name="text", vector=vector),
-                limit=limit,
-                with_vector=with_vectors,
-            )
-            for vector in vectors
-        ]
+        client = self.get_qdrant_client()
+        if limit is None:
+            collection_size = await client.count(collection_name=collection_name)
+            limit = collection_size.count
+        if limit == 0:
+            await client.close()
+            return []
 
         client = self.get_qdrant_client()
 
-        # Perform batch search with the dynamically generated requests
-        results = await client.search_batch(collection_name=collection_name, requests=requests)
+        try:
+            # Use query_batch instead of search_batch (API change in qdrant-client)
+            # query_batch is the correct method for AsyncQdrantClient
+            query_results = await client.query_batch(
+                collection_name=collection_name,
+                query_texts=query_texts,
+                limit=limit,
+                with_vectors=with_vectors,
+            )
 
-        await client.close()
+            await client.close()
 
-        return [filter(lambda result: result.score > 0.9, result_group) for result_group in results]
+            # Extract points from each query result and filter by score
+            filtered_results = []
+            for query_result in query_results:
+                points = query_result.points if hasattr(query_result, 'points') else []
+                filtered_points = [
+                    result for result in points
+                    if hasattr(result, 'score') and result.score > 0.9
+                ]
+                filtered_results.append(filtered_points)
+
+            return filtered_results
+        except Exception as e:
+            logger.error(f"Error in Qdrant batch_search: {e}", exc_info=True)
+            await client.close()
+            return []
 
     async def delete_data_points(self, collection_name: str, data_point_ids: list[str]):
         client = self.get_qdrant_client()
@@ -256,3 +282,21 @@ class QDrantAdapter(VectorDBInterface):
             await client.delete_collection(collection.name)
 
         await client.close()
+
+    async def get_collection_names(self) -> list[str]:
+        """
+        Get names of all collections in the database.
+
+        Returns:
+            list[str]: List of collection names.
+        """
+
+        client = self.get_qdrant_client()
+
+        response = await client.get_collections()
+
+        result = [collection.name for collection in response.collections]
+
+        await client.close()
+
+        return result

{cognee_community_vector_adapter_qdrant-0.0.2 → cognee_community_vector_adapter_qdrant-0.1.0}/pyproject.toml

@@ -1,10 +1,12 @@
 [project]
 name = "cognee-community-vector-adapter-qdrant"
-version = "0.0.2"
+version = "0.1.0"
 description = "Qdrant vector database adapter for cognee"
 readme = "README.md"
 requires-python = ">=3.11,<=3.13"
 dependencies = [
-    "qdrant-client>=1.14.2",
-    "cognee>=0.2.1",
+    "qdrant-client>=1.16.0",
+    "cognee>=0.4.0",
+    "starlette>=0.48.0",
+    "instructor>=1.11"
 ]

cognee_community_vector_adapter_qdrant-0.0.2/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.3
-Name: cognee-community-vector-adapter-qdrant
-Version: 0.0.2
-Summary: Qdrant vector database adapter for cognee
-Requires-Python: >=3.11,<=3.13
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: cognee (>=0.2.1)
-Requires-Dist: qdrant-client (>=1.14.2)
-Description-Content-Type: text/markdown
-
-# Cognee Qdrant Adapter
-
-## Install
-
-Install [`qdrant-client`](https://pypi.org/project/qdrant-client/) in your project.
-
-Put this line of code somewhere at the start of the execution, before cognee is initiated.
-
-```python
-import packages.vector.qdrant.register
-```
-
-## Example
-See example in `example.py` file.
-

cognee_community_vector_adapter_qdrant-0.0.2/README.md

@@ -1,14 +0,0 @@
-# Cognee Qdrant Adapter
-
-## Install
-
-Install [`qdrant-client`](https://pypi.org/project/qdrant-client/) in your project.
-
-Put this line of code somewhere at the start of the execution, before cognee is initiated.
-
-```python
-import packages.vector.qdrant.register
-```
-
-## Example
-See example in `example.py` file.