agno 2.3.2__py3-none-any.whl → 2.3.4__py3-none-any.whl

agno/db/singlestore/singlestore.py

@@ -109,7 +109,7 @@ class SingleStoreDb(BaseDb):
         self.db_url: Optional[str] = db_url
         self.db_engine: Engine = _engine
         self.db_schema: Optional[str] = db_schema
-        self.metadata: MetaData = MetaData()
+        self.metadata: MetaData = MetaData(schema=self.db_schema)
 
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
@@ -127,7 +127,7 @@ class SingleStoreDb(BaseDb):
         with self.Session() as sess:
             return is_table_available(session=sess, table_name=table_name, db_schema=self.db_schema)
 
-    def _create_table_structure_only(self, table_name: str, table_type: str, db_schema: Optional[str]) -> Table:
+    def _create_table_structure_only(self, table_name: str, table_type: str) -> Table:
         """
         Create a table structure definition without actually creating the table in the database.
         Used to avoid autoload issues with SingleStore JSON types.
@@ -135,7 +135,6 @@ class SingleStoreDb(BaseDb):
         Args:
             table_name (str): Name of the table
             table_type (str): Type of table (used to get schema definition)
-            db_schema (Optional[str]): Database schema name
 
         Returns:
             Table: SQLAlchemy Table object with column definitions
@@ -161,13 +160,12 @@ class SingleStoreDb(BaseDb):
                 columns.append(Column(*column_args, **column_kwargs))
 
             # Create the table object without constraints to avoid autoload issues
-            table_metadata = MetaData(schema=db_schema)
-            table = Table(table_name, table_metadata, *columns, schema=db_schema)
+            table = Table(table_name, self.metadata, *columns, schema=self.db_schema)
 
             return table
 
         except Exception as e:
-            table_ref = f"{db_schema}.{table_name}" if db_schema else table_name
+            table_ref = f"{self.db_schema}.{table_name}" if self.db_schema else table_name
             log_error(f"Could not create table structure for {table_ref}: {e}")
             raise
 
@@ -183,31 +181,23 @@ class SingleStoreDb(BaseDb):
         ]
 
         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._get_or_create_table(table_name=table_name, table_type=table_type, create_table_if_not_found=True)
 
-            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:
+    def _create_table(self, table_name: str, table_type: str) -> Table:
         """
         Create a table with the appropriate schema based on the table type.
 
         Args:
             table_name (str): Name of the table to create
             table_type (str): Type of table (used to get schema definition)
