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

agno/db/mongo/async_mongo.py

@@ -9,7 +9,7 @@ from agno.db.mongo.utils import (
     apply_sorting,
     bulk_upsert_metrics,
     calculate_date_metrics,
-    create_collection_indexes,
+    create_collection_indexes_async,
     deserialize_cultural_knowledge_from_db,
     fetch_all_sessions_data,
     get_dates_to_calculate_metrics_for,
@@ -167,9 +167,9 @@ class AsyncMongoDb(AsyncBaseDb):
 
             self._event_loop = current_loop
             self._database = None  # Reset database reference
-            # Clear collection caches when switching event loops
+            # Clear collection caches and initialization flags when switching event loops
             for attr in list(vars(self).keys()):
-                if attr.endswith("_collection"):
+                if attr.endswith("_collection") or attr.endswith("_initialized"):
                     delattr(self, attr)
 
         return self._client  # type: ignore
@@ -307,9 +307,8 @@ class AsyncMongoDb(AsyncBaseDb):
             if not hasattr(self, f"_{collection_name}_initialized"):
                 if not create_collection_if_not_found:
                     return None
-                # Note: Motor doesn't have sync create_index, so we use it as-is
-                # The indexes are created in the background
-                create_collection_indexes(collection, collection_type)  # type: ignore
+                # Create indexes asynchronously for Motor collections
+                await create_collection_indexes_async(collection, collection_type)
                 setattr(self, f"_{collection_name}_initialized", True)
                 log_debug(f"Initialized collection '{collection_name}'")
             else:
@@ -321,6 +320,14 @@ class AsyncMongoDb(AsyncBaseDb):
             log_error(f"Error getting collection {collection_name}: {e}")
             raise
 
+    def get_latest_schema_version(self):
+        """Get the latest version of the database schema."""
+        pass
+
+    def upsert_schema_version(self, version: str) -> None:
+        """Upsert the schema version into the database."""
+        pass
+
     # -- Session methods --
 
     async def delete_session(self, session_id: str) -> bool:
@@ -1241,6 +1248,9 @@ class AsyncMongoDb(AsyncBaseDb):
                     "memory_id": memory.memory_id,
                     "memory": memory.memory,
                     "topics": memory.topics,
+                    "input": memory.input,
+                    "feedback": memory.feedback,
+                    "created_at": memory.created_at,
                     "updated_at": updated_at,
                 }
 

agno/db/mongo/mongo.py

@@ -236,6 +236,14 @@ class MongoDb(BaseDb):
             log_error(f"Error getting collection {collection_name}: {e}")
             raise
 
+    def get_latest_schema_version(self):
+        """Get the latest version of the database schema."""
+        pass
+
+    def upsert_schema_version(self, version: str) -> None:
+        """Upsert the schema version into the database."""
+        pass
+
     # -- Session methods --
 
     def delete_session(self, session_id: str) -> bool:
@@ -1140,7 +1148,10 @@ class MongoDb(BaseDb):
                     "team_id": memory.team_id,
                     "memory_id": memory.memory_id,
                     "memory": memory.memory,
+                    "input": memory.input,
+                    "feedback": memory.feedback,
                     "topics": memory.topics,
+                    "created_at": memory.created_at,
                     "updated_at": updated_at,
                 }
 

agno/db/mongo/schemas.py

@@ -19,6 +19,9 @@ MEMORY_COLLECTION_SCHEMA = [
     {"key": "agent_id"},
     {"key": "team_id"},
     {"key": "topics"},
+    {"key": "input"},
+    {"key": "feedback"},
+    {"key": "created_at"},
     {"key": "updated_at"},
 ]
 

agno/db/mongo/utils.py

@@ -34,6 +34,23 @@ def create_collection_indexes(collection: Collection, collection_type: str) -> N
         log_warning(f"Error creating indexes for {collection_type} collection: {e}")
 
 
