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

agno/vectordb/weaviate/weaviate.py

@@ -3,7 +3,7 @@ import json
 import uuid
 from hashlib import md5
 from os import getenv
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 try:
     from warnings import filterwarnings
@@ -18,10 +18,11 @@ try:
 except ImportError:
     raise ImportError("Weaviate is not installed. Install using 'pip install weaviate-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
-from agno.utils.log import log_debug, log_info, logger
+from agno.utils.log import log_debug, log_info, log_warning, logger
 from agno.vectordb.base import VectorDb
 from agno.vectordb.search import SearchType
 from agno.vectordb.weaviate.index import Distance, VectorIndex
@@ -41,6 +42,9 @@ class Weaviate(VectorDb):
         local: bool = False,
         # Collection params
         collection: str = "default",
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        id: Optional[str] = None,
         vector_index: VectorIndex = VectorIndex.HNSW,
         distance: Distance = Distance.COSINE,
         # Search/Embedding params
@@ -49,6 +53,17 @@ class Weaviate(VectorDb):
         reranker: Optional[Reranker] = None,
         hybrid_search_alpha: float = 0.5,
     ):
+        # Dynamic ID generation based on unique identifiers
+        if id is None:
+            from agno.utils.string import generate_id
+
+            connection_identifier = wcd_url or "local" if local else "default"
+            seed = f"{connection_identifier}#{collection}"
+            id = generate_id(seed)
+
+        # Initialize base class with name, description, and generated ID
+        super().__init__(id=id, name=name, description=description)
+
         # Connection setup
         self.wcd_url = wcd_url or getenv("WCD_URL")
         self.wcd_api_key = wcd_api_key or getenv("WCD_API_KEY")
@@ -270,9 +285,45 @@ class Weaviate(VectorDb):
         if not documents:
             return
 
-        # Embed document
-        embed_tasks = [document.async_embed(embedder=self.embedder) for document in documents]
-        await asyncio.gather(*embed_tasks, return_exceptions=True)
+        # Apply batch embedding logic
+        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:
+                        logger.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:
+                    logger.error(f"Rate limit detected during batch embedding. {e}")
+                    raise e
+                else:
+                    logger.warning(f"Async batch embedding failed, falling back to individual embeddings: {e}")
+                    # Fall back to individual embedding
+                    embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
+                    await asyncio.gather(*embed_tasks, return_exceptions=True)
+        else:
+            # Use individual embedding
+            embed_tasks = [document.async_embed(embedder=self.embedder) for document in documents]
+            await asyncio.gather(*embed_tasks, return_exceptions=True)
 
         client = await self.get_async_client()
         try:
@@ -342,7 +393,9 @@ class Weaviate(VectorDb):
         await self.async_insert(content_hash=content_hash, documents=documents, filters=filters)
         return
 
-    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]:
         """
         Perform a search based on the configured search type.
 
@@ -354,6 +407,9 @@ class Weaviate(VectorDb):
         Returns:
             List[Document]: List of matching documents.
         """
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Weaviate. No filters will be applied.")
+            filters = None
         if self.search_type == SearchType.vector:
             return self.vector_search(query, limit, filters)
         elif self.search_type == SearchType.keyword:
@@ -365,7 +421,7 @@ class Weaviate(VectorDb):
             return []
 
     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]:
         """
         Perform a search based on the configured search type asynchronously.
@@ -378,6 +434,9 @@ class Weaviate(VectorDb):
         Returns:
             List[Document]: List of matching documents.
         """
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Weaviate. No filters will be applied.")
+            filters = None
         if self.search_type == SearchType.vector:
             return await self.async_vector_search(query, limit, filters)
         elif self.search_type == SearchType.keyword:
@@ -388,7 +447,9 @@ class Weaviate(VectorDb):
             logger.error(f"Invalid search type '{self.search_type}'.")
             return []
 
-    def vector_search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def vector_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         try:
             query_embedding = self.embedder.get_embedding(query)
             if query_embedding is None:
@@ -423,7 +484,7 @@ class Weaviate(VectorDb):
             self.get_client().close()
 
     async def async_vector_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]:
         """
         Perform a vector search in Weaviate asynchronously.
@@ -468,7 +529,9 @@ class Weaviate(VectorDb):
             logger.error(f"Error searching for documents: {e}")
             return []
 
-    def keyword_search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def keyword_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         try:
             collection = self.get_client().collections.get(self.collection)
             filter_expr = self._build_filter_expression(filters)
@@ -499,7 +562,7 @@ class Weaviate(VectorDb):
             self.get_client().close()
 
     async def async_keyword_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]:
         """
         Perform a keyword search in Weaviate asynchronously.
@@ -540,7 +603,9 @@ class Weaviate(VectorDb):
             logger.error(f"Error searching for documents: {e}")
             return []
 
-    def hybrid_search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def hybrid_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         try:
             query_embedding = self.embedder.get_embedding(query)
             if query_embedding is None:
@@ -578,7 +643,7 @@ class Weaviate(VectorDb):
             self.get_client().close()
 
     async def async_hybrid_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]:
         """
         Perform a hybrid search combining vector and keyword search in Weaviate asynchronously.
@@ -799,7 +864,7 @@ class Weaviate(VectorDb):
         """Indicate that upsert functionality is available."""
         return True
 
-    def _build_filter_expression(self, filters: Optional[Dict[str, Any]]):
+    def _build_filter_expression(self, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]]):
         """
         Build a filter expression for Weaviate queries.
 
