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

agno/knowledge/knowledge.py

@@ -51,9 +51,6 @@ class Knowledge:
             self.vector_db.create()
 
         self.construct_readers()
-        self.valid_metadata_filters = set()
-
-    # --- SDK Specific Methods ---
 
     # --- Add Contents ---
     @overload
@@ -269,7 +266,7 @@ class Knowledge:
             return
 
         if not skip_if_exists:
-            log_info("skip_if_exists is disabled, disabling upsert")
+            log_debug("skip_if_exists is disabled, disabling upsert")
             upsert = False
 
         content = None
@@ -431,7 +428,7 @@ class Knowledge:
 
                 else:
                     reader = ReaderFactory.get_reader_for_extension(path.suffix)
-                    log_info(f"Using Reader: {reader.__class__.__name__}")
+                    log_debug(f"Using Reader: {reader.__class__.__name__}")
                     if reader:
                         # TODO: We will refactor this to eventually pass authorization to all readers
                         import inspect
@@ -652,7 +649,7 @@ class Knowledge:
             content_io = io.BytesIO(content_bytes)
 
             if content.reader:
-                log_info(f"Using reader: {content.reader.__class__.__name__} to read content")
+                log_debug(f"Using reader: {content.reader.__class__.__name__} to read content")
                 read_documents = content.reader.read(content_io, name=name)
             else:
                 text_reader = self.text_reader
@@ -676,7 +673,7 @@ class Knowledge:
 
                 # Respect an explicitly provided reader; otherwise select based on file type
                 if content.reader:
-                    log_info(f"Using reader: {content.reader.__class__.__name__} to read content")
+                    log_debug(f"Using reader: {content.reader.__class__.__name__} to read content")
                     reader = content.reader
                 else:
                     reader = self._select_reader(content.file_data.type)
@@ -996,11 +993,6 @@ class Knowledge:
         include: Optional[List[str]] = None,
         exclude: Optional[List[str]] = None,
     ) -> None:
-        log_info(f"Loading content: {content.id}")
-
-        if content.metadata:
-            self.add_filters(content.metadata)
-
         if content.path:
             await self._load_from_path(content, upsert, skip_if_exists, include, exclude)
 
@@ -1174,9 +1166,6 @@ class Knowledge:
             if self.vector_db and content.metadata:
                 self.vector_db.update_metadata(content_id=content.id, metadata=content.metadata)
 
-            if content.metadata:
-                self.add_filters(content.metadata)
-
             return content_row.to_dict()
 
         else:
@@ -1223,13 +1212,13 @@ class Knowledge:
             if self.vector_db and content.metadata:
                 self.vector_db.update_metadata(content_id=content.id, metadata=content.metadata)
 
-            if content.metadata:
-                self.add_filters(content.metadata)
-
             return content_row.to_dict()
 
         else:
-            log_warning(f"Contents DB not found for knowledge base: {self.name}")
+            if self.name:
+                log_warning(f"Contents DB not found for knowledge base: {self.name}")
+            else:
+                log_warning("Contents DB not found for knowledge base")
             return None
 
     async def _process_lightrag_content(self, content: Content, content_type: KnowledgeContentOrigin) -> None:
@@ -1455,41 +1444,55 @@ class Knowledge:
             return []
 
     def get_valid_filters(self) -> Set[str]:
-        if self.valid_metadata_filters is None:
-            self.valid_metadata_filters = set()
-        self.valid_metadata_filters.update(self._get_filters_from_db())
-        return self.valid_metadata_filters
-
-    async def aget_valid_filters(self) -> Set[str]:
-        if self.valid_metadata_filters is None:
-            self.valid_metadata_filters = set()
-        self.valid_metadata_filters.update(await self._aget_filters_from_db())
-        return self.valid_metadata_filters
-
-    def _validate_filters(self, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]]) -> Tuple[Any, List[str]]:
-        """Internal method to validate filters against known metadata keys."""
+        if self.contents_db is None:
+            log_warning("No contents db provided. This is required for filtering.")
+            return set()
+        contents, _ = self.get_content()
+        valid_filters: Set[str] = set()
+        for content in contents:
+            if content.metadata:
+                valid_filters.update(content.metadata.keys())
+
+        return valid_filters
+
+    async def async_get_valid_filters(self) -> Set[str]:
+        if self.contents_db is None:
+            log_warning("No contents db provided. This is required for filtering.")
+            return set()
+        contents, _ = await self.aget_content()
+        valid_filters: Set[str] = set()
+        for content in contents:
+            if content.metadata:
+                valid_filters.update(content.metadata.keys())
+
+        return valid_filters
+
+    def _validate_filters(
+        self, filters: Union[Dict[str, Any], List[FilterExpr]], valid_metadata_filters: Set[str]
+    ) -> Tuple[Union[Dict[str, Any], List[FilterExpr]], List[str]]:
         if not filters:
-            return None, []
+            return {}, []
 
-        valid_filters: Optional[Dict[str, Any]] = None
+        valid_filters: Union[Dict[str, Any], List[FilterExpr]] = {}
         invalid_keys = []
 
         if isinstance(filters, dict):
             # If no metadata filters tracked yet, all keys are considered invalid
-            if self.valid_metadata_filters is None:
+            if valid_metadata_filters is None or not valid_metadata_filters:
                 invalid_keys = list(filters.keys())
-                log_debug(f"No valid metadata filters tracked yet. All filter keys considered invalid: {invalid_keys}")
-                return None, invalid_keys
+                log_warning(
+                    f"No valid metadata filters tracked yet. All filter keys considered invalid: {invalid_keys}"
+                )
+                return {}, invalid_keys
 
-            valid_filters = {}
             for key, value in filters.items():
                 # Handle both normal keys and prefixed keys like meta_data.key
                 base_key = key.split(".")[-1] if "." in key else key
-                if base_key in self.valid_metadata_filters or key in self.valid_metadata_filters:
-                    valid_filters[key] = value
+                if base_key in valid_metadata_filters or key in valid_metadata_filters:
+                    valid_filters[key] = value  # type: ignore
                 else:
                     invalid_keys.append(key)
-                    log_debug(f"Invalid filter key: {key} - not present in knowledge base")
+                    log_warning(f"Invalid filter key: {key} - not present in knowledge base")
 
         elif isinstance(filters, List):
             # Validate that list contains FilterExpr instances
@@ -1501,56 +1504,30 @@ class Knowledge:
                         f"Use filter expressions like EQ('key', 'value'), IN('key', [values]), "
                         f"AND(...), OR(...), NOT(...) from agno.filters"
                     )
-
             # Filter expressions are already validated, return empty dict/list
             # The actual filtering happens in the vector_db layer
             return filters, []
 
         return valid_filters, invalid_keys
 
-    def validate_filters(self, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]]) -> Tuple[Any, List[str]]:
-        if self.valid_metadata_filters is None:
-            self.valid_metadata_filters = set()
-        self.valid_metadata_filters.update(self._get_filters_from_db())
-
-        return self._validate_filters(filters)
-
-    async def async_validate_filters(
-        self, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]]
-    ) -> Tuple[Any, List[str]]:
-        if self.valid_metadata_filters is None:
-            self.valid_metadata_filters = set()
-        self.valid_metadata_filters.update(await self._aget_filters_from_db())
+    def validate_filters(
+        self, filters: Union[Dict[str, Any], List[FilterExpr]]
+    ) -> Tuple[Union[Dict[str, Any], List[FilterExpr]], List[str]]:
+        valid_filters_from_db = self.get_valid_filters()
 
-        return self._validate_filters(filters)
+        valid_filters, invalid_keys = self._validate_filters(filters, valid_filters_from_db)
 
-    def add_filters(self, metadata: Dict[str, Any]) -> None:
-        if self.valid_metadata_filters is None:
-            self.valid_metadata_filters = set()
+        return valid_filters, invalid_keys
 
-        if metadata is not None:
-            for key in metadata.keys():
-                self.valid_metadata_filters.add(key)
+    async def async_validate_filters(
+        self, filters: Union[Dict[str, Any], List[FilterExpr]]
+    ) -> Tuple[Union[Dict[str, Any], List[FilterExpr]], List[str]]:
+        """Return a tuple containing a dict with all valid filters and a list of invalid filter keys"""
+        valid_filters_from_db = await self.async_get_valid_filters()
 
