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

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -2,7 +2,7 @@ import asyncio
 import csv
 import io
 from pathlib import Path
-from typing import IO, Any, List, Optional, Union
+from typing import IO, Any, Iterable, List, Optional, Sequence, Tuple, Union
 
 try:
     import aiofiles
@@ -12,6 +12,12 @@ except ImportError:
 from agno.knowledge.chunking.strategy import ChunkingStrategyType
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
+from agno.knowledge.reader.csv_reader import (
+    _convert_xls_cell_value,
+    _get_workbook_name,
+    _infer_file_extension,
+    _stringify_spreadsheet_cell_value,
+)
 from agno.knowledge.types import ContentType
 from agno.utils.log import log_debug, log_error, log_warning
 
@@ -84,7 +90,8 @@ class FieldLabeledCSVReader(Reader):
             lines.append(title)
 
         for i, (header, value) in enumerate(zip(headers, row)):
-            clean_value = value.strip() if value else ""
+            # Normalize line endings before stripping to handle embedded newlines
+            clean_value = _stringify_spreadsheet_cell_value(value).strip() if value else ""
 
             if self.skip_empty_fields and not clean_value:
                 continue
@@ -98,10 +105,155 @@ class FieldLabeledCSVReader(Reader):
 
         return "\n".join(lines)
 
+    def _excel_rows_to_field_labeled_documents(
+        self,
+        *,
+        workbook_name: str,
+        sheets: Iterable[Tuple[str, Iterable[Sequence[Any]]]],
+    ) -> List[Document]:
+        """Convert Excel rows to field-labeled documents (one document per data row).
+
+        For each sheet: first row = headers, subsequent rows = data.
+        Each data row becomes a Document with field-labeled content.
+        """
+        documents = []
+        global_row_index = 0
+
+        for sheet_index, (sheet_name, rows) in enumerate(sheets, start=1):
+            rows_list = list(rows)
+
+            if not rows_list:
+                log_debug(f"Sheet '{sheet_name}' is empty, skipping")
+                continue
+
+            # First row is headers
+            headers = [_stringify_spreadsheet_cell_value(h).strip() for h in rows_list[0]]
+            if not any(headers):
+                log_debug(f"Sheet '{sheet_name}' has no valid headers, skipping")
+                continue
+
+            data_rows = rows_list[1:]
+            if not data_rows:
+                log_debug(f"Sheet '{sheet_name}' has only headers, skipping")
+                continue
+
+            log_debug(f"Processing sheet '{sheet_name}' with {len(headers)} headers and {len(data_rows)} rows")
+
+            for row_in_sheet, row in enumerate(data_rows):
+                # Convert cell values to strings
+                str_row = [_stringify_spreadsheet_cell_value(v) for v in row]
+
+                # Normalize row length
+                normalized_row = str_row[: len(headers)]
+                while len(normalized_row) < len(headers):
+                    normalized_row.append("")
+
+                # Skip entirely empty rows
+                if not any(v.strip() for v in normalized_row):
+                    continue
+
+                labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, global_row_index)
+
+                if labeled_text.strip():
+                    doc_id = f"{workbook_name}_{sheet_name}_row_{row_in_sheet + 1}"
+                    documents.append(
+                        Document(
+                            id=doc_id,
+                            name=workbook_name,
+                            meta_data={
+                                "sheet_name": sheet_name,
+                                "sheet_index": sheet_index,
+                                "row_index": row_in_sheet,
+                                "headers": headers,
+                                "source": "field_labeled_csv_reader",
+                            },
+                            content=labeled_text,
+                        )
+                    )
+                    global_row_index += 1
+
+        return documents
+
+    def _read_xlsx(self, file: Union[Path, IO[Any]], *, workbook_name: str) -> List[Document]:
+        """Read .xlsx file and convert rows to field-labeled documents."""
+        try:
+            import openpyxl  # type: ignore
+        except ImportError as e:
+            raise ImportError(
+                "`openpyxl` not installed. Please install it via `pip install agno[csv]` or `pip install openpyxl`."
+            ) from e
+
+        if isinstance(file, Path):
+            workbook = openpyxl.load_workbook(filename=str(file), read_only=True, data_only=True)
+        else:
+            file.seek(0)
+            raw = file.read()
+            if isinstance(raw, str):
+                raw = raw.encode("utf-8", errors="replace")
+            workbook = openpyxl.load_workbook(filename=io.BytesIO(raw), read_only=True, data_only=True)
+
+        try:
+            return self._excel_rows_to_field_labeled_documents(
+                workbook_name=workbook_name,
+                sheets=[(worksheet.title, worksheet.iter_rows(values_only=True)) for worksheet in workbook.worksheets],
+            )
+        finally:
+            workbook.close()
+
+    def _read_xls(self, file: Union[Path, IO[Any]], *, workbook_name: str) -> List[Document]:
+        """Read .xls file and convert rows to field-labeled documents."""
+        try:
+            import xlrd  # type: ignore
+        except ImportError as e:
+            raise ImportError(
+                "`xlrd` not installed. Please install it via `pip install agno[csv]` or `pip install xlrd`."
+            ) from e
+
+        if isinstance(file, Path):
+            workbook = xlrd.open_workbook(filename=str(file))
+        else:
+            file.seek(0)
+            raw = file.read()
+            if isinstance(raw, str):
+                raw = raw.encode("utf-8", errors="replace")
+            workbook = xlrd.open_workbook(file_contents=raw)
+
+        sheets: List[Tuple[str, Iterable[Sequence[Any]]]] = []
+        for sheet_index in range(workbook.nsheets):
+            sheet = workbook.sheet_by_index(sheet_index)
+
+            def _iter_sheet_rows(_sheet: Any = sheet, _datemode: int = workbook.datemode) -> Iterable[Sequence[Any]]:
+                for row_index in range(_sheet.nrows):
+                    yield [
+                        _convert_xls_cell_value(
+                            _sheet.cell_value(row_index, col_index),
+                            _sheet.cell_type(row_index, col_index),
+                            _datemode,
+                        )
+                        for col_index in range(_sheet.ncols)
+                    ]
+
+            sheets.append((sheet.name, _iter_sheet_rows()))
+
+        return self._excel_rows_to_field_labeled_documents(workbook_name=workbook_name, sheets=sheets)
+
     def read(
         self, file: Union[Path, IO[Any]], delimiter: str = ",", quotechar: str = '"', name: Optional[str] = None
     ) -> List[Document]:
         try:
+            file_extension = _infer_file_extension(file, name)
+
+            # Handle Excel files
+            if file_extension in {ContentType.XLSX, ContentType.XLS}:
+                workbook_name = _get_workbook_name(file, name)
+                log_debug(f"Reading Excel file: {workbook_name}{file_extension}")
+
+                if file_extension == ContentType.XLSX:
+                    return self._read_xlsx(file, workbook_name=workbook_name)
+                else:
+                    return self._read_xls(file, workbook_name=workbook_name)
+
+            # Handle CSV files
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
@@ -114,7 +266,7 @@ class FieldLabeledCSVReader(Reader):
                 log_debug(f"Reading retrieved file: {getattr(file, 'name', 'BytesIO')}")
                 csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content = io.StringIO(file.read().decode("utf-8"))
+                file_content = io.StringIO(file.read().decode(self.encoding or "utf-8"))
 
             documents = []
 
@@ -179,7 +331,19 @@ class FieldLabeledCSVReader(Reader):
         name: Optional[str] = None,
     ) -> List[Document]:
         try:
-            # Handle file input
+            file_extension = _infer_file_extension(file, name)
+
+            # Handle Excel files (use asyncio.to_thread for sync openpyxl/xlrd)
+            if file_extension in {ContentType.XLSX, ContentType.XLS}:
+                workbook_name = _get_workbook_name(file, name)
+                log_debug(f"Reading Excel file async: {workbook_name}{file_extension}")
+
+                if file_extension == ContentType.XLSX:
+                    return await asyncio.to_thread(self._read_xlsx, file, workbook_name=workbook_name)
+                else:
+                    return await asyncio.to_thread(self._read_xls, file, workbook_name=workbook_name)
+
+            # Handle CSV files
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
@@ -192,7 +356,7 @@ class FieldLabeledCSVReader(Reader):
                 log_debug(f"Reading retrieved file async: {getattr(file, 'name', 'BytesIO')}")
                 csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content_io = io.StringIO(file.read().decode("utf-8"))
