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

agno/db/singlestore/singlestore.py

@@ -990,11 +990,12 @@ class SingleStoreDb(BaseDb):
             return []
 
     # -- Memory methods --
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Returns:
             bool: True if deletion was successful, False otherwise.
@@ -1009,6 +1010,8 @@ class SingleStoreDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
 
                 success = result.rowcount > 0
@@ -1021,11 +1024,12 @@ class SingleStoreDb(BaseDb):
             log_error(f"Error deleting memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Raises:
             Exception: If an error occurs during deletion.
@@ -1037,6 +1041,8 @@ class SingleStoreDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id.in_(memory_ids))
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
                 if result.rowcount == 0:
                     log_debug(f"No memories found with ids: {memory_ids}")
@@ -1073,12 +1079,15 @@ class SingleStoreDb(BaseDb):
             log_error(f"Exception reading from memory table: {e}")
             raise e
 
-    def get_user_memory(self, memory_id: str, deserialize: Optional[bool] = True) -> Optional[UserMemory]:
+    def get_user_memory(
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
+    ) -> Optional[UserMemory]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Returns:
             Union[UserMemory, Dict[str, Any], None]:
@@ -1095,6 +1104,8 @@ class SingleStoreDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 stmt = select(table).where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
 
                 result = sess.execute(stmt).fetchone()
                 if not result:

agno/db/sqlite/sqlite.py

@@ -1,7 +1,7 @@
 import time
 from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union, cast
 from uuid import uuid4
 
 from agno.db.base import BaseDb, SessionType
@@ -24,7 +24,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Column, MetaData, Table, and_, func, select, text, update
+    from sqlalchemy import Column, MetaData, Table, and_, func, select, text
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
@@ -442,11 +442,7 @@ class SqliteDb(BaseDb):
                 if end_timestamp is not None:
                     stmt = stmt.where(table.c.created_at <= end_timestamp)
                 if session_name is not None:
-                    stmt = stmt.where(
-                        func.coalesce(func.json_extract(table.c.session_data, "$.session_name"), "").like(
-                            f"%{session_name}%"
-                        )
-                    )
+                    stmt = stmt.where(table.c.session_data.like(f"%{session_name}%"))
                 if session_type is not None:
                     stmt = stmt.where(table.c.session_type == session_type.value)
 
@@ -468,8 +464,10 @@ class SqliteDb(BaseDb):
                     return [] if deserialize else ([], 0)
 
                 sessions_raw = [deserialize_session_json_fields(dict(record._mapping)) for record in records]
-                if not sessions_raw or not deserialize:
+                if not deserialize:
                     return sessions_raw, total_count
+                if not sessions_raw:
+                    return []
 
             if session_type == SessionType.AGENT:
                 return [AgentSession.from_dict(record) for record in sessions_raw]  # type: ignore
