agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/knowledge/reader/tavily_reader.py

@@ -0,0 +1,193 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Dict, List, Literal, Optional
+
+from agno.knowledge.chunking.semantic import SemanticChunking
+from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
+from agno.knowledge.document.base import Document
+from agno.knowledge.reader.base import Reader
+from agno.knowledge.types import ContentType
+from agno.utils.log import log_debug, logger
+
+try:
+    from tavily import TavilyClient  # type: ignore[attr-defined]
+except ImportError:
+    raise ImportError(
+        "The `tavily-python` package is not installed. Please install it via `pip install tavily-python`."
+    )
+
+
+@dataclass
+class TavilyReader(Reader):
+    api_key: Optional[str] = None
+    params: Optional[Dict] = None
+    extract_format: Literal["markdown", "text"] = "markdown"
+    extract_depth: Literal["basic", "advanced"] = "basic"
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        params: Optional[Dict] = None,
+        extract_format: Literal["markdown", "text"] = "markdown",
+        extract_depth: Literal["basic", "advanced"] = "basic",
+        chunk: bool = True,
+        chunk_size: int = 5000,
+        chunking_strategy: Optional[ChunkingStrategy] = SemanticChunking(),
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize TavilyReader for extracting content from URLs using Tavily's Extract API.
+
+        Args:
+            api_key: Tavily API key (or use TAVILY_API_KEY env var)
+            params: Additional parameters to pass to the extract API
+            extract_format: Output format - "markdown" or "text"
+            extract_depth: Extraction depth - "basic" (1 credit/5 URLs) or "advanced" (2 credits/5 URLs)
+            chunk: Whether to chunk the extracted content
+            chunk_size: Size of chunks when chunking is enabled
+            chunking_strategy: Strategy to use for chunking
+            name: Name of the reader
+            description: Description of the reader
+        """
+        # Initialize base Reader (handles chunk_size / strategy)
+        super().__init__(
+            chunk=chunk, chunk_size=chunk_size, chunking_strategy=chunking_strategy, name=name, description=description
+        )
+
+        # Tavily-specific attributes
+        self.api_key = api_key
+        self.params = params or {}
+        self.extract_format = extract_format
+        self.extract_depth = extract_depth
+
+    @classmethod
+    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+        """Get the list of supported chunking strategies for Tavily readers."""
+        return [
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+        ]
+
+    @classmethod
+    def get_supported_content_types(self) -> List[ContentType]:
+        return [ContentType.URL]
+
+    def _extract(self, url: str, name: Optional[str] = None) -> List[Document]:
+        """
+        Internal method to extract content from a URL using Tavily's Extract API.
+
+        Args:
+            url: The URL to extract content from
+            name: Optional name for the document (defaults to URL)
+
+        Returns:
+            A list of documents containing the extracted content
+        """
+        log_debug(f"Extracting content from: {url}")
+
+        client = TavilyClient(api_key=self.api_key)
+
+        # Prepare extract parameters
+        extract_params = {
+            "urls": [url],
+            "depth": self.extract_depth,
+        }
+
+        # Add optional params if provided
+        if self.params:
+            extract_params.update(self.params)
+
+        try:
+            # Call Tavily Extract API
+            response = client.extract(**extract_params)
+
+            # Extract content from response
+            if not response or "results" not in response:
+                logger.warning(f"No results received for URL: {url}")
+                return [Document(name=name or url, id=url, content="")]
+
+            results = response.get("results", [])
+            if not results:
+                logger.warning(f"Empty results for URL: {url}")
+                return [Document(name=name or url, id=url, content="")]
+
+            # Get the first result (since we're extracting a single URL)
+            result = results[0]
+
+            # Check if extraction failed
+            if "failed_reason" in result:
+                logger.warning(f"Extraction failed for {url}: {result['failed_reason']}")
+                return [Document(name=name or url, id=url, content="")]
+
+            # Get raw content
+            content = result.get("raw_content", "")
+
+            if content is None:
+                content = ""
+                logger.warning(f"No content received for URL: {url}")
+
+            # Debug logging
+            log_debug(f"Received content type: {type(content)}")
+            log_debug(f"Content length: {len(content) if content else 0}")
+
+            # Create documents
+            documents = []
+            if self.chunk and content:
+                documents.extend(self.chunk_document(Document(name=name or url, id=url, content=content)))
+            else:
+                documents.append(Document(name=name or url, id=url, content=content))
+            return documents
+
+        except Exception as e:
+            logger.error(f"Error extracting content from {url}: {e}")
+            return [Document(name=name or url, id=url, content="")]
+
+    async def _async_extract(self, url: str, name: Optional[str] = None) -> List[Document]:
+        """
+        Internal async method to extract content from a URL.
+
+        Args:
+            url: The URL to extract content from
+            name: Optional name for the document
+
+        Returns:
+            A list of documents containing the extracted content
+        """
+        log_debug(f"Async extracting content from: {url}")
+
+        # Use asyncio.to_thread to run the synchronous extract in a thread
+        return await asyncio.to_thread(self._extract, url, name)
+
+    def read(self, url: str, name: Optional[str] = None) -> List[Document]:
+        """
+        Reads content from a URL using Tavily Extract API.
+
+        This is the public API method that users should call.
+
+        Args:
+            url: The URL to extract content from
+            name: Optional name for the document
+
+        Returns:
+            A list of documents containing the extracted content
+        """
+        return self._extract(url, name)
+
+    async def async_read(self, url: str, name: Optional[str] = None) -> List[Document]:
+        """
+        Asynchronously reads content from a URL using Tavily Extract API.
+
+        This is the public API method that users should call for async operations.
+
+        Args:
+            url: The URL to extract content from
+            name: Optional name for the document
+
+        Returns:
+            A list of documents containing the extracted content
+        """
+        return await self._async_extract(url, name)

agno/knowledge/reader/text_reader.py

@@ -8,7 +8,7 @@ from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyT
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
 from agno.knowledge.types import ContentType
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_debug, log_error, log_warning
 
 
 class TextReader(Reader):
@@ -37,12 +37,18 @@ class TextReader(Reader):
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                log_info(f"Reading: {file}")
+                log_debug(f"Reading: {file}")
                 file_name = name or file.stem
                 file_contents = file.read_text(self.encoding or "utf-8")
             else:
-                file_name = name or file.name.split(".")[0]
-                log_info(f"Reading uploaded file: {file_name}")
+                # Handle BytesIO and other file-like objects that may not have a name attribute
+                if name:
+                    file_name = name
+                elif hasattr(file, "name") and file.name is not None:
+                    file_name = file.name.split(".")[0]
+                else:
+                    file_name = "text_file"
+                log_debug(f"Reading uploaded file: {file_name}")
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -60,7 +66,7 @@ class TextReader(Reader):
                 return chunked_documents
             return documents
         except Exception as e:
-            logger.error(f"Error reading: {file}: {e}")
+            log_error(f"Error reading: {file}: {e}")
             return []
 
     async def async_read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
@@ -69,7 +75,7 @@ class TextReader(Reader):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
 
-                log_info(f"Reading asynchronously: {file}")
+                log_debug(f"Reading asynchronously: {file}")
                 file_name = name or file.stem
 
                 try:
@@ -78,11 +84,17 @@ class TextReader(Reader):
                     async with aiofiles.open(file, "r", encoding=self.encoding or "utf-8") as f:
                         file_contents = await f.read()
                 except ImportError:
-                    logger.warning("aiofiles not installed, using synchronous file I/O")
+                    log_warning("aiofiles not installed, using synchronous file I/O")
                     file_contents = file.read_text(self.encoding or "utf-8")
             else:
-                log_info(f"Reading uploaded file asynchronously: {file.name}")
-                file_name = name or file.name.split(".")[0]
+                # Handle BytesIO and other file-like objects that may not have a name attribute
+                if name:
+                    file_name = name
+                elif hasattr(file, "name") and file.name is not None:
+                    file_name = file.name.split(".")[0]
+                else:
+                    file_name = "text_file"
+                log_debug(f"Reading uploaded file asynchronously: {file_name}")
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -96,7 +108,7 @@ class TextReader(Reader):
                 return await self._async_chunk_document(document)
             return [document]
         except Exception as e:
-            logger.error(f"Error reading asynchronously: {file}: {e}")
+            log_error(f"Error reading asynchronously: {file}: {e}")
             return []
 
     async def _async_chunk_document(self, document: Document) -> List[Document]:

agno/knowledge/reader/web_search_reader.py

@@ -37,7 +37,7 @@ class WebSearchReader(Reader):
     user_agent: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 
     # Search engine configuration
-    search_engine: Literal["duckduckgo", "google"] = "duckduckgo"
+    search_engine: Literal["duckduckgo"] = "duckduckgo"
     search_delay: float = 3.0  # Delay between search requests
     max_search_retries: int = 2  # Retries for search operations
 
@@ -121,57 +121,10 @@ class WebSearchReader(Reader):
                     return []
         return []
 
-    def _perform_google_search(self, query: str) -> List[Dict[str, str]]:
-        """Perform web search using Google (requires googlesearch-python)"""
-        log_debug(f"Performing Google search for: {query}")
-
-        try:
-            from googlesearch import search
-        except ImportError:
-            logger.error("Google search requires 'googlesearch-python'. Install with: pip install googlesearch-python")
-            return []
-
-        for attempt in range(self.max_search_retries):
-            try:
-                self._respect_rate_limits()
-
-                results = []
-                # Use the basic search function without unsupported parameters
-                # The googlesearch-python library's search function only accepts basic parameters
-                search_results = search(query)
-
-                # Convert iterator to list and limit results
-                result_list = list(search_results)[: self.max_results]
-
-                for result in result_list:
-                    # The search function returns URLs as strings
-                    results.append(
-                        {
-                            "title": "",  # Google search doesn't provide titles directly
-                            "url": result,
-                            "description": "",  # Google search doesn't provide descriptions directly
-                        }
-                    )
-
-                log_debug(f"Found {len(results)} Google search results")
-                return results
-
-            except Exception as e:
-                logger.warning(f"Google search attempt {attempt + 1} failed: {e}")
-                if attempt < self.max_search_retries - 1:
-                    time.sleep(self.search_delay)
-                else:
-                    logger.error(f"All Google search attempts failed: {e}")
-                    return []
-
-        return []
-
     def _perform_web_search(self, query: str) -> List[Dict[str, str]]:
         """Perform web search using the configured search engine"""
         if self.search_engine == "duckduckgo":
             return self._perform_duckduckgo_search(query)
-        elif self.search_engine == "google":
-            return self._perform_google_search(query)
         else:
             logger.error(f"Unsupported search engine: {self.search_engine}")
             return []

agno/knowledge/reader/website_reader.py

@@ -12,7 +12,7 @@ from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyT
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
 from agno.knowledge.types import ContentType
-from agno.utils.log import log_debug, logger
+from agno.utils.log import log_debug, log_error, log_warning
 
 try:
     from bs4 import BeautifulSoup, Tag  # noqa: F401
@@ -229,21 +229,21 @@ class WebsiteReader(Reader):
                 # Log HTTP status errors but continue crawling other pages
                 # Skip redirect errors (3xx) as they should be handled by follow_redirects
                 if e.response.status_code >= 300 and e.response.status_code < 400:
-                    logger.debug(f"Redirect encountered for {current_url}, skipping: {e}")
+                    log_debug(f"Redirect encountered for {current_url}, skipping: {e}")
                 else:
-                    logger.warning(f"HTTP status error while crawling {current_url}: {e}")
+                    log_warning(f"HTTP status error while crawling {current_url}: {e}")
                 # For the initial URL, we should raise the error only if it's not a redirect
                 if current_url == url and not crawler_result and not (300 <= e.response.status_code < 400):
                     raise
             except httpx.RequestError as e:
                 # Log request errors but continue crawling other pages
-                logger.warning(f"Request error while crawling {current_url}: {e}")
+                log_warning(f"Request error while crawling {current_url}: {e}")
                 # For the initial URL, we should raise the error
                 if current_url == url and not crawler_result:
                     raise
             except Exception as e:
                 # Log other exceptions but continue crawling other pages
-                logger.warning(f"Failed to crawl {current_url}: {e}")
+                log_warning(f"Failed to crawl {current_url}: {e}")
                 # For the initial URL, we should raise the error
                 if current_url == url and not crawler_result:
                     # Wrap non-HTTP exceptions in a RequestError
@@ -332,19 +332,19 @@ class WebsiteReader(Reader):
 
                 except httpx.HTTPStatusError as e:
                     # Log HTTP status errors but continue crawling other pages
-                    logger.warning(f"HTTP status error while crawling asynchronously {current_url}: {e}")
+                    log_warning(f"HTTP status error while crawling asynchronously {current_url}: {e}")
                     # For the initial URL, we should raise the error
                     if current_url == url and not crawler_result:
                         raise
                 except httpx.RequestError as e:
                     # Log request errors but continue crawling other pages
-                    logger.warning(f"Request error while crawling asynchronously {current_url}: {e}")
+                    log_warning(f"Request error while crawling asynchronously {current_url}: {e}")
                     # For the initial URL, we should raise the error
                     if current_url == url and not crawler_result:
                         raise
                 except Exception as e:
                     # Log other exceptions but continue crawling other pages
-                    logger.warning(f"Failed to crawl asynchronously {current_url}: {e}")
+                    log_warning(f"Failed to crawl asynchronously {current_url}: {e}")
                     # For the initial URL, we should raise the error
                     if current_url == url and not crawler_result:
                         # Wrap non-HTTP exceptions in a RequestError
@@ -398,7 +398,7 @@ class WebsiteReader(Reader):
                     )
             return documents
         except (httpx.HTTPStatusError, httpx.RequestError) as e:
-            logger.error(f"Error reading website {url}: {e}")
+            log_error(f"Error reading website {url}: {e}")
             raise
 
     async def async_read(self, url: str, name: Optional[str] = None) -> List[Document]:
@@ -451,5 +451,5 @@ class WebsiteReader(Reader):
 
             return documents
         except (httpx.HTTPStatusError, httpx.RequestError) as e:
-            logger.error(f"Error reading website asynchronously {url}: {e}")
+            log_error(f"Error reading website asynchronously {url}: {e}")
             raise

agno/knowledge/reader/wikipedia_reader.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import List, Optional
 
 from agno.knowledge.chunking.fixed import FixedSizeChunking
@@ -45,7 +46,38 @@ class WikipediaReader(Reader):
 
         except wikipedia.exceptions.PageError:
             summary = None
-            log_info("PageError: Page not found.")
+            log_info("Wikipedia Error: Page not found.")
+
+        # Only create Document if we successfully got a summary
+        if summary:
+            return [
+                Document(
+                    name=topic,
+                    meta_data={"topic": topic},
+                    content=summary,
+                )
+            ]
+        return []
+
+    async def async_read(self, topic: str) -> List[Document]:
+        """
+        Asynchronously read content from Wikipedia.
+
+        Args:
+            topic: The Wikipedia topic to read
+
+        Returns:
+            A list of documents containing the Wikipedia summary
+        """
+        log_debug(f"Async reading Wikipedia topic: {topic}")
+        summary = None
+        try:
+            # Run the synchronous wikipedia API call in a thread pool
+            summary = await asyncio.to_thread(wikipedia.summary, topic, auto_suggest=self.auto_suggest)
+
+        except wikipedia.exceptions.PageError:
+            summary = None
+            log_info("Wikipedia Error: Page not found.")
 
         # Only create Document if we successfully got a summary
         if summary:

agno/knowledge/types.py

@@ -20,6 +20,7 @@ class ContentType(str, Enum):
     MARKDOWN = ".md"
     DOCX = ".docx"
     DOC = ".doc"
+    PPTX = ".pptx"
     JSON = ".json"
 
     # Spreadsheet file extensions

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
@@ -75,8 +76,33 @@ 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.
+
+    Args:
+        knowledge_instance: Optional Knowledge instance to include custom readers from.
+
+    Returns:
+        List of reader info dictionaries.
+    """
     readers_info = []
     keys = ReaderFactory.get_all_reader_keys()
     for key in keys:
@@ -88,18 +114,35 @@ def get_all_readers_info() -> List[Dict]:
             # Log the error but don't fail the entire request
             log_debug(f"Skipping reader '{key}': {e}")
             continue
+
+    # Add custom readers from knowledge instance if provided
+    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)
+                except ValueError as e:
+                    log_debug(f"Skipping custom reader '{reader_id}': {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 +150,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
 
@@ -129,12 +174,32 @@ def get_chunker_info(chunker_key: str) -> Dict:
             class_name = chunker_class.__name__
             docstring = chunker_class.__doc__ or f"{class_name} chunking strategy"
 
+            # Check class __init__ signature for chunk_size and overlap parameters
+            metadata = {}
+            import inspect
+
+            try:
+                sig = inspect.signature(chunker_class.__init__)
+                param_names = set(sig.parameters.keys())
+
+                # If class has chunk_size or max_chunk_size parameter, set default chunk_size
+                if "chunk_size" in param_names or "max_chunk_size" in param_names:
+                    metadata["chunk_size"] = 5000
+
+                # If class has overlap parameter, set default overlap
+                if "overlap" in param_names:
+                    metadata["chunk_overlap"] = 0
+            except Exception:
+                # If we can't inspect, skip metadata
+                pass
+
             return {
                 "key": chunker_key,
                 "class_name": class_name,
                 "name": chunker_key,
                 "description": docstring.strip(),
                 "strategy_type": strategy_type.value,
+                "metadata": metadata,
             }
         except ValueError:
             raise ValueError(f"Unknown chunker key: {chunker_key}")

agno/media.py

@@ -4,6 +4,8 @@ from uuid import uuid4
 
 from pydantic import BaseModel, field_validator, model_validator
 
+from agno.utils.log import log_error
+
 
 class Image(BaseModel):
     """Unified Image class for all use cases (input, output, artifacts)"""
@@ -395,10 +397,20 @@ class File(BaseModel):
         name: Optional[str] = None,
         format: Optional[str] = None,
     ) -> "File":
