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

agno/knowledge/remote_content/config.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+if TYPE_CHECKING:
+    from agno.knowledge.remote_content.remote_content import (
+        AzureBlobContent,
+        GCSContent,
+        GitHubContent,
+        S3Content,
+        SharePointContent,
+    )
+
+
+class RemoteContentConfig(BaseModel):
+    """Base configuration for remote content sources."""
+
+    id: str
+    name: str
+    metadata: Optional[dict] = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+class S3Config(RemoteContentConfig):
+    """Configuration for AWS S3 content source."""
+
+    bucket_name: str
+    region: Optional[str] = None
+    aws_access_key_id: Optional[str] = None
+    aws_secret_access_key: Optional[str] = None
+    prefix: Optional[str] = None
+
+    def file(self, key: str) -> "S3Content":
+        """Create a content reference for a specific file.
+
+        Args:
+            key: The S3 object key (path to file).
+
+        Returns:
+            S3Content configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import S3Content
+
+        return S3Content(
+            bucket_name=self.bucket_name,
+            key=key,
+            config_id=self.id,
+        )
+
+    def folder(self, prefix: str) -> "S3Content":
+        """Create a content reference for a folder (prefix).
+
+        Args:
+            prefix: The S3 prefix (folder path).
+
+        Returns:
+            S3Content configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import S3Content
+
+        return S3Content(
+            bucket_name=self.bucket_name,
+            prefix=prefix,
+            config_id=self.id,
+        )
+
+
+class GcsConfig(RemoteContentConfig):
+    """Configuration for Google Cloud Storage content source."""
+
+    bucket_name: str
+    project: Optional[str] = None
+    credentials_path: Optional[str] = None
+    prefix: Optional[str] = None
+
+    def file(self, blob_name: str) -> "GCSContent":
+        """Create a content reference for a specific file.
+
+        Args:
+            blob_name: The GCS blob name (path to file).
+
+        Returns:
+            GCSContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GCSContent
+
+        return GCSContent(
+            bucket_name=self.bucket_name,
+            blob_name=blob_name,
+            config_id=self.id,
+        )
+
+    def folder(self, prefix: str) -> "GCSContent":
+        """Create a content reference for a folder (prefix).
+
+        Args:
+            prefix: The GCS prefix (folder path).
+
+        Returns:
+            GCSContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GCSContent
+
+        return GCSContent(
+            bucket_name=self.bucket_name,
+            prefix=prefix,
+            config_id=self.id,
+        )
+
+
+class SharePointConfig(RemoteContentConfig):
+    """Configuration for SharePoint content source."""
+
+    tenant_id: str
+    client_id: str
+    client_secret: str
+    hostname: str
+    site_path: Optional[str] = None
+    site_id: Optional[str] = None  # Full site ID (e.g., "contoso.sharepoint.com,guid1,guid2")
+    folder_path: Optional[str] = None
+
+    def file(self, file_path: str, site_path: Optional[str] = None) -> "SharePointContent":
+        """Create a content reference for a specific file.
+
+        Args:
+            file_path: Path to the file in SharePoint.
+            site_path: Optional site path override.
+
+        Returns:
+            SharePointContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import SharePointContent
+
+        return SharePointContent(
+            config_id=self.id,
+            file_path=file_path,
+            site_path=site_path or self.site_path,
+        )
+
+    def folder(self, folder_path: str, site_path: Optional[str] = None) -> "SharePointContent":
+        """Create a content reference for a folder.
+
+        Args:
+            folder_path: Path to the folder in SharePoint.
+            site_path: Optional site path override.
+
+        Returns:
+            SharePointContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import SharePointContent
+
+        return SharePointContent(
+            config_id=self.id,
+            folder_path=folder_path,
+            site_path=site_path or self.site_path,
+        )
+
+
+class GitHubConfig(RemoteContentConfig):
+    """Configuration for GitHub content source."""
+
+    repo: str
+    token: Optional[str] = None
+    branch: Optional[str] = None
+    path: Optional[str] = None
+
+    def file(self, file_path: str, branch: Optional[str] = None) -> "GitHubContent":
+        """Create a content reference for a specific file.
+
+        Args:
+            file_path: Path to the file in the repository.
+            branch: Optional branch override.
+
+        Returns:
+            GitHubContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GitHubContent
+
+        return GitHubContent(
+            config_id=self.id,
+            file_path=file_path,
+            branch=branch or self.branch,
+        )
+
+    def folder(self, folder_path: str, branch: Optional[str] = None) -> "GitHubContent":
+        """Create a content reference for a folder.
+
+        Args:
+            folder_path: Path to the folder in the repository.
+            branch: Optional branch override.
+
+        Returns:
+            GitHubContent configured with this source's credentials.
+        """
+        from agno.knowledge.remote_content.remote_content import GitHubContent
+
+        return GitHubContent(
+            config_id=self.id,
+            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

@@ -14,21 +14,23 @@ class S3Content:
         key: Optional[str] = None,
         object: Optional[S3Object] = None,
         prefix: Optional[str] = None,
+        config_id: Optional[str] = None,
     ):
         self.bucket_name = bucket_name
         self.bucket = bucket
         self.key = key
         self.object = object
         self.prefix = prefix
+        self.config_id = config_id
 
         if bucket_name is None and bucket is None:
             raise ValueError("Either bucket_name or bucket must be provided")
-        if key is None and object is None:
-            raise ValueError("Either key or object must be provided")
+        if key is None and object is None and prefix is None:
+            raise ValueError("Either key, object, or prefix must be provided")
         if bucket_name is not None and bucket is not None:
             raise ValueError("Either bucket_name or bucket must be provided, not both")
-        if key is not None and object is not None:
-            raise ValueError("Either key or object must be provided, not both")
+        if sum(x is not None for x in [key, object, prefix]) > 1:
+            raise ValueError("Only one of key, object, or prefix should be provided")
 
         if self.bucket_name is not None:
             self.bucket = S3Bucket(name=self.bucket_name)
@@ -40,6 +42,7 @@ class S3Content:
             "key": self.key,
             "object": self.object,
             "prefix": self.prefix,
+            "config_id": self.config_id,
         }
 
 
@@ -51,19 +54,13 @@ class GCSContent:
         bucket_name: Optional[str] = None,
         blob_name: Optional[str] = None,
         prefix: Optional[str] = None,
+        config_id: Optional[str] = None,
     ):
-        # Import Google Cloud Storage only when actually needed
-        try:
-            from google.cloud import storage  # type: ignore
-        except ImportError:
-            raise ImportError(
-                "The `google-cloud-storage` package is not installed. Please install it via `pip install google-cloud-storage`."
-            )
-
         self.bucket = bucket
         self.bucket_name = bucket_name
         self.blob_name = blob_name
         self.prefix = prefix
+        self.config_id = config_id
 
         if self.bucket is None and self.bucket_name is None:
             raise ValueError("No bucket or bucket_name provided")
@@ -72,17 +69,108 @@ class GCSContent:
         if self.blob_name is None and self.prefix is None:
             raise ValueError("Either blob_name or prefix must be provided")
 
-        if self.bucket is None:
-            client = storage.Client()
-            self.bucket = client.bucket(self.bucket_name)
-
     def get_config(self):
         return {
             "bucket": self.bucket,
             "bucket_name": self.bucket_name,
             "blob_name": self.blob_name,
             "prefix": self.prefix,
+            "config_id": self.config_id,
+        }
+
+
+@dataclass
+class SharePointContent:
+    """Content reference for SharePoint files."""
+
+    def __init__(
+        self,
+        config_id: str,
+        file_path: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        site_path: Optional[str] = None,
+        drive_id: Optional[str] = None,
+    ):
+        self.config_id = config_id
+        self.file_path = file_path
+        self.folder_path = folder_path
+        self.site_path = site_path
+        self.drive_id = drive_id
+
+        if self.file_path is None and self.folder_path is None:
+            raise ValueError("Either file_path or folder_path must be provided")
+        if self.file_path is not None and self.folder_path is not None:
+            raise ValueError("Provide either file_path or folder_path, not both")
+
+    def get_config(self):
+        return {
+            "config_id": self.config_id,
+            "file_path": self.file_path,
+            "folder_path": self.folder_path,
+            "site_path": self.site_path,
+            "drive_id": self.drive_id,
+        }
+
+
+@dataclass
+class GitHubContent:
+    """Content reference for GitHub files."""
+
+    def __init__(
+        self,
+        config_id: str,
+        file_path: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        branch: Optional[str] = None,
+    ):
+        self.config_id = config_id
+        self.file_path = file_path
+        self.folder_path = folder_path
+        self.branch = branch
+
+        if self.file_path is None and self.folder_path is None:
+            raise ValueError("Either file_path or folder_path must be provided")
+        if self.file_path is not None and self.folder_path is not None:
+            raise ValueError("Provide either file_path or folder_path, not both")
+
+    def get_config(self):
+        return {
+            "config_id": self.config_id,
+            "file_path": self.file_path,
+            "folder_path": self.folder_path,
+            "branch": self.branch,
+        }
+
+
+@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]
+RemoteContent = Union[S3Content, GCSContent, SharePointContent, GitHubContent, AzureBlobContent]

agno/knowledge/utils.py

@@ -1,5 +1,6 @@
-from typing import Dict, List
+from typing import Any, Dict, List, Optional
 
+from agno.knowledge.reader.base import Reader
 from agno.knowledge.reader.reader_factory import ReaderFactory
 from agno.knowledge.types import ContentType
 from agno.utils.log import log_debug
@@ -14,6 +15,7 @@ def _get_chunker_class(strategy_type):
         ChunkingStrategyType.AGENTIC_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.agentic", "AgenticChunking"
         ),
+        ChunkingStrategyType.CODE_CHUNKER: lambda: _import_class("agno.knowledge.chunking.code", "CodeChunking"),
         ChunkingStrategyType.DOCUMENT_CHUNKER: lambda: _import_class(
             "agno.knowledge.chunking.document", "DocumentChunking"
         ),
@@ -47,26 +49,28 @@ def _import_class(module_name: str, class_name: str):
 
 
 def get_reader_info(reader_key: str) -> Dict:
-    """Get information about a reader without instantiating it."""
-    # Try to create the reader to get its info, but don't cache it
+    """Get information about a reader without instantiating it.
+
+    Uses class methods and static metadata from ReaderFactory to avoid
+    the overhead of creating reader instances.
+    """
     try:
-        reader_factory_method = ReaderFactory._get_reader_method(reader_key)
+        # Get the reader CLASS without instantiation
+        reader_class = ReaderFactory.get_reader_class(reader_key)
 
-        # Create an instance to get the class, then call class methods
-        reader_instance = reader_factory_method()
-        reader_class = reader_instance.__class__
+        # Get metadata from static registry (no instantiation needed)
+        metadata = ReaderFactory.READER_METADATA.get(reader_key, {})
 
-        supported_strategies = reader_class.get_supported_chunking_strategies()
-        supported_content_types = reader_class.get_supported_content_types()
+        # Call class methods directly (no instance needed)
+        supported_strategies = reader_class.get_supported_chunking_strategies()  # type: ignore[attr-defined]
+        supported_content_types = reader_class.get_supported_content_types()  # type: ignore[attr-defined]
 
         return {
             "id": reader_key,
-            "name": "".join(word.capitalize() for word in reader_key.split("_")) + "Reader",
-            "description": reader_instance.description,
-            "chunking_strategies": [
-                strategy.value for strategy in supported_strategies
-            ],  # Convert enums to string values
-            "content_types": [ct.value for ct in supported_content_types],  # Convert enums to string values
+            "name": metadata.get("name", reader_class.__name__),
+            "description": metadata.get("description", f"{reader_class.__name__} reader"),
+            "chunking_strategies": [strategy.value for strategy in supported_strategies],
+            "content_types": [ct.value for ct in supported_content_types],
         }
     except ImportError as e:
         # Skip readers with missing dependencies
@@ -75,31 +79,79 @@ def get_reader_info(reader_key: str) -> Dict:
         raise ValueError(f"Unknown reader: {reader_key}. Error: {str(e)}")
 
 
-def get_all_readers_info() -> List[Dict]:
-    """Get information about all available readers."""
+def get_reader_info_from_instance(reader: Reader, reader_id: str) -> Dict:
+    """Get information about a reader instance."""
+    try:
+        reader_class = reader.__class__
+        supported_strategies = reader_class.get_supported_chunking_strategies()
+        supported_content_types = reader_class.get_supported_content_types()
+
+        return {
+            "id": reader_id,
+            "name": getattr(reader, "name", reader_class.__name__),
+            "description": getattr(reader, "description", f"Custom {reader_class.__name__}"),
+            "chunking_strategies": [strategy.value for strategy in supported_strategies],
+            "content_types": [ct.value for ct in supported_content_types],
+        }
+    except Exception as e:
+        raise ValueError(f"Failed to get info for reader '{reader_id}': {str(e)}")
+
+
+def get_all_readers_info(knowledge_instance: Optional[Any] = None) -> List[Dict]:
+    """Get information about all available readers, including custom readers from a Knowledge instance.
+
+    Custom readers are added first and take precedence over factory readers with the same ID.
+
+    Args:
+        knowledge_instance: Optional Knowledge instance to include custom readers from.
+
+    Returns:
+        List of reader info dictionaries (custom readers first, then factory readers).
+    """
     readers_info = []
+    seen_ids: set = set()
+
+    # 1. Add custom readers FIRST (they take precedence over factory readers)
+    if knowledge_instance is not None:
+        custom_readers = knowledge_instance.get_readers()
+        if isinstance(custom_readers, dict):
+            for reader_id, reader in custom_readers.items():
+                try:
+                    reader_info = get_reader_info_from_instance(reader, reader_id)
+                    readers_info.append(reader_info)
+                    seen_ids.add(reader_id)
+                except ValueError as e:
+                    log_debug(f"Skipping custom reader '{reader_id}': {e}")
+                    continue
+
+    # 2. Add factory readers (skip if custom reader with same ID already exists)
     keys = ReaderFactory.get_all_reader_keys()
     for key in keys:
+        if key in seen_ids:
+            # Custom reader with this ID already added, skip factory version
+            continue
         try:
             reader_info = get_reader_info(key)
             readers_info.append(reader_info)
         except ValueError as e:
             # Skip readers with missing dependencies or other issues
-            # Log the error but don't fail the entire request
             log_debug(f"Skipping reader '{key}': {e}")
             continue
+
     return readers_info
 
 
-def get_content_types_to_readers_mapping() -> Dict[str, List[str]]:
+def get_content_types_to_readers_mapping(knowledge_instance: Optional[Any] = None) -> Dict[str, List[str]]:
     """Get mapping of content types to list of reader IDs that support them.
 
