agno 2.2.0__py3-none-any.whl → 2.2.2__py3-none-any.whl

agno/db/sqlite/sqlite.py

@@ -374,8 +374,6 @@ class SqliteDb(BaseDb):
                 # Filtering
                 if user_id is not None:
                     stmt = stmt.where(table.c.user_id == user_id)
-                if session_type is not None:
-                    stmt = stmt.where(table.c.session_type == session_type)
 
                 result = sess.execute(stmt).fetchone()
                 if result is None:

agno/db/sqlite/utils.py

@@ -4,6 +4,8 @@ from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+
 from agno.db.schemas.culture import CulturalKnowledge
 from agno.db.sqlite.schemas import get_table_schema_definition
 from agno.utils.log import log_debug, log_error, log_warning
@@ -50,6 +52,7 @@ def is_table_available(session: Session, table_name: str, db_schema: Optional[st
     """
     Check if a table with the given name exists.
     Note: db_schema parameter is ignored in SQLite but kept for API compatibility.
+
     Returns:
         bool: True if the table exists, False otherwise.
     """
@@ -65,6 +68,25 @@ def is_table_available(session: Session, table_name: str, db_schema: Optional[st
         return False
 
 
+async def ais_table_available(session: AsyncSession, table_name: str, db_schema: Optional[str] = None) -> bool:
+    """
+    Check if a table with the given name exists.
+    Note: db_schema parameter is ignored in SQLite but kept for API compatibility.
+
+    Returns:
+        bool: True if the table exists, False otherwise.
+    """
+    try:
+        exists_query = text("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = :table")
+        exists = (await session.execute(exists_query, {"table": table_name})).scalar() is not None
+        if not exists:
+            log_debug(f"Table {table_name} {'exists' if exists else 'does not exist'}")
+        return exists
+    except Exception as e:
+        log_error(f"Error checking if table exists: {e}")
+        return False
+
+
 def is_valid_table(db_engine: Engine, table_name: str, table_type: str, db_schema: Optional[str] = None) -> bool:
     """
     Check if the existing table has the expected column names.
@@ -98,6 +120,47 @@ def is_valid_table(db_engine: Engine, table_name: str, table_type: str, db_schem
         return False
 
 
+async def ais_valid_table(
+    db_engine: AsyncEngine, table_name: str, table_type: str, db_schema: Optional[str] = None
+) -> bool:
+    """
+    Check if the existing table has the expected column names.
+    Note: db_schema parameter is ignored in SQLite but kept for API compatibility.
+    Args:
+        db_engine (Engine): Database engine
+        table_name (str): Name of the table to validate
+        table_type (str): Type of table to get expected schema
+        db_schema (Optional[str]): Database schema name (ignored in SQLite)
+    Returns:
+        bool: True if table has all expected columns, False otherwise
+    """
+    try:
+        expected_table_schema = get_table_schema_definition(table_type)
+        expected_columns = {col_name for col_name in expected_table_schema.keys() if not col_name.startswith("_")}
+
+        # Get existing columns from the async engine
+        async with db_engine.connect() as conn:
+            existing_columns = await conn.run_sync(_get_table_columns, table_name)
+
+        missing_columns = expected_columns - existing_columns
+        if missing_columns:
+            log_warning(f"Missing columns {missing_columns} in table {table_name}")
+            return False
+
+        return True
+
+    except Exception as e:
+        log_error(f"Error validating table schema for {table_name}: {e}")
+        return False
+
+
+def _get_table_columns(conn, table_name: str) -> set[str]:
+    """Helper function to get table columns using sync inspector."""
+    inspector = inspect(conn)
+    columns_info = inspector.get_columns(table_name)
+    return {col["name"] for col in columns_info}
+
+
 # -- Metrics util methods --
 
 
@@ -134,6 +197,39 @@ def bulk_upsert_metrics(session: Session, table: Table, metrics_records: list[di
     return results  # type: ignore
 
 
+async def abulk_upsert_metrics(session: AsyncSession, table: Table, metrics_records: list[dict]) -> list[dict]:
+    """Bulk upsert metrics into the database.
+
+    Args:
+        table (Table): The table to upsert into.
+        metrics_records (list[dict]): The metrics records to upsert.
+
+    Returns:
+        list[dict]: The upserted metrics records.
+    """
+    if not metrics_records:
+        return []
+
+    results = []
+    stmt = sqlite.insert(table)
+
+    # Columns to update in case of conflict
+    update_columns = {
+        col.name: stmt.excluded[col.name]
+        for col in table.columns
+        if col.name not in ["id", "date", "created_at", "aggregation_period"]
+    }
+
+    stmt = stmt.on_conflict_do_update(index_elements=["date", "aggregation_period"], set_=update_columns).returning(  # type: ignore
+        table
+    )
+    result = await session.execute(stmt, metrics_records)
+    results = [dict(row._mapping) for row in result.fetchall()]
+    await session.commit()
+
+    return results  # type: ignore
+
+
 def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
     """Calculate metrics for the given single date.
 

agno/db/surrealdb/surrealdb.py

@@ -238,12 +238,6 @@ class SurrealDb(BaseDb):
         where = WhereClause()
         if user_id is not None:
             where = where.and_("user_id", user_id)
-        if session_type == SessionType.AGENT:
-            where = where.and_("agent", None, "!=")
-        elif session_type == SessionType.TEAM:
-            where = where.and_("team", None, "!=")
-        elif session_type == SessionType.WORKFLOW:
-            where = where.and_("workflow", None, "!=")
         where_clause, where_vars = where.build()
         query = dedent(f"""
             SELECT *

agno/knowledge/knowledge.py

@@ -501,7 +501,7 @@ class Knowledge:
         await self._add_to_contents_db(content)
         if self._should_skip(content.content_hash, skip_if_exists):  # type: ignore[arg-type]
             content.status = ContentStatus.COMPLETED
-            self._update_content(content)
+            await self._aupdate_content(content)
             return
 
         if self.vector_db.__class__.__name__ == "LightRag":
@@ -547,6 +547,8 @@ class Knowledge:
                 reader = self.pdf_reader
             elif file_extension == ".docx":
                 reader = self.docx_reader
+            elif file_extension == ".pptx":
+                reader = self.pptx_reader
             elif file_extension == ".json":
                 reader = self.json_reader
             elif file_extension == ".markdown":
@@ -723,7 +725,7 @@ class Knowledge:
             await self._add_to_contents_db(content)
             if self._should_skip(content.content_hash, skip_if_exists):
                 content.status = ContentStatus.COMPLETED
-                self._update_content(content)
+                await self._aupdate_content(content)
                 return
 
             if self.vector_db.__class__.__name__ == "LightRag":
@@ -739,7 +741,7 @@ class Knowledge:
                 log_error(f"No reader available for topic: {topic}")
                 content.status = ContentStatus.FAILED
                 content.status_message = "No reader available for topic"
-                self._update_content(content)
+                await self._aupdate_content(content)
                 continue
 
             read_documents = content.reader.read(topic)
@@ -835,6 +837,8 @@ class Knowledge:
                     reader = self.csv_reader
                 elif s3_object.uri.endswith(".docx"):
                     reader = self.docx_reader
+                elif s3_object.uri.endswith(".pptx"):
+                    reader = self.pptx_reader
                 elif s3_object.uri.endswith(".json"):
                     reader = self.json_reader
                 elif s3_object.uri.endswith(".markdown"):
@@ -917,6 +921,8 @@ class Knowledge:
                     reader = self.csv_reader
                 elif gcs_object.name.endswith(".docx"):
                     reader = self.docx_reader
+                elif gcs_object.name.endswith(".pptx"):
+                    reader = self.pptx_reader
                 elif gcs_object.name.endswith(".json"):
                     reader = self.json_reader
                 elif gcs_object.name.endswith(".markdown"):
@@ -1893,6 +1899,11 @@ class Knowledge:
         """Docx reader - lazy loaded via factory."""
         return self._get_reader("docx")
 
+    @property
+    def pptx_reader(self) -> Optional[Reader]:
+        """PPTX reader - lazy loaded via factory."""
+        return self._get_reader("pptx")
+
     @property
     def json_reader(self) -> Optional[Reader]:
         """JSON reader - lazy loaded via factory."""

agno/knowledge/reader/pptx_reader.py

@@ -0,0 +1,101 @@
+import asyncio
+from pathlib import Path
+from typing import IO, Any, List, Optional, Union
+from uuid import uuid4
+
+from agno.knowledge.chunking.document import DocumentChunking
+from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
+from agno.knowledge.document.base import Document
+from agno.knowledge.reader.base import Reader
+from agno.knowledge.types import ContentType
+from agno.utils.log import log_info, logger
+
+try:
+    from pptx import Presentation  # type: ignore
+except ImportError:
+    raise ImportError("The `python-pptx` package is not installed. Please install it via `pip install python-pptx`.")
+
+
+class PPTXReader(Reader):
+    """Reader for PPTX files"""
+
+    def __init__(self, chunking_strategy: Optional[ChunkingStrategy] = DocumentChunking(), **kwargs):
+        super().__init__(chunking_strategy=chunking_strategy, **kwargs)
+
+    @classmethod
+    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+        """Get the list of supported chunking strategies for PPTX readers."""
+        return [
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+        ]
+
+    @classmethod
+    def get_supported_content_types(self) -> List[ContentType]:
+        return [ContentType.PPTX]
+
+    def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
+        """Read a pptx file and return a list of documents"""
+        try:
+            if isinstance(file, Path):
+                if not file.exists():
+                    raise FileNotFoundError(f"Could not find file: {file}")
+                log_info(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')}")
+                presentation = Presentation(file)
+                doc_name = name or (
+                    getattr(file, "name", "pptx_file").split(".")[0] if hasattr(file, "name") else "pptx_file"
+                )
+
+            # Extract text from all slides
+            slide_texts = []
+            for slide_number, slide in enumerate(presentation.slides, 1):
+                slide_text = f"Slide {slide_number}:\n"
+
+                # Extract text from shapes that contain text
+                text_content = []
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        text_content.append(shape.text.strip())
+
+                if text_content:
+                    slide_text += "\n".join(text_content)
+                else:
+                    slide_text += "(No text content)"
+
+                slide_texts.append(slide_text)
+
+            doc_content = "\n\n".join(slide_texts)
+
+            documents = [
+                Document(
+                    name=doc_name,
+                    id=str(uuid4()),
+                    content=doc_content,
+                )
+            ]
+
+            if self.chunk:
+                chunked_documents = []
+                for document in documents:
+                    chunked_documents.extend(self.chunk_document(document))
+                return chunked_documents
+            return documents
+
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            return []
+
+    async def async_read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
+        """Asynchronously read a pptx file and return a list of documents"""
+        try:
+            return await asyncio.to_thread(self.read, file, name)
+        except Exception as e:
+            logger.error(f"Error reading file asynchronously: {e}")
+            return []

agno/knowledge/reader/reader_factory.py

@@ -58,6 +58,18 @@ class ReaderFactory:
         config.update(kwargs)
         return DocxReader(**config)
 
+    @classmethod
+    def _get_pptx_reader(cls, **kwargs) -> Reader:
+        """Get PPTX reader instance."""
+        from agno.knowledge.reader.pptx_reader import PPTXReader
+
+        config: Dict[str, Any] = {
+            "name": "PPTX Reader",
+            "description": "Extracts text content from Microsoft PowerPoint presentations (.pptx format)",
+        }
+        config.update(kwargs)
+        return PPTXReader(**config)
+
     @classmethod
     def _get_json_reader(cls, **kwargs) -> Reader:
         """Get JSON reader instance."""
@@ -120,6 +132,21 @@ class ReaderFactory:
         config.update(kwargs)
         return FirecrawlReader(**config)
 
+    @classmethod
+    def _get_tavily_reader(cls, **kwargs) -> Reader:
+        """Get Tavily reader instance."""
+        from agno.knowledge.reader.tavily_reader import TavilyReader
+
+        config: Dict[str, Any] = {
+            "api_key": kwargs.get("api_key") or os.getenv("TAVILY_API_KEY"),
+            "extract_format": "markdown",
+            "extract_depth": "basic",
+            "name": "Tavily Reader",
+            "description": "Extracts content from URLs using Tavily's Extract API with markdown or text output",
+        }
+        config.update(kwargs)
+        return TavilyReader(**config)
+
     @classmethod
     def _get_youtube_reader(cls, **kwargs) -> Reader:
         """Get YouTube reader instance."""
@@ -202,6 +229,8 @@ class ReaderFactory:
             return cls.create_reader("csv")
         elif extension in [".docx", ".doc", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"]:
             return cls.create_reader("docx")
+        elif extension == ".pptx":
+            return cls.create_reader("pptx")
         elif extension == ".json":
             return cls.create_reader("json")
         elif extension in [".md", ".markdown"]:
@@ -242,6 +271,7 @@ class ReaderFactory:
         url_reader_priority = [
             "website",
             "firecrawl",
+            "tavily",
             "youtube",
         ]
 

agno/knowledge/reader/tavily_reader.py

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

agno/knowledge/types.py

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