agno 2.2.8__tar.gz → 2.2.9__tar.gz

{agno-2.2.8 → agno-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.2.8
+Version: 2.2.9
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -262,8 +262,6 @@ Provides-Extra: a2a
 Requires-Dist: a2a-sdk; extra == "a2a"
 Provides-Extra: huggingface
 Requires-Dist: huggingface-hub; extra == "huggingface"
-Provides-Extra: vllm
-Requires-Dist: vllm; extra == "vllm"
 Provides-Extra: performance
 Requires-Dist: memory_profiler; extra == "performance"
 Provides-Extra: cookbooks
@@ -403,13 +401,13 @@ Dynamic: license-file
 
 Agno is a multi-agent framework, runtime and control plane. Built for speed, privacy, and scale.
 
-It provides a rich set of primitives for building:
+It provides a rich set of tools for building:
 
-- **Agents** with persistent state, knowledge retrieval, memory, and advanced features like human-in-the-loop, guardrails, dynamic context management and best-in-class MCP support.
-- **Multi-Agent Teams** that operate autonomously under a team leader that maintains shared state and context.
-- **Step-based Workflows** for controlled, deterministic execution. Steps can be Agents, Teams, or a regular python functions and can run sequentially, in parallel, in loops, branches, or conditionally.
+- **Agents** with memory, knowledge, session management, and advanced features like human-in-the-loop, guardrails, dynamic context management and best-in-class MCP support.
+- **Multi-Agent Teams** that operate autonomously under a team leader that maintains shared state and context. Perfect for use cases where the scope exceeds beyond a single agent.
+- **Step-based Workflows** for controlled, deterministic execution. Steps can be Agents, Teams, or regular python functions that run sequentially, in parallel, in loops, branches, or conditionally.
 
-Agno also provides a FastAPI-powered runtime for serving multi-agent systems in production, covering the entire {build → run → deploy} lifecycle. Building Agents is easy, running them is hard, and that's where Agno shines.
+Agno also provides a ready-to-use FastAPI app (called the AgentOS) for serving your agents, teams and workflows in production. Stateless, horizontally scalable and designed for scale, the AgentOS gives you major head start in building your AI product.
 
 ## Getting started
 
@@ -426,7 +424,7 @@ After that, checkout the [examples gallery](https://docs.agno.com/examples/intro
 
 ## Example
 
-Here’s an example of an Agent that connects to an MCP server, manages conversation state in a database, and is served using a FastAPI application that you can interact with using the [AgentOS UI](https://os.agno.com).
+Here’s an example of an Agent that connects to an MCP server, manages conversation state in a database, is served using a FastAPI application that you can chat with using the [AgentOS UI](https://os.agno.com).
 
 ```python agno_agent.py
 from agno.agent import Agent
@@ -461,11 +459,11 @@ if __name__ == "__main__":
 
 ## AgentOS - Production Runtime for Multi-Agent Systems
 
-AgentOS is Agno's high-performance runtime for serving multi-agent systems in production. Key features include:
+Building Agents is easy, running them is hard, and that's where the AgentOS comes in. AgentOS is a high-performance runtime for serving multi-agent systems in production. Key features include:
 
-1. **Pre-built FastAPI Runtime**: AgentOS ships with a ready-to-use FastAPI app for orchestrating your agents, teams, and workflows. This provides a major head start when building an AI product.
+1. **Pre-built FastAPI app**: AgentOS ships with a ready-to-use FastAPI app for orchestrating your agents, teams, and workflows. This gives you a major head start in building your AI product.
 
-2. **Integrated Control Plane**: The [AgentOS UI](https://os.agno.com) connects directly to your runtime, letting you test, monitor, and manage your system in real time. This gives you unmatched visibility and control over your system.
+2. **Integrated Control Plane**: The [AgentOS UI](https://os.agno.com) connects directly to your runtime, letting you test, monitor, and manage your system in real time, giving you unmatched control over your system.
 
 3. **Private by Design**: AgentOS runs entirely in your cloud, ensuring complete data privacy. No data ever leaves your system. This is ideal for security-conscious enterprises.
 
@@ -485,7 +483,7 @@ Agno brings a novel architecture that no other framework provides, your AgentOS
 
 ## Designed for Agent Engineering
 
-Agno is a remarkably feature-rich framework, purpose-built for large-scale multi-agent deployments.
+Agno is an incredibly feature-rich framework, designed for Agent Engineering. Here are some key features:
 
 | **Category** | **Feature** | **Description** |
 |---------------|-------------|-----------------|

{agno-2.2.8 → agno-2.2.9}/README.md

@@ -21,13 +21,13 @@
 
 Agno is a multi-agent framework, runtime and control plane. Built for speed, privacy, and scale.
 
-It provides a rich set of primitives for building:
+It provides a rich set of tools for building:
 
-- **Agents** with persistent state, knowledge retrieval, memory, and advanced features like human-in-the-loop, guardrails, dynamic context management and best-in-class MCP support.
-- **Multi-Agent Teams** that operate autonomously under a team leader that maintains shared state and context.
-- **Step-based Workflows** for controlled, deterministic execution. Steps can be Agents, Teams, or a regular python functions and can run sequentially, in parallel, in loops, branches, or conditionally.
+- **Agents** with memory, knowledge, session management, and advanced features like human-in-the-loop, guardrails, dynamic context management and best-in-class MCP support.
+- **Multi-Agent Teams** that operate autonomously under a team leader that maintains shared state and context. Perfect for use cases where the scope exceeds beyond a single agent.
+- **Step-based Workflows** for controlled, deterministic execution. Steps can be Agents, Teams, or regular python functions that run sequentially, in parallel, in loops, branches, or conditionally.
 
-Agno also provides a FastAPI-powered runtime for serving multi-agent systems in production, covering the entire {build → run → deploy} lifecycle. Building Agents is easy, running them is hard, and that's where Agno shines.
+Agno also provides a ready-to-use FastAPI app (called the AgentOS) for serving your agents, teams and workflows in production. Stateless, horizontally scalable and designed for scale, the AgentOS gives you major head start in building your AI product.
 
 ## Getting started
 
@@ -44,7 +44,7 @@ After that, checkout the [examples gallery](https://docs.agno.com/examples/intro
 
 ## Example
 
-Here’s an example of an Agent that connects to an MCP server, manages conversation state in a database, and is served using a FastAPI application that you can interact with using the [AgentOS UI](https://os.agno.com).
+Here’s an example of an Agent that connects to an MCP server, manages conversation state in a database, is served using a FastAPI application that you can chat with using the [AgentOS UI](https://os.agno.com).
 
 ```python agno_agent.py
 from agno.agent import Agent
@@ -79,11 +79,11 @@ if __name__ == "__main__":
 
 ## AgentOS - Production Runtime for Multi-Agent Systems
 
-AgentOS is Agno's high-performance runtime for serving multi-agent systems in production. Key features include:
+Building Agents is easy, running them is hard, and that's where the AgentOS comes in. AgentOS is a high-performance runtime for serving multi-agent systems in production. Key features include:
 
-1. **Pre-built FastAPI Runtime**: AgentOS ships with a ready-to-use FastAPI app for orchestrating your agents, teams, and workflows. This provides a major head start when building an AI product.
+1. **Pre-built FastAPI app**: AgentOS ships with a ready-to-use FastAPI app for orchestrating your agents, teams, and workflows. This gives you a major head start in building your AI product.
 
-2. **Integrated Control Plane**: The [AgentOS UI](https://os.agno.com) connects directly to your runtime, letting you test, monitor, and manage your system in real time. This gives you unmatched visibility and control over your system.
+2. **Integrated Control Plane**: The [AgentOS UI](https://os.agno.com) connects directly to your runtime, letting you test, monitor, and manage your system in real time, giving you unmatched control over your system.
 
 3. **Private by Design**: AgentOS runs entirely in your cloud, ensuring complete data privacy. No data ever leaves your system. This is ideal for security-conscious enterprises.
 
@@ -103,7 +103,7 @@ Agno brings a novel architecture that no other framework provides, your AgentOS
 
 ## Designed for Agent Engineering
 
-Agno is a remarkably feature-rich framework, purpose-built for large-scale multi-agent deployments.
+Agno is an incredibly feature-rich framework, designed for Agent Engineering. Here are some key features:
 
 | **Category** | **Feature** | **Description** |
 |---------------|-------------|-----------------|

{agno-2.2.8 → agno-2.2.9}/agno/agent/agent.py

@@ -1140,7 +1140,7 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
-        yield_run_response: bool = False,
+        yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> Iterator[Union[RunOutputEvent, RunOutput]]:
@@ -1410,7 +1410,7 @@ class Agent:
             if stream_events:
                 yield completed_event  # type: ignore
 
-            if yield_run_response:
+            if yield_run_output:
                 yield run_response
 
             # Log Agent Telemetry
@@ -1491,7 +1491,8 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        yield_run_response: bool = False,
+        yield_run_response: bool = False,  # To be deprecated: use yield_run_output instead
+        yield_run_output: bool = False,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> Iterator[Union[RunOutputEvent, RunOutput]]: ...
@@ -1517,7 +1518,8 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        yield_run_response: bool = False,
+        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
+        yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> Union[RunOutput, Iterator[Union[RunOutputEvent, RunOutput]]]:
@@ -1655,6 +1657,8 @@ class Agent:
         last_exception = None
         num_attempts = retries + 1
 
+        yield_run_output = yield_run_output or yield_run_response  # For backwards compatibility
+
         for attempt in range(num_attempts):
             try:
                 if stream:
@@ -1668,7 +1672,7 @@ class Agent:
                         add_session_state_to_context=add_session_state,
                         response_format=response_format,
                         stream_events=stream_events,
-                        yield_run_response=yield_run_response,
+                        yield_run_output=yield_run_output,
                         debug_mode=debug_mode,
                         **kwargs,
                     )
@@ -2009,7 +2013,7 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
-        yield_run_response: Optional[bool] = None,
+        yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> AsyncIterator[Union[RunOutputEvent, RunOutput]]:
@@ -2307,7 +2311,7 @@ class Agent:
             if stream_events:
                 yield completed_event  # type: ignore
 
-            if yield_run_response:
+            if yield_run_output:
                 yield run_response
 
             # Log Agent Telemetry
@@ -2408,7 +2412,8 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        yield_run_response: Optional[bool] = None,
+        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
+        yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> AsyncIterator[Union[RunOutputEvent, RunOutput]]: ...
@@ -2434,7 +2439,8 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        yield_run_response: Optional[bool] = None,
+        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
+        yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> Union[RunOutput, AsyncIterator[RunOutputEvent]]:
@@ -2559,6 +2565,8 @@ class Agent:
         last_exception = None
         num_attempts = retries + 1
 
+        yield_run_output = yield_run_output or yield_run_response  # For backwards compatibility
+
         for attempt in range(num_attempts):
             try:
                 # Pass the new run_response to _arun
@@ -2569,7 +2577,7 @@ class Agent:
                         user_id=user_id,
                         response_format=response_format,
                         stream_events=stream_events,
-                        yield_run_response=yield_run_response,
+                        yield_run_output=yield_run_output,
                         session_id=session_id,
                         add_history_to_context=add_history,
                         add_dependencies_to_context=add_dependencies,
@@ -3248,7 +3256,7 @@ class Agent:
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
         debug_mode: Optional[bool] = None,
-        yield_run_response: bool = False,
+        yield_run_output: bool = False,
         **kwargs,
     ) -> Union[RunOutput, AsyncIterator[Union[RunOutputEvent, RunOutput]]]:
         """Continue a previous run.
@@ -3266,7 +3274,7 @@ class Agent:
             dependencies: The dependencies to use for continuing the run.
             metadata: The metadata to use for continuing the run.
             debug_mode: Whether to enable debug mode.
-            yield_run_response: Whether to yield the run response.
+            yield_run_output: Whether to yield the run response.
             (deprecated) stream_intermediate_steps: Whether to stream all steps.
         """
         if run_response is None and run_id is None:
@@ -3351,7 +3359,7 @@ class Agent:
                         session_id=session_id,
                         response_format=response_format,
                         stream_events=stream_events,
-                        yield_run_response=yield_run_response,
+                        yield_run_output=yield_run_output,
                         debug_mode=debug_mode,
                         **kwargs,
                     )
@@ -3620,7 +3628,7 @@ class Agent:
         user_id: Optional[str] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
-        yield_run_response: Optional[bool] = None,
+        yield_run_output: bool = False,
         debug_mode: Optional[bool] = None,
         **kwargs,
     ) -> AsyncIterator[Union[RunOutputEvent, RunOutput]]:
@@ -3860,7 +3868,7 @@ class Agent:
             if stream_events:
                 yield completed_event  # type: ignore
 
-            if yield_run_response:
+            if yield_run_output:
                 yield run_response
 
             # Log Agent Telemetry

{agno-2.2.8 → agno-2.2.9}/agno/db/base.py

@@ -38,6 +38,14 @@ class BaseDb(ABC):
         self.eval_table_name = eval_table or "agno_eval_runs"
         self.knowledge_table_name = knowledge_table or "agno_knowledge"
 
+    @abstractmethod
+    def table_exists(self, table_name: str) -> bool:
+        raise NotImplementedError
+
+    def _create_all_tables(self) -> None:
+        """Create all tables for this database."""
+        pass
+
     # --- Sessions ---
     @abstractmethod
     def delete_session(self, session_id: str) -> bool:
@@ -328,6 +336,21 @@ class AsyncBaseDb(ABC):
         self.knowledge_table_name = knowledge_table or "agno_knowledge"
         self.culture_table_name = culture_table or "agno_culture"
 
+    @abstractmethod
+    async def table_exists(self, table_name: str) -> bool:
+        """Check if a table with the given name exists in this database.
+
+        Default implementation returns True if the table name is configured.
+        Subclasses should override this to perform actual existence checks.
+
+        Args:
+            table_name: Name of the table to check
+
+        Returns:
+            bool: True if the table exists, False otherwise
+        """
+        raise NotImplementedError
+
     # --- Sessions ---
     @abstractmethod
     async def delete_session(self, session_id: str) -> bool:

{agno-2.2.8 → agno-2.2.9}/agno/db/dynamo/dynamo.py

@@ -112,27 +112,8 @@ class DynamoDb(BaseDb):
             session = boto3.Session(**session_kwargs)
             self.client = session.client("dynamodb")
 
-    def _create_tables(self):
-        tables_to_create = [
-            (self.session_table_name, "sessions"),
-            (self.memory_table_name, "memories"),
-            (self.metrics_table_name, "metrics"),
-            (self.eval_table_name, "evals"),
-            (self.knowledge_table_name, "knowledge_sources"),
-        ]
-
-        for table_name, table_type in tables_to_create:
-            if table_name:
-                try:
-                    schema = get_table_schema_definition(table_type)
-                    schema["TableName"] = table_name
-                    create_table_if_not_exists(self.client, table_name, schema)
-
-                except Exception as e:
-                    log_error(f"Failed to create table {table_name}: {e}")
-
-    def _table_exists(self, table_name: str) -> bool:
-        """Check if a DynamoDB table with the given name exists.
+    def table_exists(self, table_name: str) -> bool:
+        """Check if a DynamoDB table exists.
 
         Args:
             table_name: The name of the table to check
@@ -145,9 +126,23 @@ class DynamoDb(BaseDb):
             return True
         except self.client.exceptions.ResourceNotFoundException:
             return False
-        except Exception as e:
-            log_error(f"Error checking if table {table_name} exists: {e}")
-            return False
+
+    def _create_all_tables(self):
+        """Create all configured DynamoDB tables if they don't exist."""
+        tables_to_create = [
+            ("sessions", self.session_table_name),
+            ("memories", self.memory_table_name),
+            ("metrics", self.metrics_table_name),
+            ("evals", self.eval_table_name),
+            ("knowledge", self.knowledge_table_name),
+            ("culture", self.culture_table_name),
+        ]
+
+        for table_type, table_name in tables_to_create:
+            if not self.table_exists(table_name):
+                schema = get_table_schema_definition(table_type)
+                schema["TableName"] = table_name
+                create_table_if_not_exists(self.client, table_name, schema)
 
     def _get_table(self, table_type: str, create_table_if_not_found: Optional[bool] = True) -> Optional[str]:
         """
@@ -180,7 +175,7 @@ class DynamoDb(BaseDb):
             raise ValueError(f"Unknown table type: {table_type}")
 
         # Check if table exists, create if it doesn't
-        if not self._table_exists(table_name) and create_table_if_not_found:
+        if not self.table_exists(table_name) and create_table_if_not_found:
             schema = get_table_schema_definition(table_type)
             schema["TableName"] = table_name
             create_table_if_not_exists(self.client, table_name, schema)

{agno-2.2.8 → agno-2.2.9}/agno/db/dynamo/schemas.py

@@ -176,6 +176,7 @@ KNOWLEDGE_TABLE_SCHEMA = {
     "KeySchema": [{"AttributeName": "id", "KeyType": "HASH"}],
     "AttributeDefinitions": [
         {"AttributeName": "id", "AttributeType": "S"},
+        {"AttributeName": "user_id", "AttributeType": "S"},
         {"AttributeName": "type", "AttributeType": "S"},
         {"AttributeName": "status", "AttributeType": "S"},
         {"AttributeName": "created_at", "AttributeType": "N"},

{agno-2.2.8 → agno-2.2.9}/agno/db/firestore/firestore.py

@@ -89,6 +89,17 @@ class FirestoreDb(BaseDb):
 
     # -- DB methods --
 
+    def table_exists(self, table_name: str) -> bool:
+        """Check if a collection with the given name exists in the Firestore database.
+
+        Args:
+            table_name: Name of the collection to check
+
+        Returns:
+            bool: True if the collection exists in the database, False otherwise
+        """
+        return table_name in self.db_client.list_collections()
+
     def _get_collection(self, table_type: str, create_collection_if_not_found: Optional[bool] = True):
         """Get or create a collection based on table type.
 

{agno-2.2.8 → agno-2.2.9}/agno/db/gcs_json/gcs_json_db.py

@@ -83,6 +83,10 @@ class GcsJsonDb(BaseDb):
         self.client = gcs.Client(project=project, credentials=credentials)
         self.bucket = self.client.bucket(self.bucket_name)
 
+    def table_exists(self, table_name: str) -> bool:
+        """JSON implementation, always returns True."""
+        return True
+
     def _get_blob_name(self, filename: str) -> str:
         """Get the full blob name including prefix for a given filename."""
         return f"{self.prefix}{filename}.json"

{agno-2.2.8 → agno-2.2.9}/agno/db/in_memory/in_memory_db.py

@@ -34,6 +34,10 @@ class InMemoryDb(BaseDb):
         self._knowledge: List[Dict[str, Any]] = []
         self._cultural_knowledge: List[Dict[str, Any]] = []
 
+    def table_exists(self, table_name: str) -> bool:
+        """In-memory implementation, always returns True."""
+        return True
+
     # -- Session methods --
 
     def delete_session(self, session_id: str) -> bool:

{agno-2.2.8 → agno-2.2.9}/agno/db/json/json_db.py

@@ -66,6 +66,10 @@ class JsonDb(BaseDb):
         # Create the directory where the JSON files will be stored, if it doesn't exist
         self.db_path = Path(db_path or os.path.join(os.getcwd(), "agno_json_db"))
 
+    def table_exists(self, table_name: str) -> bool:
+        """JSON implementation, always returns True."""
+        return True
+
     def _read_json_file(self, filename: str, create_table_if_not_found: Optional[bool] = True) -> List[Dict[str, Any]]:
         """Read data from a JSON file, creating it if it doesn't exist.
 

{agno-2.2.8 → agno-2.2.9}/agno/db/mongo/async_mongo.py

@@ -99,6 +99,33 @@ class AsyncMongoDb(AsyncBaseDb):
         self._database: Optional[AsyncIOMotorDatabase] = None
         self._event_loop: Optional[asyncio.AbstractEventLoop] = None
 
+    async def table_exists(self, table_name: str) -> bool:
+        """Check if a collection with the given name exists in the MongoDB database.
+
+        Args:
+            table_name: Name of the collection to check
+
+        Returns:
+            bool: True if the collection exists in the database, False otherwise
+        """
+        collection_names = await self.database.list_collection_names()
+        return table_name in collection_names
+
+    async def _create_all_tables(self):
+        """Create all configured MongoDB collections if they don't exist."""
+        collections_to_create = [
+            ("sessions", self.session_table_name),
+            ("memories", self.memory_table_name),
+            ("metrics", self.metrics_table_name),
+            ("evals", self.eval_table_name),
+            ("knowledge", self.knowledge_table_name),
+            ("culture", self.culture_table_name),
+        ]
+
+        for collection_type, collection_name in collections_to_create:
+            if collection_name and not await self.table_exists(collection_name):
+                await self._get_collection(collection_type, create_collection_if_not_found=True)
+
     def _ensure_client(self) -> AsyncIOMotorClient:
         """
         Ensure the Motor client is valid for the current event loop.

{agno-2.2.8 → agno-2.2.9}/agno/db/mongo/mongo.py

@@ -100,6 +100,31 @@ class MongoDb(BaseDb):
         return self._database
 
     # -- DB methods --
+    def table_exists(self, table_name: str) -> bool:
+        """Check if a collection with the given name exists in the MongoDB database.
+
+        Args:
+            table_name: Name of the collection to check
+
+        Returns:
+            bool: True if the collection exists in the database, False otherwise
+        """
+        return table_name in self.database.list_collection_names()
+
+    def _create_all_tables(self):
+        """Create all configured MongoDB collections if they don't exist."""
+        collections_to_create = [
+            ("sessions", self.session_table_name),
+            ("memories", self.memory_table_name),
+            ("metrics", self.metrics_table_name),
+            ("evals", self.eval_table_name),
+            ("knowledge", self.knowledge_table_name),
+            ("culture", self.culture_table_name),
+        ]
+
+        for collection_type, collection_name in collections_to_create:
+            if collection_name and not self.table_exists(collection_name):
+                self._get_collection(collection_type, create_collection_if_not_found=True)
 
     def _get_collection(
         self, table_type: str, create_collection_if_not_found: Optional[bool] = True

{agno-2.2.8 → agno-2.2.9}/agno/db/mysql/mysql.py

@@ -107,6 +107,18 @@ class MySQLDb(BaseDb):
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
 
     # -- DB methods --
+    def table_exists(self, table_name: str) -> bool:
+        """Check if a table with the given name exists in the MySQL database.
+
+        Args:
+            table_name: Name of the table to check
+
+        Returns:
+            bool: True if the table exists in the database, False otherwise
+        """
+        with self.Session() as sess:
+            return is_table_available(session=sess, table_name=table_name, db_schema=self.db_schema)
+
     def _create_table(self, table_name: str, table_type: str, db_schema: str) -> Table:
         """
         Create a table with the appropriate schema based on the table type.
@@ -191,13 +203,26 @@ class MySQLDb(BaseDb):
                 except Exception as e:
                     log_error(f"Error creating index {idx.name}: {e}")
 
-            log_info(f"Successfully created table {db_schema}.{table_name}")
+            log_debug(f"Successfully created table {db_schema}.{table_name}")
             return table
 
         except Exception as e:
             log_error(f"Could not create table {db_schema}.{table_name}: {e}")
             raise
 
+    def _create_all_tables(self):
+        """Create all tables for the database."""
+        tables_to_create = [
+            (self.session_table_name, "sessions"),
+            (self.memory_table_name, "memories"),
+            (self.metrics_table_name, "metrics"),
+            (self.eval_table_name, "evals"),
+            (self.knowledge_table_name, "knowledge"),
+        ]
+
+        for table_name, table_type in tables_to_create:
+            self._create_table(table_name=table_name, table_type=table_type, db_schema=self.db_schema)
+
     def _get_table(self, table_type: str, create_table_if_not_found: Optional[bool] = False) -> Optional[Table]:
         if table_type == "sessions":
             self.session_table = self._get_or_create_table(

{agno-2.2.8 → agno-2.2.9}/agno/db/postgres/async_postgres.py

@@ -102,6 +102,31 @@ class AsyncPostgresDb(AsyncBaseDb):
         self.async_session_factory = async_sessionmaker(bind=self.db_engine)
 
     # -- DB methods --
+    async def table_exists(self, table_name: str) -> bool:
+        """Check if a table with the given name exists in the Postgres database.
+
+        Args:
+            table_name: Name of the table to check
+
+        Returns:
+            bool: True if the table exists in the database, False otherwise
+        """
+        async with self.async_session_factory() as sess:
+            return await ais_table_available(session=sess, table_name=table_name, db_schema=self.db_schema)
+
+    async def _create_all_tables(self):
+        """Create all tables for the database."""
+        tables_to_create = [
+            (self.session_table_name, "sessions"),
+            (self.memory_table_name, "memories"),
+            (self.metrics_table_name, "metrics"),
+            (self.eval_table_name, "evals"),
+            (self.knowledge_table_name, "knowledge"),
+        ]
+
+        for table_name, table_type in tables_to_create:
+            await self._create_table(table_name=table_name, table_type=table_type, db_schema=self.db_schema)
+
     async def _create_table(self, table_name: str, table_type: str, db_schema: str) -> Table:
         """
         Create a table with the appropriate schema based on the table type.
@@ -180,7 +205,7 @@ class AsyncPostgresDb(AsyncBaseDb):
                 except Exception as e:
                     log_error(f"Error creating index {idx.name}: {e}")
 
-            log_info(f"Successfully created table {table_name} in schema {db_schema}")
+            log_debug(f"Successfully created table {table_name} in schema {db_schema}")
             return table
 
         except Exception as e:

{agno-2.2.8 → agno-2.2.9}/agno/db/postgres/postgres.py

@@ -106,6 +106,31 @@ class PostgresDb(BaseDb):
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
 
     # -- DB methods --
+    def table_exists(self, table_name: str) -> bool:
+        """Check if a table with the given name exists in the Postgres database.
+
+        Args:
+            table_name: Name of the table to check
+
+        Returns:
+            bool: True if the table exists in the database, False otherwise
+        """
+        with self.Session() as sess:
+            return is_table_available(session=sess, table_name=table_name, db_schema=self.db_schema)
+
+    def _create_all_tables(self):
+        """Create all tables for the database."""
+        tables_to_create = [
+            (self.session_table_name, "sessions"),
+            (self.memory_table_name, "memories"),
+            (self.metrics_table_name, "metrics"),
+            (self.eval_table_name, "evals"),
+            (self.knowledge_table_name, "knowledge"),
+        ]
+
+        for table_name, table_type in tables_to_create:
+            self._create_table(table_name=table_name, table_type=table_type, db_schema=self.db_schema)
+
     def _create_table(self, table_name: str, table_type: str, db_schema: str) -> Table:
         """
         Create a table with the appropriate schema based on the table type.
@@ -184,7 +209,7 @@ class PostgresDb(BaseDb):
                 except Exception as e:
                     log_error(f"Error creating index {idx.name}: {e}")
 
-            log_info(f"Successfully created table {table_name} in schema {db_schema}")
+            log_debug(f"Successfully created table {table_name} in schema {db_schema}")
             return table
 
         except Exception as e:

{agno-2.2.8 → agno-2.2.9}/agno/db/redis/redis.py

@@ -100,6 +100,10 @@ class RedisDb(BaseDb):
 
     # -- DB methods --
 
+    def table_exists(self, table_name: str) -> bool:
+        """Redis implementation, always returns True."""
+        return True
+
     def _get_table_name(self, table_type: str) -> str:
         """Get the active table name for the given table type."""
         if table_type == "sessions":