-        """Create File from base64 encoded content"""
+        """Create File from base64 encoded content or plain text.
+
+        Handles both base64-encoded binary content and plain text content
+        (which is stored as UTF-8 strings for text/* MIME types).
+        """
         import base64
 
-        content_bytes = base64.b64decode(base64_content)
+        try:
+            content_bytes = base64.b64decode(base64_content)
+        except Exception:
+            # If not valid base64, it might be plain text content (text/csv, text/plain, etc.)
+            # which is stored as UTF-8 strings, not base64
+            content_bytes = base64_content.encode("utf-8")
+
         return cls(
             content=content_bytes,
             id=id,
@@ -413,10 +425,14 @@ class File(BaseModel):
         import httpx
 
         if self.url:
-            response = httpx.get(self.url)
-            content = response.content
-            mime_type = response.headers.get("Content-Type", "").split(";")[0]
-            return content, mime_type
+            try:
+                response = httpx.get(self.url)
+                content = response.content
+                mime_type = response.headers.get("Content-Type", "").split(";")[0]
+                return content, mime_type
+            except Exception:
+                log_error(f"Failed to download file from {self.url}")
+                return None
         else:
             return None
 

agno/memory/__init__.py

@@ -1,3 +1,16 @@
 from agno.memory.manager import MemoryManager, UserMemory
+from agno.memory.strategies import (
+    MemoryOptimizationStrategy,
+    MemoryOptimizationStrategyFactory,
+    MemoryOptimizationStrategyType,
+    SummarizeStrategy,
+)
 
-__all__ = ["MemoryManager", "UserMemory"]
+__all__ = [
+    "MemoryManager",
+    "UserMemory",
+    "MemoryOptimizationStrategy",
+    "MemoryOptimizationStrategyType",
+    "MemoryOptimizationStrategyFactory",
+    "SummarizeStrategy",
+]