agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/vectordb/qdrant/qdrant.py

@@ -102,7 +102,7 @@ class Qdrant(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
 
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
@@ -259,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.
@@ -347,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:
@@ -448,16 +423,18 @@ class Qdrant(VectorDb):
                         # Fall back to individual embedding
                         for doc in documents:
                             if self.search_type in [SearchType.vector, SearchType.hybrid]:
-                                doc.embed(embedder=self.embedder)
+                                await doc.async_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)
+                        await doc.async_embed(embedder=self.embedder)
 
         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
@@ -545,13 +522,13 @@ class Qdrant(VectorDb):
             log_warning("Filters Expressions are not supported in Qdrant. No filters will be applied.")
             filters = None
 
-        filters = self._format_filters(filters or {})  # type: ignore
+        formatted_filters = self._format_filters(filters or {})  # type: ignore
         if self.search_type == SearchType.vector:
-            results = self._run_vector_search_sync(query, limit, filters)  # type: ignore
+            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)  # type: ignore
+            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)  # type: ignore
+            results = self._run_hybrid_search_sync(query, limit, formatted_filters=formatted_filters)  # type: ignore
         else:
             raise ValueError(f"Unsupported search type: {self.search_type}")
 
@@ -564,13 +541,13 @@ class Qdrant(VectorDb):
             log_warning("Filters Expressions are not supported in Qdrant. No filters will be applied.")
             filters = None
 
-        filters = self._format_filters(filters or {})  # type: ignore
+        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)  # type: ignore
+            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)  # type: ignore
+            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)  # type: ignore
+            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}")
 
@@ -580,7 +557,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
+        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()
@@ -598,7 +575,7 @@ class Qdrant(VectorDb):
             with_vectors=True,
             with_payload=True,
             limit=limit,
-            query_filter=filters,
+            query_filter=formatted_filters,
         )
         return call.points
 
@@ -606,7 +583,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         dense_embedding = self.embedder.get_embedding(query)
 
@@ -618,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:
@@ -629,7 +606,7 @@ class Qdrant(VectorDb):
                 with_vectors=True,
                 with_payload=True,
                 limit=limit,
-                query_filter=filters,
+                query_filter=formatted_filters,
             )
         return call.points
 
@@ -637,7 +614,7 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
         sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = self.client.query_points(
@@ -647,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
 
@@ -655,9 +632,9 @@ 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)
+        dense_embedding = await self.embedder.async_get_embedding(query)
 
         # TODO(v2.0.0): Remove this conditional and always use named vectors
         if self.use_named_vectors:
@@ -667,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:
@@ -678,7 +655,7 @@ class Qdrant(VectorDb):
                 with_vectors=True,
                 with_payload=True,
                 limit=limit,
-                query_filter=filters,
+                query_filter=formatted_filters,
             )
         return call.points
 
@@ -686,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(
@@ -696,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
 
@@ -704,9 +681,9 @@ class Qdrant(VectorDb):
         self,
         query: str,
         limit: int,
-        filters: Optional[Union[Dict[str, Any], List[FilterExpr]]],
+        formatted_filters: Optional[models.Filter],
     ) -> List[models.ScoredPoint]:
-        dense_embedding = self.embedder.get_embedding(query)
+        dense_embedding = await self.embedder.async_get_embedding(query)
         sparse_embedding = next(iter(self.sparse_encoder.embed([query]))).as_object()
         call = await self.async_client.query_points(
             collection_name=self.collection,
@@ -722,7 +699,7 @@ class Qdrant(VectorDb):
             with_vectors=True,
             with_payload=True,
             limit=limit,
-            query_filter=filters,
+            query_filter=formatted_filters,
         )
         return call.points
 

agno/vectordb/redis/__init__.py

@@ -1,4 +1,4 @@
-from agno.vectordb.redis.redisdb import RedisDB
+from agno.vectordb.redis.redisdb import RedisDB, SearchType
 
 # Backward compatibility alias
 RedisVectorDb = RedisDB
@@ -6,4 +6,5 @@ RedisVectorDb = RedisDB
 __all__ = [
     "RedisVectorDb",
     "RedisDB",
+    "SearchType",
 ]

agno/vectordb/redis/redisdb.py

@@ -15,7 +15,8 @@ except ImportError:
 from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
-from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.knowledge.reranker.base import Reranker
+from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.string import hash_string_sha256
 from agno.vectordb.base import VectorDb
 from agno.vectordb.distance import Distance
@@ -39,6 +40,7 @@ class RedisDB(VectorDb):
         search_type: SearchType = SearchType.vector,
         distance: Distance = Distance.cosine,
         vector_score_weight: float = 0.7,
