agno 2.3.16__py3-none-any.whl → 2.3.17__py3-none-any.whl

agno/db/base.py

@@ -58,6 +58,14 @@ class BaseDb(ABC):
         """Create all tables for this database."""
         pass
 
+    def close(self) -> None:
+        """Close database connections and release resources.
+
+        Override in subclasses to properly dispose of connection pools.
+        Should be called during application shutdown.
+        """
+        pass
+
     # --- Schema Version ---
     @abstractmethod
     def get_latest_schema_version(self, table_name: str):
@@ -517,6 +525,18 @@ class AsyncBaseDb(ABC):
         self.culture_table_name = culture_table or "agno_culture"
         self.versions_table_name = versions_table or "agno_schema_versions"
 
+    async def _create_all_tables(self) -> None:
+        """Create all tables for this database. Override in subclasses."""
+        pass
+
+    async def close(self) -> None:
+        """Close database connections and release resources.
+
+        Override in subclasses to properly dispose of connection pools.
+        Should be called during application shutdown.
+        """
+        pass
+
     @abstractmethod
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in this database.

agno/db/mongo/async_mongo.py

@@ -249,6 +249,17 @@ class AsyncMongoDb(AsyncBaseDb):
             if collection_name and not await self.table_exists(collection_name):
                 await self._get_collection(collection_type, create_collection_if_not_found=True)
 
+    async def close(self) -> None:
+        """Close the MongoDB client connection.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+            self._database = None
+
     def _ensure_client(self) -> AsyncMongoClientType:
         """
         Ensure the MongoDB async client is valid for the current event loop.

agno/db/mongo/mongo.py

@@ -98,10 +98,20 @@ class MongoDb(BaseDb):
 
         self.db_url: Optional[str] = db_url
         self.db_client: MongoClient = _client
+
         self.db_name: str = db_name if db_name is not None else "agno"
 
         self._database: Optional[Database] = None
 
+    def close(self) -> None:
+        """Close the MongoDB client connection.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_client is not None:
+            self.db_client.close()
+
     @property
     def database(self) -> Database:
         if self._database is None:

agno/db/mysql/async_mysql.py

@@ -123,6 +123,15 @@ class AsyncMySQLDb(AsyncBaseDb):
             expire_on_commit=False,
         )
 
+    async def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            await self.db_engine.dispose()
+
     # -- DB methods --
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the MySQL database.

agno/db/mysql/mysql.py

@@ -121,6 +121,15 @@ class MySQLDb(BaseDb):
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
 
+    def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            self.db_engine.dispose()
+
     # -- DB methods --
     def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the MySQL database.

agno/db/postgres/async_postgres.py

@@ -128,6 +128,15 @@ class AsyncPostgresDb(AsyncBaseDb):
             expire_on_commit=False,
         )
 
+    async def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            await self.db_engine.dispose()
+
     # -- DB methods --
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the Postgres database.

agno/db/postgres/postgres.py

@@ -124,6 +124,15 @@ class PostgresDb(BaseDb):
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine, expire_on_commit=False))
 
+    def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            self.db_engine.dispose()
+
     # -- DB methods --
     def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the Postgres database.

agno/db/postgres/utils.py

@@ -298,8 +298,9 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
         for session in sessions:
             if session.get("user_id"):
                 all_user_ids.add(session["user_id"])
-            metrics[runs_count_key] += len(session.get("runs", []))
-            if runs := session.get("runs", []):
+            runs = session.get("runs", []) or []
+            metrics[runs_count_key] += len(runs)
+            if runs:
                 for run in runs:
                     if model_id := run.get("model"):
                         model_provider = run.get("model_provider", "")

agno/db/sqlite/async_sqlite.py

@@ -124,6 +124,15 @@ class AsyncSqliteDb(AsyncBaseDb):
         # Initialize database session factory
         self.async_session_factory = async_sessionmaker(bind=self.db_engine, expire_on_commit=False)
 
+    async def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            await self.db_engine.dispose()
+
     # -- DB methods --
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the SQLite database.

agno/db/sqlite/sqlite.py

@@ -125,6 +125,15 @@ class SqliteDb(BaseDb):
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
 
+    def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            self.db_engine.dispose()
+
     # -- DB methods --
     def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the SQLite database.
@@ -1110,7 +1119,8 @@ class SqliteDb(BaseDb):
                 # Select topics from all results
                 stmt = select(table.c.topics)
                 result = sess.execute(stmt).fetchall()
-                return list(set([record[0] for record in result]))
+                result = result[0][0]
+                return list(set(result))
 
         except Exception as e:
             log_debug(f"Exception reading from memory table: {e}")

agno/exceptions.py

@@ -178,3 +178,26 @@ class RetryableModelProviderError(Exception):
     original_error: Optional[str] = None
     # Guidance message to retry a model invocation after an error
     retry_guidance_message: Optional[str] = None
+
+
+class RemoteServerUnavailableError(AgnoError):
+    """Exception raised when a remote server is unavailable.
+
+    This can happen due to:
+    - Connection refused (server not running)
+    - Connection timeout
+    - Network errors
+    - DNS resolution failures
+    """
+
+    def __init__(
+        self,
+        message: str,
+        base_url: Optional[str] = None,
+        original_error: Optional[Exception] = None,
+    ):
+        super().__init__(message, status_code=503)
+        self.base_url = base_url
+        self.original_error = original_error
+        self.type = "remote_server_unavailable_error"
+        self.error_id = "remote_server_unavailable_error"

agno/knowledge/chunking/semantic.py

@@ -1,5 +1,18 @@
-import inspect
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional, Union
+
+try:
+    import numpy as np
+except ImportError:
+    raise ImportError("`numpy` not installed. Please install using `pip install numpy`")
+
+try:
+    from chonkie import SemanticChunker
+    from chonkie.embeddings.base import BaseEmbeddings
+except ImportError:
+    raise ImportError(
+        "`chonkie` is required for semantic chunking. "
+        "Please install it using `pip install chonkie` to use SemanticChunking."
+    )
 
 from agno.knowledge.chunking.strategy import ChunkingStrategy
 from agno.knowledge.document.base import Document
@@ -7,10 +20,69 @@ from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import log_info
 
 
-class SemanticChunking(ChunkingStrategy):
-    """Chunking strategy that splits text into semantic chunks using chonkie"""
+def _get_chonkie_embedder_wrapper(embedder: Embedder):
+    """Create a wrapper that adapts Agno Embedder to chonkie's BaseEmbeddings interface."""
+
+    class _ChonkieEmbedderWrapper(BaseEmbeddings):
+        """Wrapper to make Agno Embedders compatible with chonkie."""
+
+        def __init__(self, agno_embedder: Embedder):
+            super().__init__()
+            self._embedder = agno_embedder
+
+        def embed(self, text: str):
+            embedding = self._embedder.get_embedding(text)  # type: ignore[attr-defined]
+            return np.array(embedding, dtype=np.float32)
+
+        def get_tokenizer(self):
+            """Return a simple token counter function."""
+            return lambda text: len(text.split())
 
-    def __init__(self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: float = 0.5):
+        @property
+        def dimension(self) -> int:
+            return getattr(self._embedder, "dimensions")
+
+    return _ChonkieEmbedderWrapper(embedder)
+
+
+class SemanticChunking(ChunkingStrategy):
+    """Chunking strategy that splits text into semantic chunks using chonkie.
+
+    Args:
+        embedder: The embedder to use for generating embeddings. Can be:
+            - A string model identifier (e.g., "minishlab/potion-base-32M") for chonkie's built-in models
+            - A chonkie BaseEmbeddings instance (used directly)
+            - An Agno Embedder (wrapped for chonkie compatibility)
+        chunk_size: Maximum tokens allowed per chunk.
+        similarity_threshold: Threshold for semantic similarity (0-1).
+        similarity_window: Number of sentences to consider for similarity calculation.
+        min_sentences_per_chunk: Minimum number of sentences per chunk.
+        min_characters_per_sentence: Minimum number of characters per sentence.
+        delimiters: Delimiters to use for sentence splitting.
+        include_delimiters: Whether to include delimiter in prev/next sentence or None.
+        skip_window: Number of groups to skip when merging (0=disabled).
+        filter_window: Window length for the Savitzky-Golay filter.
+        filter_polyorder: Polynomial order for the Savitzky-Golay filter.
+        filter_tolerance: Tolerance for the Savitzky-Golay filter.
+        chunker_params: Additional parameters to pass to chonkie's SemanticChunker.
+    """
+
+    def __init__(
+        self,
+        embedder: Optional[Union[str, Embedder, BaseEmbeddings]] = None,
+        chunk_size: int = 5000,
+        similarity_threshold: float = 0.5,
+        similarity_window: int = 3,
+        min_sentences_per_chunk: int = 1,
+        min_characters_per_sentence: int = 24,
+        delimiters: Optional[List[str]] = None,
+        include_delimiters: Literal["prev", "next", None] = "prev",
+        skip_window: int = 0,
+        filter_window: int = 5,
+        filter_polyorder: int = 3,
+        filter_tolerance: float = 0.2,
+        chunker_params: Optional[Dict[str, Any]] = None,
+    ):
         if embedder is None:
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
@@ -19,50 +91,55 @@ class SemanticChunking(ChunkingStrategy):
         self.embedder = embedder
         self.chunk_size = chunk_size
         self.similarity_threshold = similarity_threshold
