agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/vectordb/pineconedb/pineconedb.py

@@ -22,6 +22,7 @@ except ImportError:
     raise ImportError("The `pinecone` package is not installed, please install using `pip install pinecone`.")
 
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
 from agno.knowledge.reranker.base import Reranker
@@ -66,9 +67,11 @@ class PineconeDb(VectorDb):
 
     def __init__(
         self,
-        name: str,
         dimension: int,
         spec: Union[Dict, ServerlessSpec, PodSpec],
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        id: Optional[str] = None,
         embedder: Optional[Embedder] = None,
         metric: Optional[str] = "cosine",
         additional_headers: Optional[Dict[str, str]] = None,
@@ -84,6 +87,23 @@ class PineconeDb(VectorDb):
         reranker: Optional[Reranker] = None,
         **kwargs,
     ):
+        # Validate required parameters
+        if dimension is None or dimension <= 0:
+            raise ValueError("Dimension must be provided and greater than 0.")
+        if spec is None:
+            raise ValueError("Spec must be provided for Pinecone index.")
+
+        # Dynamic ID generation based on unique identifiers
+        if id is None:
+            from agno.utils.string import generate_id
+
+            index_name = name or "default_index"
+            seed = f"{host or 'pinecone'}#{index_name}#{dimension}"
+            id = generate_id(seed)
+
+        # Initialize base class with name, description, and generated ID
+        super().__init__(id=id, name=name, description=description)
+
         self._client = None
         self._index = None
         self.api_key: Optional[str] = api_key
@@ -93,7 +113,6 @@ class PineconeDb(VectorDb):
         self.pool_threads: Optional[int] = pool_threads
         self.namespace: Optional[str] = namespace
         self.index_api: Optional[Any] = index_api
-        self.name: str = name
         self.dimension: Optional[int] = dimension
         self.spec: Union[Dict, ServerlessSpec, PodSpec] = spec
         self.metric: Optional[str] = metric
@@ -198,23 +217,6 @@ class PineconeDb(VectorDb):
             log_debug(f"Deleting index: {self.name}")
             self.client.delete_index(name=self.name, timeout=self.timeout)
 
-    def doc_exists(self, document: Document) -> bool:
-        """Check if a document exists in the index.
-
-        Args:
-            document (Document): The document to check.
-
-        Returns:
-            bool: True if the document exists, False otherwise.
-
-        """
-        response = self.index.fetch(ids=[document.id], namespace=self.namespace)
-        return len(response.vectors) > 0
-
-    async def async_doc_exists(self, document: Document) -> bool:
-        """Check if a document exists in the index asynchronously."""
-        return await asyncio.to_thread(self.doc_exists, document)
-
     def name_exists(self, name: str) -> bool:
         """Check if an index with the given name exists.
 
@@ -307,6 +309,8 @@ class PineconeDb(VectorDb):
         show_progress: bool = False,
     ) -> None:
         """Upsert documents into the index asynchronously with batching."""
+        if self.content_hash_exists(content_hash):
+            await asyncio.to_thread(self._delete_by_content_hash, content_hash)
         if not documents:
             return
 
@@ -320,7 +324,7 @@ class PineconeDb(VectorDb):
 
         # Process each batch in parallel
         async def process_batch(batch_docs):
-            return await self._prepare_vectors(batch_docs)
+            return await self._prepare_vectors(batch_docs, content_hash, filters)
 
         # Run all batches in parallel
         batch_vectors = await asyncio.gather(*[process_batch(batch) for batch in batches])
@@ -335,7 +339,9 @@ class PineconeDb(VectorDb):
 
         log_debug(f"Finished async upsert of {len(documents)} documents")
 
-    async def _prepare_vectors(self, documents: List[Document]) -> List[Dict[str, Any]]:
+    async def _prepare_vectors(
+        self, documents: List[Document], content_hash: str, filters: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
         """Prepare vectors for upsert."""
         vectors = []
 
@@ -382,11 +388,16 @@ class PineconeDb(VectorDb):
             doc.meta_data["text"] = doc.content
             # Include name and content_id in metadata
             metadata = doc.meta_data.copy()
+            if filters:
+                metadata.update(filters)
+
             if doc.name:
                 metadata["name"] = doc.name
             if doc.content_id:
                 metadata["content_id"] = doc.content_id
 
+            metadata["content_hash"] = content_hash
+
             data_to_upsert = {
                 "id": doc.id,
                 "values": doc.embedding,
@@ -447,7 +458,7 @@ class PineconeDb(VectorDb):
         self,
         query: str,
         limit: int = 5,
-        filters: Optional[Dict[str, Union[str, float, int, bool, List, dict]]] = None,
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         namespace: Optional[str] = None,
         include_values: Optional[bool] = None,
     ) -> List[Document]:
@@ -465,6 +476,9 @@ class PineconeDb(VectorDb):
             List[Document]: The list of matching documents.
 
         """
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in PineconeDB. No filters will be applied.")
+            filters = None
         dense_embedding = self.embedder.get_embedding(query)
 
         if self.use_hybrid_search:
@@ -513,7 +527,7 @@ class PineconeDb(VectorDb):
         self,
         query: str,
         limit: int = 5,
-        filters: Optional[Dict[str, Union[str, float, int, bool, List, dict]]] = None,
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         namespace: Optional[str] = None,
         include_values: Optional[bool] = None,
     ) -> List[Document]:
@@ -710,3 +724,7 @@ class PineconeDb(VectorDb):
         except Exception as e:
             logger.error(f"Error updating metadata for content_id '{content_id}': {e}")
             raise
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return []  # PineconeDb doesn't use SearchType enum

agno/vectordb/qdrant/qdrant.py

@@ -1,5 +1,5 @@
 from hashlib import md5
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 try:
     from qdrant_client import AsyncQdrantClient, QdrantClient  # noqa: F401
@@ -9,6 +9,7 @@ except ImportError:
         "The `qdrant-client` package is not installed. Please install it via `pip install qdrant-client`."
     )
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
 from agno.knowledge.reranker.base import Reranker
@@ -28,6 +29,9 @@ class Qdrant(VectorDb):
     def __init__(
         self,
         collection: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        id: Optional[str] = None,
         embedder: Optional[Embedder] = None,
         distance: Distance = Distance.cosine,
         location: Optional[str] = None,
@@ -52,6 +56,8 @@ class Qdrant(VectorDb):
         """
         Args:
             collection (str): Name of the Qdrant collection.
+            name (Optional[str]): Name of the vector database.
+            description (Optional[str]): Description of the vector database.
             embedder (Optional[Embedder]): Optional embedder for automatic vector generation.
             distance (Distance): Distance metric to use (default: cosine).
             location (Optional[str]): `":memory:"` for in-memory, or str used as `url`. If `None`, use default host/port.
@@ -73,6 +79,21 @@ class Qdrant(VectorDb):
             fastembed_kwargs (Optional[dict]): Keyword args for `fastembed.SparseTextEmbedding.__init__()`.
             **kwargs: Keyword args for `qdrant_client.QdrantClient.__init__()`.
         """
+        # Validate required parameters
+        if not collection:
+            raise ValueError("Collection name must be provided.")
+
+        # Dynamic ID generation based on unique identifiers
+        if id is None:
+            from agno.utils.string import generate_id
+
+            host_identifier = host or location or url or "localhost"
+            seed = f"{host_identifier}#{collection}"
+            id = generate_id(seed)
+
+        # Initialize base class with name, description, and generated ID
+        super().__init__(id=id, name=name, description=description)
+
         # Collection attributes
         self.collection: str = collection
 
@@ -238,33 +259,6 @@ class Qdrant(VectorDb):
                 else None,
             )
 
-    def doc_exists(self, document: Document) -> bool:
-        """
-        Validating if the document exists or not
-
-        Args:
-            document (Document): Document to validate
-        """
-        if self.client:
-            cleaned_content = document.content.replace("\x00", "\ufffd")
-            doc_id = md5(cleaned_content.encode()).hexdigest()
-            collection_points = self.client.retrieve(
-                collection_name=self.collection,
-                ids=[doc_id],
-            )
-            return len(collection_points) > 0
-        return False
-
-    async def async_doc_exists(self, document: Document) -> bool:
-        """Check if a document exists asynchronously."""
-        cleaned_content = document.content.replace("\x00", "\ufffd")
-        doc_id = md5(cleaned_content.encode()).hexdigest()
-        collection_points = await self.async_client.retrieve(
-            collection_name=self.collection,
-            ids=[doc_id],
-        )
-        return len(collection_points) > 0
-
     def name_exists(self, name: str) -> bool:
         """
         Validates if a document with the given name exists in the collection.
@@ -326,7 +320,9 @@ class Qdrant(VectorDb):
         points = []
         for document in documents:
             cleaned_content = document.content.replace("\x00", "\ufffd")
-            doc_id = md5(cleaned_content.encode()).hexdigest()
+            # Include content_hash in ID to ensure uniqueness across different content hashes
+            base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+            doc_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
 
             # TODO(v2.0.0): Remove conditional vector naming logic
             if self.use_named_vectors:
@@ -436,7 +432,9 @@ class Qdrant(VectorDb):
 
         async def process_document(document):
             cleaned_content = document.content.replace("\x00", "\ufffd")
-            doc_id = md5(cleaned_content.encode()).hexdigest()
+            # Include content_hash in ID to ensure uniqueness across different content hashes
+            base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+            doc_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
 
             if self.search_type == SearchType.vector:
                 # For vector search, maintain backward compatibility with unnamed vectors
@@ -508,7 +506,9 @@ class Qdrant(VectorDb):
         log_debug("Redirecting the async request to async_insert")
         await self.async_insert(content_hash=content_hash, documents=documents, filters=filters)
 
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         """
         Search for documents in the collection.
 