+        reranker: Optional[Reranker] = None,
         **redis_kwargs,
     ):
         """
@@ -78,7 +80,7 @@ class RedisDB(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
 
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
@@ -91,8 +93,8 @@ class RedisDB(VectorDb):
         self.distance: Distance = distance
         self.vector_score_weight: float = vector_score_weight
 
-        # # Reranker instance
-        # self.reranker: Optional[Reranker] = reranker
+        # Reranker instance
+        self.reranker: Optional[Reranker] = reranker
 
         # Create index schema
         self.schema = self._get_schema()
@@ -184,32 +186,6 @@ class RedisDB(VectorDb):
                 log_error(f"Error creating Redis index: {e}")
                 raise
 
-    def doc_exists(self, document: Document) -> bool:
-        """Check if a document exists in the index."""
-        try:
-            doc_id = document.id or hash_string_sha256(document.content)
-            return self.id_exists(doc_id)
-        except Exception as e:
-            log_error(f"Error checking if document exists: {e}")
-            return False
-
-    async def async_doc_exists(self, document: Document) -> bool:
-        """Async version of doc_exists method."""
-        try:
-            doc_id = document.id or hash_string_sha256(document.content)
-            async_index = await self._get_async_index()
-            id_filter = Tag("id") == doc_id
-            query = FilterQuery(
-                filter_expression=id_filter,
-                return_fields=["id"],
-                num_results=1,
-            )
-            results = await async_index.query(query)
-            return len(results) > 0
-        except Exception as e:
-            log_error(f"Error checking if document exists: {e}")
-            return False
-
     def name_exists(self, name: str) -> bool:
         """Check if a document with the given name exists."""
         try:
@@ -453,6 +429,10 @@ class RedisDB(VectorDb):
             # Convert results to documents
             documents = [Document.from_dict(r) for r in results]
 
+            # Apply reranking if reranker is available
+            if self.reranker:
+                documents = self.reranker.rerank(query=query, documents=documents)
+
             return documents
         except Exception as e:
             log_error(f"Error in vector search: {e}")
@@ -476,6 +456,10 @@ class RedisDB(VectorDb):
             # Convert results to documents
             documents = [Document.from_dict(p) for p in parsed]
 
+            # Apply reranking if reranker is available
+            if self.reranker:
+                documents = self.reranker.rerank(query=query, documents=documents)
+
             return documents
         except Exception as e:
             log_error(f"Error in keyword search: {e}")
@@ -493,7 +477,7 @@ class RedisDB(VectorDb):
                 vector_field_name="embedding",
                 text=query,
                 text_field_name="content",
-                alpha=self.vector_score_weight,
+                linear_alpha=self.vector_score_weight,
                 return_fields=["id", "name", "content"],
                 num_results=limit,
             )
@@ -505,6 +489,10 @@ class RedisDB(VectorDb):
             # Convert results to documents
             documents = [Document.from_dict(p) for p in parsed]
 
+            # Apply reranking if reranker is available
+            if self.reranker:
+                documents = self.reranker.rerank(query=query, documents=documents)
+
             return documents
         except Exception as e:
             log_error(f"Error in hybrid search: {e}")

agno/vectordb/singlestore/singlestore.py

@@ -56,7 +56,7 @@ class SingleStore(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
 
@@ -185,8 +185,10 @@ class SingleStore(VectorDb):
             for document in documents:
                 document.embed(embedder=self.embedder)
                 cleaned_content = document.content.replace("\x00", "\ufffd")
-                record_id = md5(cleaned_content.encode()).hexdigest()
-                _id = document.id or record_id
+                # Include content_hash in ID to ensure uniqueness across different content hashes
+                base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+                record_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
+                _id = record_id
 
                 meta_data_json = json.dumps(document.meta_data)
                 usage_json = json.dumps(document.usage)
@@ -246,8 +248,10 @@ class SingleStore(VectorDb):
             for document in documents:
                 document.embed(embedder=self.embedder)
                 cleaned_content = document.content.replace("\x00", "\ufffd")
-                record_id = md5(cleaned_content.encode()).hexdigest()
-                _id = document.id or record_id
+                # Include content_hash in ID to ensure uniqueness across different content hashes
+                base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+                record_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
+                _id = record_id
 
                 meta_data_json = json.dumps(document.meta_data)
                 usage_json = json.dumps(document.usage)
@@ -548,8 +552,10 @@ class SingleStore(VectorDb):
             counter = 0
             for document in documents:
                 cleaned_content = document.content.replace("\x00", "\ufffd")
-                record_id = md5(cleaned_content.encode()).hexdigest()
-                _id = document.id or record_id
+                # Include content_hash in ID to ensure uniqueness across different content hashes
+                base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+                record_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
+                _id = record_id
 
                 meta_data_json = json.dumps(document.meta_data)
                 usage_json = json.dumps(document.usage)
@@ -632,8 +638,10 @@ class SingleStore(VectorDb):
             counter = 0
             for document in documents:
                 cleaned_content = document.content.replace("\x00", "\ufffd")
-                record_id = md5(cleaned_content.encode()).hexdigest()
-                _id = document.id or record_id
+                # Include content_hash in ID to ensure uniqueness across different content hashes
+                base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+                record_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
+                _id = record_id
 
                 meta_data_json = json.dumps(document.meta_data)
                 usage_json = json.dumps(document.usage)

agno/vectordb/surrealdb/surrealdb.py

@@ -14,7 +14,7 @@ except ImportError as e:
 from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
-from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.log import log_debug, log_error, log_warning
 from agno.vectordb.base import VectorDb
 from agno.vectordb.distance import Distance
 
@@ -31,12 +31,6 @@ class SurrealDb(VectorDb):
         DEFINE INDEX IF NOT EXISTS vector_idx ON {collection} FIELDS embedding HNSW DIMENSION {dimensions} DIST {distance};
     """
 