-    def _get_filters_from_db(self) -> Set[str]:
-        if self.contents_db is None:
-            return set()
-        contents, _ = self.get_content()
-        valid_filters: Set[str] = set()
-        for content in contents:
-            if content.metadata:
-                valid_filters.update(content.metadata.keys())
-        return valid_filters
+        valid_filters, invalid_keys = self._validate_filters(filters, valid_filters_from_db)
 
-    async def _aget_filters_from_db(self) -> Set[str]:
-        if self.contents_db is None:
-            return set()
-        contents, _ = await self.aget_content()
-        valid_filters: Set[str] = set()
-        for content in contents:
-            if content.metadata:
-                valid_filters.update(content.metadata.keys())
-        return valid_filters
+        return valid_filters, invalid_keys
 
     def remove_vector_by_id(self, id: str) -> bool:
         from agno.vectordb import VectorDb
@@ -1855,12 +1832,6 @@ class Knowledge:
         log_info(f"Selecting reader for extension: {extension}")
         return ReaderFactory.get_reader_for_extension(extension)
 
-    def get_filters(self) -> List[str]:
-        return [
-            "filter_tag_1",
-            "filter_tag2",
-        ]
-
     # --- Convenience Properties for Backward Compatibility ---
 
     def _is_text_mime_type(self, mime_type: str) -> bool:

agno/knowledge/reader/csv_reader.py

@@ -15,7 +15,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 logger
+from agno.utils.log import log_debug, log_error
 
 
 class CSVReader(Reader):
@@ -46,10 +46,10 @@ class CSVReader(Reader):
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                logger.info(f"Reading: {file}")
+                log_debug(f"Reading: {file}")
                 file_content = file.open(newline="", mode="r", encoding=self.encoding or "utf-8")
             else:
-                logger.info(f"Reading retrieved file: {name or file.name}")
+                log_debug(f"Reading retrieved file: {name or file.name}")
                 file.seek(0)
                 file_content = io.StringIO(file.read().decode("utf-8"))  # type: ignore
 
@@ -78,7 +78,7 @@ class CSVReader(Reader):
                 return chunked_documents
             return documents
         except Exception as e:
-            logger.error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
+            log_error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
             return []
 
     async def async_read(
@@ -105,12 +105,12 @@ class CSVReader(Reader):
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                logger.info(f"Reading async: {file}")
+                log_debug(f"Reading async: {file}")
                 async with aiofiles.open(file, mode="r", encoding="utf-8", newline="") as file_content:
                     content = await file_content.read()
                     file_content_io = io.StringIO(content)
             else:
-                logger.info(f"Reading retrieved file async: {file.name}")
+                log_debug(f"Reading retrieved file async: {file.name}")
                 file.seek(0)
                 file_content_io = io.StringIO(file.read().decode("utf-8"))  # type: ignore
 
@@ -160,7 +160,5 @@ class CSVReader(Reader):
 
             return documents
         except Exception as e:
-            logger.error(
-                f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}"
-            )
+            log_error(f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
             return []

agno/knowledge/reader/docx_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
 
 try:
     from docx import Document as DocxDocument  # type: ignore
@@ -43,11 +43,11 @@ class DocxReader(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}")
                 docx_document = DocxDocument(str(file))
                 doc_name = name or file.stem
             else:
-                log_info(f"Reading uploaded file: {getattr(file, 'name', 'docx_file')}")
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'docx_file')}")
                 docx_document = DocxDocument(file)
                 doc_name = name or (
                     getattr(file, "name", "docx_file").split(".")[0] if hasattr(file, "name") else "docx_file"
@@ -70,7 +70,7 @@ class DocxReader(Reader):
             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]:
@@ -78,5 +78,5 @@ class DocxReader(Reader):
         try:
             return await asyncio.to_thread(self.read, file, name)
         except Exception as e:
-            logger.error(f"Error reading file asynchronously: {e}")
+            log_error(f"Error reading file asynchronously: {e}")
             return []

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -13,7 +13,7 @@ from agno.knowledge.chunking.strategy import 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 logger
+from agno.utils.log import log_debug, log_error, log_warning
 
 
 class FieldLabeledCSVReader(Reader):