-            db_schema (Optional[str]): Database schema name
 
         Returns:
             Table: SQLAlchemy Table object
         """
-        table_ref = f"{db_schema}.{table_name}" if db_schema else table_name
+        table_ref = f"{self.db_schema}.{table_name}" if self.db_schema else table_name
         try:
             table_schema = get_table_schema_definition(table_type)
 
-            log_debug(f"Creating table {table_ref}")
-
             columns: List[Column] = []
             indexes: List[str] = []
             unique_constraints: List[str] = []
@@ -229,8 +219,7 @@ class SingleStoreDb(BaseDb):
                 columns.append(Column(*column_args, **column_kwargs))
 
             # Create the table object
-            table_metadata = MetaData(schema=db_schema)
-            table = Table(table_name, table_metadata, *columns, schema=db_schema)
+            table = Table(table_name, self.metadata, *columns, schema=self.db_schema)
 
             # Add multi-column unique constraints with table-specific names
             for constraint in schema_unique_constraints:
@@ -244,48 +233,52 @@ class SingleStoreDb(BaseDb):
                 table.append_constraint(Index(idx_name, idx_col))
 
             # Create schema if one is specified
-            if db_schema is not None:
+            if self.db_schema is not None:
                 with self.Session() as sess, sess.begin():
-                    create_schema(session=sess, db_schema=db_schema)
+                    create_schema(session=sess, db_schema=self.db_schema)
 
             # SingleStore has a limitation on the number of unique multi-field constraints per table.
             # We need to work around that limitation for the sessions table.
-            if table_type == "sessions":
-                with self.Session() as sess, sess.begin():
-                    # Build column definitions
-                    columns_sql = []
-                    for col in table.columns:
-                        col_sql = f"{col.name} {col.type.compile(self.db_engine.dialect)}"
-                        if not col.nullable:
-                            col_sql += " NOT NULL"
-                        columns_sql.append(col_sql)
-
-                    columns_def = ", ".join(columns_sql)
-
-                    # Add shard key and single unique constraint
-                    table_sql = f"""CREATE TABLE IF NOT EXISTS {table_ref} (
-                        {columns_def},
-                        SHARD KEY (session_id),
-                        UNIQUE KEY uq_session_type (session_id, session_type)
-                    )"""
-
-                    sess.execute(text(table_sql))
+            table_created = False
+            if not self.table_exists(table_name):
+                if table_type == "sessions":
+                    with self.Session() as sess, sess.begin():
+                        # Build column definitions
+                        columns_sql = []
+                        for col in table.columns:
+                            col_sql = f"{col.name} {col.type.compile(self.db_engine.dialect)}"
+                            if not col.nullable:
+                                col_sql += " NOT NULL"
+                            columns_sql.append(col_sql)
+
+                        columns_def = ", ".join(columns_sql)
+
+                        # Add shard key and single unique constraint
+                        table_sql = f"""CREATE TABLE IF NOT EXISTS {table_ref} (
+                            {columns_def},
+                            SHARD KEY (session_id),
+                            UNIQUE KEY uq_session_type (session_id, session_type)
+                        )"""
+
+                        sess.execute(text(table_sql))
+                else:
+                    table.create(self.db_engine, checkfirst=True)
+                log_debug(f"Successfully created table '{table_ref}'")
+                table_created = True
             else:
-                table.create(self.db_engine, checkfirst=True)
+                log_debug(f"Table '{table_ref}' already exists, skipping creation")
 
             # Create indexes
             for idx in table.indexes:
                 try:
-                    log_debug(f"Creating index: {idx.name}")
-
                     # Check if index already exists
                     with self.Session() as sess:
-                        if db_schema is not None:
+                        if self.db_schema is not None:
                             exists_query = text(
                                 "SELECT 1 FROM information_schema.statistics WHERE table_schema = :schema AND index_name = :index_name"
                             )
                             exists = (
-                                sess.execute(exists_query, {"schema": db_schema, "index_name": idx.name}).scalar()
+                                sess.execute(exists_query, {"schema": self.db_schema, "index_name": idx.name}).scalar()
                                 is not None
                             )
                         else:
@@ -299,10 +292,15 @@ class SingleStoreDb(BaseDb):
 
                     idx.create(self.db_engine)
 
+                    log_debug(f"Created index: {idx.name} for table {table_ref}")
                 except Exception as e:
                     log_error(f"Error creating index {idx.name}: {e}")
 
-            log_debug(f"Successfully created table {table_ref}")
+            # Store the schema version for the created table
+            if table_name != self.versions_table_name and table_created:
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             return table
 
         except Exception as e:
@@ -314,7 +312,6 @@ class SingleStoreDb(BaseDb):
             self.session_table = self._get_or_create_table(
                 table_name=self.session_table_name,
                 table_type="sessions",
-                db_schema=self.db_schema,
                 create_table_if_not_found=create_table_if_not_found,
             )
             return self.session_table
@@ -323,7 +320,6 @@ class SingleStoreDb(BaseDb):
             self.memory_table = self._get_or_create_table(
                 table_name=self.memory_table_name,
                 table_type="memories",
-                db_schema=self.db_schema,
                 create_table_if_not_found=create_table_if_not_found,
             )
             return self.memory_table
@@ -332,7 +328,6 @@ class SingleStoreDb(BaseDb):
             self.metrics_table = self._get_or_create_table(
                 table_name=self.metrics_table_name,
                 table_type="metrics",
-                db_schema=self.db_schema,
                 create_table_if_not_found=create_table_if_not_found,
             )
             return self.metrics_table
@@ -341,7 +336,6 @@ class SingleStoreDb(BaseDb):
             self.eval_table = self._get_or_create_table(
                 table_name=self.eval_table_name,
                 table_type="evals",
-                db_schema=self.db_schema,
                 create_table_if_not_found=create_table_if_not_found,
             )
             return self.eval_table
@@ -350,7 +344,6 @@ class SingleStoreDb(BaseDb):
             self.knowledge_table = self._get_or_create_table(
                 table_name=self.knowledge_table_name,
                 table_type="knowledge",
-                db_schema=self.db_schema,
                 create_table_if_not_found=create_table_if_not_found,
             )
             return self.knowledge_table
@@ -359,7 +352,6 @@ class SingleStoreDb(BaseDb):
             self.culture_table = self._get_or_create_table(
                 table_name=self.culture_table_name,
                 table_type="culture",
-                db_schema=self.db_schema,
                 create_table_if_not_found=create_table_if_not_found,
             )
             return self.culture_table
@@ -368,54 +360,16 @@ class SingleStoreDb(BaseDb):
             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,
         table_type: str,
-        db_schema: Optional[str],
         create_table_if_not_found: Optional[bool] = False,
     ) -> Optional[Table]:
         """
