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

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"},
 }
 
@@ -81,6 +84,50 @@ KNOWLEDGE_SCHEMA = {
 }
 
 
+CULTURAL_KNOWLEDGE_SCHEMA = {
+    "id": {"type": "string", "primary_key": True},
+    "name": {"type": "string"},
+    "summary": {"type": "string"},
+    "content": {"type": "json"},
+    "metadata": {"type": "json"},
+    "input": {"type": "string"},
+    "created_at": {"type": "integer"},
+    "updated_at": {"type": "integer"},
+    "agent_id": {"type": "string"},
+    "team_id": {"type": "string"},
+}
+
+TRACE_SCHEMA = {
+    "trace_id": {"type": "string", "primary_key": True},
+    "name": {"type": "string"},
+    "status": {"type": "string"},
+    "duration_ms": {"type": "integer"},
+    "run_id": {"type": "string"},
+    "session_id": {"type": "string"},
+    "user_id": {"type": "string"},
+    "agent_id": {"type": "string"},
+    "team_id": {"type": "string"},
+    "workflow_id": {"type": "string"},
+    "start_time": {"type": "string"},
+    "end_time": {"type": "string"},
+    "created_at": {"type": "string"},
+}
+
+SPAN_SCHEMA = {
+    "span_id": {"type": "string", "primary_key": True},
+    "trace_id": {"type": "string"},
+    "parent_span_id": {"type": "string"},
+    "name": {"type": "string"},
+    "span_kind": {"type": "string"},
+    "status_code": {"type": "string"},
+    "status_message": {"type": "string"},
+    "start_time": {"type": "string"},
+    "end_time": {"type": "string"},
+    "attributes": {"type": "json"},
+    "created_at": {"type": "string"},
+}
+
+
 def get_table_schema_definition(table_type: str) -> dict[str, Any]:
     """
     Get the expected schema definition for the given table.
@@ -100,6 +147,9 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "metrics": METRICS_SCHEMA,
         "evals": EVAL_SCHEMA,
         "knowledge": KNOWLEDGE_SCHEMA,
+        "culture": CULTURAL_KNOWLEDGE_SCHEMA,
+        "traces": TRACE_SCHEMA,
+        "spans": SPAN_SCHEMA,
     }
 
     schema = schemas.get(table_type, {})

agno/db/redis/utils.py

@@ -3,13 +3,14 @@
 import json
 import time
 from datetime import date, datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 
+from agno.db.schemas.culture import CulturalKnowledge
 from agno.utils.log import log_warning
 
 try:
-    from redis import Redis
+    from redis import Redis, RedisCluster
 except ImportError:
     raise ImportError("`redis` not installed. Please install it using `pip install redis`")
 
@@ -50,7 +51,7 @@ def generate_index_key(prefix: str, table_type: str, index_field: str, index_val
     return f"{prefix}:{table_type}:index:{index_field}:{index_value}"
 
 
-def get_all_keys_for_table(redis_client: Redis, prefix: str, table_type: str) -> List[str]:
+def get_all_keys_for_table(redis_client: Union[Redis, RedisCluster], prefix: str, table_type: str) -> List[str]:
     """Get all relevant keys for the given table type.
 
     Args:
@@ -129,7 +130,7 @@ def apply_filters(records: List[Dict[str, Any]], conditions: Dict[str, Any]) ->
 
 
 def create_index_entries(
-    redis_client: Redis,
+    redis_client: Union[Redis, RedisCluster],
     prefix: str,
     table_type: str,
     record_id: str,
@@ -143,7 +144,7 @@ def create_index_entries(
 
 
 def remove_index_entries(
-    redis_client: Redis,
+    redis_client: Union[Redis, RedisCluster],
     prefix: str,
     table_type: str,
     record_id: str,
@@ -199,7 +200,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
     all_user_ids = set()
 
     for session_type, sessions_count_key, runs_count_key in session_types:
-        sessions = sessions_data.get(session_type, [])
+        sessions = sessions_data.get(session_type, []) or []
         metrics[sessions_count_key] = len(sessions)
 
         for session in sessions:
@@ -220,7 +221,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)
@@ -286,3 +287,60 @@ def get_dates_to_calculate_metrics_for(starting_date: date) -> list[date]:
     if days_diff <= 0:
         return []
     return [starting_date + timedelta(days=x) for x in range(days_diff)]
+
+
+# -- Cultural Knowledge util methods --
+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
+    into a single dict for the database content column.
+
+    Args:
+        cultural_knowledge (CulturalKnowledge): The cultural knowledge object to serialize.
+
+    Returns:
+        Dict[str, Any]: A dictionary with the content field as a dict containing content, categories, and notes.
+    """
+    content_dict: Dict[str, Any] = {}
+    if cultural_knowledge.content is not None:
+        content_dict["content"] = cultural_knowledge.content
+    if cultural_knowledge.categories is not None:
+        content_dict["categories"] = cultural_knowledge.categories
+    if cultural_knowledge.notes is not None:
+        content_dict["notes"] = cultural_knowledge.notes
+
+    return content_dict if content_dict else {}
+
+
+def deserialize_cultural_knowledge_from_db(db_row: Dict[str, Any]) -> CulturalKnowledge:
+    """Deserialize a database row to a CulturalKnowledge object.
+
+    The database stores content as a dict containing content, categories, and notes.
+    This method extracts those fields and converts them back to the model format.
+
+    Args:
+        db_row (Dict[str, Any]): The database row as a dictionary.
+
+    Returns:
+        CulturalKnowledge: The cultural knowledge object.
+    """
+    # Extract content, categories, and notes from the content field
+    content_json = db_row.get("content", {}) or {}
+
+    return CulturalKnowledge.from_dict(
+        {
+            "id": db_row.get("id"),
+            "name": db_row.get("name"),
+            "summary": db_row.get("summary"),
+            "content": content_json.get("content"),
+            "categories": content_json.get("categories"),
+            "notes": content_json.get("notes"),
+            "metadata": db_row.get("metadata"),
+            "input": db_row.get("input"),
+            "created_at": db_row.get("created_at"),
+            "updated_at": db_row.get("updated_at"),
+            "agent_id": db_row.get("agent_id"),
+            "team_id": db_row.get("team_id"),
+        }
+    )

agno/db/schemas/__init__.py

@@ -1,3 +1,4 @@
+from agno.db.schemas.culture import CulturalKnowledge
 from agno.db.schemas.memory import UserMemory
 
-__all__ = ["UserMemory"]
+__all__ = ["CulturalKnowledge", "UserMemory"]

agno/db/schemas/culture.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Union
+
+from typing_extensions import List
+
+
+@dataclass
+class CulturalKnowledge:
+    """Model for Cultural Knowledge
+
+    Notice: Culture is an experimental feature and is subject to change.
+    """
+
+    # The id of the cultural knowledge, auto-generated if not provided
+    id: Optional[str] = None
+    name: Optional[str] = None
+
+    content: Optional[str] = None
+    categories: Optional[List[str]] = None
+    notes: Optional[List[str]] = None
+
+    summary: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    input: Optional[str] = None
+
+    created_at: Optional[int] = field(default=None)
+    updated_at: Optional[int] = field(default=None)
+
+    agent_id: Optional[str] = None
+    team_id: Optional[str] = None
+
+    def __post_init__(self):
+        if self.name is not None and not self.name.strip():
+            raise ValueError("name must be a non-empty string")
+        self.created_at = _now_epoch_s() if self.created_at is None else _to_epoch_s(self.created_at)
+        self.updated_at = self.created_at if self.updated_at is None else _to_epoch_s(self.updated_at)
+
+    def bump_updated_at(self) -> None:
+        """Bump updated_at to now (UTC)."""
+        self.updated_at = _now_epoch_s()
+
+    def preview(self) -> Dict[str, Any]:
+        """Return a preview of the cultural knowledge"""
+        _preview: Dict[str, Any] = {
+            "name": self.name,
+        }
+        if self.categories is not None:
+            _preview["categories"] = self.categories
+        if self.summary is not None:
+            _preview["summary"] = self.summary[:100] + "..." if len(self.summary) > 100 else self.summary
+        if self.content is not None:
+            _preview["content"] = self.content[:100] + "..." if len(self.content) > 100 else self.content
+        if self.notes is not None:
+            _preview["notes"] = [note[:100] + "..." if len(note) > 100 else note for note in self.notes]
+        return _preview
+
+    def to_dict(self) -> Dict[str, Any]:
+        _dict = {
+            "id": self.id,
+            "name": self.name,
+            "summary": self.summary,
+            "content": self.content,
+            "categories": self.categories,
+            "metadata": self.metadata,
+            "notes": self.notes,
+            "input": self.input,
+            "created_at": (_epoch_to_rfc3339_z(self.created_at) if self.created_at is not None else None),
+            "updated_at": (_epoch_to_rfc3339_z(self.updated_at) if self.updated_at is not None else None),
+            "agent_id": self.agent_id,
+            "team_id": self.team_id,
+        }
+        return {k: v for k, v in _dict.items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "CulturalKnowledge":
+        d = dict(data)
+
+        # Preserve 0 and None explicitly; only process if key exists
+        if "created_at" in d and d["created_at"] is not None:
+            d["created_at"] = _to_epoch_s(d["created_at"])
+        if "updated_at" in d and d["updated_at"] is not None:
+            d["updated_at"] = _to_epoch_s(d["updated_at"])
+
+        return cls(**d)
+
+
+def _now_epoch_s() -> int:
+    return int(datetime.now(timezone.utc).timestamp())
+
+
+def _to_epoch_s(value: Union[int, float, str, datetime]) -> int:
+    """Normalize various datetime representations to epoch seconds (UTC)."""
+    if isinstance(value, (int, float)):
+        # assume value is already in seconds
+        return int(value)
+
+    if isinstance(value, datetime):
+        dt = value
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp())
+
+    if isinstance(value, str):
+        s = value.strip()
+        if s.endswith("Z"):
+            s = s[:-1] + "+00:00"
+        try:
+            dt = datetime.fromisoformat(s)
+        except ValueError as e:
+            raise ValueError(f"Unsupported datetime string: {value!r}") from e
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp())
+
+    raise TypeError(f"Unsupported datetime value: {type(value)}")
+
+
+def _epoch_to_rfc3339_z(ts: Union[int, float]) -> str:
+    return datetime.fromtimestamp(float(ts), tz=timezone.utc).isoformat().replace("+00:00", "Z")

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"
 

agno/db/schemas/memory.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
+from agno.utils.dttm import now_epoch_s
+
 
 @dataclass
 class UserMemory:
@@ -12,18 +14,25 @@ class UserMemory:
     topics: Optional[List[str]] = None
     user_id: Optional[str] = None
     input: Optional[str] = None
-    updated_at: Optional[datetime] = None
+    created_at: Optional[int] = None
+    updated_at: Optional[int] = 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 = now_epoch_s()
+
     def to_dict(self) -> Dict[str, Any]:
         _dict = {
             "memory_id": self.memory_id,
             "memory": self.memory,
             "topics": self.topics,
-            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+            "created_at": datetime.fromtimestamp(self.created_at).isoformat() if self.created_at else None,
+            "updated_at": datetime.fromtimestamp(self.updated_at).isoformat() if self.updated_at else None,
             "input": self.input,
             "user_id": self.user_id,
             "agent_id": self.agent_id,
@@ -36,6 +45,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},
 }
 
@@ -92,6 +94,63 @@ METRICS_TABLE_SCHEMA = {
     "completed": {"type": Boolean, "nullable": False, "default": False},
 }
 
+CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
+    "id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "name": {"type": lambda: String(255), "nullable": False, "index": True},
+    "summary": {"type": Text, "nullable": True},
+    "content": {"type": JSON, "nullable": True},
+    "metadata": {"type": JSON, "nullable": True},
+    "input": {"type": Text, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+}
+
+
+VERSIONS_TABLE_SCHEMA = {
+    "table_name": {"type": lambda: String(128), "nullable": False, "primary_key": True},
+    "version": {"type": lambda: String(10), "nullable": False},
+    "created_at": {"type": lambda: String(128), "nullable": False, "index": True},
+    "updated_at": {"type": lambda: String(128), "nullable": True},
+}
+
+TRACE_TABLE_SCHEMA = {
+    "trace_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "name": {"type": lambda: String(512), "nullable": False},
+    "status": {"type": lambda: String(20), "nullable": False, "index": True},
+    "start_time": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+    "end_time": {"type": lambda: String(64), "nullable": False},  # ISO 8601 datetime string
+    "duration_ms": {"type": BigInteger, "nullable": False},
+    "run_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "session_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "team_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "workflow_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "created_at": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+}
+
+SPAN_TABLE_SCHEMA = {
+    "span_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "trace_id": {
+        "type": lambda: String(128),
+        "nullable": False,
+        "index": True,
+        "foreign_key": "agno_traces.trace_id",  # Foreign key to traces table
+    },
+    "parent_span_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "name": {"type": lambda: String(512), "nullable": False},
+    "span_kind": {"type": lambda: String(50), "nullable": False},
+    "status_code": {"type": lambda: String(20), "nullable": False},
+    "status_message": {"type": Text, "nullable": True},
+    "start_time": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+    "end_time": {"type": lambda: String(64), "nullable": False},  # ISO 8601 datetime string
+    "duration_ms": {"type": BigInteger, "nullable": False},
+    "attributes": {"type": JSON, "nullable": True},
+    "created_at": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+}
+
 
 def get_table_schema_definition(table_type: str) -> dict[str, Any]:
     """
@@ -107,6 +166,10 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "metrics": METRICS_TABLE_SCHEMA,
         "memories": USER_MEMORY_TABLE_SCHEMA,
         "knowledge": KNOWLEDGE_TABLE_SCHEMA,
+        "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
+        "versions": VERSIONS_TABLE_SCHEMA,
+        "traces": TRACE_TABLE_SCHEMA,
+        "spans": SPAN_TABLE_SCHEMA,
     }
     schema = schemas.get(table_type, {})