agno 1.7.10__py3-none-any.whl → 1.7.12__py3-none-any.whl

agno/agent/agent.py

@@ -5885,6 +5885,9 @@ class Agent:
                 telemetry=self.telemetry,
                 debug_mode=self.debug_mode,
                 debug_level=self.debug_level,
+                session_state=self.session_state,
+                context=self.context,
+                extra_data=self.extra_data,
             )
             is_deepseek = is_deepseek_reasoning_model(reasoning_model)
             is_groq = is_groq_reasoning_model(reasoning_model)
@@ -5974,6 +5977,9 @@ class Agent:
                     telemetry=self.telemetry,
                     debug_mode=self.debug_mode,
                     debug_level=self.debug_level,
+                    session_state=self.session_state,
+                    context=self.context,
+                    extra_data=self.extra_data,
                 )
 
             # Validate reasoning agent
@@ -6108,6 +6114,9 @@ class Agent:
                 telemetry=self.telemetry,
                 debug_mode=self.debug_mode,
                 debug_level=self.debug_level,
+                session_state=self.session_state,
+                context=self.context,
+                extra_data=self.extra_data,
             )
             is_deepseek = is_deepseek_reasoning_model(reasoning_model)
             is_groq = is_groq_reasoning_model(reasoning_model)
@@ -6197,6 +6206,9 @@ class Agent:
                     telemetry=self.telemetry,
                     debug_mode=self.debug_mode,
                     debug_level=self.debug_level,
+                    session_state=self.session_state,
+                    context=self.context,
+                    extra_data=self.extra_data,
                 )
 
             # Validate reasoning agent
@@ -7443,6 +7455,7 @@ class Agent:
                         if citation.url  # Only include citations with valid URLs
                     )
                     if md_content:  # Only create panel if there are citations
+                        md_content = md_content.strip()
                         citations_panel = create_panel(
                             content=Markdown(md_content),
                             title="Citations",

agno/app/fastapi/app.py

@@ -81,6 +81,7 @@ class FastAPIApp(BaseAPIApp):
                     workflow.app_id = self.app_id
                 if not workflow.workflow_id:
                     workflow.workflow_id = generate_id(workflow.name)
+                workflow.initialize_workflow()
 
     def get_router(self) -> APIRouter:
         return get_sync_router(agents=self.agents, teams=self.teams, workflows=self.workflows)
@@ -95,6 +96,7 @@ class FastAPIApp(BaseAPIApp):
         host: str = "localhost",
         port: int = 7777,
         reload: bool = False,
+        workers: Optional[int] = None,
         **kwargs,
     ):
         self.set_app_id()
@@ -102,4 +104,4 @@ class FastAPIApp(BaseAPIApp):
 
         log_info(f"Starting API on {host}:{port}")
 
-        uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)
+        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, **kwargs)

agno/app/fastapi/async_router.py