@@ -424,14 +378,13 @@ class SingleStoreDb(BaseDb):
         Args:
             table_name (str): Name of the table to get or create
             table_type (str): Type of table (used to get schema definition)
-            db_schema (Optional[str]): Database schema name
 
         Returns:
             Table: SQLAlchemy Table object representing the schema.
         """
 
         with self.Session() as sess, sess.begin():
-            table_is_available = is_table_available(session=sess, table_name=table_name, db_schema=db_schema)
+            table_is_available = is_table_available(session=sess, table_name=table_name, db_schema=self.db_schema)
 
         if not table_is_available:
             if not create_table_if_not_found:
@@ -442,25 +395,61 @@ class SingleStoreDb(BaseDb):
                 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)
+            return self._create_table(table_name=table_name, table_type=table_type)
 
         if not is_valid_table(
             db_engine=self.db_engine,
             table_name=table_name,
             table_type=table_type,
-            db_schema=db_schema,
+            db_schema=self.db_schema,
         ):
-            table_ref = f"{db_schema}.{table_name}" if db_schema else table_name
+            table_ref = f"{self.db_schema}.{table_name}" if self.db_schema else table_name
             raise ValueError(f"Table {table_ref} has an invalid schema")
 
         try:
-            return self._create_table_structure_only(table_name=table_name, table_type=table_type, db_schema=db_schema)
+            return self._create_table_structure_only(table_name=table_name, table_type=table_type)
 
         except Exception as e:
-            table_ref = f"{db_schema}.{table_name}" if db_schema else table_name
+            table_ref = f"{self.db_schema}.{table_name}" if self.db_schema else table_name
             log_error(f"Error loading existing table {table_ref}: {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)
+        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)
+
     # -- Session methods --
     def delete_session(self, session_id: str) -> bool:
         """
@@ -1307,13 +1296,14 @@ class SingleStoreDb(BaseDb):
             raise e
 
     def get_user_memory_stats(
-        self, limit: Optional[int] = None, page: Optional[int] = None
+        self, limit: Optional[int] = None, page: Optional[int] = None, user_id: Optional[str] = None
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memories stats.
 
         Args:
             limit (Optional[int]): The maximum number of user stats to return.
             page (Optional[int]): The page number.
+            user_id (Optional[str]): User ID for filtering.
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: A list of dictionaries containing user stats and total count.
@@ -1336,16 +1326,17 @@ class SingleStoreDb(BaseDb):
                 return [], 0
 
             with self.Session() as sess, sess.begin():
-                stmt = (
-                    select(
-                        table.c.user_id,
-                        func.count(table.c.memory_id).label("total_memories"),
-                        func.max(table.c.updated_at).label("last_memory_updated_at"),
-                    )
-                    .where(table.c.user_id.is_not(None))
-                    .group_by(table.c.user_id)
-                    .order_by(func.max(table.c.updated_at).desc())
+                stmt = select(
+                    table.c.user_id,
+                    func.count(table.c.memory_id).label("total_memories"),
+                    func.max(table.c.updated_at).label("last_memory_updated_at"),
                 )
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
+                else:
+                    stmt = stmt.where(table.c.user_id.is_not(None))
+                stmt = stmt.group_by(table.c.user_id)
+                stmt = stmt.order_by(func.max(table.c.updated_at).desc())
 
                 count_stmt = select(func.count()).select_from(stmt.alias())
                 total_count = sess.execute(count_stmt).scalar()

agno/db/sqlite/async_sqlite.py

@@ -140,12 +140,7 @@ class AsyncSqliteDb(AsyncBaseDb):
         ]
 
         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
-                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)
+            await self._get_or_create_table(table_name=table_name, table_type=table_type)
 
     async def _create_table(self, table_name: str, table_type: str) -> Table:
         """
@@ -160,7 +155,6 @@ class AsyncSqliteDb(AsyncBaseDb):
         """
         try:
             table_schema = get_table_schema_definition(table_type)