@@ -517,28 +517,37 @@ class Qdrant(VectorDb):
             limit (int): Number of search results to return
             filters (Optional[Dict[str, Any]]): Filters to apply while searching
         """
-        filters = self._format_filters(filters or {})  # type: ignore
+
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Qdrant. No filters will be applied.")
+            filters = None
+
+        formatted_filters = self._format_filters(filters or {})  # type: ignore
         if self.search_type == SearchType.vector:
-            results = self._run_vector_search_sync(query, limit, filters)
+            results = self._run_vector_search_sync(query, limit, formatted_filters=formatted_filters)  # type: ignore
         elif self.search_type == SearchType.keyword:
-            results = self._run_keyword_search_sync(query, limit, filters)
+            results = self._run_keyword_search_sync(query, limit, formatted_filters=formatted_filters)  # type: ignore
         elif self.search_type == SearchType.hybrid:
-            results = self._run_hybrid_search_sync(query, limit, filters)
+            results = self._run_hybrid_search_sync(query, limit, formatted_filters=formatted_filters)  # type: ignore
         else:
             raise ValueError(f"Unsupported search type: {self.search_type}")
 
         return self._build_search_results(results, query)
 
     async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     ) -> List[Document]:
-        filters = self._format_filters(filters or {})  # type: ignore
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Qdrant. No filters will be applied.")
+            filters = None
+
+        formatted_filters = self._format_filters(filters or {})  # type: ignore
         if self.search_type == SearchType.vector:
-            results = await self._run_vector_search_async(query, limit, filters)
+            results = await self._run_vector_search_async(query, limit, formatted_filters=formatted_filters)  # type: ignore
         elif self.search_type == SearchType.keyword:
-            results = await self._run_keyword_search_async(query, limit, filters)
+            results = await self._run_keyword_search_async(query, limit, formatted_filters=formatted_filters)  # type: ignore
         elif self.search_type == SearchType.hybrid:
-            results = await self._run_hybrid_search_async(query, limit, filters)
+            results = await self._run_hybrid_search_async(query, limit, formatted_filters=formatted_filters)  # type: ignore
         else:
             raise ValueError(f"Unsupported search type: {self.search_type}")
 
@@ -548,7 +557,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
         sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
@@ -566,7 +575,7 @@ class Qdrant(VectorDb):
             with_vectors=True,
             with_payload=True,
             limit=limit,
-            query_filter=filters,
+            query_filter=formatted_filters,
         )
         return call.points
 
@@ -574,7 +583,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
 
@@ -586,7 +595,7 @@ class Qdrant(VectorDb):
                 with_vectors=True,
                 with_payload=True,
                 limit=limit,
-                query_filter=filters,
+                query_filter=formatted_filters,
                 using=self.dense_vector_name,
             )
         else:
@@ -597,7 +606,7 @@ class Qdrant(VectorDb):
                 with_vectors=True,
                 with_payload=True,
                 limit=limit,
-                query_filter=filters,
+                query_filter=formatted_filters,
             )
         return call.points
 
@@ -605,7 +614,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = self.client.query_points(
@@ -615,7 +624,7 @@ class Qdrant(VectorDb):
             with_payload=True,
             limit=limit,
             using=self.sparse_vector_name,
-            query_filter=filters,
+            query_filter=formatted_filters,
         )
         return call.points
 
@@ -623,7 +632,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
 
@@ -635,7 +644,7 @@ class Qdrant(VectorDb):
                 with_vectors=True,
                 with_payload=True,
                 limit=limit,
-                query_filter=filters,
+                query_filter=formatted_filters,
                 using=self.dense_vector_name,
             )
         else:
@@ -646,7 +655,7 @@ class Qdrant(VectorDb):
                 with_vectors=True,
                 with_payload=True,
                 limit=limit,
-                query_filter=filters,
+                query_filter=formatted_filters,
             )
         return call.points
 
@@ -654,7 +663,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = await self.async_client.query_points(
@@ -664,7 +673,7 @@ class Qdrant(VectorDb):
             with_payload=True,
             limit=limit,
             using=self.sparse_vector_name,
-            query_filter=filters,
+            query_filter=formatted_filters,
         )
         return call.points
 
@@ -672,7 +681,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
         sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
@@ -690,7 +699,7 @@ class Qdrant(VectorDb):
             with_vectors=True,
             with_payload=True,
             limit=limit,
-            query_filter=filters,
+            query_filter=formatted_filters,
         )
         return call.points
 
@@ -1096,3 +1105,7 @@ class Qdrant(VectorDb):
                 log_debug(f"Error closing async Qdrant client: {e}")
             finally:
                 self._async_client = None
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return [SearchType.vector, SearchType.keyword, SearchType.hybrid]

agno/vectordb/redis/__init__.py

@@ -0,0 +1,9 @@
+from agno.vectordb.redis.redisdb import RedisDB
+
+# Backward compatibility alias
+RedisVectorDb = RedisDB
+
+__all__ = [
+    "RedisVectorDb",
+    "RedisDB",
+]