@@ -231,7 +231,7 @@ def get_async_router(
 
         return base64_images, base64_audios, base64_videos
 
-    def team_process_file(
+    async def team_process_file(
         files: List[UploadFile],
     ):
         base64_images: List[Image] = []

agno/app/playground/app.py

@@ -87,6 +87,7 @@ class Playground:
                     workflow.app_id = self.app_id
                 if not workflow.workflow_id:
                     workflow.workflow_id = generate_id(workflow.name)
+                workflow.initialize_workflow()
 
     def set_app_id(self) -> str:
         # If app_id is already set, keep it instead of overriding with UUID

agno/document/chunking/semantic.py

@@ -14,9 +14,7 @@ except ImportError:
 class SemanticChunking(ChunkingStrategy):
     """Chunking strategy that splits text into semantic chunks using chonkie"""
 
-    def __init__(
-        self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: Optional[float] = 0.5
-    ):
+    def __init__(self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: float = 0.5):
         self.embedder = embedder or OpenAIEmbedder(id="text-embedding-3-small")  # type: ignore
         self.chunk_size = chunk_size
         self.similarity_threshold = similarity_threshold

agno/document/reader/markdown_reader.py

@@ -1,11 +1,9 @@
 import asyncio
 import uuid
 from pathlib import Path
-from typing import IO, Any, List, Optional, Union
+from typing import IO, Any, List, Union
 
 from agno.document.base import Document
-from agno.document.chunking.markdown import MarkdownChunking
-from agno.document.chunking.strategy import ChunkingStrategy
 from agno.document.reader.base import Reader
 from agno.utils.log import log_info, logger
 
@@ -13,9 +11,6 @@ from agno.utils.log import log_info, logger
 class MarkdownReader(Reader):
     """Reader for Markdown files"""
 
-    def __init__(self, chunking_strategy: Optional[ChunkingStrategy] = MarkdownChunking()) -> None:
-        super().__init__(chunking_strategy=chunking_strategy)
-
     def read(self, file: Union[Path, IO[Any]]) -> List[Document]:
         try:
             if isinstance(file, Path):
@@ -30,7 +25,7 @@ class MarkdownReader(Reader):
                 file.seek(0)
                 file_contents = file.read().decode("utf-8")
 
-            documents = [Document(name=file_name, id=str({uuid.uuid4()}), content=file_contents)]
+            documents = [Document(name=file_name, id=str(uuid.uuid4()), content=file_contents)]
             if self.chunk:
                 chunked_documents = []
                 for document in documents:

agno/document/reader/text_reader.py

@@ -28,7 +28,7 @@ class TextReader(Reader):
             documents = [
                 Document(
                     name=file_name,
-                    id=str({uuid.uuid4()}),
+                    id=str(uuid.uuid4()),
                     content=file_contents,
                 )
             ]
@@ -67,7 +67,7 @@ class TextReader(Reader):
 
             document = Document(
                 name=file_name,
-                id=str({uuid.uuid4()}),
+                id=str(uuid.uuid4()),
                 content=file_contents,
             )
 

agno/embedder/google.py

@@ -23,6 +23,10 @@ class GeminiEmbedder(Embedder):
     request_params: Optional[Dict[str, Any]] = None
     client_params: Optional[Dict[str, Any]] = None
     gemini_client: Optional[GeminiClient] = None
+    # Vertex AI parameters
+    vertexai: bool = False
+    project_id: Optional[str] = None
+    location: Optional[str] = None
 
     @property
     def client(self):
@@ -30,13 +34,21 @@ class GeminiEmbedder(Embedder):
             return self.gemini_client
 
         _client_params: Dict[str, Any] = {}
+        vertexai = self.vertexai or getenv("GOOGLE_GENAI_USE_VERTEXAI", "false").lower() == "true"
 
-        self.api_key = self.api_key or getenv("GOOGLE_API_KEY")
-        if not self.api_key:
-            log_error("GOOGLE_API_KEY not set. Please set the GOOGLE_API_KEY environment variable.")
-
-        if self.api_key:
+        if not vertexai:
+            self.api_key = self.api_key or getenv("GOOGLE_API_KEY")
+            if not self.api_key:
+                log_error("GOOGLE_API_KEY not set. Please set the GOOGLE_API_KEY environment variable.")
             _client_params["api_key"] = self.api_key
+        else:
+            log_info("Using Vertex AI API for embeddings")
+            _client_params["vertexai"] = True
+            _client_params["project"] = self.project_id or getenv("GOOGLE_CLOUD_PROJECT")
+            _client_params["location"] = self.location or getenv("GOOGLE_CLOUD_LOCATION")
+
+        _client_params = {k: v for k, v in _client_params.items() if v is not None}
+
         if self.client_params:
             _client_params.update(self.client_params)
 

agno/knowledge/agent.py

@@ -2,7 +2,7 @@ import asyncio
 from pathlib import Path
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Set, Tuple
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, model_validator
 
 from agno.document import Document
 from agno.document.chunking.fixed import FixedSizeChunking
@@ -24,8 +24,7 @@ class AgentKnowledge(BaseModel):
     # Number of documents to optimize the vector db on
     optimize_on: Optional[int] = 1000
 
-    chunking_strategy: ChunkingStrategy = Field(default_factory=FixedSizeChunking)
-
+    chunking_strategy: Optional[ChunkingStrategy] = None
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     valid_metadata_filters: Set[str] = None  # type: ignore
@@ -33,7 +32,7 @@ class AgentKnowledge(BaseModel):
     @model_validator(mode="after")
     def update_reader(self) -> "AgentKnowledge":
         if self.reader is not None and self.reader.chunking_strategy is None:
-            self.reader.chunking_strategy = self.chunking_strategy
+            self.reader.chunking_strategy = self.chunking_strategy or FixedSizeChunking()
         return self
 
     @property
@@ -237,7 +236,7 @@ class AgentKnowledge(BaseModel):
         self._load_init(recreate=False, upsert=upsert)
         if self.vector_db is None:
             return
-        
+
         log_info("Loading knowledge base")
         # Upsert documents if upsert is True
         if upsert and self.vector_db.upsert_available():

agno/knowledge/gcs/pdf.py

@@ -1,8 +1,9 @@
-from typing import AsyncIterator, Iterator, List
+from typing import AsyncIterator, Iterator, List, Optional, Dict, Any
 
 from agno.document import Document
 from agno.document.reader.gcs.pdf_reader import GCSPDFReader
 from agno.knowledge.gcs.base import GCSKnowledgeBase
+from agno.utils.log import log_debug, log_info
 
 
 class GCSPDFKnowledgeBase(GCSKnowledgeBase):
@@ -19,3 +20,106 @@ class GCSPDFKnowledgeBase(GCSKnowledgeBase):
         for blob in self.gcs_blobs:
             if blob.name.endswith(".pdf"):
                 yield await self.reader.async_read(blob=blob)
+
+    def load(
+        self,
+        recreate: bool = False,
+        upsert: bool = False,
+        skip_existing: bool = True,
+    ) -> None:
+        """Load the knowledge base to the vector db
+        Args:
+            recreate (bool): If True, recreates the collection in the vector db. Defaults to False.
+            upsert (bool): If True, upserts documents to the vector db. Defaults to False.
+            skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
+        """
+        self._load_init(recreate, upsert)
+        if self.vector_db is None:
+            return
+
+        log_info("Loading knowledge base")
+        num_documents = 0
+        for document_list in self.document_lists:
+            documents_to_load = document_list
+
+            # Track metadata for filtering capabilities and collect metadata for filters
+            filters_metadata: Optional[Dict[str, Any]] = None
+            for doc in document_list:
+                if doc.meta_data:
+                    self._track_metadata_structure(doc.meta_data)
+                    # Use the first non-None metadata for filters
+                    if filters_metadata is None:
+                        filters_metadata = doc.meta_data
+
+            # Skip processing if no documents in this batch
+            if not documents_to_load:
+                log_debug("Skipping empty document batch")
+                continue
+
+            # Upsert documents if upsert is True and vector db supports upsert
+            if upsert and self.vector_db.upsert_available():
+                self.vector_db.upsert(documents=documents_to_load, filters=filters_metadata)
+            # Insert documents
+            else:
+                # Filter out documents which already exist in the vector db
+                if skip_existing:
+                    log_debug("Filtering out existing documents before insertion.")
+                    documents_to_load = self.filter_existing_documents(document_list)
+
+                if documents_to_load:
+                    self.vector_db.insert(documents=documents_to_load, filters=filters_metadata)
+
+            num_documents += len(documents_to_load)
+        log_info(f"Added {num_documents} documents to knowledge base")
+
+    async def aload(
+        self,
+        recreate: bool = False,
+        upsert: bool = False,
+        skip_existing: bool = True,
+    ) -> None:
+        """Load the knowledge base to the vector db asynchronously
+        Args:
+            recreate (bool): If True, recreates the collection in the vector db. Defaults to False.
+            upsert (bool): If True, upserts documents to the vector db. Defaults to False.
+            skip_existing (bool): If True, skips documents which already exist in the vector db when inserting. Defaults to True.
+        """
+        await self._aload_init(recreate, upsert)
+        if self.vector_db is None:
+            return
+
+        log_info("Loading knowledge base")
+        num_documents = 0
+        document_iterator = self.async_document_lists
+        async for document_list in document_iterator:  # type: ignore
+            documents_to_load = document_list
+            
+            # Track metadata for filtering capabilities and collect metadata for filters
+            filters_metadata: Optional[Dict[str, Any]] = None
+            for doc in document_list:
+                if doc.meta_data:
+                    self._track_metadata_structure(doc.meta_data)
+                    # Use the first non-None metadata for filters
+                    if filters_metadata is None:
+                        filters_metadata = doc.meta_data
+
+            # Skip processing if no documents in this batch
+            if not documents_to_load:
+                log_debug("Skipping empty document batch")
+                continue
+
+            # Upsert documents if upsert is True and vector db supports upsert
+            if upsert and self.vector_db.upsert_available():
+                await self.vector_db.async_upsert(documents=documents_to_load, filters=filters_metadata)
+            # Insert documents
+            else:
+                # Filter out documents which already exist in the vector db
+                if skip_existing:
+                    log_debug("Filtering out existing documents before insertion.")
+                    documents_to_load = await self.async_filter_existing_documents(document_list)
+
+                if documents_to_load:
+                    await self.vector_db.async_insert(documents=documents_to_load, filters=filters_metadata)
+
+            num_documents += len(documents_to_load)
+        log_info(f"Added {num_documents} documents to knowledge base")

agno/knowledge/markdown.py

@@ -1,7 +1,10 @@
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union, cast
+
+from pydantic import model_validator
 
 from agno.document import Document
+from agno.document.chunking.markdown import MarkdownChunking
 from agno.document.reader.markdown_reader import MarkdownReader
 from agno.knowledge.agent import AgentKnowledge
 from agno.utils.log import log_info, logger
@@ -10,11 +13,18 @@ from agno.utils.log import log_info, logger
 class MarkdownKnowledgeBase(AgentKnowledge):
     path: Optional[Union[str, Path, List[Dict[str, Union[str, Dict[str, Any]]]]]] = None
     formats: List[str] = [".md"]
-    reader: MarkdownReader = MarkdownReader()
+    reader: Optional[MarkdownReader] = None
+
+    @model_validator(mode="after")
+    def set_reader(self) -> "MarkdownKnowledgeBase":
+        if self.reader is None:
+            self.reader = MarkdownReader(chunking_strategy=self.chunking_strategy or MarkdownChunking())
+        return self
 
     @property
     def document_lists(self) -> Iterator[List[Document]]:
         """Iterate over text files and yield lists of documents."""
+        self.reader = cast(MarkdownReader, self.reader)
         if self.path is None:
             raise ValueError("Path is not set")
 
@@ -49,6 +59,7 @@ class MarkdownKnowledgeBase(AgentKnowledge):
     @property
     async def async_document_lists(self) -> AsyncIterator[List[Document]]:
         """Iterate over text files and yield lists of documents asynchronously."""
+        self.reader = cast(MarkdownReader, self.reader)
         if self.path is None:
             raise ValueError("Path is not set")
 
@@ -85,6 +96,7 @@ class MarkdownKnowledgeBase(AgentKnowledge):
         skip_existing: bool = True,
     ) -> None:
         """Load documents from a single text file with specific metadata into the vector DB."""
+        self.reader = cast(MarkdownReader, self.reader)
 
         _file_path = Path(path) if isinstance(path, str) else path
 
@@ -117,6 +129,7 @@ class MarkdownKnowledgeBase(AgentKnowledge):
         skip_existing: bool = True,
     ) -> None:
         """Load documents from a single text file with specific metadata into the vector DB."""