+                file_content_io = io.StringIO(file.read().decode(self.encoding or "utf-8"))
 
             file_content_io.seek(0)
             csv_reader = csv.reader(file_content_io, delimiter=delimiter, quotechar=quotechar)

agno/knowledge/reader/firecrawl_reader.py

@@ -43,7 +43,7 @@ class FirecrawlReader(Reader):
         self.mode = mode
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Firecrawl readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -55,7 +55,7 @@ class FirecrawlReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.URL]
 
     def scrape(self, url: str, name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/json_reader.py

@@ -21,7 +21,7 @@ class JSONReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for JSON readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -33,7 +33,7 @@ class JSONReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.JSON]
 
     def read(self, path: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/markdown_reader.py

@@ -28,7 +28,7 @@ class MarkdownReader(Reader):
     """Reader for Markdown files"""
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Markdown readers."""
         strategies = [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -46,7 +46,7 @@ class MarkdownReader(Reader):
         return strategies
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.MARKDOWN]
 
     def __init__(

agno/knowledge/reader/pdf_reader.py

@@ -200,7 +200,7 @@ class BasePDFReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for PDF readers."""
         return [
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -232,8 +232,9 @@ class BasePDFReader(Reader):
             return True
 
         # Use provided password or fall back to instance password
-        pdf_password = password or self.password
-        if not pdf_password:
+        # Note: Empty string "" is a valid password for PDFs with blank user password
+        pdf_password = self.password if password is None else password
+        if pdf_password is None:
             log_error(f'PDF file "{doc_name}" is password protected but no password provided')
             return False
 
@@ -335,7 +336,7 @@ class PDFReader(BasePDFReader):
     """Reader for PDF files"""
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.PDF]
 
     def read(

agno/knowledge/reader/pptx_reader.py

@@ -23,7 +23,7 @@ class PPTXReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for PPTX readers."""
         return [
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -35,7 +35,7 @@ class PPTXReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.PPTX]
 
     def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/reader_factory.py

@@ -10,6 +10,70 @@ class ReaderFactory:
     # Cache for instantiated readers
     _reader_cache: Dict[str, Reader] = {}
 
+    # Static metadata for readers - avoids instantiation just to get metadata
+    READER_METADATA: Dict[str, Dict[str, str]] = {
+        "pdf": {
+            "name": "PdfReader",
+            "description": "Processes PDF documents with OCR support for images and text extraction",
+        },
+        "csv": {
+            "name": "CsvReader",
+            "description": "Parses CSV, XLSX, and XLS files with custom delimiter support",
+        },
+        "field_labeled_csv": {
+            "name": "FieldLabeledCsvReader",
+            "description": "Converts CSV rows to field-labeled text format for enhanced readability and context",
+        },
+        "docx": {
+            "name": "DocxReader",
+            "description": "Extracts text content from Microsoft Word documents (.docx and .doc formats)",
+        },
+        "pptx": {
+            "name": "PptxReader",
+            "description": "Extracts text content from Microsoft PowerPoint presentations (.pptx format)",
+        },
+        "json": {
+            "name": "JsonReader",
+            "description": "Processes JSON data structures and API responses with nested object handling",
+        },
+        "markdown": {
+            "name": "MarkdownReader",
+            "description": "Processes Markdown documentation with header-aware chunking and formatting preservation",
+        },
+        "text": {
+            "name": "TextReader",
+            "description": "Handles plain text files with customizable chunking strategies and encoding detection",
+        },
+        "website": {
+            "name": "WebsiteReader",
+            "description": "Scrapes and extracts content from web pages with HTML parsing and text cleaning",
+        },
+        "firecrawl": {
+            "name": "FirecrawlReader",
+            "description": "Advanced web scraping and crawling with JavaScript rendering and structured data extraction",
+        },
+        "tavily": {
+            "name": "TavilyReader",
+            "description": "Extracts content from URLs using Tavily's Extract API with markdown or text output",
+        },
+        "youtube": {
+            "name": "YouTubeReader",
+            "description": "Extracts transcripts and metadata from YouTube videos and playlists",
+        },
+        "arxiv": {
+            "name": "ArxivReader",
+            "description": "Downloads and processes academic papers from ArXiv with PDF parsing and metadata extraction",
+        },
+        "wikipedia": {
+            "name": "WikipediaReader",
+            "description": "Fetches and processes Wikipedia articles with section-aware chunking and link resolution",
+        },
+        "web_search": {
+            "name": "WebSearchReader",
+            "description": "Executes web searches and processes results with relevance ranking and content extraction",
+        },
+    }
+
     @classmethod
     def _get_pdf_reader(cls, **kwargs) -> Reader:
         """Get PDF reader instance."""
@@ -203,6 +267,52 @@ class ReaderFactory:
             raise ValueError(f"Unknown reader: {reader_key}")
         return getattr(cls, method_name)
 
+    @classmethod
+    def get_reader_class(cls, reader_key: str) -> type:
+        """Get the reader CLASS without instantiation.
+
+        This is useful for accessing class methods like get_supported_chunking_strategies()
+        without the overhead of creating an instance.
+
+        Args:
+            reader_key: The reader key (e.g., 'pdf', 'csv', 'markdown')
+
+        Returns:
+            The reader class (not an instance)
+
+        Raises:
+            ValueError: If the reader key is unknown
+            ImportError: If the reader's dependencies are not installed
+        """
+        # Map reader keys to their import paths
+        reader_class_map: Dict[str, tuple] = {
+            "pdf": ("agno.knowledge.reader.pdf_reader", "PDFReader"),
+            "csv": ("agno.knowledge.reader.csv_reader", "CSVReader"),
+            "field_labeled_csv": ("agno.knowledge.reader.field_labeled_csv_reader", "FieldLabeledCSVReader"),
+            "docx": ("agno.knowledge.reader.docx_reader", "DocxReader"),
+            "pptx": ("agno.knowledge.reader.pptx_reader", "PPTXReader"),
+            "json": ("agno.knowledge.reader.json_reader", "JSONReader"),
+            "markdown": ("agno.knowledge.reader.markdown_reader", "MarkdownReader"),
+            "text": ("agno.knowledge.reader.text_reader", "TextReader"),
+            "website": ("agno.knowledge.reader.website_reader", "WebsiteReader"),
+            "firecrawl": ("agno.knowledge.reader.firecrawl_reader", "FirecrawlReader"),
+            "tavily": ("agno.knowledge.reader.tavily_reader", "TavilyReader"),
+            "youtube": ("agno.knowledge.reader.youtube_reader", "YouTubeReader"),
+            "arxiv": ("agno.knowledge.reader.arxiv_reader", "ArxivReader"),
+            "wikipedia": ("agno.knowledge.reader.wikipedia_reader", "WikipediaReader"),
+            "web_search": ("agno.knowledge.reader.web_search_reader", "WebSearchReader"),
+        }
+
+        if reader_key not in reader_class_map:
+            raise ValueError(f"Unknown reader: {reader_key}")
+
+        module_path, class_name = reader_class_map[reader_key]
+
+        import importlib
+
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+
     @classmethod
     def create_reader(cls, reader_key: str, **kwargs) -> Reader:
         """Create a reader instance with the given key and optional overrides."""
@@ -225,7 +335,14 @@ class ReaderFactory:
 
         if extension in [".pdf", "application/pdf"]:
             return cls.create_reader("pdf")
-        elif extension in [".csv", "text/csv"]:
+        elif extension in [
+            ".csv",
+            ".xlsx",
+            ".xls",
+            "text/csv",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-excel",
+        ]:
             return cls.create_reader("csv")
         elif extension in [".docx", ".doc", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"]:
             return cls.create_reader("docx")

agno/knowledge/reader/s3_reader.py

@@ -35,7 +35,7 @@ class S3Reader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for S3 readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -47,7 +47,7 @@ class S3Reader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.FILE, ContentType.URL, ContentType.TEXT]
 
     def read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:

agno/knowledge/reader/tavily_reader.py

@@ -62,7 +62,7 @@ class TavilyReader(Reader):
         self.extract_depth = extract_depth
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Tavily readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -74,7 +74,7 @@ class TavilyReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.URL]
 
     def _extract(self, url: str, name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/text_reader.py

@@ -18,7 +18,7 @@ class TextReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Text readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -30,7 +30,7 @@ class TextReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TXT]
 
     def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/web_search_reader.py

@@ -53,7 +53,7 @@ class WebSearchReader(Reader):
     chunking_strategy: Optional[ChunkingStrategy] = SemanticChunking()
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Web Search readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -65,7 +65,7 @@ class WebSearchReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TOPIC]
 
     def _respect_rate_limits(self):

agno/knowledge/reader/website_reader.py

@@ -49,7 +49,7 @@ class WebsiteReader(Reader):
         self._urls_to_crawl = []
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Website readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -61,7 +61,7 @@ class WebsiteReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.URL]
 
     def delay(self, min_seconds=1, max_seconds=3):
@@ -428,7 +428,8 @@ class WebsiteReader(Reader):
                         meta_data={"url": str(crawled_url)},
                         content=crawled_content,
                     )
-                    return self.chunk_document(doc)
+                    chunks = self.chunk_document(doc)
+                    return chunks
                 else:
                     return [
                         Document(
@@ -444,6 +445,7 @@ class WebsiteReader(Reader):
                 process_document(crawled_url, crawled_content)
                 for crawled_url, crawled_content in crawler_result.items()
             ]
+
             results = await asyncio.gather(*tasks)
 
             # Flatten the results

agno/knowledge/reader/wikipedia_reader.py

@@ -24,7 +24,7 @@ class WikipediaReader(Reader):
         self.auto_suggest = auto_suggest
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Wikipedia readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -36,7 +36,7 @@ class WikipediaReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TOPIC]
 
     def read(self, topic: str) -> List[Document]:

agno/knowledge/reader/youtube_reader.py

@@ -23,7 +23,7 @@ class YouTubeReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for YouTube readers."""
         return [
             ChunkingStrategyType.RECURSIVE_CHUNKER,
@@ -35,7 +35,7 @@ class YouTubeReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.YOUTUBE]
 
     def read(self, url: str, name: Optional[str] = None) -> List[Document]:

agno/knowledge/remote_content/__init__.py

@@ -0,0 +1,29 @@
+from agno.knowledge.remote_content.config import (
+    GcsConfig,
+    GitHubConfig,
+    RemoteContentConfig,
+    S3Config,
+    SharePointConfig,
+)
+from agno.knowledge.remote_content.remote_content import (
+    GCSContent,
+    GitHubContent,
+    RemoteContent,
+    S3Content,
+    SharePointContent,
+)
+
+__all__ = [
+    # Config classes
+    "RemoteContentConfig",
+    "S3Config",
+    "GcsConfig",
+    "SharePointConfig",
+    "GitHubConfig",
+    # Content classes
+    "RemoteContent",
+    "S3Content",
+    "GCSContent",
+    "SharePointContent",
+    "GitHubContent",
+]