agno 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

agno/db/mysql/mysql.py

@@ -3,8 +3,6 @@ from datetime import date, datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Tuple, Union
 from uuid import uuid4
 
-from sqlalchemy import ForeignKey, Index, UniqueConstraint
-
 if TYPE_CHECKING:
     from agno.tracing.schemas import Span, Trace
 
@@ -32,7 +30,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import TEXT, and_, cast, func, update
+    from sqlalchemy import TEXT, ForeignKey, Index, UniqueConstraint, and_, cast, func, update
     from sqlalchemy.dialects import mysql
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
@@ -45,6 +43,7 @@ except ImportError:
 class MySQLDb(BaseDb):
     def __init__(
         self,
+        id: Optional[str] = None,
         db_engine: Optional[Engine] = None,
         db_schema: Optional[str] = None,
         db_url: Optional[str] = None,
@@ -57,7 +56,7 @@ class MySQLDb(BaseDb):
         traces_table: Optional[str] = None,
         spans_table: Optional[str] = None,
         versions_table: Optional[str] = None,
-        id: Optional[str] = None,
+        create_schema: bool = True,
     ):
         """
         Interface for interacting with a MySQL database.
@@ -68,6 +67,7 @@ class MySQLDb(BaseDb):
             3. Raise an error if neither is provided
 
         Args:
+            id (Optional[str]): ID of the database.
             db_url (Optional[str]): The database URL to connect to.
             db_engine (Optional[Engine]): The SQLAlchemy database engine to use.
             db_schema (Optional[str]): The database schema to use.
@@ -80,7 +80,8 @@ class MySQLDb(BaseDb):
             traces_table (Optional[str]): Name of the table to store run traces.
             spans_table (Optional[str]): Name of the table to store span events.
             versions_table (Optional[str]): Name of the table to store schema versions.
-            id (Optional[str]): ID of the database.
+            create_schema (bool): Whether to automatically create the database schema if it doesn't exist.
+                Set to False if schema is managed externally (e.g., via migrations). Defaults to True.
 
         Raises:
             ValueError: If neither db_url nor db_engine is provided.
@@ -115,6 +116,7 @@ class MySQLDb(BaseDb):
         self.db_engine: Engine = _engine
         self.db_schema: str = db_schema if db_schema is not None else "ai"
         self.metadata: MetaData = MetaData(schema=self.db_schema)
+        self.create_schema: bool = create_schema
 
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
@@ -190,8 +192,9 @@ class MySQLDb(BaseDb):
                 idx_name = f"idx_{table_name}_{idx_col}"
                 table.append_constraint(Index(idx_name, idx_col))
 
-            with self.Session() as sess, sess.begin():
-                create_schema(session=sess, db_schema=self.db_schema)
+            if self.create_schema:
+                with self.Session() as sess, sess.begin():
+                    create_schema(session=sess, db_schema=self.db_schema)
 
             # Create table
             table_created = False
@@ -252,6 +255,9 @@ class MySQLDb(BaseDb):
             (self.metrics_table_name, "metrics"),
             (self.eval_table_name, "evals"),
             (self.knowledge_table_name, "knowledge"),
+            (self.culture_table_name, "culture"),
+            (self.trace_table_name, "traces"),
+            (self.span_table_name, "spans"),
             (self.versions_table_name, "versions"),
         ]
 
@@ -1109,9 +1115,12 @@ class MySQLDb(BaseDb):
         except Exception as e:
             log_error(f"Error deleting user memories: {e}")
 
-    def get_all_memory_topics(self) -> List[str]:
+    def get_all_memory_topics(self, user_id: Optional[str] = None) -> List[str]:
         """Get all memory topics from the database.
 
+        Args:
+            user_id (Optional[str]): Optional user ID to filter topics.
+
         Returns:
             List[str]: List of memory topics.
         """
@@ -2514,14 +2523,6 @@ class MySQLDb(BaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     sess.execute(stmt)
                 else:
@@ -2642,7 +2643,6 @@ class MySQLDb(BaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2664,14 +2664,12 @@ class MySQLDb(BaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(table.c.start_time.desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count
@@ -2709,12 +2707,6 @@ class MySQLDb(BaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2758,14 +2750,12 @@ class MySQLDb(BaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(func.max(table.c.created_at).desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/mysql/utils.py

@@ -5,15 +5,14 @@ from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
-from sqlalchemy import Engine
-
 from agno.db.mysql.schemas import get_table_schema_definition
 from agno.db.schemas.culture import CulturalKnowledge
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
-    from sqlalchemy import Table
+    from sqlalchemy import Engine, Table
     from sqlalchemy.dialects import mysql
+    from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
     from sqlalchemy.inspection import inspect
     from sqlalchemy.orm import Session
     from sqlalchemy.sql.expression import text
@@ -91,8 +90,10 @@ def is_valid_table(db_engine: Engine, table_name: str, table_type: str, db_schem
     Check if the existing table has the expected column names.
 
     Args:
+        db_engine: Database engine
         table_name (str): Name of the table to validate
-        schema (str): Database schema name
+        table_type (str): Type of table (for schema lookup)
+        db_schema (str): Database schema name
 
     Returns:
         bool: True if table has all expected columns, False otherwise
@@ -123,6 +124,7 @@ def bulk_upsert_metrics(session: Session, table: Table, metrics_records: list[di
     """Bulk upsert metrics into the database.
 
     Args:
+        session (Session): The SQLAlchemy session
         table (Table): The table to upsert into.
         metrics_records (list[dict]): The metrics records to upsert.
 
@@ -156,7 +158,10 @@ def bulk_upsert_metrics(session: Session, table: Table, metrics_records: list[di
 
     for record in metrics_records:
         select_stmt = select(table).where(
-            and_(table.c.date == record["date"], table.c.aggregation_period == record["aggregation_period"])
+            and_(
+                table.c.date == record["date"],
+                table.c.aggregation_period == record["aggregation_period"],
+            )
         )
         result = session.execute(select_stmt).fetchone()
         if result:
@@ -165,6 +170,55 @@ def bulk_upsert_metrics(session: Session, table: Table, metrics_records: list[di
     return results  # type: ignore
 
 
+async def abulk_upsert_metrics(session: AsyncSession, table: Table, metrics_records: list[dict]) -> list[dict]:
+    """Async bulk upsert metrics into the database.
+
+    Args:
+        session (AsyncSession): The async SQLAlchemy session
+        table (Table): The table to upsert into.
+        metrics_records (list[dict]): The metrics records to upsert.
+
+    Returns:
+        list[dict]: The upserted metrics records.
+    """
+    if not metrics_records:
+        return []
+
+    results = []
+
+    # MySQL doesn't support returning in the same way as PostgreSQL
+    # We'll need to insert/update and then fetch the records
+    for record in metrics_records:
+        stmt = mysql.insert(table).values(record)
+
+        # Columns to update in case of conflict
+        update_dict = {
+            col.name: record.get(col.name)
+            for col in table.columns
+            if col.name not in ["id", "date", "created_at", "aggregation_period"] and col.name in record
+        }
+
+        stmt = stmt.on_duplicate_key_update(**update_dict)
+        await session.execute(stmt)
+
+    # Fetch the updated records
+    from sqlalchemy import and_, select
+
+    for record in metrics_records:
+        select_stmt = select(table).where(
+            and_(
+                table.c.date == record["date"],
+                table.c.aggregation_period == record["aggregation_period"],
+            )
+        )
+        result = await session.execute(select_stmt)
+        fetched_row = result.fetchone()
+        if fetched_row:
+            results.append(dict(fetched_row._mapping))
+
+    return results
+
+
 def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
     """Calculate metrics for the given single date.
 
@@ -299,7 +353,9 @@ def get_dates_to_calculate_metrics_for(starting_date: date) -> list[date]:
 
 
 # -- Cultural Knowledge util methods --
-def serialize_cultural_knowledge_for_db(cultural_knowledge: CulturalKnowledge) -> Dict[str, Any]:
+def serialize_cultural_knowledge_for_db(
+    cultural_knowledge: CulturalKnowledge,
+) -> Dict[str, Any]:
     """Serialize a CulturalKnowledge object for database storage.
 
     Converts the model's separate content, categories, and notes fields
@@ -353,3 +409,80 @@ def deserialize_cultural_knowledge_from_db(db_row: Dict[str, Any]) -> CulturalKn
             "team_id": db_row.get("team_id"),
         }
     )
+
+
+# -- Async DB util methods --
+async def acreate_schema(session: AsyncSession, db_schema: str) -> None:
+    """Async version: Create the database schema if it doesn't exist.
+
+    Args:
+        session: The async SQLAlchemy session to use
+        db_schema (str): The definition of the database schema to create
+    """
+    try:
+        log_debug(f"Creating database if not exists: {db_schema}")
+        # MySQL uses CREATE DATABASE instead of CREATE SCHEMA
+        await session.execute(text(f"CREATE DATABASE IF NOT EXISTS `{db_schema}`;"))
+    except Exception as e:
+        log_warning(f"Could not create database {db_schema}: {e}")
+
+
+async def ais_table_available(session: AsyncSession, table_name: str, db_schema: str) -> bool:
+    """Async version: Check if a table with the given name exists in the given schema.
+
+    Returns:
+        bool: True if the table exists, False otherwise.
+    """
+    try:
+        exists_query = text(
+            "SELECT 1 FROM information_schema.tables WHERE table_schema = :schema AND table_name = :table"
+        )
+        result = await session.execute(exists_query, {"schema": db_schema, "table": table_name})
+        exists = result.scalar() is not None
+        if not exists:
+            log_debug(f"Table {db_schema}.{table_name} {'exists' if exists else 'does not exist'}")
+
+        return exists
+
+    except Exception as e:
+        log_error(f"Error checking if table exists: {e}")
+        return False
+
+
+async def ais_valid_table(db_engine: AsyncEngine, table_name: str, table_type: str, db_schema: str) -> bool:
+    """Async version: Check if the existing table has the expected column names.
+
+    Args:
+        db_engine: Async database engine
+        table_name (str): Name of the table to validate
+        table_type (str): Type of table (for schema lookup)
+        db_schema (str): Database schema name
+
+    Returns:
+        bool: True if table has all expected columns, False otherwise
+    """
+    try:
+        expected_table_schema = get_table_schema_definition(table_type)
+        expected_columns = {col_name for col_name in expected_table_schema.keys() if not col_name.startswith("_")}
+
+        # Get existing columns from the async engine
+        async with db_engine.connect() as conn:
+            existing_columns = await conn.run_sync(_get_table_columns, table_name, db_schema)
+
+        # Check if all expected columns exist
+        missing_columns = expected_columns - existing_columns
+        if missing_columns:
+            log_warning(f"Missing columns {missing_columns} in table {db_schema}.{table_name}")
+            return False
+
+        return True
+    except Exception as e:
+        log_error(f"Error validating table schema for {db_schema}.{table_name}: {e}")
+        return False
+
+
+def _get_table_columns(connection, table_name: str, db_schema: str) -> set[str]:
+    """Helper function to get table columns using sync inspector."""
+    inspector = inspect(connection)
+    columns_info = inspector.get_columns(table_name, schema=db_schema)
+    return {col["name"] for col in columns_info}

agno/db/postgres/async_postgres.py

@@ -56,6 +56,7 @@ class AsyncPostgresDb(AsyncBaseDb):
         traces_table: Optional[str] = None,
         spans_table: Optional[str] = None,
         versions_table: Optional[str] = None,
+        create_schema: bool = True,
         db_id: Optional[str] = None,  # Deprecated, use id instead.
     ):
         """
@@ -80,6 +81,8 @@ class AsyncPostgresDb(AsyncBaseDb):
             traces_table (Optional[str]): Name of the table to store run traces.
             spans_table (Optional[str]): Name of the table to store span events.
             versions_table (Optional[str]): Name of the table to store schema versions.
+            create_schema (bool): Whether to automatically create the database schema if it doesn't exist.
+                Set to False if schema is managed externally (e.g., via migrations). Defaults to True.
             db_id: Deprecated, use id instead.
 
         Raises:
@@ -116,6 +119,7 @@ class AsyncPostgresDb(AsyncBaseDb):
         self.db_engine: AsyncEngine = _engine
         self.db_schema: str = db_schema if db_schema is not None else "ai"
         self.metadata: MetaData = MetaData(schema=self.db_schema)
+        self.create_schema: bool = create_schema
 
         # Initialize database session factory
         self.async_session_factory = async_sessionmaker(
@@ -200,8 +204,9 @@ class AsyncPostgresDb(AsyncBaseDb):
                 idx_name = f"idx_{table_name}_{idx_col}"
                 table.append_constraint(Index(idx_name, idx_col))
 
-            async with self.async_session_factory() as sess, sess.begin():
-                await acreate_schema(session=sess, db_schema=self.db_schema)
+            if self.create_schema:
+                async with self.async_session_factory() as sess, sess.begin():
+                    await acreate_schema(session=sess, db_schema=self.db_schema)
 
             # Create table
             table_created = False
@@ -1237,7 +1242,7 @@ class AsyncPostgresDb(AsyncBaseDb):
             Exception: If an error occurs during upsert.
         """
         try:
-            table = await self._get_table(table_type="culture")
+            table = await self._get_table(table_type="culture", create_table_if_not_found=True)
 
             # Generate ID if not present
             if cultural_knowledge.id is None:
@@ -1381,7 +1386,7 @@ class AsyncPostgresDb(AsyncBaseDb):
             Exception: If an error occurs during upsert.
         """
         try:
-            table = await self._get_table(table_type="memories")
+            table = await self._get_table(table_type="memories", create_table_if_not_found=True)
 
             current_time = int(time.time())
 
@@ -1725,7 +1730,7 @@ class AsyncPostgresDb(AsyncBaseDb):
             Optional[KnowledgeRow]: The upserted knowledge row, or None if the operation fails.
         """
         try:
-            table = await self._get_table(table_type="knowledge")
+            table = await self._get_table(table_type="knowledge", create_table_if_not_found=True)
             async with self.async_session_factory() as sess, sess.begin():
                 # Get the actual table columns to avoid "unconsumed column names" error
                 table_columns = set(table.columns.keys())
@@ -2186,14 +2191,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     await sess.execute(stmt)
                 else:
@@ -2293,10 +2290,6 @@ class AsyncPostgresDb(AsyncBaseDb):
         try:
             from agno.tracing.schemas import Trace
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             table = await self._get_table(table_type="traces")
 
             # Get spans table for JOIN
@@ -2310,7 +2303,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2378,12 +2370,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = await self._get_table(table_type="traces")
 
             async with self.async_session_factory() as sess:
@@ -2424,7 +2410,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = await sess.scalar(count_stmt) or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
@@ -2432,7 +2417,6 @@ class AsyncPostgresDb(AsyncBaseDb):
 
                 result = await sess.execute(paginated_stmt)
                 results = result.fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/postgres/postgres.py

@@ -57,6 +57,7 @@ class PostgresDb(BaseDb):
         spans_table: Optional[str] = None,
         versions_table: Optional[str] = None,
         id: Optional[str] = None,
+        create_schema: bool = True,
     ):
         """
         Interface for interacting with a PostgreSQL database.
@@ -80,6 +81,8 @@ class PostgresDb(BaseDb):
             spans_table (Optional[str]): Name of the table to store span events.
             versions_table (Optional[str]): Name of the table to store schema versions.
             id (Optional[str]): ID of the database.
+            create_schema (bool): Whether to automatically create the database schema if it doesn't exist.
+                Set to False if schema is managed externally (e.g., via migrations). Defaults to True.
 
         Raises:
             ValueError: If neither db_url nor db_engine is provided.
@@ -115,6 +118,7 @@ class PostgresDb(BaseDb):
 
         self.db_schema: str = db_schema if db_schema is not None else "ai"
         self.metadata: MetaData = MetaData(schema=self.db_schema)
+        self.create_schema: bool = create_schema
 
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine, expire_on_commit=False))
@@ -204,8 +208,9 @@ class PostgresDb(BaseDb):
                 idx_name = f"idx_{table_name}_{idx_col}"
                 table.append_constraint(Index(idx_name, idx_col))
 
-            with self.Session() as sess, sess.begin():
-                create_schema(session=sess, db_schema=self.db_schema)
+            if self.create_schema:
+                with self.Session() as sess, sess.begin():
+                    create_schema(session=sess, db_schema=self.db_schema)
 
             # Create table
             table_created = False
@@ -2466,14 +2471,6 @@ class PostgresDb(BaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     sess.execute(stmt)
                 else:
@@ -2574,10 +2571,6 @@ class PostgresDb(BaseDb):
         try:
             from agno.tracing.schemas import Trace
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2594,7 +2587,6 @@ class PostgresDb(BaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2616,14 +2608,12 @@ class PostgresDb(BaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(table.c.start_time.desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count
@@ -2661,12 +2651,6 @@ class PostgresDb(BaseDb):
                 first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2710,14 +2694,12 @@ class PostgresDb(BaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(func.max(table.c.created_at).desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/redis/redis.py

@@ -1919,14 +1919,12 @@ class RedisDb(BaseDb):
                 filtered_traces.append(trace)
 
             total_count = len(filtered_traces)
-            log_debug(f"Total matching traces: {total_count}")
 
             # Sort by start_time descending
             filtered_traces.sort(key=lambda x: x.get("start_time", ""), reverse=True)
 
             # Apply pagination
             paginated_traces = apply_pagination(records=filtered_traces, limit=limit, page=page)
-            log_debug(f"Returning page {page} with {len(paginated_traces)} traces")
 
             traces = []
             for row in paginated_traces:
@@ -2025,11 +2023,9 @@ class RedisDb(BaseDb):
             stats_list.sort(key=lambda x: x.get("last_trace_at", ""), reverse=True)
 
             total_count = len(stats_list)
-            log_debug(f"Total matching sessions: {total_count}")
 
             # Apply pagination
             paginated_stats = apply_pagination(records=stats_list, limit=limit, page=page)
-            log_debug(f"Returning page {page} with {len(paginated_stats)} session stats")
 
             # Convert ISO strings to datetime objects
             for stat in paginated_stats:

agno/db/schemas/evals.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 
 class EvalType(str, Enum):
     ACCURACY = "accuracy"
+    AGENT_AS_JUDGE = "agent_as_judge"
     PERFORMANCE = "performance"
     RELIABILITY = "reliability"