+        self.reader = cast(MarkdownReader, self.reader)
 
         _file_path = Path(path) if isinstance(path, str) else path
 

agno/knowledge/website.py

@@ -4,6 +4,7 @@ from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
 from pydantic import model_validator
 
 from agno.document import Document
+from agno.document.chunking.fixed import FixedSizeChunking
 from agno.document.reader.website_reader import WebsiteReader
 from agno.knowledge.agent import AgentKnowledge
 from agno.utils.log import log_debug, log_info, logger
@@ -21,7 +22,9 @@ class WebsiteKnowledgeBase(AgentKnowledge):
     def set_reader(self) -> "WebsiteKnowledgeBase":
         if self.reader is None:
             self.reader = WebsiteReader(
-                max_depth=self.max_depth, max_links=self.max_links, chunking_strategy=self.chunking_strategy
+                max_depth=self.max_depth,
+                max_links=self.max_links,
+                chunking_strategy=self.chunking_strategy or FixedSizeChunking(),
             )
         return self
 

agno/media.py

@@ -319,6 +319,8 @@ class File(BaseModel):
     mime_type: Optional[str] = None
     # External file object (e.g. GeminiFile, must be a valid object as expected by the model you are using)
     external: Optional[Any] = None
+    format: Optional[str] = None  # E.g. `pdf`, `txt`, `csv`, `xml`, etc.
+    name: Optional[str] = None  # Name of the file, mandatory for AWS Bedrock document input
 
     @model_validator(mode="before")
     @classmethod

