agno 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

agno/db/mysql/mysql.py

@@ -917,9 +917,13 @@ class MySQLDb(BaseDb):
             ]
 
     # -- Memory methods --
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
+        Args:
+            memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
+
         Returns:
             bool: True if deletion was successful, False otherwise.
 
@@ -933,6 +937,8 @@ class MySQLDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
 
                 success = result.rowcount > 0
@@ -944,11 +950,12 @@ class MySQLDb(BaseDb):
         except Exception as e:
             log_error(f"Error deleting user memory: {e}")
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
 
         Raises:
             Exception: If an error occurs during deletion.
@@ -960,6 +967,8 @@ class MySQLDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id.in_(memory_ids))
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
                 if result.rowcount == 0:
                     log_debug(f"No user memories found with ids: {memory_ids}")
@@ -1002,12 +1011,15 @@ class MySQLDb(BaseDb):
             log_error(f"Exception reading from memory table: {e}")
             raise e
 
-    def get_user_memory(self, memory_id: str, deserialize: Optional[bool] = True) -> Optional[UserMemory]:
+    def get_user_memory(
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
+    ) -> Optional[UserMemory]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
 
         Returns:
             Union[UserMemory, Dict[str, Any], None]:
@@ -1024,6 +1036,8 @@ class MySQLDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 stmt = select(table).where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
 
                 result = sess.execute(stmt).fetchone()
                 if not result:

agno/db/postgres/postgres.py

@@ -870,9 +870,13 @@ class PostgresDb(BaseDb):
             return []
 
     # -- Memory methods --
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
+        Args:
+            memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
+
         Returns:
             bool: True if deletion was successful, False otherwise.
 
@@ -886,6 +890,10 @@ class PostgresDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id == memory_id)
+
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
+
                 result = sess.execute(delete_stmt)
 
                 success = result.rowcount > 0
@@ -898,11 +906,12 @@ class PostgresDb(BaseDb):
             log_error(f"Error deleting user memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Raises:
             Exception: If an error occurs during deletion.
@@ -914,6 +923,10 @@ class PostgresDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id.in_(memory_ids))
+
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
+
                 result = sess.execute(delete_stmt)
 
                 if result.rowcount == 0:
@@ -938,6 +951,7 @@ class PostgresDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 stmt = select(func.json_array_elements_text(table.c.topics))
+
                 result = sess.execute(stmt).fetchall()
 
                 return list(set([record[0] for record in result]))
@@ -947,13 +961,14 @@ class PostgresDb(BaseDb):
             return []
 
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Returns:
             Union[UserMemory, Dict[str, Any], None]:
@@ -971,6 +986,9 @@ class PostgresDb(BaseDb):
             with self.Session() as sess, sess.begin():
                 stmt = select(table).where(table.c.memory_id == memory_id)
 
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
+
                 result = sess.execute(stmt).fetchone()
                 if not result:
                     return None

agno/db/redis/redis.py

@@ -627,11 +627,12 @@ class RedisDb(BaseDb):
 
     # -- Memory methods --
 
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from Redis.
 
         Args:
             memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The ID of the user. If provided, verifies the memory belongs to this user before deleting.
 
         Returns:
             bool: True if the memory was deleted, False otherwise.
@@ -640,6 +641,16 @@ class RedisDb(BaseDb):
             Exception: If any error occurs while deleting the memory.
         """
         try:
+            # If user_id is provided, verify ownership before deleting
+            if user_id is not None:
+                memory = self._get_record("memories", memory_id)
+                if memory is None:
+                    log_debug(f"No user memory found with id: {memory_id}")
+                    return
+                if memory.get("user_id") != user_id:
+                    log_debug(f"Memory {memory_id} does not belong to user {user_id}")
+                    return
+
             if self._delete_record(
                 "memories", memory_id, index_fields=["user_id", "agent_id", "team_id", "workflow_id"]
             ):
@@ -651,15 +662,25 @@ class RedisDb(BaseDb):
             log_error(f"Error deleting user memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from Redis.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The ID of the user. If provided, only deletes memories belonging to this user.
         """
         try:
             # TODO: cant we optimize this?
             for memory_id in memory_ids:
+                # If user_id is provided, verify ownership before deleting
+                if user_id is not None:
+                    memory = self._get_record("memories", memory_id)
+                    if memory is None:
+                        continue
+                    if memory.get("user_id") != user_id:
+                        log_debug(f"Memory {memory_id} does not belong to user {user_id}, skipping deletion")
+                        continue
+
                 self._delete_record(
                     "memories",
                     memory_id,
@@ -692,12 +713,14 @@ class RedisDb(BaseDb):
             raise e
 
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
         """Get a memory from Redis.
 
         Args:
             memory_id (str): The ID of the memory to get.
+            deserialize (Optional[bool]): Whether to deserialize the memory. Defaults to True.
+            user_id (Optional[str]): The ID of the user. If provided, only returns the memory if it belongs to this user.
 
         Returns:
             Optional[UserMemory]: The memory data if found, None otherwise.
@@ -707,6 +730,10 @@ class RedisDb(BaseDb):
             if memory_raw is None:
                 return None
 
+            # Filter by user_id if provided
+            if user_id is not None and memory_raw.get("user_id") != user_id:
+                return None
+
             if not deserialize:
                 return memory_raw
 
@@ -812,21 +839,21 @@ class RedisDb(BaseDb):
             # Group by user_id
             user_stats = {}
             for memory in all_memories:
-                user_id = memory.get("user_id")
-                if user_id is None:
+                memory_user_id = memory.get("user_id")
+                if memory_user_id is None:
                     continue
 
-                if user_id not in user_stats:
-                    user_stats[user_id] = {
-                        "user_id": user_id,
+                if memory_user_id not in user_stats:
+                    user_stats[memory_user_id] = {
+                        "user_id": memory_user_id,
                         "total_memories": 0,
                         "last_memory_updated_at": 0,
                     }
 
-                user_stats[user_id]["total_memories"] += 1
+                user_stats[memory_user_id]["total_memories"] += 1
                 updated_at = memory.get("updated_at", 0)
-                if updated_at > user_stats[user_id]["last_memory_updated_at"]:
-                    user_stats[user_id]["last_memory_updated_at"] = updated_at
+                if updated_at > user_stats[memory_user_id]["last_memory_updated_at"]:
+                    user_stats[memory_user_id]["last_memory_updated_at"] = updated_at
 
             stats_list = list(user_stats.values())
 

agno/db/singlestore/singlestore.py

@@ -990,11 +990,12 @@ class SingleStoreDb(BaseDb):
             return []
 
     # -- Memory methods --
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Returns:
             bool: True if deletion was successful, False otherwise.
@@ -1009,6 +1010,8 @@ class SingleStoreDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
 
                 success = result.rowcount > 0
@@ -1021,11 +1024,12 @@ class SingleStoreDb(BaseDb):
             log_error(f"Error deleting memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Raises:
             Exception: If an error occurs during deletion.
@@ -1037,6 +1041,8 @@ class SingleStoreDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id.in_(memory_ids))
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
                 if result.rowcount == 0:
                     log_debug(f"No memories found with ids: {memory_ids}")
@@ -1073,12 +1079,15 @@ class SingleStoreDb(BaseDb):
             log_error(f"Exception reading from memory table: {e}")
             raise e
 
-    def get_user_memory(self, memory_id: str, deserialize: Optional[bool] = True) -> Optional[UserMemory]:
+    def get_user_memory(
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
+    ) -> Optional[UserMemory]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The ID of the user to filter by. Defaults to None.
 
         Returns:
             Union[UserMemory, Dict[str, Any], None]:
@@ -1095,6 +1104,8 @@ class SingleStoreDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 stmt = select(table).where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
 
                 result = sess.execute(stmt).fetchone()
                 if not result:

agno/db/sqlite/sqlite.py

@@ -1,7 +1,7 @@
 import time
 from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union, cast
 from uuid import uuid4
 
 from agno.db.base import BaseDb, SessionType
@@ -24,7 +24,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 Column, MetaData, Table, and_, func, select, text, update
+    from sqlalchemy import Column, MetaData, Table, and_, func, select, text
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
@@ -442,11 +442,7 @@ class SqliteDb(BaseDb):
                 if end_timestamp is not None:
                     stmt = stmt.where(table.c.created_at <= end_timestamp)
                 if session_name is not None:
-                    stmt = stmt.where(
-                        func.coalesce(func.json_extract(table.c.session_data, "$.session_name"), "").like(
-                            f"%{session_name}%"
-                        )
-                    )
+                    stmt = stmt.where(table.c.session_data.like(f"%{session_name}%"))
                 if session_type is not None:
                     stmt = stmt.where(table.c.session_type == session_type.value)
 
@@ -468,8 +464,10 @@ class SqliteDb(BaseDb):
                     return [] if deserialize else ([], 0)
 
                 sessions_raw = [deserialize_session_json_fields(dict(record._mapping)) for record in records]
-                if not sessions_raw or not deserialize:
+                if not deserialize:
                     return sessions_raw, total_count
+                if not sessions_raw:
+                    return []
 
             if session_type == SessionType.AGENT:
                 return [AgentSession.from_dict(record) for record in sessions_raw]  # type: ignore
@@ -505,43 +503,20 @@ class SqliteDb(BaseDb):
             Exception: If an error occurs during renaming.
         """
         try:
-            table = self._get_table(table_type="sessions")
-            if table is None:
+            # Get the current session as a deserialized object
+            # Get the session record
+            session = self.get_session(session_id, session_type, deserialize=True)
+            if session is None:
                 return None
 
-            with self.Session() as sess, sess.begin():
-                # Update session_name inside the session_data JSON field
-                stmt = (
-                    update(table)
-                    .where(table.c.session_id == session_id)
-                    .values(session_data=func.json_set(table.c.session_data, "$.session_name", session_name))
-                )
-                result = sess.execute(stmt)
-
-                # Check if any rows were affected
-                if result.rowcount == 0:
-                    return None
-
-                # Fetch the updated row
-                select_stmt = select(table).where(table.c.session_id == session_id)
-                row = sess.execute(select_stmt).fetchone()
-
-                if not row:
-                    return None
-
-            session_raw = deserialize_session_json_fields(dict(row._mapping))
-            if not session_raw or not deserialize:
-                return session_raw
+            session = cast(Session, session)
+            # Update the session name
+            if session.session_data is None:
+                session.session_data = {}
+            session.session_data["session_name"] = session_name
 
-            # Return the appropriate session type
-            if session_type == SessionType.AGENT:
-                return AgentSession.from_dict(session_raw)
-            elif session_type == SessionType.TEAM:
-                return TeamSession.from_dict(session_raw)
-            elif session_type == SessionType.WORKFLOW:
-                return WorkflowSession.from_dict(session_raw)
-            else:
-                raise ValueError(f"Invalid session type: {session_type}")
+            # Upsert the updated session back to the database
+            return self.upsert_session(session, deserialize=deserialize)
 
         except Exception as e:
             log_error(f"Exception renaming session: {e}")
@@ -909,9 +884,13 @@ class SqliteDb(BaseDb):
 
     # -- Memory methods --
 
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
+        Args:
+            memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
+
         Returns:
             bool: True if deletion was successful, False otherwise.
 
@@ -925,6 +904,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
 
                 success = result.rowcount > 0
@@ -937,11 +918,12 @@ class SqliteDb(BaseDb):
             log_error(f"Error deleting user memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
 
         Raises:
             Exception: If an error occurs during deletion.
@@ -953,6 +935,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 delete_stmt = table.delete().where(table.c.memory_id.in_(memory_ids))
+                if user_id is not None:
+                    delete_stmt = delete_stmt.where(table.c.user_id == user_id)
                 result = sess.execute(delete_stmt)
                 if result.rowcount == 0:
                     log_debug(f"No user memories found with ids: {memory_ids}")
@@ -973,7 +957,8 @@ class SqliteDb(BaseDb):
                 return []
 
             with self.Session() as sess, sess.begin():
-                stmt = select(func.json_array_elements_text(table.c.topics))
+                # Select topics from all results
+                stmt = select(func.json_array_elements_text(table.c.topics)).select_from(table)
                 result = sess.execute(stmt).fetchall()
 
                 return list(set([record[0] for record in result]))
@@ -983,13 +968,14 @@ class SqliteDb(BaseDb):
             raise e
 
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The user ID to filter by. Defaults to None.
 
         Returns:
             Optional[Union[UserMemory, Dict[str, Any]]]:
@@ -1006,6 +992,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 stmt = select(table).where(table.c.memory_id == memory_id)
+                if user_id is not None:
+                    stmt = stmt.where(table.c.user_id == user_id)
                 result = sess.execute(stmt).fetchone()
                 if result is None:
                     return None

agno/db/utils.py

@@ -4,7 +4,6 @@ import json
 from datetime import date, datetime
 from uuid import UUID
 
-from agno.db.base import SessionType
 from agno.models.message import Message
 from agno.models.metrics import Metrics
 
@@ -55,34 +54,63 @@ def serialize_session_json_fields(session: dict) -> dict:
 
 
 def deserialize_session_json_fields(session: dict) -> dict:
-    """Deserialize all JSON fields in the given Session dictionary.
+    """Deserialize JSON fields in the given Session dictionary.
 
     Args:
         session (dict): The dictionary to deserialize.
 
     Returns:
-        dict: The dictionary with JSON fields deserialized.
+        dict: The dictionary with JSON string fields deserialized to objects.
     """
-    if session.get("agent_data") is not None:
-        session["agent_data"] = json.loads(session["agent_data"])
-    if session.get("team_data") is not None:
-        session["team_data"] = json.loads(session["team_data"])
-    if session.get("workflow_data") is not None:
-        session["workflow_data"] = json.loads(session["workflow_data"])
-    if session.get("metadata") is not None:
-        session["metadata"] = json.loads(session["metadata"])
-    if session.get("chat_history") is not None:
-        session["chat_history"] = json.loads(session["chat_history"])
-    if session.get("summary") is not None:
-        session["summary"] = json.loads(session["summary"])
+    from agno.utils.log import log_warning
+
+    if session.get("agent_data") is not None and isinstance(session["agent_data"], str):
+        try:
+            session["agent_data"] = json.loads(session["agent_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse agent_data as JSON, keeping as string: {e}")
+
+    if session.get("team_data") is not None and isinstance(session["team_data"], str):
+        try:
+            session["team_data"] = json.loads(session["team_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse team_data as JSON, keeping as string: {e}")
+
+    if session.get("workflow_data") is not None and isinstance(session["workflow_data"], str):
+        try:
+            session["workflow_data"] = json.loads(session["workflow_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse workflow_data as JSON, keeping as string: {e}")
+
+    if session.get("metadata") is not None and isinstance(session["metadata"], str):
+        try:
+            session["metadata"] = json.loads(session["metadata"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse metadata as JSON, keeping as string: {e}")
+
+    if session.get("chat_history") is not None and isinstance(session["chat_history"], str):
+        try:
+            session["chat_history"] = json.loads(session["chat_history"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse chat_history as JSON, keeping as string: {e}")
+
+    if session.get("summary") is not None and isinstance(session["summary"], str):
+        try:
+            session["summary"] = json.loads(session["summary"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse summary as JSON, keeping as string: {e}")
+
     if session.get("session_data") is not None and isinstance(session["session_data"], str):
-        session["session_data"] = json.loads(session["session_data"])
-    if session.get("runs") is not None:
-        if session["session_type"] == SessionType.AGENT.value:
-            session["runs"] = json.loads(session["runs"])
-        if session["session_type"] == SessionType.TEAM.value:
-            session["runs"] = json.loads(session["runs"])
-        if session["session_type"] == SessionType.WORKFLOW.value:
+        try:
+            session["session_data"] = json.loads(session["session_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse session_data as JSON, keeping as string: {e}")
+
+    # Handle runs field with session type checking
+    if session.get("runs") is not None and isinstance(session["runs"], str):
+        try:
             session["runs"] = json.loads(session["runs"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse runs as JSON, keeping as string: {e}")
 
     return session

agno/knowledge/knowledge.py

@@ -1357,6 +1357,12 @@ class Knowledge:
             log_error(f"Error searching for documents: {e}")
             return []
 
+    def get_valid_filters(self) -> Set[str]:
+        if self.valid_metadata_filters is None:
+            self.valid_metadata_filters = set()
+        self.valid_metadata_filters.update(self._get_filters_from_db)
+        return self.valid_metadata_filters
+
     def validate_filters(self, filters: Optional[Dict[str, Any]]) -> Tuple[Dict[str, Any], List[str]]:
         if self.valid_metadata_filters is None:
             self.valid_metadata_filters = set()