@@ -505,43 +503,20 @@ class SqliteDb(BaseDb):
             Exception: If an error occurs during renaming.
         """
         try:
-            table = self._get_table(table_type="sessions")
-            if table is None:
+            # Get the current session as a deserialized object
+            # Get the session record
+            session = self.get_session(session_id, session_type, deserialize=True)
+            if session is None:
                 return None
 
-            with self.Session() as sess, sess.begin():
-                # Update session_name inside the session_data JSON field
-                stmt = (
-                    update(table)
-                    .where(table.c.session_id == session_id)
-                    .values(session_data=func.json_set(table.c.session_data, "$.session_name", session_name))
-                )
-                result = sess.execute(stmt)
-
-                # Check if any rows were affected
-                if result.rowcount == 0:
-                    return None
-
-                # Fetch the updated row
-                select_stmt = select(table).where(table.c.session_id == session_id)
-                row = sess.execute(select_stmt).fetchone()
-
-                if not row:
-                    return None
-
-            session_raw = deserialize_session_json_fields(dict(row._mapping))
-            if not session_raw or not deserialize:
-                return session_raw
+            session = cast(Session, session)
+            # Update the session name
+            if session.session_data is None:
+                session.session_data = {}
+            session.session_data["session_name"] = session_name
 
-            # Return the appropriate session type
-            if session_type == SessionType.AGENT:
-                return AgentSession.from_dict(session_raw)
-            elif session_type == SessionType.TEAM:
-                return TeamSession.from_dict(session_raw)
-            elif session_type == SessionType.WORKFLOW:
-                return WorkflowSession.from_dict(session_raw)
-            else:
-                raise ValueError(f"Invalid session type: {session_type}")
+            # Upsert the updated session back to the database
+            return self.upsert_session(session, deserialize=deserialize)
 
         except Exception as e:
             log_error(f"Exception renaming session: {e}")
@@ -909,9 +884,13 @@ class SqliteDb(BaseDb):
 
     # -- Memory methods --
 
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
+        Args:
+            memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
+
         Returns:
             bool: True if deletion was successful, False otherwise.
 
@@ -925,6 +904,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
 
                 success = result.rowcount > 0
@@ -937,11 +918,12 @@ class SqliteDb(BaseDb):
             log_error(f"Error deleting user memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
 
         Raises:
             Exception: If an error occurs during deletion.
@@ -953,6 +935,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id.in_(memory_ids))
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
                 if result.rowcount == 0:
                     log_debug(f"No user memories found with ids: {memory_ids}")
@@ -973,7 +957,8 @@ class SqliteDb(BaseDb):
                 return []
 
             with self.Session() as sess, sess.begin():
-                stmt = select(func.json_array_elements_text(table.c.topics))
+                # Select topics from all results
+                stmt = select(func.json_array_elements_text(table.c.topics)).select_from(table)
                 result = sess.execute(stmt).fetchall()
 
                 return list(set([record[0] for record in result]))
@@ -983,13 +968,14 @@ class SqliteDb(BaseDb):
             raise e
 
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
 
         Returns:
             Optional[Union[UserMemory, Dict[str, Any]]]:
@@ -1006,6 +992,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 stmt = select(table).where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
                 result = sess.execute(stmt).fetchone()
                 if result is None:
                     return None

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -0,0 +1,294 @@
+import asyncio
+import csv
+import io
+from pathlib import Path
+from typing import IO, Any, List, Optional, Union
+
+try:
+    import aiofiles
+except ImportError:
+    raise ImportError("`aiofiles` not installed. Please install it with `pip install aiofiles`")
+
+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
+
+
+class FieldLabeledCSVReader(Reader):
+    """Reader for CSV files that converts each row to a field-labeled document."""
+
+    def __init__(
+        self,
+        chunk_title: Optional[Union[str, List[str]]] = None,
+        field_names: Optional[List[str]] = None,
+        format_headers: bool = True,
+        skip_empty_fields: bool = True,
+        **kwargs,
+    ):
+        super().__init__(chunk=False, chunking_strategy=None, **kwargs)
+        self.chunk_title = chunk_title
+        self.field_names = field_names or []
+        self.format_headers = format_headers
+        self.skip_empty_fields = skip_empty_fields
+
+        logger.info(f"FieldLabeledCSVReader initialized - chunk_title: {chunk_title}, field_names: {self.field_names}")
+
+    @classmethod
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
+        """Chunking is not supported - each row is already a logical document unit."""
+        return []
+
+    @classmethod
+    def get_supported_content_types(cls) -> List[ContentType]:
+        """Get the list of supported content types."""
+        return [ContentType.CSV, ContentType.XLSX, ContentType.XLS]
+
+    def _format_field_name(self, field_name: str) -> str:
+        """Format field name to be more readable."""
+        if not self.format_headers:
+            return field_name.strip()
+
+        # Replace underscores with spaces and title case
+        formatted = field_name.replace("_", " ").strip().title()
+        return formatted
+
+    def _get_title_for_entry(self, entry_index: int) -> Optional[str]:
+        """Get title for a specific entry."""
+        if self.chunk_title is None:
+            return None
+
+        if isinstance(self.chunk_title, str):
+            return self.chunk_title
+
+        if isinstance(self.chunk_title, list) and self.chunk_title:
+            return self.chunk_title[entry_index % len(self.chunk_title)]
+
+        return None
+
+    def _convert_row_to_labeled_text(self, headers: List[str], row: List[str], entry_index: int) -> str:
+        """
+        Convert a CSV row to field-labeled text format.
+
+        Args:
+            headers: Column headers
+            row: Data row values
+            entry_index: Index of this entry (for title rotation)
+
+        Returns:
+            Formatted text with field labels
+        """
+        lines = []
+
+        title = self._get_title_for_entry(entry_index)
+        if title:
+            lines.append(title)
+
+        for i, (header, value) in enumerate(zip(headers, row)):
+            clean_value = value.strip() if value else ""
+
+            if self.skip_empty_fields and not clean_value:
+                continue
+
+            if self.field_names and i < len(self.field_names):
+                field_name = self.field_names[i]
+            else:
+                field_name = self._format_field_name(header)
+
+            lines.append(f"{field_name}: {clean_value}")
+
+        return "\n".join(lines)
+
+    def read(
+        self, file: Union[Path, IO[Any]], delimiter: str = ",", quotechar: str = '"', name: Optional[str] = None
+    ) -> List[Document]:
+        try:
+            if isinstance(file, Path):
+                if not file.exists():
+                    raise FileNotFoundError(f"Could not find file: {file}")
+                logger.info(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}")
+                file.seek(0)
+                file_content = io.StringIO(file.read().decode("utf-8"))  # type: ignore
+
+            csv_name = name or (
+                Path(file.name).stem
+                if isinstance(file, Path)
+                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
+            )
+
+            documents = []
+
+            with file_content as csvfile:
+                csv_reader = csv.reader(csvfile, delimiter=delimiter, quotechar=quotechar)
+
+                # Read all rows
+                rows = list(csv_reader)
+
+                if not rows:
+                    logger.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}")
+
+                data_rows = rows[1:] if len(rows) > 1 else []
+                logger.info(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)
+                    normalized_row = row[: len(headers)]  # Truncate if too long
+                    while len(normalized_row) < len(headers):  # Pad if too short
+                        normalized_row.append("")
+
+                    # Convert row to labeled text
+                    labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, row_index)
+
+                    if labeled_text.strip():
+                        # Create document for this row
+                        doc_id = f"{csv_name}_row_{row_index + 1}"
+
+                        document = Document(
+                            id=doc_id,
+                            name=csv_name,
+                            meta_data={
+                                "row_index": row_index,
+                                "headers": headers,
+                                "total_rows": len(data_rows),
+                                "source": "field_labeled_csv_reader",
+                            },
+                            content=labeled_text,
+                        )
+
+                        documents.append(document)
+                        logger.debug(f"Created document for row {row_index + 1}: {len(labeled_text)} chars")
+
+            logger.info(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}")
+            return []
+
+    async def async_read(
+        self,
+        file: Union[Path, IO[Any]],
+        delimiter: str = ",",
+        quotechar: str = '"',
+        page_size: int = 1000,
+        name: Optional[str] = None,
+    ) -> List[Document]:
+        try:
+            # Handle file input
+            if isinstance(file, Path):
+                if not file.exists():
+                    raise FileNotFoundError(f"Could not find file: {file}")
+                logger.info(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}")
+                file.seek(0)
+                file_content_io = io.StringIO(file.read().decode("utf-8"))  # type: ignore
+
+            csv_name = name or (
+                Path(file.name).stem
+                if isinstance(file, Path)
+                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
+            )
+
+            file_content_io.seek(0)
+            csv_reader = csv.reader(file_content_io, delimiter=delimiter, quotechar=quotechar)
+            rows = list(csv_reader)
+
+            if not rows:
+                logger.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}")
+
+            # 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")
+
+            # For small files, process all at once
+            if total_rows <= 10:
+                documents = []
+                for row_index, row in enumerate(data_rows):
+                    normalized_row = row[: len(headers)]
+                    while len(normalized_row) < len(headers):
+                        normalized_row.append("")
+
+                    labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, row_index)
+
+                    if labeled_text.strip():
+                        document = Document(
+                            id=f"{csv_name}_row_{row_index + 1}",
+                            name=csv_name,
+                            meta_data={
+                                "row_index": row_index,
+                                "headers": headers,
+                                "total_rows": total_rows,
+                                "source": "field_labeled_csv_reader",
+                            },
+                            content=labeled_text,
+                        )
+                        documents.append(document)
+            else:
+                pages = []
+                for i in range(0, total_rows, page_size):
+                    pages.append(data_rows[i : i + page_size])
+
+                async def _process_page(page_number: int, page_rows: List[List[str]]) -> List[Document]:
+                    """Process a page of rows into documents"""
+                    page_documents = []
+                    start_row_index = (page_number - 1) * page_size
+
+                    for i, row in enumerate(page_rows):
+                        row_index = start_row_index + i
+
+                        normalized_row = row[: len(headers)]
+                        while len(normalized_row) < len(headers):
+                            normalized_row.append("")
+
+                        labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, row_index)
+
+                        if labeled_text.strip():
+                            document = Document(
+                                id=f"{csv_name}_row_{row_index + 1}",
+                                name=csv_name,
+                                meta_data={
+                                    "row_index": row_index,
+                                    "headers": headers,
+                                    "total_rows": total_rows,
+                                    "page": page_number,
+                                    "source": "field_labeled_csv_reader",
+                                },
+                                content=labeled_text,
+                            )
+                            page_documents.append(document)
+
+                    return page_documents
+
+                page_results = await asyncio.gather(
+                    *[_process_page(page_number, page) for page_number, page in enumerate(pages, start=1)]
+                )
+
+                documents = [doc for page_docs in page_results for doc in page_docs]
+
+            logger.info(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}"
+            )
+            return []

agno/knowledge/reader/pdf_reader.py

@@ -218,6 +218,19 @@ class BasePDFReader(Reader):
             chunked_documents.extend(self.chunk_document(document))
         return chunked_documents
 
+    def _get_doc_name(self, pdf_source: Union[str, Path, IO[Any]], name: Optional[str] = None) -> str:
+        """Determines the document name from the source or a provided name."""
+        try:
+            if name:
+                return name
+            if isinstance(pdf_source, str):
+                return pdf_source.split("/")[-1].split(".")[0].replace(" ", "_")
+            # Assumes a file-like object with a .name attribute
+            return pdf_source.name.split(".")[0]
+        except Exception:
+            # The original code had a bug here, it should check `name` first.
+            return name or "pdf"
+
     def _decrypt_pdf(self, doc_reader: DocumentReader, doc_name: str, password: Optional[str] = None) -> bool:
         if not doc_reader.is_encrypted:
             return True
@@ -332,30 +345,7 @@ class PDFReader(BasePDFReader):
     def read(
         self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
     ) -> List[Document]:
-        try:
-            if name:
-                doc_name = name
-            elif isinstance(pdf, str):
-                doc_name = pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = "pdf"
-
-        try:
-            DocumentReader(pdf)
-        except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
-            return []
-
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = name or pdf.name.split(".")[0]
-        except Exception:
-            doc_name = name or "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
 
         try:
@@ -363,7 +353,6 @@ class PDFReader(BasePDFReader):
         except PdfStreamError as e:
             logger.error(f"Error reading PDF: {e}")
             return []
-
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):
             return []
@@ -380,15 +369,7 @@ class PDFReader(BasePDFReader):
         if pdf is None:
             log_error("No pdf provided")
             return []
-
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = name or "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
 
         try:
@@ -414,16 +395,13 @@ class PDFImageReader(BasePDFReader):
         if not pdf:
             raise ValueError("No pdf provided")
 
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
-        pdf_reader = DocumentReader(pdf)
+        try:
+            pdf_reader = DocumentReader(pdf)
+        except PdfStreamError as e:
+            logger.error(f"Error reading PDF: {e}")
+            return []
 
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):
@@ -438,16 +416,14 @@ class PDFImageReader(BasePDFReader):
         if not pdf:
             raise ValueError("No pdf provided")
 
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
-        pdf_reader = DocumentReader(pdf)
+
+        try:
+            pdf_reader = DocumentReader(pdf)
+        except PdfStreamError as e:
+            logger.error(f"Error reading PDF: {e}")
+            return []
 
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):

agno/knowledge/reader/reader_factory.py

@@ -35,6 +35,18 @@ class ReaderFactory:
         config.update(kwargs)
         return CSVReader(**config)
 
+    @classmethod
+    def _get_field_labeled_csv_reader(cls, **kwargs) -> Reader:
+        """Get Field Labeled CSV reader instance."""
+        from agno.knowledge.reader.field_labeled_csv_reader import FieldLabeledCSVReader
+
+        config: Dict[str, Any] = {
+            "name": "Field Labeled CSV Reader",
+            "description": "Converts CSV rows to field-labeled text format for enhanced readability and context",
+        }
+        config.update(kwargs)
+        return FieldLabeledCSVReader(**config)
+
     @classmethod
     def _get_docx_reader(cls, **kwargs) -> Reader:
         """Get Docx reader instance."""