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

agno/knowledge/protocol.py

@@ -0,0 +1,134 @@
+"""
+Knowledge Protocol
+==================
+Defines the minimal interface that knowledge implementations must implement.
+
+This protocol enables:
+- Custom knowledge bases to be used with agents
+- Each implementation defines its own tools and context
+- Flexible tool naming (not forced to use 'search')
+- Type safety with Protocol typing
+"""
+
+from typing import Callable, List, Protocol, runtime_checkable
+
+from agno.knowledge.document import Document
+
+
+@runtime_checkable
+class KnowledgeProtocol(Protocol):
+    """Minimal protocol for knowledge implementations.
+
+    Enables custom knowledge bases to be used with agents.
+    Each implementation defines what tools it exposes and what
+    context/instructions it provides to the agent.
+
+    Required methods:
+    - build_context(): Return instructions for the agent's system prompt
+    - get_tools(): Return tools to expose to the agent
+    - aget_tools(): Async version of get_tools
+
+    Optional methods:
+    - retrieve(): Default retrieval for context injection (add_knowledge_to_context)
+    - aretrieve(): Async version of retrieve
+
+    Example:
+        ```python
+        from agno.knowledge.protocol import KnowledgeProtocol
+        from agno.knowledge.document import Document
+
+        class MyKnowledge:
+            def build_context(self, **kwargs) -> str:
+                return "Use search_docs to find information."
+
+            def get_tools(self, **kwargs) -> List[Callable]:
+                return [self.search_docs]
+
+            async def aget_tools(self, **kwargs) -> List[Callable]:
+                return [self.search_docs]
+
+            def search_docs(self, query: str) -> str:
+                # Your search implementation
+                return "Results for: " + query
+
+            # Optional: for add_knowledge_to_context feature
+            def retrieve(self, query: str, **kwargs) -> List[Document]:
+                results = self._internal_search(query)
+                return [Document(content=r) for r in results]
+
+        # MyKnowledge satisfies KnowledgeProtocol
+        agent = Agent(knowledge=MyKnowledge())
+        ```
+    """
+
+    def build_context(self, **kwargs) -> str:
+        """Build context string for the agent's system prompt.
+
+        Returns instructions about how to use this knowledge,
+        what tools are available, and any usage guidelines.
+
+        Args:
+            **kwargs: Context including enable_agentic_filters, etc.
+
+        Returns:
+            Formatted context string to inject into system prompt.
+        """
+        ...
+
+    def get_tools(self, **kwargs) -> List[Callable]:
+        """Get tools to expose to the agent.
+
+        Returns callable tools that the agent can use to interact
+        with this knowledge. Each implementation decides what
+        tools make sense (e.g., search, grep, list_files, query_db).
+
+        Args:
+            **kwargs: Context including run_response, run_context,
+                     async_mode, enable_agentic_filters, agent, etc.
+
+        Returns:
+            List of callable tools.
+        """
+        ...
+
+    async def aget_tools(self, **kwargs) -> List[Callable]:
+        """Async version of get_tools.
+
+        Args:
+            **kwargs: Same as get_tools.
+
+        Returns:
+            List of callable tools.
+        """
+        ...
+
+    # Optional methods - used by add_knowledge_to_context feature
+    # Implementations that don't support context injection can omit these
+
+    def retrieve(self, query: str, **kwargs) -> List[Document]:
+        """Retrieve documents for context injection.
+
+        Used by the add_knowledge_to_context feature to pre-fetch
+        relevant documents into the user message. This is optional;
+        if not implemented, add_knowledge_to_context will be skipped.
+
+        Args:
+            query: The query string.
+            **kwargs: Additional parameters (max_results, filters, etc.)
+
+        Returns:
+            List of Document objects.
+        """
+        ...
+
+    async def aretrieve(self, query: str, **kwargs) -> List[Document]:
+        """Async version of retrieve.
+
+        Args:
+            query: The query string.
+            **kwargs: Additional parameters.
+
+        Returns:
+            List of Document objects.
+        """
+        ...

agno/knowledge/reader/arxiv_reader.py

@@ -17,7 +17,7 @@ class ArxivReader(Reader):
     sort_by: arxiv.SortCriterion = arxiv.SortCriterion.Relevance
 
     @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 Arxiv readers."""
         return [
             ChunkingStrategyType.CODE_CHUNKER,
@@ -29,7 +29,7 @@ class ArxivReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TOPIC]
 
     def __init__(

agno/knowledge/reader/base.py

@@ -73,11 +73,17 @@ class Reader:
     def chunk_document(self, document: Document) -> List[Document]:
         if self.chunking_strategy is None:
             self.chunking_strategy = FixedSizeChunking(chunk_size=self.chunk_size)
-        return self.chunking_strategy.chunk(document)  # type: ignore
+        return self.chunking_strategy.chunk(document)
+
+    async def achunk_document(self, document: Document) -> List[Document]:
+        """Async version of chunk_document."""
+        if self.chunking_strategy is None:
+            self.chunking_strategy = FixedSizeChunking(chunk_size=self.chunk_size)
+        return await self.chunking_strategy.achunk(document)
 
     async def chunk_documents_async(self, documents: List[Document]) -> List[Document]:
         """
-        Asynchronously chunk a list of documents using the instance's chunk_document method.
+        Asynchronously chunk a list of documents.
 
         Args:
             documents: List of documents to be chunked.
@@ -85,11 +91,7 @@ class Reader:
         Returns:
             A flattened list of chunked documents.
         """
-
-        async def _chunk_document_async(doc: Document) -> List[Document]:
-            return await asyncio.to_thread(self.chunk_document, doc)
-
         # Process chunking in parallel for all documents
-        chunked_lists = await asyncio.gather(*[_chunk_document_async(doc) for doc in documents])
+        chunked_lists = await asyncio.gather(*[self.achunk_document(doc) for doc in documents])
         # Flatten the result
         return [chunk for sublist in chunked_lists for chunk in sublist]

agno/knowledge/reader/csv_reader.py

@@ -25,7 +25,7 @@ class CSVReader(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 CSV readers."""
         return [
             ChunkingStrategyType.ROW_CHUNKER,
@@ -37,7 +37,7 @@ class CSVReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.CSV, ContentType.XLSX, ContentType.XLS]
 
     def read(
@@ -56,7 +56,7 @@ class CSVReader(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"))
 
             csv_content = ""
             with file_content as csvfile:
@@ -106,14 +106,14 @@ class CSVReader(Reader):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
                 log_debug(f"Reading async: {file}")
-                async with aiofiles.open(file, mode="r", encoding="utf-8", newline="") as file_content:
+                async with aiofiles.open(file, mode="r", encoding=self.encoding or "utf-8", newline="") as file_content:
                     content = await file_content.read()
                     file_content_io = io.StringIO(content)
                 csv_name = name or file.stem
             else:
                 log_debug(f"Reading retrieved file async: {getattr(file, 'name', 'BytesIO')}")
                 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"))
                 csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
 
             file_content_io.seek(0)

agno/knowledge/reader/docx_reader.py

@@ -23,7 +23,7 @@ class DocxReader(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 DOCX readers."""
         return [
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -35,7 +35,7 @@ class DocxReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.DOCX, ContentType.DOC]
 
     def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -114,7 +114,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 = []
 
@@ -192,7 +192,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."""

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]: