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

agno/knowledge/remote_content/config.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from agno.knowledge.remote_content.remote_content import (
+        GCSContent,
+        GitHubContent,
+        S3Content,
+        SharePointContent,
+    )
+
+
+class RemoteContentConfig(BaseModel):
+    """Base configuration for remote content sources."""
+
+    id: str
+    name: str
+    metadata: Optional[dict] = None
+
+    class Config:
+        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,
+        )

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,77 @@ 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,
         }
 
 
-RemoteContent = Union[S3Content, GCSContent]
+RemoteContent = Union[S3Content, GCSContent, SharePointContent, GitHubContent]

agno/knowledge/utils.py

@@ -49,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
@@ -98,38 +100,44 @@ def get_reader_info_from_instance(reader: Reader, reader_id: str) -> Dict:
 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.
+        List of reader info dictionaries (custom readers first, then factory readers).
     """
     readers_info = []
-    keys = ReaderFactory.get_all_reader_keys()
-    for key in keys:
-        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
+    seen_ids: set = set()
 
-    # Add custom readers from knowledge instance if provided
+    # 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)
-                    # Only add if not already present (custom readers take precedence)
-                    if not any(r["id"] == reader_id for r in readers_info):
-                        readers_info.append(reader_info)
+                    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_debug(f"Skipping reader '{key}': {e}")
+            continue
+
     return readers_info
 
 

agno/learn/__init__.py

@@ -11,6 +11,7 @@ Main Components:
 """
 
 from agno.learn.config import (
+    DecisionLogConfig,
     EntityMemoryConfig,
     LearnedKnowledgeConfig,
     LearningMode,
@@ -21,6 +22,7 @@ from agno.learn.config import (
 )
 from agno.learn.machine import LearningMachine
 from agno.learn.schemas import (
+    DecisionLog,
     EntityMemory,
     LearnedKnowledge,
     Memories,
@@ -28,6 +30,7 @@ from agno.learn.schemas import (
     UserProfile,
 )
 from agno.learn.stores import (
+    DecisionLogStore,
     EntityMemoryStore,
     LearnedKnowledgeStore,
     LearningStore,
@@ -48,12 +51,14 @@ __all__ = [
     "EntityMemoryConfig",
     "SessionContextConfig",
     "LearnedKnowledgeConfig",
+    "DecisionLogConfig",  # Phase 2
     # Schemas
     "UserProfile",
     "Memories",
     "EntityMemory",
     "SessionContext",
     "LearnedKnowledge",
+    "DecisionLog",  # Phase 2
     # Stores
     "LearningStore",
     "UserProfileStore",
@@ -62,4 +67,5 @@ __all__ = [
     "SessionContextStore",
     "LearnedKnowledgeStore",
     "EntityMemoryStore",
+    "DecisionLogStore",  # Phase 2
 ]

agno/learn/machine.py

@@ -17,6 +17,7 @@ from os import getenv
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from agno.learn.config import (
+    DecisionLogConfig,
     EntityMemoryConfig,
     LearnedKnowledgeConfig,
     LearningMode,
@@ -45,6 +46,7 @@ UserMemoryInput = Union[bool, UserMemoryConfig, LearningStore, None]
 EntityMemoryInput = Union[bool, EntityMemoryConfig, LearningStore, None]
 SessionContextInput = Union[bool, SessionContextConfig, LearningStore, None]
 LearnedKnowledgeInput = Union[bool, LearnedKnowledgeConfig, LearningStore, None]
+DecisionLogInput = Union[bool, DecisionLogConfig, LearningStore, None]
 
 
 @dataclass
@@ -80,6 +82,7 @@ class LearningMachine:
     session_context: SessionContextInput = False
     entity_memory: EntityMemoryInput = False
     learned_knowledge: LearnedKnowledgeInput = False
+    decision_log: DecisionLogInput = False  # Phase 2
 
     # Namespace for entity_memory and learned_knowledge
     namespace: str = "global"
@@ -144,6 +147,13 @@ class LearningMachine:
                 store_type="learned_knowledge",
             )
 
+        # Decision Log (Phase 2)
+        if self.decision_log:
+            self._stores["decision_log"] = self._resolve_store(
+                input_value=self.decision_log,
+                store_type="decision_log",
+            )
+
         # Custom stores
         if self.custom_stores:
             for name, store in self.custom_stores.items():
@@ -180,6 +190,8 @@ class LearningMachine:
             return self._create_entity_memory_store(config=input_value)
         elif store_type == "learned_knowledge":
             return self._create_learned_knowledge_store(config=input_value)
+        elif store_type == "decision_log":
+            return self._create_decision_log_store(config=input_value)
         else:
             raise ValueError(f"Unknown store type: {store_type}")
 
@@ -274,6 +286,24 @@ class LearningMachine:
 
         return LearnedKnowledgeStore(config=config, debug_mode=self.debug_mode)
 
+    def _create_decision_log_store(self, config: Any) -> LearningStore:
+        """Create DecisionLogStore with resolved config."""
+        from agno.learn.stores import DecisionLogStore
+
+        if isinstance(config, DecisionLogConfig):
+            if config.db is None:
+                config.db = self.db
+            if config.model is None:
+                config.model = self.model
+        else:
+            config = DecisionLogConfig(
+                db=self.db,
+                model=self.model,
+                mode=LearningMode.AGENTIC,  # Default to AGENTIC for explicit logging
+            )
+
+        return DecisionLogStore(config=config, debug_mode=self.debug_mode)
+
     # =========================================================================
     # Store Accessors (Type-Safe)
     # =========================================================================
@@ -303,6 +333,11 @@ class LearningMachine:
         """Get learned knowledge store if enabled."""
         return self.stores.get("learned_knowledge")
 
+    @property
+    def decision_log_store(self) -> Optional[LearningStore]:
+        """Get decision log store if enabled."""
+        return self.stores.get("decision_log")
+
     @property
     def was_updated(self) -> bool:
         """True if any store was updated in the last operation."""