+    Args:
+        knowledge_instance: Optional Knowledge instance to include custom readers from.
+
     Returns:
         Dictionary mapping content type strings (ContentType enum values) to list of reader IDs.
     """
     content_type_mapping: Dict[str, List[str]] = {}
-    readers_info = get_all_readers_info()
-
+    readers_info = get_all_readers_info(knowledge_instance)
     for reader_info in readers_info:
         reader_id = reader_info["id"]
         content_types = reader_info.get("content_types", [])
@@ -107,7 +159,9 @@ def get_content_types_to_readers_mapping() -> Dict[str, List[str]]:
         for content_type in content_types:
             if content_type not in content_type_mapping:
                 content_type_mapping[content_type] = []
-            content_type_mapping[content_type].append(reader_id)
+            # Avoid duplicates
+            if reader_id not in content_type_mapping[content_type]:
+                content_type_mapping[content_type].append(reader_id)
 
     return content_type_mapping
 

agno/learn/__init__.py

@@ -0,0 +1,71 @@
+"""
+Agno Learning Module
+====================
+Gives agents the ability to learn and remember.
+
+Main Components:
+- LearningMachine: Unified learning system
+- Config: Configuration for learning types
+- Schemas: Data structures for learning types
+- Stores: Storage backends for learning types
+"""
+
+from agno.learn.config import (
+    DecisionLogConfig,
+    EntityMemoryConfig,
+    LearnedKnowledgeConfig,
+    LearningMode,
+    MemoriesConfig,
+    SessionContextConfig,
+    UserMemoryConfig,
+    UserProfileConfig,
+)
+from agno.learn.machine import LearningMachine
+from agno.learn.schemas import (
+    DecisionLog,
+    EntityMemory,
+    LearnedKnowledge,
+    Memories,
+    SessionContext,
+    UserProfile,
+)
+from agno.learn.stores import (
+    DecisionLogStore,
+    EntityMemoryStore,
+    LearnedKnowledgeStore,
+    LearningStore,
+    MemoriesStore,
+    SessionContextStore,
+    UserMemoryStore,
+    UserProfileStore,
+)
+
+__all__ = [
+    # Main class
+    "LearningMachine",
+    # Configs
+    "LearningMode",
+    "UserProfileConfig",
+    "UserMemoryConfig",
+    "MemoriesConfig",  # Backwards compatibility alias
+    "EntityMemoryConfig",
+    "SessionContextConfig",
+    "LearnedKnowledgeConfig",
+    "DecisionLogConfig",  # Phase 2
+    # Schemas
+    "UserProfile",
+    "Memories",
+    "EntityMemory",
+    "SessionContext",
+    "LearnedKnowledge",
+    "DecisionLog",  # Phase 2
+    # Stores
+    "LearningStore",
+    "UserProfileStore",
+    "UserMemoryStore",
+    "MemoriesStore",  # Backwards compatibility alias
+    "SessionContextStore",
+    "LearnedKnowledgeStore",
+    "EntityMemoryStore",
+    "DecisionLogStore",  # Phase 2
+]