agno 2.4.1__py3-none-any.whl → 2.4.2__py3-none-any.whl

agno/knowledge/knowledge.py

@@ -19,6 +19,7 @@ from agno.knowledge.content import Content, ContentAuth, ContentStatus, FileData
 from agno.knowledge.document import Document
 from agno.knowledge.reader import Reader, ReaderFactory
 from agno.knowledge.remote_content.config import (
+    AzureBlobConfig,
     GcsConfig,
     GitHubConfig,
     RemoteContentConfig,
@@ -26,6 +27,7 @@ from agno.knowledge.remote_content.config import (
     SharePointConfig,
 )
 from agno.knowledge.remote_content.remote_content import (
+    AzureBlobContent,
     GCSContent,
     GitHubContent,
     RemoteContent,
@@ -1964,6 +1966,9 @@ class Knowledge:
         elif isinstance(remote_content, GitHubContent):
             await self._aload_from_github(content, upsert, skip_if_exists, config)
 
+        elif isinstance(remote_content, AzureBlobContent):
+            await self._aload_from_azure_blob(content, upsert, skip_if_exists, config)
+
         else:
             log_warning(f"Unsupported remote content type: {type(remote_content)}")
 
@@ -1976,6 +1981,8 @@ class Knowledge:
     ):
         """Load the contextual S3 content.
 
+        Note: Uses sync boto3 calls as boto3 doesn't have an async API.
+
         1. Identify objects to read
         2. Setup Content object
         3. Hash content and add it to the contents database
@@ -2042,7 +2049,7 @@ class Knowledge:
             if self._should_skip(content_entry.content_hash, skip_if_exists):
                 content_entry.status = ContentStatus.COMPLETED
                 await self._aupdate_content(content_entry)
-                return
+                continue
 
             # 4. Select reader
             reader = self._select_reader_by_uri(s3_object.uri, content.reader)
@@ -2079,6 +2086,8 @@ class Knowledge:
     ):
         """Load the contextual GCS content.
 
+        Note: Uses sync google-cloud-storage calls as it doesn't have an async API.
+
         1. Identify objects to read
         2. Setup Content object
         3. Hash content and add it to the contents database
@@ -2142,7 +2151,7 @@ class Knowledge:
             if self._should_skip(content_entry.content_hash, skip_if_exists):
                 content_entry.status = ContentStatus.COMPLETED
                 await self._aupdate_content(content_entry)
-                return
+                continue
 
             # 4. Select reader
             reader = self._select_reader_by_uri(gcs_object.name, content.reader)
@@ -2190,6 +2199,9 @@ class Knowledge:
         elif isinstance(remote_content, GitHubContent):
             self._load_from_github(content, upsert, skip_if_exists, config)
 
+        elif isinstance(remote_content, AzureBlobContent):
+            self._load_from_azure_blob(content, upsert, skip_if_exists, config)
+
         else:
             log_warning(f"Unsupported remote content type: {type(remote_content)}")
 
@@ -2266,7 +2278,7 @@ class Knowledge:
             if self._should_skip(content_entry.content_hash, skip_if_exists):
                 content_entry.status = ContentStatus.COMPLETED
                 self._update_content(content_entry)
-                return
+                continue
 
             # 4. Select reader
             reader = self._select_reader_by_uri(s3_object.uri, content.reader)
@@ -2367,7 +2379,7 @@ class Knowledge:
             if self._should_skip(content_entry.content_hash, skip_if_exists):
                 content_entry.status = ContentStatus.COMPLETED
                 self._update_content(content_entry)
-                return
+                continue
 
             # 4. Select reader
             reader = self._select_reader_by_uri(gcs_object.name, content.reader)
@@ -3250,6 +3262,431 @@ class Knowledge:
                 self._prepare_documents_for_insert(read_documents, content_entry.id)
                 self._handle_vector_db_insert(content_entry, read_documents, upsert)
 
+    # --- Azure Blob Storage loaders ---
+
+    def _get_azure_blob_client(self, azure_config: AzureBlobConfig):
+        """Get a sync Azure Blob Service Client using client credentials flow.
+
+        Requires the `azure-identity` and `azure-storage-blob` packages.
+        """
+        try:
+            from azure.identity import ClientSecretCredential  # type: ignore
+            from azure.storage.blob import BlobServiceClient  # type: ignore
+        except ImportError:
+            raise ImportError(
+                "The `azure-identity` and `azure-storage-blob` packages are not installed. "
+                "Please install them via `pip install azure-identity azure-storage-blob`."
+            )
+
+        credential = ClientSecretCredential(
+            tenant_id=azure_config.tenant_id,
+            client_id=azure_config.client_id,
+            client_secret=azure_config.client_secret,
+        )
+
+        blob_service = BlobServiceClient(
+            account_url=f"https://{azure_config.storage_account}.blob.core.windows.net",
+            credential=credential,
+        )
+
+        return blob_service
+
+    def _get_azure_blob_client_async(self, azure_config: AzureBlobConfig):
+        """Get an async Azure Blob Service Client using client credentials flow.
+
+        Requires the `azure-identity` and `azure-storage-blob` packages.
+        Uses the async versions from azure.storage.blob.aio and azure.identity.aio.
+        """
+        try:
+            from azure.identity.aio import ClientSecretCredential  # type: ignore
+            from azure.storage.blob.aio import BlobServiceClient  # type: ignore
+        except ImportError:
+            raise ImportError(
+                "The `azure-identity` and `azure-storage-blob` packages are not installed. "
+                "Please install them via `pip install azure-identity azure-storage-blob`."
+            )
+
+        credential = ClientSecretCredential(
+            tenant_id=azure_config.tenant_id,
+            client_id=azure_config.client_id,
+            client_secret=azure_config.client_secret,
+        )
+
+        blob_service = BlobServiceClient(
+            account_url=f"https://{azure_config.storage_account}.blob.core.windows.net",
+            credential=credential,
+        )
+
+        return blob_service
+
+    async def _aload_from_azure_blob(
+        self,
+        content: Content,
+        upsert: bool,
+        skip_if_exists: bool,
+        config: Optional[RemoteContentConfig] = None,
+    ):
+        """Load content from Azure Blob Storage (async version).
+
+        Requires the AzureBlobConfig to contain tenant_id, client_id, client_secret,
+        storage_account, and container.
+
+        Uses the async Azure SDK to avoid blocking the event loop.
+
+        1. Authenticate with Azure AD using client credentials
+        2. List blobs in container (by prefix or single blob)
+        3. Download and process each blob
+        4. Insert to vector database
+        """
+        remote_content: AzureBlobContent = cast(AzureBlobContent, content.remote_content)
+        azure_config = cast(AzureBlobConfig, config) if isinstance(config, AzureBlobConfig) else None
+
+        if azure_config is None:
+            log_error(f"Azure Blob config not found for config_id: {remote_content.config_id}")
+            return
+
+        # Get async blob service client
+        try:
+            blob_service = self._get_azure_blob_client_async(azure_config)
+        except ImportError as e:
+            log_error(str(e))
+            return
+        except Exception as e:
+            log_error(f"Error creating Azure Blob client: {e}")
+            return
+
+        # Use async context manager for proper resource cleanup
+        async with blob_service:
+            container_client = blob_service.get_container_client(azure_config.container)
+
+            # Helper to list blobs with a given prefix (async)
+            async def list_blobs_with_prefix(prefix: str) -> List[Dict[str, Any]]:
+                """List all blobs under a given prefix (folder)."""
+                results: List[Dict[str, Any]] = []
+                normalized_prefix = prefix.rstrip("/") + "/" if not prefix.endswith("/") else prefix
+                async for blob in container_client.list_blobs(name_starts_with=normalized_prefix):
+                    # Skip "directory" markers (blobs ending with /)
+                    if not blob.name.endswith("/"):
+                        results.append(
+                            {
+                                "name": blob.name,
+                                "size": blob.size,
+                                "content_type": blob.content_settings.content_type if blob.content_settings else None,
+                            }
+                        )
+                return results
+
+            # Identify blobs to process
+            blobs_to_process: List[Dict[str, Any]] = []
+
+            try:
+                if remote_content.blob_name:
+                    # Try to get as a single blob first
+                    blob_client = container_client.get_blob_client(remote_content.blob_name)
+                    try:
+                        props = await blob_client.get_blob_properties()
+                        blobs_to_process.append(
+                            {
+                                "name": remote_content.blob_name,
+                                "size": props.size,
+                                "content_type": props.content_settings.content_type if props.content_settings else None,
+                            }
+                        )
+                    except Exception:
+                        # Blob doesn't exist - check if it's actually a folder (prefix)
+                        log_debug(f"Blob {remote_content.blob_name} not found, checking if it's a folder...")
+                        blobs_to_process = await list_blobs_with_prefix(remote_content.blob_name)
+                        if not blobs_to_process:
+                            log_error(
+                                f"No blob or folder found at path: {remote_content.blob_name}. "
+                                "If this is a folder, ensure files exist inside it."
+                            )
+                            return
+                elif remote_content.prefix:
+                    # List blobs with prefix
+                    blobs_to_process = await list_blobs_with_prefix(remote_content.prefix)
+            except Exception as e:
+                log_error(f"Error listing Azure blobs: {e}")
+                return
+
+            if not blobs_to_process:
+                log_warning(f"No blobs found in Azure container: {azure_config.container}")
+                return
+
+            # For single file uploads, use the original content object to preserve the ID
+            # returned by the API. For folder uploads, create new content entries for each file.
+            is_folder_upload = len(blobs_to_process) > 1
+
+            # Process each blob
+            for blob_info in blobs_to_process:
+                blob_name = blob_info["name"]
+                file_name = blob_name.split("/")[-1]
+
+                # Build a unique virtual path for hashing
+                virtual_path = f"azure://{azure_config.storage_account}/{azure_config.container}/{blob_name}"
+
+                # Build metadata
+                azure_metadata = {
+                    "source_type": "azure_blob",
+                    "source_config_id": azure_config.id,
+                    "source_config_name": azure_config.name,
+                    "azure_storage_account": azure_config.storage_account,
+                    "azure_container": azure_config.container,
+                    "azure_blob_name": blob_name,
+                    "azure_filename": file_name,
+                }
+                merged_metadata = {**azure_metadata, **(content.metadata or {})}
+
+                # Setup Content object
+                if is_folder_upload:
+                    # For folder uploads, create new content entries for each file
+                    relative_path = blob_name
+                    if remote_content.prefix and blob_name.startswith(remote_content.prefix):
+                        relative_path = blob_name[len(remote_content.prefix) :].lstrip("/")
+                    content_name = f"{content.name}/{relative_path}" if content.name else blob_name
+
+                    content_entry = Content(
+                        name=content_name,
+                        description=content.description,
+                        path=virtual_path,
+                        status=ContentStatus.PROCESSING,
+                        metadata=merged_metadata,
+                        file_type="azure_blob",
+                    )
+                    content_entry.content_hash = self._build_content_hash(content_entry)
+                    content_entry.id = generate_id(content_entry.content_hash)
+                else:
+                    # For single file uploads, use the original content object to preserve ID
+                    content_entry = content
+                    content_entry.path = virtual_path
+                    content_entry.status = ContentStatus.PROCESSING
+                    content_entry.metadata = merged_metadata
+                    content_entry.file_type = "azure_blob"
+                    # Use existing id and content_hash from the original content if available
+                    if not content_entry.content_hash:
+                        content_entry.content_hash = self._build_content_hash(content_entry)
+                    if not content_entry.id:
+                        content_entry.id = generate_id(content_entry.content_hash)
+
+                await self._ainsert_contents_db(content_entry)
+
+                if self._should_skip(content_entry.content_hash, skip_if_exists):
+                    content_entry.status = ContentStatus.COMPLETED
+                    await self._aupdate_content(content_entry)
+                    continue
+
+                # Download blob (async)
+                try:
+                    blob_client = container_client.get_blob_client(blob_name)
+                    download_stream = await blob_client.download_blob()
+                    blob_data = await download_stream.readall()
+                    file_content = BytesIO(blob_data)
+                except Exception as e:
+                    log_error(f"Error downloading Azure blob {blob_name}: {e}")
+                    content_entry.status = ContentStatus.FAILED
+                    content_entry.status_message = str(e)
+                    await self._aupdate_content(content_entry)
+                    continue
+
+                # Select reader and read content
+                reader = self._select_reader_by_uri(file_name, content.reader)
+                if reader is None:
+                    log_warning(f"No reader found for file: {file_name}")
+                    content_entry.status = ContentStatus.FAILED
+                    content_entry.status_message = "No suitable reader found"
+                    await self._aupdate_content(content_entry)
+                    continue
+
+                reader = cast(Reader, reader)
+                read_documents = await reader.async_read(file_content, name=file_name)
+
+                # Prepare and insert into vector database
+                if not content_entry.id:
+                    content_entry.id = generate_id(content_entry.content_hash or "")
+                self._prepare_documents_for_insert(read_documents, content_entry.id)
+                await self._ahandle_vector_db_insert(content_entry, read_documents, upsert)
+
+    def _load_from_azure_blob(
+        self,
+        content: Content,
+        upsert: bool,
+        skip_if_exists: bool,
+        config: Optional[RemoteContentConfig] = None,
+    ):
+        """Synchronous version of _load_from_azure_blob.
+
+        Load content from Azure Blob Storage:
+        1. Authenticate with Azure AD using client credentials
+        2. List blobs in container (by prefix or single blob)
+        3. Download and process each blob
+        4. Insert to vector database
+        """
+        remote_content: AzureBlobContent = cast(AzureBlobContent, content.remote_content)
+        azure_config = cast(AzureBlobConfig, config) if isinstance(config, AzureBlobConfig) else None
+
+        if azure_config is None:
+            log_error(f"Azure Blob config not found for config_id: {remote_content.config_id}")
+            return
+
+        # Get blob service client
+        try:
+            blob_service = self._get_azure_blob_client(azure_config)
+        except ImportError as e:
+            log_error(str(e))
+            return
+        except Exception as e:
+            log_error(f"Error creating Azure Blob client: {e}")
+            return
+
+        container_client = blob_service.get_container_client(azure_config.container)
+
+        # Helper to list blobs with a given prefix
+        def list_blobs_with_prefix(prefix: str) -> List[Dict[str, Any]]:
+            """List all blobs under a given prefix (folder)."""
+            results: List[Dict[str, Any]] = []
+            normalized_prefix = prefix.rstrip("/") + "/" if not prefix.endswith("/") else prefix
+            blobs = container_client.list_blobs(name_starts_with=normalized_prefix)
+            for blob in blobs:
+                # Skip "directory" markers (blobs ending with /)
+                if not blob.name.endswith("/"):
+                    results.append(
+                        {
+                            "name": blob.name,
+                            "size": blob.size,
+                            "content_type": blob.content_settings.content_type if blob.content_settings else None,
+                        }
+                    )
+            return results
+
+        # Identify blobs to process
+        blobs_to_process: List[Dict[str, Any]] = []
+
+        try:
+            if remote_content.blob_name:
+                # Try to get as a single blob first
+                blob_client = container_client.get_blob_client(remote_content.blob_name)
+                try:
+                    props = blob_client.get_blob_properties()
+                    blobs_to_process.append(
+                        {
+                            "name": remote_content.blob_name,
+                            "size": props.size,
+                            "content_type": props.content_settings.content_type if props.content_settings else None,
+                        }
+                    )
+                except Exception:
+                    # Blob doesn't exist - check if it's actually a folder (prefix)
+                    log_debug(f"Blob {remote_content.blob_name} not found, checking if it's a folder...")
+                    blobs_to_process = list_blobs_with_prefix(remote_content.blob_name)
+                    if not blobs_to_process:
+                        log_error(
+                            f"No blob or folder found at path: {remote_content.blob_name}. "
+                            "If this is a folder, ensure files exist inside it."
+                        )
+                        return
+            elif remote_content.prefix:
+                # List blobs with prefix
+                blobs_to_process = list_blobs_with_prefix(remote_content.prefix)
+        except Exception as e:
+            log_error(f"Error listing Azure blobs: {e}")
+            return
+
+        if not blobs_to_process:
+            log_warning(f"No blobs found in Azure container: {azure_config.container}")
+            return
+
+        # For single file uploads, use the original content object to preserve the ID
+        # returned by the API. For folder uploads, create new content entries for each file.
+        is_folder_upload = len(blobs_to_process) > 1
+
+        # Process each blob
+        for blob_info in blobs_to_process:
+            blob_name = blob_info["name"]
+            file_name = blob_name.split("/")[-1]
+
+            # Build a unique virtual path for hashing
+            virtual_path = f"azure://{azure_config.storage_account}/{azure_config.container}/{blob_name}"
+
+            # Build metadata
+            azure_metadata = {
+                "source_type": "azure_blob",
+                "source_config_id": azure_config.id,
+                "source_config_name": azure_config.name,
+                "azure_storage_account": azure_config.storage_account,
+                "azure_container": azure_config.container,
+                "azure_blob_name": blob_name,
+                "azure_filename": file_name,
+            }
+            merged_metadata = {**azure_metadata, **(content.metadata or {})}
+
+            # Setup Content object
+            if is_folder_upload:
+                # For folder uploads, create new content entries for each file
+                relative_path = blob_name
+                if remote_content.prefix and blob_name.startswith(remote_content.prefix):
+                    relative_path = blob_name[len(remote_content.prefix) :].lstrip("/")
+                content_name = f"{content.name}/{relative_path}" if content.name else blob_name
+
+                content_entry = Content(
+                    name=content_name,
+                    description=content.description,
+                    path=virtual_path,
+                    status=ContentStatus.PROCESSING,
+                    metadata=merged_metadata,
+                    file_type="azure_blob",
+                )
+                content_entry.content_hash = self._build_content_hash(content_entry)
+                content_entry.id = generate_id(content_entry.content_hash)
+            else:
+                # For single file uploads, use the original content object to preserve ID
+                content_entry = content
+                content_entry.path = virtual_path
+                content_entry.status = ContentStatus.PROCESSING
+                content_entry.metadata = merged_metadata
+                content_entry.file_type = "azure_blob"
+                # Use existing id and content_hash from the original content if available
+                if not content_entry.content_hash:
+                    content_entry.content_hash = self._build_content_hash(content_entry)
+                if not content_entry.id:
+                    content_entry.id = generate_id(content_entry.content_hash)
+
+            self._insert_contents_db(content_entry)
+
+            if self._should_skip(content_entry.content_hash, skip_if_exists):
+                content_entry.status = ContentStatus.COMPLETED
+                self._update_content(content_entry)
+                continue
+
+            # Download blob
+            try:
+                blob_client = container_client.get_blob_client(blob_name)
+                download_stream = blob_client.download_blob()
+                file_content = BytesIO(download_stream.readall())
+            except Exception as e:
+                log_error(f"Error downloading Azure blob {blob_name}: {e}")
+                content_entry.status = ContentStatus.FAILED
+                content_entry.status_message = str(e)
+                self._update_content(content_entry)
+                continue
+
+            # Select reader and read content
+            reader = self._select_reader_by_uri(file_name, content.reader)
+            if reader is None:
+                log_warning(f"No reader found for file: {file_name}")
+                content_entry.status = ContentStatus.FAILED
+                content_entry.status_message = "No suitable reader found"
+                self._update_content(content_entry)
+                continue
+
+            reader = cast(Reader, reader)
+            read_documents = reader.read(file_content, name=file_name)
+
+            # Prepare and insert into vector database
+            if not content_entry.id:
+                content_entry.id = generate_id(content_entry.content_hash or "")
+            self._prepare_documents_for_insert(read_documents, content_entry.id)
+            self._handle_vector_db_insert(content_entry, read_documents, upsert)
+
     async def _ahandle_vector_db_insert(self, content: Content, read_documents, upsert):
         from agno.vectordb import VectorDb
 

agno/knowledge/remote_content/__init__.py

@@ -1,4 +1,5 @@
 from agno.knowledge.remote_content.config import (
+    AzureBlobConfig,
     GcsConfig,
     GitHubConfig,
     RemoteContentConfig,
@@ -6,6 +7,7 @@ from agno.knowledge.remote_content.config import (
     SharePointConfig,
 )
 from agno.knowledge.remote_content.remote_content import (
+    AzureBlobContent,
     GCSContent,
     GitHubContent,
     RemoteContent,
@@ -20,10 +22,12 @@ __all__ = [
     "GcsConfig",
     "SharePointConfig",
     "GitHubConfig",
+    "AzureBlobConfig",
     # Content classes
     "RemoteContent",
     "S3Content",
     "GCSContent",
     "SharePointContent",
     "GitHubContent",
+    "AzureBlobContent",
 ]

agno/knowledge/remote_content/config.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 if TYPE_CHECKING:
     from agno.knowledge.remote_content.remote_content import (
+        AzureBlobContent,
         GCSContent,
         GitHubContent,
         S3Content,
@@ -20,8 +21,7 @@ class RemoteContentConfig(BaseModel):
     name: str
     metadata: Optional[dict] = None
 
-    class Config:
-        extra = "allow"
+    model_config = ConfigDict(extra="allow")
 
 
 class S3Config(RemoteContentConfig):
@@ -202,3 +202,65 @@ class GitHubConfig(RemoteContentConfig):
             folder_path=folder_path,
             branch=branch or self.branch,
         )
+
+
+class AzureBlobConfig(RemoteContentConfig):
+    """Configuration for Azure Blob Storage content source.
+
+    Uses Azure AD client credentials flow for authentication.
+
+    Required Azure AD App Registration permissions:
+        - Storage Blob Data Reader (or Contributor) role on the storage account
+
+    Example:
+        ```python
+        config = AzureBlobConfig(
+            id="company-docs",
+            name="Company Documents",
+            tenant_id=os.getenv("AZURE_TENANT_ID"),
+            client_id=os.getenv("AZURE_CLIENT_ID"),
+            client_secret=os.getenv("AZURE_CLIENT_SECRET"),
+            storage_account=os.getenv("AZURE_STORAGE_ACCOUNT_NAME"),
+            container=os.getenv("AZURE_CONTAINER_NAME"),
+        )
+        ```
+    """
+
+    tenant_id: str
+    client_id: str
+    client_secret: str
+    storage_account: str
+    container: str
+    prefix: Optional[str] = None
+
+    def file(self, blob_name: str) -> "AzureBlobContent":
+        """Create a content reference for a specific blob (file).
+
+        Args:
+            blob_name: The blob name (path to file in container).
+
+        Returns:
+            AzureBlobContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import AzureBlobContent
+
+        return AzureBlobContent(
+            config_id=self.id,
+            blob_name=blob_name,
+        )
+
+    def folder(self, prefix: str) -> "AzureBlobContent":
+        """Create a content reference for a folder (prefix).
+
+        Args:
+            prefix: The blob prefix (folder path).
+
+        Returns:
+            AzureBlobContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import AzureBlobContent
+
+        return AzureBlobContent(
+            config_id=self.id,
+            prefix=prefix,
+        )

agno/knowledge/remote_content/remote_content.py

@@ -142,4 +142,35 @@ class GitHubContent:
         }
 
 
-RemoteContent = Union[S3Content, GCSContent, SharePointContent, GitHubContent]
+@dataclass
+class AzureBlobContent:
+    """Content reference for Azure Blob Storage files.
+
+    Used with AzureBlobConfig to load files from Azure Blob Storage containers.
+    Supports loading single blobs or entire prefixes (folders).
+    """
+
+    def __init__(
+        self,
+        config_id: str,
+        blob_name: Optional[str] = None,
+        prefix: Optional[str] = None,
+    ):
+        self.config_id = config_id
+        self.blob_name = blob_name
+        self.prefix = prefix
+
+        if self.blob_name is None and self.prefix is None:
+            raise ValueError("Either blob_name or prefix must be provided")
+        if self.blob_name is not None and self.prefix is not None:
+            raise ValueError("Provide either blob_name or prefix, not both")
+
+    def get_config(self):
+        return {
+            "config_id": self.config_id,
+            "blob_name": self.blob_name,
+            "prefix": self.prefix,
+        }
+
+
+RemoteContent = Union[S3Content, GCSContent, SharePointContent, GitHubContent, AzureBlobContent]

agno/models/ollama/__init__.py

@@ -1,5 +1,7 @@
 from agno.models.ollama.chat import Ollama
+from agno.models.ollama.responses import OllamaResponses
 
 __all__ = [
     "Ollama",
+    "OllamaResponses",
 ]