@@ -811,7 +876,9 @@ class Weaviate(VectorDb):
         """
         if not filters:
             return None
-
+        if isinstance(filters, List):
+            log_warning("Filters Expressions are not supported in Weaviate. No filters will be applied.")
+            return None
         try:
             # Create a filter for each key-value pair
             filter_conditions = []
@@ -932,3 +999,7 @@ class Weaviate(VectorDb):
         except Exception as e:
             logger.error(f"Error deleting documents by content_hash '{content_hash}': {e}")
             return False
+
+    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/workflow/__init__.py

@@ -1,3 +1,4 @@
+from agno.workflow.agent import WorkflowAgent
 from agno.workflow.condition import Condition
 from agno.workflow.loop import Loop
 from agno.workflow.parallel import Parallel
@@ -9,6 +10,7 @@ from agno.workflow.workflow import Workflow
 
 __all__ = [
     "Workflow",
+    "WorkflowAgent",
     "Steps",
     "Step",
     "Loop",

agno/workflow/agent.py

@@ -0,0 +1,299 @@
+"""WorkflowAgent - A restricted Agent for workflow orchestration"""
+
+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.session.workflow import WorkflowSession
+    from agno.workflow.types import WorkflowExecutionInput
+
+
+class WorkflowAgent(Agent):
+    """
+    A restricted Agent class specifically designed for workflow orchestration.
+    This agent can:
+    1. Decide whether to run the workflow or answer directly from history
+    2. Call the workflow execution tool when needed
+    3. Access workflow session history for context
+    Restrictions:
+    - Only model configuration allowed
+    - No custom tools (tools are set by workflow)
+    - No knowledge base
+    - Limited configuration options
+    """
+
+    def __init__(
+        self,
+        model: Model,
+        instructions: Optional[str] = None,
+        add_workflow_history: bool = True,
+        num_history_runs: int = 5,
+    ):
+        """
+        Initialize WorkflowAgent with restricted parameters.
+        Args:
+            model: The model to use for the agent (required)
+            instructions: Custom instructions (will be combined with workflow context)
+            add_workflow_history: Whether to add workflow history to context (default: True)
+            num_history_runs: Number of previous workflow runs to include in context (default: 5)
+        """
+        self.add_workflow_history = add_workflow_history
+
+        default_instructions = """You are a workflow orchestration agent. Your job is to help users by either:
+1. **Answering directly** from the workflow history context if the question can be answered from previous runs
+2. **Running the workflow** by calling the run_workflow tool ONCE when you need to process a new query
+
+Guidelines:
+- ALWAYS check the workflow history first before calling the tool
+- Answer directly from history if:
+    * The user asks about something already in history
+    * The user asks for comparisons/analysis of things in history (e.g., "compare X and Y")
+    * The user asks follow-up questions about previous results
+- Only call the run_workflow tool for NEW topics not covered in history
+- IMPORTANT: Do NOT call the tool multiple times. Call it once and use the result.
+- Keep your responses concise and helpful
+- When you must call the workflow, pass a clear and concise query
+
+{workflow_context}
+"""
+
+        if instructions:
+            if "{workflow_context}" not in instructions:
+                # Add the workflow context placeholder
+                final_instructions = f"{instructions}\n\n{{workflow_context}}"
+            else:
+                final_instructions = instructions
+        else:
+            final_instructions = default_instructions
+
+        super().__init__(
+            model=model,
+            instructions=final_instructions,
+            resolve_in_context=True,
+            num_history_runs=num_history_runs,
+        )
+
+    def create_workflow_tool(
+        self,
+        workflow: "Any",  # Workflow type
+        session: "WorkflowSession",
+        execution_input: "WorkflowExecutionInput",
+        run_context: RunContext,
+        stream: bool = False,
+    ) -> Callable:
+        """
+        Create the workflow execution tool that this agent can call.
+        This is similar to how Agent has search_knowledge_base() method.
+        Args:
+            workflow: The workflow instance
+            session: The workflow session
+            execution_input: The execution input
+            run_context: The run context
+            stream: Whether to stream the workflow execution
+        Returns:
+            Callable tool function
+        """
+        from datetime import datetime
+        from uuid import uuid4
+
+        from pydantic import BaseModel
+
+        from agno.run.workflow import WorkflowRunOutput
+        from agno.utils.log import log_debug
+        from agno.workflow.types import WorkflowExecutionInput
+
+        def run_workflow(query: str):
+            """
+            Execute the complete workflow with the given query.
+            Use this tool when you need to run the workflow to answer the user's question.
+
+            Args:
+                query: The input query/question to process through the workflow
+            Returns:
+                The workflow execution result (str in non-streaming, generator in streaming)
+            """
+            # Reload session to get latest data from database
+            # This ensures we don't overwrite any updates made after the tool was created
+            session_from_db = workflow.get_session(session_id=session.session_id)
+            if session_from_db is None:
+                session_from_db = session  # Fallback to closure session if reload fails
+                log_debug(f"Fallback to closure session: {len(session_from_db.runs or [])} runs")
+            else:
+                log_debug(f"Reloaded session before tool execution: {len(session_from_db.runs or [])} runs")
+
+            # Create a new run ID for this execution
+            run_id = str(uuid4())
+
+            workflow_run_response = WorkflowRunOutput(
+                run_id=run_id,
+                input=execution_input.input,  # Use original user input
+                session_id=session_from_db.session_id,
+                workflow_id=workflow.id,
+                workflow_name=workflow.name,
+                created_at=int(datetime.now().timestamp()),
+            )
+
+            workflow_execution_input = WorkflowExecutionInput(
+                input=query,  # Agent's refined query for execution
+                additional_data=execution_input.additional_data,
+                audio=execution_input.audio,
+                images=execution_input.images,
+                videos=execution_input.videos,
+                files=execution_input.files,
+            )
+
+            # ===== EXECUTION LOGIC (Based on streaming mode) =====
+            if stream:
+                final_content = ""
+                for event in workflow._execute_stream(
+                    session=session_from_db,
+                    run_context=run_context,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    stream_events=True,
+                ):
+                    yield event
+
+                    # Capture final content from WorkflowCompletedEvent
+                    from agno.run.workflow import WorkflowCompletedEvent
+
+                    if isinstance(event, WorkflowCompletedEvent):
+                        final_content = str(event.content) if event.content else ""
+
+                return final_content
+            else:
+                # NON-STREAMING MODE: Execute synchronously
+                result = workflow._execute(
+                    session=session_from_db,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    run_context=run_context,
+                )
+
+                if isinstance(result.content, str):
+                    return result.content
+                elif isinstance(result.content, BaseModel):
+                    return result.content.model_dump_json(exclude_none=True)
+                else:
+                    return str(result.content)
+
+        return run_workflow
+
+    def async_create_workflow_tool(
+        self,
+        workflow: "Any",  # Workflow type
+        session: "WorkflowSession",
+        execution_input: "WorkflowExecutionInput",
+        run_context: RunContext,
+        stream: bool = False,
+        websocket_handler: Optional[WebSocketHandler] = None,
+    ) -> Callable:
+        """
+        Create the async workflow execution tool that this agent can call.
+        This is the async counterpart of create_workflow_tool.
+
+        Args:
+            workflow: The workflow instance
+            session: The workflow session
+            execution_input: The execution input
+            run_context: The run context
+            stream: Whether to stream the workflow execution
+
+        Returns:
+            Async callable tool function
+        """
+        from datetime import datetime
+        from uuid import uuid4
+
+        from pydantic import BaseModel
+
+        from agno.run.workflow import WorkflowRunOutput
+        from agno.utils.log import log_debug
+        from agno.workflow.types import WorkflowExecutionInput
+
+        async def run_workflow(query: str):
+            """
+            Execute the complete workflow with the given query asynchronously.
+            Use this tool when you need to run the workflow to answer the user's question.
+
+            Args:
+                query: The input query/question to process through the workflow
+
+            Returns:
+                The workflow execution result (str in non-streaming, async generator in streaming)
+            """
+            # Reload session to get latest data from database
+            # This ensures we don't overwrite any updates made after the tool was created
+            # Use async or sync method based on database type
+            if workflow._has_async_db():
+                session_from_db = await workflow.aget_session(session_id=session.session_id)
+            else:
+                session_from_db = workflow.get_session(session_id=session.session_id)
+
+            if session_from_db is None:
+                session_from_db = session  # Fallback to closure session if reload fails
+                log_debug(f"Fallback to closure session: {len(session_from_db.runs or [])} runs")
+            else:
+                log_debug(f"Reloaded session before async tool execution: {len(session_from_db.runs or [])} runs")
+
+            # Create a new run ID for this execution
+            run_id = str(uuid4())
+
+            workflow_run_response = WorkflowRunOutput(
+                run_id=run_id,
+                input=execution_input.input,  # Use original user input
+                session_id=session_from_db.session_id,
+                workflow_id=workflow.id,
+                workflow_name=workflow.name,
+                created_at=int(datetime.now().timestamp()),
+            )
+
+            workflow_execution_input = WorkflowExecutionInput(
+                input=query,  # Agent's refined query for execution
+                additional_data=execution_input.additional_data,
+                audio=execution_input.audio,
+                images=execution_input.images,
+                videos=execution_input.videos,
+                files=execution_input.files,
+            )
+
+            if stream:
+                final_content = ""
+                async for event in workflow._aexecute_stream(
+                    session_id=session_from_db.session_id,
+                    user_id=session_from_db.user_id,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    run_context=run_context,
+                    stream_events=True,
+                    websocket_handler=websocket_handler,
+                ):
+                    yield event
+
+                    from agno.run.workflow import WorkflowCompletedEvent
+
+                    if isinstance(event, WorkflowCompletedEvent):
+                        final_content = str(event.content) if event.content else ""
+
+                yield final_content
+            else:
+                result = await workflow._aexecute(
+                    session_id=session_from_db.session_id,
+                    user_id=session_from_db.user_id,
+                    execution_input=workflow_execution_input,
+                    workflow_run_response=workflow_run_response,
+                    run_context=run_context,
+                )
+
+                if isinstance(result.content, str):
+                    yield result.content
+                elif isinstance(result.content, BaseModel):
+                    yield result.content.model_dump_json(exclude_none=True)
+                else:
+                    yield str(result.content)
+
+        return run_workflow