agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

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
 
@@ -131,7 +152,8 @@ class Qdrant(VectorDb):
                 if fastembed_kwargs:
                     default_kwargs.update(fastembed_kwargs)
 
-                self.sparse_encoder = SparseTextEmbedding(**default_kwargs)
+                # Type ignore for mypy as SparseTextEmbedding constructor accepts flexible kwargs
+                self.sparse_encoder = SparseTextEmbedding(**default_kwargs)  # type: ignore
 
             except ImportError as e:
                 raise ImportError(
@@ -192,10 +214,12 @@ class Qdrant(VectorDb):
             # Configure vectors based on search type
             if self.search_type == SearchType.vector:
                 # Maintain backward compatibility with unnamed vectors
-                vectors_config = models.VectorParams(size=self.dimensions, distance=_distance)
+                vectors_config = models.VectorParams(size=self.dimensions or 1536, distance=_distance)
             else:
                 # Use named vectors for hybrid search
-                vectors_config = {self.dense_vector_name: models.VectorParams(size=self.dimensions, distance=_distance)}  # type: ignore
+                vectors_config = {
+                    self.dense_vector_name: models.VectorParams(size=self.dimensions or 1536, distance=_distance)
+                }  # type: ignore
 
             self.client.create_collection(
                 collection_name=self.collection,
@@ -220,10 +244,12 @@ class Qdrant(VectorDb):
             # Configure vectors based on search type
             if self.search_type == SearchType.vector:
                 # Maintain backward compatibility with unnamed vectors
-                vectors_config = models.VectorParams(size=self.dimensions, distance=_distance)
+                vectors_config = models.VectorParams(size=self.dimensions or 1536, distance=_distance)
             else:
                 # Use named vectors for hybrid search
-                vectors_config = {self.dense_vector_name: models.VectorParams(size=self.dimensions, distance=_distance)}  # type: ignore
+                vectors_config = {
+                    self.dense_vector_name: models.VectorParams(size=self.dimensions or 1536, distance=_distance)
+                }  # type: ignore
 
             await self.async_client.create_collection(
                 collection_name=self.collection,
@@ -281,7 +307,7 @@ class Qdrant(VectorDb):
             return len(scroll_result[0]) > 0
         return False
 
-    async def async_name_exists(self, name: str) -> bool:
+    async def async_name_exists(self, name: str) -> bool:  # type: ignore[override]
         """
         Asynchronously validates if a document with the given name exists in the collection.
 
@@ -341,7 +367,9 @@ class Qdrant(VectorDb):
                     vector[self.dense_vector_name] = document.embedding
 
                 if self.search_type in [SearchType.keyword, SearchType.hybrid]:
-                    vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
+                    vector[self.sparse_vector_name] = next(
+                        iter(self.sparse_encoder.embed([document.content]))
+                    ).as_object()  # type: ignore
 
             # Create payload with document properties
             payload = {
@@ -363,7 +391,7 @@ class Qdrant(VectorDb):
             points.append(
                 models.PointStruct(
                     id=doc_id,
-                    vector=vector,
+                    vector=vector,  # type: ignore
                     payload=payload,
                 )
             )
@@ -384,26 +412,69 @@ class Qdrant(VectorDb):
         """
         log_debug(f"Inserting {len(documents)} documents asynchronously")
 
+        # Apply batch embedding when needed for vector or hybrid search
+        if self.search_type in [SearchType.vector, SearchType.hybrid]:
+            if self.embedder.enable_batch and hasattr(self.embedder, "async_get_embeddings_batch_and_usage"):
+                # Use batch embedding when enabled and supported
+                try:
+                    # Extract content from all documents
+                    doc_contents = [doc.content for doc in documents]
+
+                    # Get batch embeddings and usage
+                    embeddings, usages = await self.embedder.async_get_embeddings_batch_and_usage(doc_contents)
+
+                    # Process documents with pre-computed embeddings
+                    for j, doc in enumerate(documents):
+                        try:
+                            if j < len(embeddings):
+                                doc.embedding = embeddings[j]
+                                doc.usage = usages[j] if j < len(usages) else None
+                        except Exception as e:
+                            log_error(f"Error assigning batch embedding to document '{doc.name}': {e}")
+
+                except Exception as e:
+                    # Check if this is a rate limit error - don't fall back as it would make things worse
+                    error_str = str(e).lower()
+                    is_rate_limit = any(
+                        phrase in error_str
+                        for phrase in ["rate limit", "too many requests", "429", "trial key", "api calls / minute"]
+                    )
+
+                    if is_rate_limit:
+                        log_error(f"Rate limit detected during batch embedding. {e}")
+                        raise e
+                    else:
+                        log_warning(f"Async batch embedding failed, falling back to individual embeddings: {e}")
+                        # Fall back to individual embedding
+                        for doc in documents:
+                            if self.search_type in [SearchType.vector, SearchType.hybrid]:
+                                doc.embed(embedder=self.embedder)
+            else:
+                # Use individual embedding
+                for doc in documents:
+                    if self.search_type in [SearchType.vector, SearchType.hybrid]:
+                        doc.embed(embedder=self.embedder)
+
         async def process_document(document):
             cleaned_content = document.content.replace("\x00", "\ufffd")
             doc_id = md5(cleaned_content.encode()).hexdigest()
 
             if self.search_type == SearchType.vector:
                 # For vector search, maintain backward compatibility with unnamed vectors
-                document.embed(embedder=self.embedder)
-                vector = document.embedding
+                vector = document.embedding  # Already embedded above
             else:
                 # For other search types, use named vectors
                 vector = {}
                 if self.search_type in [SearchType.hybrid]:
-                    document.embed(embedder=self.embedder)
-                    vector[self.dense_vector_name] = document.embedding
+                    vector[self.dense_vector_name] = document.embedding  # Already embedded above
 
                 if self.search_type in [SearchType.keyword, SearchType.hybrid]:
-                    vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
+                    vector[self.sparse_vector_name] = next(
+                        iter(self.sparse_encoder.embed([document.content]))
+                    ).as_object()  # type: ignore
 
             if self.search_type in [SearchType.keyword, SearchType.hybrid]:
-                vector[self.sparse_vector_name] = next(self.sparse_encoder.embed([document.content])).as_object()
+                vector[self.sparse_vector_name] = next(iter(self.sparse_encoder.embed([document.content]))).as_object()
 
             # Create payload with document properties
             payload = {
@@ -423,9 +494,9 @@ class Qdrant(VectorDb):
                 payload["meta_data"].update(filters)
 
             log_debug(f"Inserted document asynchronously: {document.name} ({document.meta_data})")
-            return models.PointStruct(
+            return models.PointStruct(  # type: ignore
                 id=doc_id,
-                vector=vector,
+                vector=vector,  # type: ignore
                 payload=payload,
             )
 
@@ -458,7 +529,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.
 
@@ -467,28 +540,37 @@ class Qdrant(VectorDb):
             limit (int): Number of search results to return
             filters (Optional[Dict[str, Any]]): Filters to apply while searching
         """
+
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Qdrant. No filters will be applied.")
+            filters = None
+
         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, 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, 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, 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]:
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Qdrant. No filters will be applied.")
+            filters = None
+
         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, 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, 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, filters)  # type: ignore
         else:
             raise ValueError(f"Unsupported search type: {self.search_type}")
 
@@ -498,15 +580,15 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
-        sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
+        sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = self.client.query_points(
             collection_name=self.collection,
             prefetch=[
                 models.Prefetch(
-                    query=models.SparseVector(**sparse_embedding),
+                    query=models.SparseVector(**sparse_embedding),  # type: ignore  # type: ignore
                     limit=limit,
                     using=self.sparse_vector_name,
                 ),
@@ -524,7 +606,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
 
@@ -555,12 +637,12 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
     ) -> List[models.ScoredPoint]:
-        sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
+        sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = self.client.query_points(
             collection_name=self.collection,
-            query=models.SparseVector(**sparse_embedding),
+            query=models.SparseVector(**sparse_embedding),  # type: ignore
             with_vectors=True,
             with_payload=True,
             limit=limit,
@@ -606,10 +688,10 @@ class Qdrant(VectorDb):
         limit: int,
         filters: Optional[Dict[str, Any]],
     ) -> List[models.ScoredPoint]:
-        sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
+        sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = await self.async_client.query_points(
             collection_name=self.collection,
-            query=models.SparseVector(**sparse_embedding),
+            query=models.SparseVector(**sparse_embedding),  # type: ignore
             with_vectors=True,
             with_payload=True,
             limit=limit,
@@ -622,15 +704,15 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Dict[str, Any]],
+        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
-        sparse_embedding = next(self.sparse_encoder.embed([query])).as_object()
+        sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = await self.async_client.query_points(
             collection_name=self.collection,
             prefetch=[
                 models.Prefetch(
-                    query=models.SparseVector(**sparse_embedding),
+                    query=models.SparseVector(**sparse_embedding),  # type: ignore  # type: ignore
                     limit=limit,
                     using=self.sparse_vector_name,
                 ),
@@ -689,7 +771,7 @@ class Qdrant(VectorDb):
                     filter_conditions.append(models.FieldCondition(key=key, match=models.MatchValue(value=value)))
 
             if filter_conditions:
-                return models.Filter(must=filter_conditions)
+                return models.Filter(must=filter_conditions)  # type: ignore
 
         return None
 
@@ -807,7 +889,7 @@ class Qdrant(VectorDb):
                 )
 
             # Create a filter that requires ALL metadata conditions to match
-            filter_condition = models.Filter(must=filter_conditions)
+            filter_condition = models.Filter(must=filter_conditions)  # type: ignore
 
             # First, count how many points will be deleted
             count_result = self.client.count(collection_name=self.collection, count_filter=filter_condition, exact=True)
@@ -1046,3 +1128,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",
+]