-        self.chunker = None  # Will be initialized lazily when needed
+        self.similarity_window = similarity_window
+        self.min_sentences_per_chunk = min_sentences_per_chunk
+        self.min_characters_per_sentence = min_characters_per_sentence
+        self.delimiters = delimiters if delimiters is not None else [". ", "! ", "? ", "\n"]
+        self.include_delimiters = include_delimiters
+        self.skip_window = skip_window
+        self.filter_window = filter_window
+        self.filter_polyorder = filter_polyorder
+        self.filter_tolerance = filter_tolerance
+        self.chunker_params = chunker_params
+        self.chunker: Optional[SemanticChunker] = None
 
     def _initialize_chunker(self):
         """Lazily initialize the chunker with chonkie dependency."""
-        if self.chunker is None:
-            try:
-                from chonkie import SemanticChunker
-            except ImportError:
-                raise ImportError(
-                    "`chonkie` is required for semantic chunking. "
-                    "Please install it using `pip install chonkie` to use SemanticChunking."
-                )
-
-            # Build arguments dynamically based on chonkie's supported signature
-            params: Dict[str, Any] = {
-                "chunk_size": self.chunk_size,
-                "threshold": self.similarity_threshold,
-            }
-
-            try:
-                sig = inspect.signature(SemanticChunker)
-                param_names = set(sig.parameters.keys())
-
-                # Prefer passing a callable to avoid Chonkie initializing its own client
-                if "embedding_fn" in param_names:
-                    params["embedding_fn"] = self.embedder.get_embedding  # type: ignore[attr-defined]
-                    # If chonkie allows specifying dimensions, provide them
-                    if "embedding_dimensions" in param_names and getattr(self.embedder, "dimensions", None):
-                        params["embedding_dimensions"] = self.embedder.dimensions  # type: ignore[attr-defined]
-                elif "embedder" in param_names:
-                    # Some versions may accept an embedder object directly
-                    params["embedder"] = self.embedder
-                else:
-                    # Fallback to model id
-                    params["embedding_model"] = getattr(self.embedder, "id", None) or "text-embedding-3-small"
-
-                self.chunker = SemanticChunker(**params)  # type: ignore
-            except Exception:
-                # As a final fallback, use the original behavior
-                self.chunker = SemanticChunker(  # type: ignore
-                    embedding_model=getattr(self.embedder, "id", None) or "text-embedding-3-small",
-                    chunk_size=self.chunk_size,
-                    threshold=self.similarity_threshold,
-                )
+        if self.chunker is not None:
+            return
+
+        # Determine embedding model based on type:
+        # - str: pass directly to chonkie (uses chonkie's built-in models)
+        # - BaseEmbeddings: pass directly to chonkie
+        # - Agno Embedder: wrap for chonkie compatibility
+        embedding_model: Union[str, BaseEmbeddings]
+        if isinstance(self.embedder, str):
+            embedding_model = self.embedder
+        elif isinstance(self.embedder, BaseEmbeddings):
+            embedding_model = self.embedder
+        elif isinstance(self.embedder, Embedder):
+            embedding_model = _get_chonkie_embedder_wrapper(self.embedder)
+        else:
+            raise ValueError("Invalid embedder type. Must be a string, BaseEmbeddings, or Embedder instance.")
+
+        _chunker_params: Dict[str, Any] = {
+            "embedding_model": embedding_model,
+            "chunk_size": self.chunk_size,
+            "threshold": self.similarity_threshold,
+            "similarity_window": self.similarity_window,
+            "min_sentences_per_chunk": self.min_sentences_per_chunk,
+            "min_characters_per_sentence": self.min_characters_per_sentence,
+            "delim": self.delimiters,
+            "include_delim": self.include_delimiters,
+            "skip_window": self.skip_window,
+            "filter_window": self.filter_window,
+            "filter_polyorder": self.filter_polyorder,
+            "filter_tolerance": self.filter_tolerance,
+        }
+        if self.chunker_params:
+            _chunker_params.update(self.chunker_params)
+
+        self.chunker = SemanticChunker(**_chunker_params)
 
     def chunk(self, document: Document) -> List[Document]:
         """Split document into semantic chunks using chonkie"""

agno/knowledge/reader/csv_reader.py

@@ -156,4 +156,4 @@ class CSVReader(Reader):
             return documents
         except Exception as e:
             log_error(f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
-            return []
+            return []

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -281,4 +281,4 @@ class FieldLabeledCSVReader(Reader):
 
         except Exception as e:
             log_error(f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
-            return []
+            return []

agno/knowledge/reader/json_reader.py

@@ -77,4 +77,4 @@ class JSONReader(Reader):
 
     async def async_read(self, path: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
         """Asynchronously read JSON files."""
-        return await asyncio.to_thread(self.read, path, name)
+        return await asyncio.to_thread(self.read, path, name)