+async def create_collection_indexes_async(collection: Any, collection_type: str) -> None:
+    """Create all required indexes for a collection (async version for Motor)"""
+    try:
+        indexes = get_collection_indexes(collection_type)
+        for index_spec in indexes:
+            key = index_spec["key"]
+            unique = index_spec.get("unique", False)
+
+            if isinstance(key, list):
+                await collection.create_index(key, unique=unique)
+            else:
+                await collection.create_index([(key, 1)], unique=unique)
+
+    except Exception as e:
+        log_warning(f"Error creating indexes for {collection_type} collection: {e}")
+
+
 def apply_sorting(
     query_args: Dict[str, Any], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[tuple]:

agno/db/mysql/mysql.py

@@ -6,6 +6,7 @@ from uuid import uuid4
 from sqlalchemy import Index, UniqueConstraint
 
 from agno.db.base import BaseDb, SessionType
+from agno.db.migrations.manager import MigrationManager
 from agno.db.mysql.schemas import get_table_schema_definition
 from agno.db.mysql.utils import (
     apply_sorting,
@@ -50,6 +51,7 @@ class MySQLDb(BaseDb):
         metrics_table: Optional[str] = None,
         eval_table: Optional[str] = None,
         knowledge_table: Optional[str] = None,
+        versions_table: Optional[str] = None,
         id: Optional[str] = None,
     ):
         """
@@ -70,6 +72,7 @@ class MySQLDb(BaseDb):
             metrics_table (Optional[str]): Name of the table to store metrics.
             eval_table (Optional[str]): Name of the table to store evaluation runs data.
             knowledge_table (Optional[str]): Name of the table to store knowledge content.
+            versions_table (Optional[str]): Name of the table to store schema versions.
             id (Optional[str]): ID of the database.
 
         Raises:
@@ -90,6 +93,7 @@ class MySQLDb(BaseDb):
             metrics_table=metrics_table,
             eval_table=eval_table,
             knowledge_table=knowledge_table,
+            versions_table=versions_table,
         )
 
         _engine: Optional[Engine] = db_engine
@@ -218,9 +222,15 @@ class MySQLDb(BaseDb):
             (self.metrics_table_name, "metrics"),
             (self.eval_table_name, "evals"),
             (self.knowledge_table_name, "knowledge"),
+            (self.versions_table_name, "versions"),
         ]
 
         for table_name, table_type in tables_to_create:
+            if table_name != self.versions_table_name:
+                # Also store the schema version for the created table
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             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]:
@@ -278,6 +288,15 @@ class MySQLDb(BaseDb):
             )
             return self.culture_table
 
+        if table_type == "versions":
+            self.versions_table = self._get_or_create_table(
+                table_name=self.versions_table_name,
+                table_type="versions",
+                db_schema=self.db_schema,
+                create_table_if_not_found=create_table_if_not_found,
+            )
+            return self.versions_table
+
         raise ValueError(f"Unknown table type: {table_type}")
 
     def _get_or_create_table(
@@ -302,7 +321,14 @@ class MySQLDb(BaseDb):
             if not create_table_if_not_found:
                 return None
 
-            return self._create_table(table_name=table_name, table_type=table_type, db_schema=db_schema)
+            created_table = self._create_table(table_name=table_name, table_type=table_type, db_schema=db_schema)
+
+            if table_name != self.versions_table_name:
+                # Also store the schema version for the created table
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
+            return created_table
 
         if not is_valid_table(
             db_engine=self.db_engine,
@@ -321,6 +347,39 @@ class MySQLDb(BaseDb):
             log_error(f"Error loading existing table {db_schema}.{table_name}: {e}")
             raise
 
+    def get_latest_schema_version(self, table_name: str) -> str:
+        """Get the latest version of the database schema."""
+        table = self._get_table(table_type="versions", create_table_if_not_found=True)
+        with self.Session() as sess:
+            # Latest version for the given table
+            stmt = select(table).where(table.c.table_name == table_name).order_by(table.c.version.desc()).limit(1)  # type: ignore
+            result = sess.execute(stmt).fetchone()
+            if result is None:
+                return "2.0.0"
+            version_dict = dict(result._mapping)
+            return version_dict.get("version") or "2.0.0"
+
+    def upsert_schema_version(self, table_name: str, version: str) -> None:
+        """Upsert the schema version into the database."""
+        table = self._get_table(table_type="versions", create_table_if_not_found=True)
+        if table is None:
+            return
+        current_datetime = datetime.now().isoformat()
+        with self.Session() as sess, sess.begin():
+            stmt = mysql.insert(table).values(  # type: ignore
+                table_name=table_name,
+                version=version,
+                created_at=current_datetime,  # Store as ISO format string
+                updated_at=current_datetime,
+            )
+            # Update version if table_name already exists
+            stmt = stmt.on_duplicate_key_update(
+                version=version,
+                created_at=current_datetime,
+                updated_at=current_datetime,
+            )
+            sess.execute(stmt)
+
     # -- Session methods --
     def delete_session(self, session_id: str) -> bool:
         """
@@ -1287,6 +1346,8 @@ class MySQLDb(BaseDb):
                 if memory.memory_id is None:
                     memory.memory_id = str(uuid4())
 
+                current_time = int(time.time())
+
                 stmt = mysql.insert(table).values(
                     memory_id=memory.memory_id,
                     memory=memory.memory,
@@ -1295,7 +1356,9 @@ class MySQLDb(BaseDb):
                     agent_id=memory.agent_id,
                     team_id=memory.team_id,
                     topics=memory.topics,
-                    updated_at=int(time.time()),
+                    feedback=memory.feedback,
+                    created_at=memory.created_at,
+                    updated_at=memory.created_at,
                 )
                 stmt = stmt.on_duplicate_key_update(
                     memory=memory.memory,
@@ -1303,7 +1366,10 @@ class MySQLDb(BaseDb):
                     input=memory.input,
                     agent_id=memory.agent_id,
                     team_id=memory.team_id,
-                    updated_at=int(time.time()),
+                    feedback=memory.feedback,
+                    updated_at=current_time,
+                    # Preserve created_at on update - don't overwrite existing value
+                    created_at=table.c.created_at,
                 )
                 sess.execute(stmt)
 
@@ -1358,12 +1424,14 @@ class MySQLDb(BaseDb):
             # Prepare bulk data
             bulk_data = []
             current_time = int(time.time())
+
             for memory in memories:
                 if memory.memory_id is None:
                     memory.memory_id = str(uuid4())
 
                 # Use preserved updated_at if flag is set and value exists, otherwise use current time
                 updated_at = memory.updated_at if preserve_updated_at else current_time
+
                 bulk_data.append(
                     {
                         "memory_id": memory.memory_id,
@@ -1373,6 +1441,8 @@ class MySQLDb(BaseDb):
                         "agent_id": memory.agent_id,
                         "team_id": memory.team_id,
                         "topics": memory.topics,
+                        "feedback": memory.feedback,
+                        "created_at": memory.created_at,
                         "updated_at": updated_at,
                     }
                 )
@@ -1388,7 +1458,10 @@ class MySQLDb(BaseDb):
                     input=stmt.inserted.input,
                     agent_id=stmt.inserted.agent_id,
                     team_id=stmt.inserted.team_id,
+                    feedback=stmt.inserted.feedback,
                     updated_at=stmt.inserted.updated_at,
+                    # Preserve created_at on update
+                    created_at=table.c.created_at,
                 )
                 sess.execute(stmt, bulk_data)
 

