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

agno/db/postgres/postgres.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 from uuid import uuid4
 
 from agno.db.base import BaseDb, SessionType
+from agno.db.migrations.manager import MigrationManager
 from agno.db.postgres.schemas import get_table_schema_definition
 from agno.db.postgres.utils import (
     apply_sorting,
@@ -26,12 +27,12 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Index, String, UniqueConstraint, func, update
+    from sqlalchemy import Index, String, UniqueConstraint, func, select, update
     from sqlalchemy.dialects import postgresql
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
     from sqlalchemy.schema import Column, MetaData, Table
-    from sqlalchemy.sql.expression import select, text
+    from sqlalchemy.sql.expression import text
 except ImportError:
     raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
 
@@ -48,6 +49,7 @@ class PostgresDb(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,
     ):
         """
@@ -68,6 +70,7 @@ class PostgresDb(BaseDb):
             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.
             id (Optional[str]): ID of the database.
 
         Raises:
@@ -97,6 +100,7 @@ class PostgresDb(BaseDb):
             eval_table=eval_table,
             knowledge_table=knowledge_table,
             culture_table=culture_table,
+            versions_table=versions_table,
         )
 
         self.db_schema: str = db_schema if db_schema is not None else "ai"
@@ -126,9 +130,15 @@ class PostgresDb(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 _create_table(self, table_name: str, table_type: str, db_schema: str) -> Table:
@@ -271,6 +281,15 @@ class PostgresDb(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(
@@ -295,6 +314,11 @@ class PostgresDb(BaseDb):
             if not create_table_if_not_found:
                 return None
 
+            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 self._create_table(table_name=table_name, table_type=table_type, db_schema=db_schema)
 
         if not is_valid_table(
@@ -313,8 +337,43 @@ class PostgresDb(BaseDb):
             log_error(f"Error loading existing table {db_schema}.{table_name}: {e}")
             raise
 
-    # -- Session methods --
+    def get_latest_schema_version(self, table_name: str):
+        """Get the latest version of the database schema."""
+        table = self._get_table(table_type="versions", create_table_if_not_found=True)
+        if table is None:
+            return "2.0.0"
+        with self.Session() 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 = 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 = 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),
+            )
+            sess.execute(stmt)
 
+    # -- Session methods --
     def delete_session(self, session_id: str) -> bool:
         """
         Delete a session from the database.
@@ -1241,6 +1300,8 @@ class PostgresDb(BaseDb):
                 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,
@@ -1249,7 +1310,9 @@ class PostgresDb(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_conflict_do_update(  # type: ignore
                     index_elements=["memory_id"],
@@ -1259,7 +1322,10 @@ class PostgresDb(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,
                     ),
                 ).returning(table)
 
@@ -1313,6 +1379,7 @@ class PostgresDb(BaseDb):
 
                 # Use preserved updated_at if flag is set (even if None), otherwise use current time
                 updated_at = memory.updated_at if preserve_updated_at else current_time
+
                 memory_records.append(
                     {
                         "memory_id": memory.memory_id,
@@ -1322,6 +1389,8 @@ class PostgresDb(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,
                     }
                 )
@@ -1333,7 +1402,7 @@ class PostgresDb(BaseDb):
                 update_columns = {
                     col.name: insert_stmt.excluded[col.name]
                     for col in table.columns
-                    if col.name not in ["memory_id"]  # Don't update primary key
+                    if col.name not in ["memory_id", "created_at"]  # Don't update primary key or created_at
                 }
                 stmt = insert_stmt.on_conflict_do_update(index_elements=["memory_id"], set_=update_columns).returning(
                     table

agno/db/postgres/schemas.py

@@ -4,7 +4,7 @@ from typing import Any
 
 try:
     from sqlalchemy.dialects.postgresql import JSONB
-    from sqlalchemy.types import JSON, BigInteger, Boolean, Date, String
+    from sqlalchemy.types import BigInteger, Boolean, Date, String, Text
 except ImportError:
     raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
 
@@ -15,13 +15,13 @@ SESSION_TABLE_SCHEMA = {
     "team_id": {"type": String, "nullable": True},
     "workflow_id": {"type": String, "nullable": True},
     "user_id": {"type": String, "nullable": True},
-    "session_data": {"type": JSON, "nullable": True},
-    "agent_data": {"type": JSON, "nullable": True},
-    "team_data": {"type": JSON, "nullable": True},
-    "workflow_data": {"type": JSON, "nullable": True},
-    "metadata": {"type": JSON, "nullable": True},
-    "runs": {"type": JSON, "nullable": True},
-    "summary": {"type": JSON, "nullable": True},
+    "session_data": {"type": JSONB, "nullable": True},
+    "agent_data": {"type": JSONB, "nullable": True},
+    "team_data": {"type": JSONB, "nullable": True},
+    "workflow_data": {"type": JSONB, "nullable": True},
+    "metadata": {"type": JSONB, "nullable": True},
+    "runs": {"type": JSONB, "nullable": True},
+    "summary": {"type": JSONB, "nullable": True},
     "created_at": {"type": BigInteger, "nullable": False, "index": True},
     "updated_at": {"type": BigInteger, "nullable": True},
     "_unique_constraints": [
@@ -34,20 +34,22 @@ SESSION_TABLE_SCHEMA = {
 
 MEMORY_TABLE_SCHEMA = {
     "memory_id": {"type": String, "primary_key": True, "nullable": False},
-    "memory": {"type": JSON, "nullable": False},
-    "input": {"type": String, "nullable": True},
+    "memory": {"type": JSONB, "nullable": False},
+    "feedback": {"type": Text, "nullable": True},
+    "input": {"type": Text, "nullable": True},
     "agent_id": {"type": String, "nullable": True},
     "team_id": {"type": String, "nullable": True},
     "user_id": {"type": String, "nullable": True, "index": True},
-    "topics": {"type": JSON, "nullable": True},
+    "topics": {"type": JSONB, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
     "updated_at": {"type": BigInteger, "nullable": True, "index": True},
 }
 
 EVAL_TABLE_SCHEMA = {
     "run_id": {"type": String, "primary_key": True, "nullable": False},
     "eval_type": {"type": String, "nullable": False},
-    "eval_data": {"type": JSON, "nullable": False},
-    "eval_input": {"type": JSON, "nullable": False},
+    "eval_data": {"type": JSONB, "nullable": False},
+    "eval_input": {"type": JSONB, "nullable": False},
     "name": {"type": String, "nullable": True},
     "agent_id": {"type": String, "nullable": True},
     "team_id": {"type": String, "nullable": True},
@@ -62,14 +64,14 @@ EVAL_TABLE_SCHEMA = {
 KNOWLEDGE_TABLE_SCHEMA = {
     "id": {"type": String, "primary_key": True, "nullable": False},
     "name": {"type": String, "nullable": False},
-    "description": {"type": String, "nullable": False},
-    "metadata": {"type": JSON, "nullable": True},
+    "description": {"type": Text, "nullable": False},
+    "metadata": {"type": JSONB, "nullable": True},
     "type": {"type": String, "nullable": True},
     "size": {"type": BigInteger, "nullable": True},
     "linked_to": {"type": String, "nullable": True},
     "access_count": {"type": BigInteger, "nullable": True},
     "status": {"type": String, "nullable": True},
-    "status_message": {"type": String, "nullable": True},
+    "status_message": {"type": Text, "nullable": True},
     "created_at": {"type": BigInteger, "nullable": True},
     "updated_at": {"type": BigInteger, "nullable": True},
     "external_id": {"type": String, "nullable": True},
@@ -84,8 +86,8 @@ METRICS_TABLE_SCHEMA = {
     "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": {}},
+    "token_metrics": {"type": JSONB, "nullable": False, "default": {}},
+    "model_metrics": {"type": JSONB, "nullable": False, "default": {}},
     "date": {"type": Date, "nullable": False, "index": True},
     "aggregation_period": {"type": String, "nullable": False},
     "created_at": {"type": BigInteger, "nullable": False},
@@ -102,16 +104,23 @@ METRICS_TABLE_SCHEMA = {
 CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
     "id": {"type": String, "primary_key": True, "nullable": False},
     "name": {"type": String, "nullable": False, "index": True},
-    "summary": {"type": String, "nullable": True},
+    "summary": {"type": Text, "nullable": True},
     "content": {"type": JSONB, "nullable": True},
     "metadata": {"type": JSONB, "nullable": True},
-    "input": {"type": String, "nullable": True},
+    "input": {"type": Text, "nullable": True},
     "created_at": {"type": BigInteger, "nullable": True},
     "updated_at": {"type": BigInteger, "nullable": True},
     "agent_id": {"type": String, "nullable": True},
     "team_id": {"type": String, "nullable": True},
 }
 
+VERSIONS_TABLE_SCHEMA = {
+    "table_name": {"type": String, "nullable": False, "primary_key": True},
+    "version": {"type": String, "nullable": False},
+    "created_at": {"type": String, "nullable": False, "index": True},
+    "updated_at": {"type": String, "nullable": True},
+}
+
 
 def get_table_schema_definition(table_type: str) -> dict[str, Any]:
     """
@@ -130,6 +139,7 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "memories": MEMORY_TABLE_SCHEMA,
         "knowledge": KNOWLEDGE_TABLE_SCHEMA,
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
+        "versions": VERSIONS_TABLE_SCHEMA,
     }
 
     schema = schemas.get(table_type, {})

agno/db/redis/redis.py

@@ -29,7 +29,7 @@ from agno.utils.log import log_debug, log_error, log_info
 from agno.utils.string import generate_id
 
 try:
-    from redis import Redis
+    from redis import Redis, RedisCluster
 except ImportError:
     raise ImportError("`redis` not installed. Please install it using `pip install redis`")
 
@@ -38,7 +38,7 @@ class RedisDb(BaseDb):
     def __init__(
         self,
         id: Optional[str] = None,
-        redis_client: Optional[Redis] = None,
+        redis_client: Optional[Union[Redis, RedisCluster]] = None,
         db_url: Optional[str] = None,
         db_prefix: str = "agno",
         expire: Optional[int] = None,
@@ -57,6 +57,8 @@ class RedisDb(BaseDb):
             2. Use the db_url
             3. Raise an error if neither is provided
 
+        db_url only supports single-node Redis connections, if you need Redis Cluster support, provide a redis_client.
+
         Args:
             id (Optional[str]): The ID of the database.
             redis_client (Optional[Redis]): Redis client instance to use. If not provided a new client will be created.
@@ -252,6 +254,14 @@ class RedisDb(BaseDb):
             log_error(f"Error getting all records for {table_type}: {e}")
             return []
 
+    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:
@@ -903,6 +913,9 @@ class RedisDb(BaseDb):
                 "memory_id": memory.memory_id,
                 "memory": memory.memory,
                 "topics": memory.topics,
+                "input": memory.input,
+                "feedback": memory.feedback,
+                "created_at": memory.created_at,
                 "updated_at": int(time.time()),
             }
 

agno/db/redis/schemas.py

@@ -27,6 +27,9 @@ USER_MEMORY_SCHEMA = {
     "team_id": {"type": "string"},
     "user_id": {"type": "string"},
     "topics": {"type": "json"},
+    "input": {"type": "string"},
+    "feedback": {"type": "string"},
+    "created_at": {"type": "integer"},
     "updated_at": {"type": "integer"},
 }
 
@@ -114,6 +117,7 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "metrics": METRICS_SCHEMA,
         "evals": EVAL_SCHEMA,
         "knowledge": KNOWLEDGE_SCHEMA,
+        "culture": CULTURAL_KNOWLEDGE_SCHEMA,
     }
 
     schema = schemas.get(table_type, {})

agno/db/schemas/memory.py

@@ -12,17 +12,24 @@ class UserMemory:
     topics: Optional[List[str]] = None
     user_id: Optional[str] = None
     input: Optional[str] = None
+    created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
     feedback: Optional[str] = None
 
     agent_id: Optional[str] = None
     team_id: Optional[str] = None
 
+    def __post_init__(self) -> None:
+        """Automatically set created_at if not provided."""
+        if self.created_at is None:
+            self.created_at = datetime.now(timezone.utc)
+
     def to_dict(self) -> Dict[str, Any]:
         _dict = {
             "memory_id": self.memory_id,
             "memory": self.memory,
             "topics": self.topics,
+            "created_at": self.created_at.isoformat() if self.created_at else None,
             "updated_at": self.updated_at.isoformat() if self.updated_at else None,
             "input": self.input,
             "user_id": self.user_id,
@@ -36,6 +43,12 @@ class UserMemory:
     def from_dict(cls, data: Dict[str, Any]) -> "UserMemory":
         data = dict(data)
 
+        if created_at := data.get("created_at"):
+            if isinstance(created_at, (int, float)):
+                data["created_at"] = datetime.fromtimestamp(created_at, tz=timezone.utc)
+            else:
+                data["created_at"] = datetime.fromisoformat(created_at)
+
         # Convert updated_at to datetime
         if updated_at := data.get("updated_at"):
             if isinstance(updated_at, (int, float)):

agno/db/singlestore/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},
 }
 
@@ -106,6 +108,14 @@ CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
 }
 
 
+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]:
     """
     Get the expected schema definition for the given table.
@@ -121,6 +131,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/singlestore/singlestore.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from uuid import uuid4
 
 from agno.db.base import BaseDb, SessionType
+from agno.db.migrations.manager import MigrationManager
 from agno.db.schemas.culture import CulturalKnowledge
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
@@ -27,12 +28,12 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Index, UniqueConstraint, and_, func, update
+    from sqlalchemy import Index, UniqueConstraint, and_, func, select, update
     from sqlalchemy.dialects import mysql
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
     from sqlalchemy.schema import Column, MetaData, Table
-    from sqlalchemy.sql.expression import select, text
+    from sqlalchemy.sql.expression import text
 except ImportError:
     raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
 
@@ -50,6 +51,7 @@ class SingleStoreDb(BaseDb):
         metrics_table: Optional[str] = None,
         eval_table: Optional[str] = None,
         knowledge_table: Optional[str] = None,
+        versions_table: Optional[str] = None,
     ):
         """
         Interface for interacting with a SingleStore database.
@@ -70,7 +72,7 @@ class SingleStoreDb(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.
         Raises:
             ValueError: If neither db_url nor db_engine is provided.
             ValueError: If none of the tables are provided.
@@ -89,6 +91,7 @@ class SingleStoreDb(BaseDb):
             metrics_table=metrics_table,
             eval_table=eval_table,
             knowledge_table=knowledge_table,
+            versions_table=versions_table,
         )
 
         _engine: Optional[Engine] = db_engine
@@ -176,9 +179,15 @@ class SingleStoreDb(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 _create_table(self, table_name: str, table_type: str, db_schema: Optional[str]) -> Table:
@@ -355,8 +364,53 @@ class SingleStoreDb(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_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)
+        if table is None:
+            return "2.0.0"
+        with self.Session() 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 = 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(
+                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,
+                updated_at=current_datetime,
+            )
+            sess.execute(stmt)
+
     def _get_or_create_table(
         self,
         table_name: str,
@@ -382,6 +436,12 @@ class SingleStoreDb(BaseDb):
         if not table_is_available:
             if not create_table_if_not_found:
                 return None
+
+            # Also store the schema version for the created table
+            if table_name != self.versions_table_name:
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             return self._create_table(table_name=table_name, table_type=table_type, db_schema=db_schema)
 
         if not is_valid_table(
@@ -1339,6 +1399,8 @@ class SingleStoreDb(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,
@@ -1347,7 +1409,9 @@ class SingleStoreDb(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=current_time,
                 )
                 stmt = stmt.on_duplicate_key_update(
                     memory=stmt.inserted.memory,
@@ -1356,7 +1420,10 @@ class SingleStoreDb(BaseDb):
                     user_id=stmt.inserted.user_id,
                     agent_id=stmt.inserted.agent_id,
                     team_id=stmt.inserted.team_id,
-                    updated_at=int(time.time()),
+                    feedback=stmt.inserted.feedback,
+                    updated_at=stmt.inserted.updated_at,
+                    # Preserve created_at on update - don't overwrite existing value
+                    created_at=table.c.created_at,
                 )
 
                 sess.execute(stmt)
@@ -1404,11 +1471,13 @@ class SingleStoreDb(BaseDb):
             # Prepare data for bulk insert
             memory_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, otherwise use current time
                 updated_at = memory.updated_at if preserve_updated_at else current_time
+
                 memory_data.append(
                     {
                         "memory_id": memory.memory_id,
@@ -1418,6 +1487,8 @@ class SingleStoreDb(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,
                     }
                 )
@@ -1434,7 +1505,10 @@ class SingleStoreDb(BaseDb):
                         user_id=stmt.inserted.user_id,
                         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, memory_data)