-            log_debug(f"Creating table {table_name}")
 
             columns: List[Column] = []
             indexes: List[str] = []
@@ -185,8 +179,7 @@ class AsyncSqliteDb(AsyncBaseDb):
                 columns.append(Column(*column_args, **column_kwargs))  # type: ignore
 
             # Create the table object
-            table_metadata = MetaData()
-            table = Table(table_name, table_metadata, *columns)
+            table = Table(table_name, self.metadata, *columns)
 
             # Add multi-column unique constraints with table-specific names
             for constraint in schema_unique_constraints:
@@ -200,13 +193,18 @@ class AsyncSqliteDb(AsyncBaseDb):
                 table.append_constraint(Index(idx_name, idx_col))
 
             # Create table
-            async with self.db_engine.begin() as conn:
-                await conn.run_sync(table.create, checkfirst=True)
+            table_created = False
+            if not await self.table_exists(table_name):
+                async with self.db_engine.begin() as conn:
+                    await conn.run_sync(table.create, checkfirst=True)
+                log_debug(f"Successfully created table '{table_name}'")
+                table_created = True
+            else:
+                log_debug(f"Table {table_name} already exists, skipping creation")
 
             # Create indexes
             for idx in table.indexes:
                 try:
-                    log_debug(f"Creating index: {idx.name}")
                     # Check if index already exists
                     async with self.async_session_factory() as sess:
                         exists_query = text("SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = :index_name")
@@ -218,11 +216,16 @@ class AsyncSqliteDb(AsyncBaseDb):
 
                     async with self.db_engine.begin() as conn:
                         await conn.run_sync(idx.create)
+                    log_debug(f"Created index: {idx.name} for table {table_name}")
 
                 except Exception as e:
                     log_warning(f"Error creating index {idx.name}: {e}")
 
-            log_debug(f"Successfully created table '{table_name}'")
+            # Store the schema version for the created table
+            if table_name != self.versions_table_name and table_created:
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                await self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             return table
 
         except Exception as e:
@@ -308,11 +311,6 @@ class AsyncSqliteDb(AsyncBaseDb):
             table_is_available = await ais_table_available(session=sess, table_name=table_name)
 
         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)
 
         # SQLite version of table validation (no schema)
@@ -1218,12 +1216,14 @@ class AsyncSqliteDb(AsyncBaseDb):
         self,
         limit: Optional[int] = None,
         page: Optional[int] = None,
+        user_id: Optional[str] = None,
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memories stats.
 
         Args:
             limit (Optional[int]): The maximum number of user stats to return.
             page (Optional[int]): The page number.
+            user_id (Optional[str]): User ID for filtering.
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: A list of dictionaries containing user stats and total count.
@@ -1246,17 +1246,19 @@ class AsyncSqliteDb(AsyncBaseDb):
                 return [], 0
 
             async with self.async_session_factory() as sess, sess.begin():
-                stmt = (
-                    select(
-                        table.c.user_id,
-                        func.count(table.c.memory_id).label("total_memories"),
-                        func.max(table.c.updated_at).label("last_memory_updated_at"),
-                    )
-                    .where(table.c.user_id.is_not(None))
-                    .group_by(table.c.user_id)
-                    .order_by(func.max(table.c.updated_at).desc())
+                stmt = select(
+                    table.c.user_id,
+                    func.count(table.c.memory_id).label("total_memories"),
+                    func.max(table.c.updated_at).label("last_memory_updated_at"),
                 )
 
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
+                else:
+                    stmt = stmt.where(table.c.user_id.is_not(None))
+                stmt = stmt.group_by(table.c.user_id)
+                stmt = stmt.order_by(func.max(table.c.updated_at).desc())
+
                 count_stmt = select(func.count()).select_from(stmt.alias())
                 total_count = (await sess.execute(count_stmt)).scalar() or 0
 

agno/db/sqlite/sqlite.py

@@ -141,12 +141,7 @@ class SqliteDb(BaseDb):
         ]
 
         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)