agno/models/aws/bedrock.py

@@ -27,6 +27,11 @@ except ImportError:
     AIOBOTO3_AVAILABLE = False
 
 
+BEDROCK_SUPPORTED_IMAGE_FORMATS = ["png", "jpeg", "webp", "gif"]
+BEDROCK_SUPPORTED_VIDEO_FORMATS = ["mp4", "mov", "mkv", "webm", "flv", "mpeg", "mpg", "wmv", "three_gp"]
+BEDROCK_SUPPORTED_FILE_FORMATS = ["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]
+
+
 @dataclass
 class AwsBedrock(Model):
     """
@@ -262,11 +267,16 @@ class AwsBedrock(Model):
 
                 if message.images:
                     for image in message.images:
-                        if not image.content or not image.format:
-                            raise ValueError("Image content and format are required.")
+                        if not image.content:
+                            raise ValueError("Image content is required for AWS Bedrock.")
+                        if not image.format:
+                            raise ValueError("Image format is required for AWS Bedrock.")
 
-                        if image.format not in ["png", "jpeg", "webp", "gif"]:
-                            raise ValueError(f"Unsupported image format: {image.format}")
+                        if image.format not in BEDROCK_SUPPORTED_IMAGE_FORMATS:
+                            raise ValueError(
+                                f"Unsupported image format: {image.format}. "
+                                f"Supported formats: {BEDROCK_SUPPORTED_IMAGE_FORMATS}"
+                            )
 
                         formatted_message["content"].append(
                             {
@@ -283,21 +293,16 @@ class AwsBedrock(Model):
 
                 if message.videos:
                     for video in message.videos:
-                        if not video.content or not video.format:
-                            raise ValueError("Video content and format are required.")
-
-                        if video.format not in [
-                            "mp4",
-                            "mov",
-                            "mkv",
-                            "webm",
-                            "flv",
-                            "mpeg",
-                            "mpg",
-                            "wmv",
-                            "three_gp",
-                        ]:
-                            raise ValueError(f"Unsupported video format: {video.format}")
+                        if not video.content:
+                            raise ValueError("Video content is required for AWS Bedrock.")
+                        if not video.format:
+                            raise ValueError("Video format is required for AWS Bedrock.")
+
+                        if video.format not in BEDROCK_SUPPORTED_VIDEO_FORMATS:
+                            raise ValueError(
+                                f"Unsupported video format: {video.format}. "
+                                f"Supported formats: {BEDROCK_SUPPORTED_VIDEO_FORMATS}"
+                            )
 
                         formatted_message["content"].append(
                             {
@@ -309,8 +314,33 @@ class AwsBedrock(Model):
                                 }
                             }
                         )
-                if message.files is not None and len(message.files) > 0:
-                    log_warning("File input is currently unsupported.")
+
+                if message.files:
+                    for file in message.files:
+                        if not file.content:
+                            raise ValueError("File content is required for AWS Bedrock document input.")
+                        if not file.format:
+                            raise ValueError("File format is required for AWS Bedrock document input.")
+                        if not file.name:
+                            raise ValueError("File name is required for AWS Bedrock document input.")
+
+                        if file.format not in BEDROCK_SUPPORTED_FILE_FORMATS:
+                            raise ValueError(
+                                f"Unsupported file format: {file.format}. "
+                                f"Supported formats: {BEDROCK_SUPPORTED_FILE_FORMATS}"
+                            )
+
+                        formatted_message["content"].append(
+                            {
+                                "document": {
+                                    "format": file.format,
+                                    "name": file.name,
+                                    "source": {
+                                        "bytes": file.content,
+                                    },
+                                }
+                            }
+                        )
 
                 formatted_messages.append(formatted_message)
         # TODO: Add caching: https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html

agno/models/dashscope/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.dashscope.dashscope import DashScope
+
+__all__ = [
+    "DashScope",
+]

agno/models/dashscope/dashscope.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.exceptions import ModelProviderError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class DashScope(OpenAILike):
+    """
+    A class for interacting with Qwen models via DashScope API.
+
+    Attributes:
+        id (str): The model id. Defaults to "qwen-plus".
+        name (str): The model name. Defaults to "Qwen".
+        provider (str): The provider name. Defaults to "Qwen".
+        api_key (Optional[str]): The DashScope API key.
+        base_url (str): The base URL. Defaults to "https://dashscope-intl.aliyuncs.com/compatible-mode/v1".
+        enable_thinking (Optional[bool]): Enable thinking process (DashScope native parameter). Defaults to None.
+        include_thoughts (Optional[bool]): Include thinking process in response (alternative parameter). Defaults to None.
+    """
+
+    id: str = "qwen-plus"
+    name: str = "Qwen"
+    provider: str = "Dashscope"
+
+    api_key: Optional[str] = getenv("DASHSCOPE_API_KEY") or getenv("QWEN_API_KEY")
+    base_url: str = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+
+    # Thinking parameters
+    enable_thinking: Optional[bool] = None
+    include_thoughts: Optional[bool] = None
+
+    # DashScope supports structured outputs
+    supports_native_structured_outputs: bool = True
+    supports_json_schema_outputs: bool = True
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        if not self.api_key:
+            self.api_key = getenv("DASHSCOPE_API_KEY")
+            if not self.api_key:
+                raise ModelProviderError(
+                    message="DASHSCOPE_API_KEY not set. Please set the DASHSCOPE_API_KEY environment variable.",
+                    model_name=self.name,
+                    model_id=self.id,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+        return client_params
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
+
+        should_include_thoughts = self.enable_thinking or self.include_thoughts
+        if should_include_thoughts:
+            params["extra_body"] = {"enable_thinking": True}
+        return params