agno/db/mysql/schemas.py

@@ -39,6 +39,8 @@ USER_MEMORY_TABLE_SCHEMA = {
     "team_id": {"type": lambda: String(128), "nullable": True},
     "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
     "topics": {"type": JSON, "nullable": True},
+    "feedback": {"type": Text, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
     "updated_at": {"type": BigInteger, "nullable": True, "index": True},
 }
 
@@ -76,20 +78,20 @@ KNOWLEDGE_TABLE_SCHEMA = {
 
 METRICS_TABLE_SCHEMA = {
     "id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
-    "agent_runs_count": {"type": BigInteger, "nullable": False},
-    "team_runs_count": {"type": BigInteger, "nullable": False},
-    "workflow_runs_count": {"type": BigInteger, "nullable": False},
-    "agent_sessions_count": {"type": BigInteger, "nullable": False},
-    "team_sessions_count": {"type": BigInteger, "nullable": False},
-    "workflow_sessions_count": {"type": BigInteger, "nullable": False},
-    "users_count": {"type": BigInteger, "nullable": False},
-    "token_metrics": {"type": JSON, "nullable": False},
-    "model_metrics": {"type": JSON, "nullable": False},
+    "agent_runs_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "team_runs_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "workflow_runs_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "agent_sessions_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "team_sessions_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "workflow_sessions_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "users_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "token_metrics": {"type": JSON, "nullable": False, "default": {}},
+    "model_metrics": {"type": JSON, "nullable": False, "default": {}},
     "date": {"type": Date, "nullable": False, "index": True},
     "aggregation_period": {"type": lambda: String(20), "nullable": False},
     "created_at": {"type": BigInteger, "nullable": False},
     "updated_at": {"type": BigInteger, "nullable": True},
-    "completed": {"type": Boolean, "nullable": False},
+    "completed": {"type": Boolean, "nullable": False, "default": False},
     "_unique_constraints": [
         {
             "name": "uq_metrics_date_period",
@@ -111,6 +113,13 @@ CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
     "team_id": {"type": lambda: String(128), "nullable": True},
 }
 
+VERSIONS_TABLE_SCHEMA = {
+    "table_name": {"type": lambda: String(128), "nullable": False, "primary_key": True},
+    "version": {"type": lambda: String(10), "nullable": False},
+    "created_at": {"type": lambda: String(128), "nullable": False, "index": True},
+    "updated_at": {"type": lambda: String(128), "nullable": True},
+}
+
 
 def get_table_schema_definition(table_type: str) -> dict[str, Any]:
     """
@@ -129,6 +138,7 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "memories": USER_MEMORY_TABLE_SCHEMA,
         "knowledge": KNOWLEDGE_TABLE_SCHEMA,
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
+        "versions": VERSIONS_TABLE_SCHEMA,
     }
 
     schema = schemas.get(table_type, {})

agno/db/postgres/async_postgres.py

@@ -1,9 +1,11 @@
 import time
+import warnings
 from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 from uuid import uuid4
 
 from agno.db.base import AsyncBaseDb, SessionType
+from agno.db.migrations.manager import MigrationManager
 from agno.db.postgres.schemas import get_table_schema_definition
 from agno.db.postgres.utils import (
     abulk_upsert_metrics,
@@ -47,6 +49,7 @@ class AsyncPostgresDb(AsyncBaseDb):
         eval_table: Optional[str] = None,
         knowledge_table: Optional[str] = None,
         culture_table: Optional[str] = None,
+        versions_table: Optional[str] = None,
         db_id: Optional[str] = None,  # Deprecated, use id instead.
     ):
         """
@@ -68,6 +71,7 @@ class AsyncPostgresDb(AsyncBaseDb):
             eval_table (Optional[str]): Name of the table to store evaluation runs data.
             knowledge_table (Optional[str]): Name of the table to store knowledge content.
             culture_table (Optional[str]): Name of the table to store cultural knowledge.
+            versions_table (Optional[str]): Name of the table to store schema versions.
             db_id: Deprecated, use id instead.
 
         Raises:
@@ -75,7 +79,11 @@ class AsyncPostgresDb(AsyncBaseDb):
             ValueError: If none of the tables are provided.
         """
         if db_id is not None:
-            log_warning("db_id is deprecated and will be removed in a future version, use id instead.")
+            warnings.warn(
+                "The 'db_id' parameter is deprecated and will be removed in future versions. Use 'id' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
 
         super().__init__(
             id=id or db_id,
@@ -85,6 +93,7 @@ class AsyncPostgresDb(AsyncBaseDb):
             eval_table=eval_table,
             knowledge_table=knowledge_table,
             culture_table=culture_table,
+            versions_table=versions_table,
         )
 
         _engine: Optional[AsyncEngine] = db_engine
@@ -122,9 +131,14 @@ class AsyncPostgresDb(AsyncBaseDb):
             (self.metrics_table_name, "metrics"),
             (self.eval_table_name, "evals"),
             (self.knowledge_table_name, "knowledge"),
+            (self.versions_table_name, "versions"),
         ]
 
         for table_name, table_type in tables_to_create:
+            # Also store the schema version for the created table
+            latest_schema_version = MigrationManager(self).latest_schema_version
+            await self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             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:
@@ -255,6 +269,13 @@ class AsyncPostgresDb(AsyncBaseDb):
                 )
             return self.culture_table
 
+        if table_type == "versions":
+            if not hasattr(self, "versions_table"):
+                self.versions_table = await self._get_or_create_table(
+                    table_name=self.versions_table_name, table_type="versions", db_schema=self.db_schema
+                )
+            return self.versions_table
+
         raise ValueError(f"Unknown table type: {table_type}")
 
     async def _get_or_create_table(self, table_name: str, table_type: str, db_schema: str) -> Table:
@@ -274,6 +295,11 @@ class AsyncPostgresDb(AsyncBaseDb):
             table_is_available = await ais_table_available(session=sess, table_name=table_name, db_schema=db_schema)
 
         if not table_is_available:
+            if table_name != self.versions_table_name:
+                # Also store the schema version for the created table
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                await self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             return await self._create_table(table_name=table_name, table_type=table_type, db_schema=db_schema)
 
         if not await ais_valid_table(
@@ -291,12 +317,52 @@ class AsyncPostgresDb(AsyncBaseDb):
                     return Table(table_name, self.metadata, schema=db_schema, autoload_with=connection)
 
                 table = await conn.run_sync(create_table)
+
                 return table
 
         except Exception as e:
             log_error(f"Error loading existing table {db_schema}.{table_name}: {e}")
             raise
 
+    async def get_latest_schema_version(self, table_name: str) -> str:
+        """Get the latest version of the database schema."""
+        table = await self._get_table(table_type="versions")
+        if table is None:
+            return "2.0.0"
+
+        async with self.async_session_factory() as sess:
+            stmt = select(table)
+            # Latest version for the given table
+            stmt = stmt.where(table.c.table_name == table_name)
+            stmt = stmt.order_by(table.c.version.desc()).limit(1)
+            result = await sess.execute(stmt)
+            row = result.fetchone()
+            if row is None:
+                return "2.0.0"
+
+            version_dict = dict(row._mapping)
+            return version_dict.get("version") or "2.0.0"
+
+    async def upsert_schema_version(self, table_name: str, version: str) -> None:
+        """Upsert the schema version into the database."""
+        table = await self._get_table(table_type="versions")
+        if table is None:
+            return
+        current_datetime = datetime.now().isoformat()
+        async with self.async_session_factory() as sess, sess.begin():
+            stmt = postgresql.insert(table).values(
+                table_name=table_name,
+                version=version,
+                created_at=current_datetime,  # Store as ISO format string
+                updated_at=current_datetime,
+            )
+            # Update version if table_name already exists
+            stmt = stmt.on_conflict_do_update(
+                index_elements=["table_name"],
+                set_=dict(version=version, updated_at=current_datetime),
+            )
+            await sess.execute(stmt)
+
     # -- Session methods --
     async def delete_session(self, session_id: str) -> bool:
         """
@@ -1231,36 +1297,44 @@ class AsyncPostgresDb(AsyncBaseDb):
         try:
             table = await self._get_table(table_type="memories")
 
-            async with self.async_session_factory() as sess, sess.begin():
-                if memory.memory_id is None:
-                    memory.memory_id = str(uuid4())
+            current_time = int(time.time())
 
-                stmt = postgresql.insert(table).values(
-                    memory_id=memory.memory_id,
-                    memory=memory.memory,
-                    input=memory.input,
-                    user_id=memory.user_id,
-                    agent_id=memory.agent_id,
-                    team_id=memory.team_id,
-                    topics=memory.topics,
-                    updated_at=int(time.time()),
-                )
-                stmt = stmt.on_conflict_do_update(  # type: ignore
-                    index_elements=["memory_id"],
-                    set_=dict(
+            async with self.async_session_factory() as sess:
+                async with sess.begin():
+                    if memory.memory_id is None:
+                        memory.memory_id = str(uuid4())
+
+                    stmt = postgresql.insert(table).values(
+                        memory_id=memory.memory_id,
                         memory=memory.memory,
-                        topics=memory.topics,
                         input=memory.input,
+                        user_id=memory.user_id,
                         agent_id=memory.agent_id,
                         team_id=memory.team_id,
-                        updated_at=int(time.time()),
-                    ),
-                ).returning(table)
+                        topics=memory.topics,
+                        feedback=memory.feedback,
+                        created_at=memory.created_at,
+                        updated_at=memory.created_at,
+                    )
+                    stmt = stmt.on_conflict_do_update(  # type: ignore
+                        index_elements=["memory_id"],
+                        set_=dict(
+                            memory=memory.memory,
+                            topics=memory.topics,
+                            input=memory.input,
+                            agent_id=memory.agent_id,
+                            team_id=memory.team_id,
+                            feedback=memory.feedback,
+                            updated_at=current_time,
+                            # Preserve created_at on update - don't overwrite existing value
+                            created_at=table.c.created_at,
+                        ),
+                    ).returning(table)
 
-                result = await sess.execute(stmt)
-                row = result.fetchone()
-                if row is None:
-                    return None
+                    result = await sess.execute(stmt)
+                    row = result.fetchone()
+                    if row is None:
+                        return None
 
             memory_raw = dict(row._mapping)