+            self._get_or_create_table(table_name=table_name, table_type=table_type, create_table_if_not_found=True)
 
     def _create_table(self, table_name: str, table_type: str) -> Table:
         """
@@ -161,7 +156,6 @@ class SqliteDb(BaseDb):
         """
         try:
             table_schema = get_table_schema_definition(table_type)
-            log_debug(f"Creating table {table_name}")
 
             columns: List[Column] = []
             indexes: List[str] = []
@@ -186,8 +180,7 @@ class SqliteDb(BaseDb):
                 columns.append(Column(*column_args, **column_kwargs))  # type: ignore
 
             # Create the table object
-            table_metadata = MetaData()
-            table = Table(table_name, table_metadata, *columns)
+            table = Table(table_name, self.metadata, *columns)
 
             # Add multi-column unique constraints with table-specific names
             for constraint in schema_unique_constraints:
@@ -201,12 +194,17 @@ class SqliteDb(BaseDb):
                 table.append_constraint(Index(idx_name, idx_col))
 
             # Create table
-            table.create(self.db_engine, checkfirst=True)
+            table_created = False
+            if not self.table_exists(table_name):
+                table.create(self.db_engine, checkfirst=True)
+                log_debug(f"Successfully created table '{table_name}'")
+                table_created = True
+            else:
+                log_debug(f"Table '{table_name}' already exists, skipping creation")
 
             # Create indexes
             for idx in table.indexes:
                 try:
-                    log_debug(f"Creating index: {idx.name}")
                     # Check if index already exists
                     with self.Session() as sess:
                         exists_query = text("SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = :index_name")
@@ -217,13 +215,21 @@ class SqliteDb(BaseDb):
 
                     idx.create(self.db_engine)
 
+                    log_debug(f"Created index: {idx.name} for table {table_name}")
                 except Exception as e:
                     log_warning(f"Error creating index {idx.name}: {e}")
 
-            log_debug(f"Successfully created table '{table_name}'")
+            # Store the schema version for the created table
+            if table_name != self.versions_table_name and table_created:
+                latest_schema_version = MigrationManager(self).latest_schema_version
+                self.upsert_schema_version(table_name=table_name, version=latest_schema_version.public)
+
             return table
 
         except Exception as e:
+            from traceback import format_exc
+
+            print(format_exc())
             log_error(f"Could not create table '{table_name}': {e}")
             raise e
 
@@ -311,11 +317,6 @@ class SqliteDb(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)
 
         # SQLite version of table validation (no schema)
@@ -1212,12 +1213,14 @@ class SqliteDb(BaseDb):
         self,
         limit: Optional[int] = None,
         page: Optional[int] = None,
+        user_id: Optional[str] = None,
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memories stats.
 
         Args:
             limit (Optional[int]): The maximum number of user stats to return.
             page (Optional[int]): The page number.
+            user_id (Optional[str]): User ID for filtering.
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: A list of dictionaries containing user stats and total count.
@@ -1240,16 +1243,17 @@ class SqliteDb(BaseDb):
                 return [], 0
 
             with self.Session() as sess, sess.begin():
-                stmt = (
-                    select(
-                        table.c.user_id,
-                        func.count(table.c.memory_id).label("total_memories"),
-                        func.max(table.c.updated_at).label("last_memory_updated_at"),
-                    )
-                    .where(table.c.user_id.is_not(None))
-                    .group_by(table.c.user_id)
-                    .order_by(func.max(table.c.updated_at).desc())
+                stmt = select(
+                    table.c.user_id,
+                    func.count(table.c.memory_id).label("total_memories"),
+                    func.max(table.c.updated_at).label("last_memory_updated_at"),
                 )
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
+                else:
+                    stmt = stmt.where(table.c.user_id.is_not(None))
+                stmt = stmt.group_by(table.c.user_id)
+                stmt = stmt.order_by(func.max(table.c.updated_at).desc())
 
                 count_stmt = select(func.count()).select_from(stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0