-    DOC_EXISTS_QUERY: Final[str] = """
-        SELECT * FROM {collection}
-        WHERE content = $content
-        LIMIT 1
-    """
-
     NAME_EXISTS_QUERY: Final[str] = """
         SELECT * FROM {collection}
         WHERE meta_data.name = $name
@@ -141,7 +135,7 @@ class SurrealDb(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         self.dimensions = self.embedder.dimensions
         self.collection = collection
@@ -221,23 +215,6 @@ class SurrealDb(VectorDb):
             )
             self.client.query(query)
 
-    def doc_exists(self, document: Document) -> bool:
-        """Check if a document exists by its content.
-
-        Args:
-            document: The document to check.
-
-        Returns:
-            True if the document exists, False otherwise.
-
-        """
-        log_debug(f"Checking if document exists: {document.content}")
-        result = self.client.query(
-            self.DOC_EXISTS_QUERY.format(collection=self.collection),
-            {"content": document.content},
-        )
-        return bool(self._extract_result(result))
-
     def name_exists(self, name: str) -> bool:
         """Check if a document exists by its name.
 
@@ -493,19 +470,6 @@ class SurrealDb(VectorDb):
             ),
         )
 
-    async def async_doc_exists(self, document: Document) -> bool:
-        """Check if a document exists by its content asynchronously.
-
-        Returns:
-            True if the document exists, False otherwise.
-
-        """
-        response = await self.async_client.query(
-            self.DOC_EXISTS_QUERY.format(collection=self.collection),
-            {"content": document.content},
-        )
-        return bool(self._extract_result(response))
-
     async def async_name_exists(self, name: str) -> bool:
         """Check if a document exists by its name asynchronously.
 

agno/vectordb/weaviate/__init__.py

@@ -1,8 +1,9 @@
 from agno.vectordb.weaviate.index import Distance, VectorIndex
-from agno.vectordb.weaviate.weaviate import Weaviate
+from agno.vectordb.weaviate.weaviate import SearchType, Weaviate
 
 __all__ = [
     "Distance",
     "VectorIndex",
     "Weaviate",
+    "SearchType",
 ]

agno/vectordb/weaviate/weaviate.py

@@ -81,7 +81,7 @@ class Weaviate(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
 
         # Search setup
@@ -247,7 +247,9 @@ class Weaviate(VectorDb):
                 continue
 
             cleaned_content = document.content.replace("\x00", "\ufffd")
-            record_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()
+            record_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
             doc_uuid = uuid.UUID(hex=record_id[:32])
 
             # Merge filters with metadata
@@ -338,7 +340,9 @@ class Weaviate(VectorDb):
 
                     # Clean content and generate UUID
                     cleaned_content = document.content.replace("\x00", "\ufffd")
-                    record_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()
+                    record_id = md5(f"{base_id}_{content_hash}".encode()).hexdigest()
                     doc_uuid = uuid.UUID(hex=record_id[:32])
 
                     # Serialize meta_data to JSON string

agno/workflow/__init__.py

@@ -2,15 +2,17 @@ from agno.workflow.agent import WorkflowAgent
 from agno.workflow.condition import Condition
 from agno.workflow.loop import Loop
 from agno.workflow.parallel import Parallel
+from agno.workflow.remote import RemoteWorkflow
 from agno.workflow.router import Router
 from agno.workflow.step import Step
 from agno.workflow.steps import Steps
 from agno.workflow.types import StepInput, StepOutput, WorkflowExecutionInput
-from agno.workflow.workflow import Workflow
+from agno.workflow.workflow import Workflow, get_workflow_by_id, get_workflows
 
 __all__ = [
     "Workflow",
     "WorkflowAgent",
+    "RemoteWorkflow",
     "Steps",
     "Step",
     "Loop",
@@ -20,4 +22,6 @@ __all__ = [
     "WorkflowExecutionInput",
     "StepInput",
     "StepOutput",
+    "get_workflow_by_id",
+    "get_workflows",
 ]

agno/workflow/agent.py

@@ -5,9 +5,9 @@ from typing import TYPE_CHECKING, Any, Callable, Optional
 from agno.agent import Agent
 from agno.models.base import Model
 from agno.run import RunContext
-from agno.workflow.types import WebSocketHandler
 
 if TYPE_CHECKING:
+    from agno.os.managers import WebSocketHandler
     from agno.session.workflow import WorkflowSession
     from agno.workflow.types import WorkflowExecutionInput
 
@@ -190,7 +190,7 @@ Guidelines:
         execution_input: "WorkflowExecutionInput",
         run_context: RunContext,
         stream: bool = False,
-        websocket_handler: Optional[WebSocketHandler] = None,
+        websocket_handler: Optional["WebSocketHandler"] = None,
     ) -> Callable:
         """
         Create the async workflow execution tool that this agent can call.