agno 2.0.1__py3-none-any.whl → 2.3.0__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,20 @@ 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"},
+}
+
+
 def get_table_schema_definition(table_type: str) -> dict[str, Any]:
     """
     Get the expected schema definition for the given table.
@@ -100,6 +117,7 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "metrics": METRICS_SCHEMA,
         "evals": EVAL_SCHEMA,
         "knowledge": KNOWLEDGE_SCHEMA,
+        "culture": CULTURAL_KNOWLEDGE_SCHEMA,
     }
 
     schema = schemas.get(table_type, {})

agno/db/redis/utils.py

@@ -6,6 +6,7 @@ from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional
 from uuid import UUID
 
+from agno.db.schemas.culture import CulturalKnowledge
 from agno.utils.log import log_warning
 
 try:
@@ -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/memory.py

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

agno/db/singlestore/schemas.py

@@ -39,6 +39,8 @@ USER_MEMORY_TABLE_SCHEMA = {
     "team_id": {"type": lambda: String(128), "nullable": True},
     "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
     "topics": {"type": JSON, "nullable": True},
+    "feedback": {"type": Text, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
     "updated_at": {"type": BigInteger, "nullable": True, "index": True},
 }
 
@@ -92,6 +94,27 @@ 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},
+}
+
 
 def get_table_schema_definition(table_type: str) -> dict[str, Any]:
     """
@@ -106,7 +129,9 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "evals": EVAL_TABLE_SCHEMA,
         "metrics": METRICS_TABLE_SCHEMA,
         "memories": USER_MEMORY_TABLE_SCHEMA,
-        "knowledge_contents": KNOWLEDGE_TABLE_SCHEMA,
+        "knowledge": KNOWLEDGE_TABLE_SCHEMA,
+        "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
+        "versions": VERSIONS_TABLE_SCHEMA,
     }
     schema = schemas.get(table_type, {})