@@ -105,10 +105,10 @@ class FieldLabeledCSVReader(Reader):
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                logger.info(f"Reading: {file}")
+                log_debug(f"Reading: {file}")
                 file_content = file.open(newline="", mode="r", encoding=self.encoding or "utf-8")
             else:
-                logger.info(f"Reading retrieved file: {name or file.name}")
+                log_debug(f"Reading retrieved file: {name or file.name}")
                 file.seek(0)
                 file_content = io.StringIO(file.read().decode("utf-8"))  # type: ignore
 
@@ -127,15 +127,15 @@ class FieldLabeledCSVReader(Reader):
                 rows = list(csv_reader)
 
                 if not rows:
-                    logger.warning("CSV file is empty")
+                    log_warning("CSV file is empty")
                     return []
 
                 # First row is headers
                 headers = [header.strip() for header in rows[0]]
-                logger.info(f"Found {len(headers)} headers: {headers}")
+                log_debug(f"Found {len(headers)} headers: {headers}")
 
                 data_rows = rows[1:] if len(rows) > 1 else []
-                logger.info(f"Processing {len(data_rows)} data rows")
+                log_debug(f"Processing {len(data_rows)} data rows")
 
                 for row_index, row in enumerate(data_rows):
                     # Ensure row has same length as headers (pad or truncate)
@@ -163,13 +163,13 @@ class FieldLabeledCSVReader(Reader):
                         )
 
                         documents.append(document)
-                        logger.debug(f"Created document for row {row_index + 1}: {len(labeled_text)} chars")
+                        log_debug(f"Created document for row {row_index + 1}: {len(labeled_text)} chars")
 
-            logger.info(f"Successfully created {len(documents)} labeled documents from CSV")
+            log_debug(f"Successfully created {len(documents)} labeled documents from CSV")
             return documents
 
         except Exception as e:
-            logger.error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
+            log_error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
             return []
 
     async def async_read(
@@ -185,12 +185,12 @@ class FieldLabeledCSVReader(Reader):
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                logger.info(f"Reading async: {file}")
+                log_debug(f"Reading async: {file}")
                 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)
             else:
-                logger.info(f"Reading retrieved file async: {name or file.name}")
+                log_debug(f"Reading retrieved file async: {name or file.name}")
                 file.seek(0)
                 file_content_io = io.StringIO(file.read().decode("utf-8"))  # type: ignore
 
@@ -205,17 +205,17 @@ class FieldLabeledCSVReader(Reader):
             rows = list(csv_reader)
 
             if not rows:
-                logger.warning("CSV file is empty")
+                log_warning("CSV file is empty")
                 return []
 
             # First row is headers
             headers = [header.strip() for header in rows[0]]
-            logger.info(f"Found {len(headers)} headers: {headers}")
+            log_debug(f"Found {len(headers)} headers: {headers}")
 
             # Process data rows
             data_rows = rows[1:] if len(rows) > 1 else []
             total_rows = len(data_rows)
-            logger.info(f"Processing {total_rows} data rows")
+            log_debug(f"Processing {total_rows} data rows")
 
             # For small files, process all at once
             if total_rows <= 10:
@@ -282,11 +282,9 @@ class FieldLabeledCSVReader(Reader):
 
                 documents = [doc for page_docs in page_results for doc in page_docs]
 
-            logger.info(f"Successfully created {len(documents)} labeled documents from CSV")
+            log_debug(f"Successfully created {len(documents)} labeled documents from CSV")
             return documents
 
         except Exception as e:
-            logger.error(
-                f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}"
-            )
+            log_error(f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
             return []

agno/knowledge/reader/json_reader.py

@@ -10,7 +10,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
+from agno.utils.log import log_debug, log_error
 
 
 class JSONReader(Reader):
@@ -41,13 +41,13 @@ class JSONReader(Reader):
             if isinstance(path, Path):
                 if not path.exists():
                     raise FileNotFoundError(f"Could not find file: {path}")
-                log_info(f"Reading: {path}")
+                log_debug(f"Reading: {path}")
                 json_name = name or path.name.split(".")[0]
                 json_contents = json.loads(path.read_text(self.encoding or "utf-8"))
 
             elif isinstance(path, BytesIO):
                 json_name = name or path.name.split(".")[0]
-                log_info(f"Reading uploaded file: {json_name}")
+                log_debug(f"Reading uploaded file: {json_name}")
                 path.seek(0)
                 json_contents = json.load(path)
 
@@ -72,7 +72,8 @@ class JSONReader(Reader):
                     chunked_documents.extend(self.chunk_document(document))
                 return chunked_documents
             return documents
-        except Exception:
+        except Exception as e:
+            log_error(f"Error reading: {path}: {e}")
             raise
 
     async def async_read(self, path: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/markdown_reader.py

@@ -7,7 +7,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
 
 DEFAULT_CHUNKER_STRATEGY: ChunkingStrategy
 
@@ -65,11 +65,11 @@ class MarkdownReader(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(encoding=self.encoding or "utf-8")
             else:
-                log_info(f"Reading uploaded file: {file.name}")
+                log_debug(f"Reading uploaded file: {file.name}")
                 file_name = name or file.name.split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
@@ -82,7 +82,7 @@ class MarkdownReader(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]:
@@ -91,7 +91,7 @@ class MarkdownReader(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:
@@ -100,10 +100,10 @@ class MarkdownReader(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}")
+                log_debug(f"Reading uploaded file asynchronously: {file.name}")
                 file_name = name or file.name.split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
@@ -118,7 +118,7 @@ class MarkdownReader(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/pdf_reader.py

@@ -9,7 +9,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_error, log_info, logger
+from agno.utils.log import log_debug, log_error
 
 try:
     from pypdf import PdfReader as DocumentReader  # noqa: F401
@@ -236,13 +236,13 @@ class BasePDFReader(Reader):
         # Use provided password or fall back to instance password
         pdf_password = password or self.password
         if not pdf_password:
-            logger.error(f'PDF file "{doc_name}" is password protected but no password provided')
+            log_error(f'PDF file "{doc_name}" is password protected but no password provided')
             return False
 
         try:
             decrypted_pdf = doc_reader.decrypt(pdf_password)
             if decrypted_pdf:
-                log_info(f'Successfully decrypted PDF file "{doc_name}" with user password')
+                log_debug(f'Successfully decrypted PDF file "{doc_name}" with user password')
                 return True
             else:
                 log_error(f'Failed to decrypt PDF file "{doc_name}": incorrect password')
@@ -344,12 +344,12 @@ class PDFReader(BasePDFReader):
         self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
     ) -> List[Document]:
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
 
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):
@@ -368,12 +368,12 @@ class PDFReader(BasePDFReader):
             log_error("No pdf provided")
             return []
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
 
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
 
         # Handle PDF decryption
@@ -394,11 +394,11 @@ class PDFImageReader(BasePDFReader):
             raise ValueError("No pdf provided")
 
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
 
         # Handle PDF decryption
@@ -415,12 +415,12 @@ class PDFImageReader(BasePDFReader):
             raise ValueError("No pdf provided")
 
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
 
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
 
         # Handle PDF decryption

agno/knowledge/reader/pptx_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
 
 try:
     from pptx import Presentation  # type: ignore
@@ -43,11 +43,11 @@ class PPTXReader(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}")
                 presentation = Presentation(str(file))
                 doc_name = name or file.stem
             else:
-                log_info(f"Reading uploaded file: {getattr(file, 'name', 'pptx_file')}")
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'pptx_file')}")
                 presentation = Presentation(file)
                 doc_name = name or (
                     getattr(file, "name", "pptx_file").split(".")[0] if hasattr(file, "name") else "pptx_file"
@@ -89,7 +89,7 @@ class PPTXReader(Reader):
             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]:
@@ -97,5 +97,5 @@ class PPTXReader(Reader):
         try:
             return await asyncio.to_thread(self.read, file, name)
         except Exception as e:
-            logger.error(f"Error reading file asynchronously: {e}")
+            log_error(f"Error reading file asynchronously: {e}")
             return []