agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/db/redis/schemas.py

@@ -0,0 +1,109 @@
+"""Table schemas and related utils used by the RedisDb class"""
+
+from typing import Any
+
+SESSION_SCHEMA = {
+    "session_id": {"type": "string", "primary_key": True},
+    "session_type": {"type": "string"},
+    "agent_id": {"type": "string"},
+    "team_id": {"type": "string"},
+    "workflow_id": {"type": "string"},
+    "user_id": {"type": "string"},
+    "session_data": {"type": "json"},
+    "agent_data": {"type": "json"},
+    "team_data": {"type": "json"},
+    "workflow_data": {"type": "json"},
+    "metadata": {"type": "json"},
+    "runs": {"type": "json"},
+    "summary": {"type": "json"},
+    "created_at": {"type": "integer"},
+    "updated_at": {"type": "integer"},
+}
+
+USER_MEMORY_SCHEMA = {
+    "memory_id": {"type": "string", "primary_key": True},
+    "memory": {"type": "json"},
+    "agent_id": {"type": "string"},
+    "team_id": {"type": "string"},
+    "user_id": {"type": "string"},
+    "topics": {"type": "json"},
+    "updated_at": {"type": "integer"},
+}
+
+METRICS_SCHEMA = {
+    "id": {"type": "string", "primary_key": True},
+    "agent_runs_count": {"type": "integer", "default": 0},
+    "team_runs_count": {"type": "integer", "default": 0},
+    "workflow_runs_count": {"type": "integer", "default": 0},
+    "agent_sessions_count": {"type": "integer", "default": 0},
+    "team_sessions_count": {"type": "integer", "default": 0},
+    "workflow_sessions_count": {"type": "integer", "default": 0},
+    "users_count": {"type": "integer", "default": 0},
+    "token_metrics": {"type": "json", "default": {}},
+    "model_metrics": {"type": "json", "default": {}},
+    "date": {"type": "date"},
+    "aggregation_period": {"type": "string"},
+    "created_at": {"type": "integer"},
+    "updated_at": {"type": "integer"},
+    "completed": {"type": "boolean", "default": False},
+}
+
+EVAL_SCHEMA = {
+    "run_id": {"type": "string", "primary_key": True},
+    "eval_type": {"type": "string"},
+    "eval_data": {"type": "json"},
+    "eval_input": {"type": "json"},
+    "name": {"type": "string"},
+    "agent_id": {"type": "string"},
+    "team_id": {"type": "string"},
+    "workflow_id": {"type": "string"},
+    "model_id": {"type": "string"},
+    "model_provider": {"type": "string"},
+    "evaluated_component_name": {"type": "string"},
+    "created_at": {"type": "integer"},
+    "updated_at": {"type": "integer"},
+}
+
+KNOWLEDGE_SCHEMA = {
+    "id": {"type": "string", "primary_key": True},
+    "name": {"type": "string"},
+    "description": {"type": "string"},
+    "metadata": {"type": "json"},
+    "type": {"type": "string"},
+    "size": {"type": "integer"},
+    "linked_to": {"type": "string"},
+    "access_count": {"type": "integer"},
+    "created_at": {"type": "integer"},
+    "updated_at": {"type": "integer"},
+    "status": {"type": "string"},
+    "status_message": {"type": "string"},
+    "external_id": {"type": "string"},
+}
+
+
+def get_table_schema_definition(table_type: str) -> dict[str, Any]:
+    """
+    Get the expected schema definition for the given table.
+
+    For Redis, we don't need actual schemas since it's a key-value store,
+    but we maintain this for compatibility with the base interface.
+
+    Args:
+        table_type (str): The type of table to get the schema for.
+
+    Returns:
+        Dict[str, Any]: Dictionary containing schema information for the table
+    """
+    schemas = {
+        "sessions": SESSION_SCHEMA,
+        "memories": USER_MEMORY_SCHEMA,
+        "metrics": METRICS_SCHEMA,
+        "evals": EVAL_SCHEMA,
+        "knowledge": KNOWLEDGE_SCHEMA,
+    }
+
+    schema = schemas.get(table_type, {})
+    if not schema:
+        raise ValueError(f"Unknown table type: {table_type}")
+
+    return schema

agno/db/redis/utils.py

@@ -0,0 +1,288 @@
+"""Utility functions for the Redis database class."""
+
+import json
+import time
+from datetime import date, datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from agno.utils.log import log_warning
+
+try:
+    from redis import Redis
+except ImportError:
+    raise ImportError("`redis` not installed. Please install it using `pip install redis`")
+
+
+# -- Serialization and deserialization --
+
+
+class CustomEncoder(json.JSONEncoder):
+    """Custom encoder to handle non JSON serializable types."""
+
+    def default(self, obj):
+        if isinstance(obj, UUID):
+            return str(obj)
+        elif isinstance(obj, (date, datetime)):
+            return obj.isoformat()
+
+        return super().default(obj)
+
+
+def serialize_data(data: dict) -> str:
+    return json.dumps(data, ensure_ascii=False, cls=CustomEncoder)
+
+
+def deserialize_data(data: str) -> dict:
+    return json.loads(data)
+
+
+# -- Redis utils --
+
+
+def generate_redis_key(prefix: str, table_type: str, key_id: str) -> str:
+    """Generate Redis key with proper namespacing."""
+    return f"{prefix}:{table_type}:{key_id}"
+
+
+def generate_index_key(prefix: str, table_type: str, index_field: str, index_value: str) -> str:
+    """Generate Redis key for index entries."""
+    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]:
+    """Get all relevant keys for the given table type.
+
+    Args:
+        redis_client (Redis): The Redis client.
+        prefix (str): The prefix for the keys.
+        table_type (str): The table type.
+
+    Returns:
+        List[str]: A list of all relevant keys for the given table type.
+    """
+    pattern = f"{prefix}:{table_type}:*"
+    all_keys = redis_client.scan_iter(match=pattern)
+    relevant_keys = []
+
+    for key in all_keys:
+        if ":index:" in key:  # Skip index keys
+            continue
+        relevant_keys.append(key)
+
+    return relevant_keys
+
+
+# -- DB util methods --
+
+
+def apply_sorting(
+    records: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
+) -> List[Dict[str, Any]]:
+    if sort_by is None:
+        return records
+
+    def get_sort_key(record):
+        value = record.get(sort_by, 0)
+        if value is None:
+            return 0 if isinstance(records[0].get(sort_by, 0), (int, float)) else ""
+        return value
+
+    try:
+        is_reverse = sort_order == "desc"
+        return sorted(records, key=get_sort_key, reverse=is_reverse)
+
+    except Exception as e:
+        log_warning(f"Error sorting Redisrecords: {e}")
+        return records
+
+
+def apply_pagination(
+    records: List[Dict[str, Any]], limit: Optional[int] = None, page: Optional[int] = None
+) -> List[Dict[str, Any]]:
+    if limit is None:
+        return records
+
+    if page is not None and page > 0:
+        start_idx = (page - 1) * limit
+        end_idx = start_idx + limit
+        return records[start_idx:end_idx]
+
+    return records[:limit]
+
+
+def apply_filters(records: List[Dict[str, Any]], conditions: Dict[str, Any]) -> List[Dict[str, Any]]:
+    if not conditions:
+        return records
+
+    filtered_records = []
+    for record in records:
+        match = True
+        for key, value in conditions.items():
+            if key not in record or record[key] != value:
+                match = False
+                break
+        if match:
+            filtered_records.append(record)
+
+    return filtered_records
+
+
+def create_index_entries(
+    redis_client: Redis,
+    prefix: str,
+    table_type: str,
+    record_id: str,
+    record_data: Dict[str, Any],
+    index_fields: List[str],
+) -> None:
+    for field in index_fields:
+        if field in record_data and record_data[field] is not None:
+            index_key = generate_index_key(prefix, table_type, field, str(record_data[field]))
+            redis_client.sadd(index_key, record_id)
+
+
+def remove_index_entries(
+    redis_client: Redis,
+    prefix: str,
+    table_type: str,
+    record_id: str,
+    record_data: Dict[str, Any],
+    index_fields: List[str],
+) -> None:
+    for field in index_fields:
+        if field in record_data and record_data[field] is not None:
+            index_key = generate_index_key(prefix, table_type, field, str(record_data[field]))
+            redis_client.srem(index_key, record_id)
+
+
+# -- Metrics utils --
+
+
+def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
+    """Calculate metrics for the given date.
+
+    Args:
+        date_to_process (date): The date to calculate metrics for.
+        sessions_data (dict): The sessions data.
+
+    Returns:
+        dict: A dictionary with the calculated metrics.
+    """
+    metrics = {
+        "users_count": 0,
+        "agent_sessions_count": 0,
+        "team_sessions_count": 0,
+        "workflow_sessions_count": 0,
+        "agent_runs_count": 0,
+        "team_runs_count": 0,
+        "workflow_runs_count": 0,
+    }
+    token_metrics = {
+        "input_tokens": 0,
+        "output_tokens": 0,
+        "total_tokens": 0,
+        "audio_total_tokens": 0,
+        "audio_input_tokens": 0,
+        "audio_output_tokens": 0,
+        "cache_read_tokens": 0,
+        "cache_write_tokens": 0,
+        "reasoning_tokens": 0,
+    }
+    model_counts: Dict[str, int] = {}
+
+    session_types = [
+        ("agent", "agent_sessions_count", "agent_runs_count"),
+        ("team", "team_sessions_count", "team_runs_count"),
+        ("workflow", "workflow_sessions_count", "workflow_runs_count"),
+    ]
+    all_user_ids = set()
+
+    for session_type, sessions_count_key, runs_count_key in session_types:
+        sessions = sessions_data.get(session_type, [])
+        metrics[sessions_count_key] = len(sessions)
+
+        for session in sessions:
+            if session.get("user_id"):
+                all_user_ids.add(session["user_id"])
+            metrics[runs_count_key] += len(session.get("runs", []))
+            if runs := session.get("runs", []):
+                for run in runs:
+                    if model_id := run.get("model"):
+                        model_provider = run.get("model_provider", "")
+                        model_counts[f"{model_id}:{model_provider}"] = (
+                            model_counts.get(f"{model_id}:{model_provider}", 0) + 1
+                        )
+
+            session_metrics = session.get("session_data", {}).get("session_metrics", {})
+            for field in token_metrics:
+                token_metrics[field] += session_metrics.get(field, 0)
+
+    model_metrics = []
+    for model, count in model_counts.items():
+        model_id, model_provider = model.split(":")
+        model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
+
+    metrics["users_count"] = len(all_user_ids)
+    current_time = int(time.time())
+
+    # Create a deterministic ID based on date and aggregation period. This simplifies avoiding duplicates
+    metric_id = f"{date_to_process.isoformat()}_daily"
+
+    return {
+        "id": metric_id,
+        "date": date_to_process,
+        "completed": date_to_process < datetime.now(timezone.utc).date(),
+        "token_metrics": token_metrics,
+        "model_metrics": model_metrics,
+        "created_at": current_time,
+        "updated_at": current_time,
+        "aggregation_period": "daily",
+        **metrics,
+    }
+
+
+def fetch_all_sessions_data(
+    sessions: List[Dict[str, Any]], dates_to_process: list[date], start_timestamp: int
+) -> Optional[dict]:
+    """Return all session data for the given dates, for all session types.
+
+    Args:
+        sessions (List[Dict[str, Any]]): The sessions data.
+        dates_to_process (list[date]): The dates to process.
+        start_timestamp (int): The start timestamp.
+
+    Returns:
+        Optional[dict]: A dictionary with the session data for the given dates, for all session types.
+    """
+    if not dates_to_process:
+        return None
+
+    all_sessions_data: Dict[str, Dict[str, List[Dict[str, Any]]]] = {
+        date_to_process.isoformat(): {"agent": [], "team": [], "workflow": []} for date_to_process in dates_to_process
+    }
+
+    for session in sessions:
+        session_date = (
+            datetime.fromtimestamp(session.get("created_at", start_timestamp), tz=timezone.utc).date().isoformat()
+        )
+        if session_date in all_sessions_data:
+            all_sessions_data[session_date][session["session_type"]].append(session)
+
+    return all_sessions_data
+
+
+def get_dates_to_calculate_metrics_for(starting_date: date) -> list[date]:
+    """Return the list of dates to calculate metrics for.
+
+    Args:
+        starting_date (date): The starting date.
+
+    Returns:
+        list[date]: The list of dates to calculate metrics for.
+    """
+    today = datetime.now(timezone.utc).date()
+    days_diff = (today - starting_date).days + 1
+    if days_diff <= 0:
+        return []
+    return [starting_date + timedelta(days=x) for x in range(days_diff)]

agno/db/schemas/__init__.py

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

agno/db/schemas/evals.py

@@ -0,0 +1,33 @@
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel
+
+
+class EvalType(str, Enum):
+    ACCURACY = "accuracy"
+    PERFORMANCE = "performance"
+    RELIABILITY = "reliability"
+
+
+class EvalFilterType(str, Enum):
+    AGENT = "agent"
+    TEAM = "team"
+    WORKFLOW = "workflow"
+
+
+class EvalRunRecord(BaseModel):
+    """Evaluation run results stored in the database"""
+
+    agent_id: Optional[str] = None
+    model_id: Optional[str] = None
+    model_provider: Optional[str] = None
+    team_id: Optional[str] = None
+    workflow_id: Optional[str] = None
+    name: Optional[str] = None
+    evaluated_component_name: Optional[str] = None
+
+    run_id: str
+    eval_type: EvalType
+    eval_data: Dict[str, Any]
+    eval_input: Optional[Dict[str, Any]] = None

agno/db/schemas/knowledge.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+
+class KnowledgeRow(BaseModel):
+    """Knowledge Row that is stored in the database"""
+
+    # id for this knowledge, auto-generated if not provided
+    id: Optional[str] = None
+    name: str
+    description: str
+    metadata: Optional[Dict[str, Any]] = None
+    type: Optional[str] = None
+    size: Optional[int] = None
+    linked_to: Optional[str] = None
+    access_count: Optional[int] = None
+    status: Optional[str] = None
+    status_message: Optional[str] = None
+    created_at: Optional[int] = None
+    updated_at: Optional[int] = None
+    external_id: Optional[str] = None
+
+    model_config = ConfigDict(from_attributes=True, arbitrary_types_allowed=True)
+
+    @model_validator(mode="after")
+    def generate_id(self) -> "KnowledgeRow":
+        if self.id is None:
+            from uuid import uuid4
+
+            self.id = str(uuid4())
+        return self
+
+    def to_dict(self) -> Dict[str, Any]:
+        _dict = self.model_dump(exclude={"updated_at"})
+
+        _dict["updated_at"] = datetime.fromtimestamp(self.updated_at).isoformat() if self.updated_at else None
+
+        return _dict

agno/db/schemas/memory.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class UserMemory:
+    """Model for User Memories"""
+
+    memory: str
+    memory_id: Optional[str] = None
+    topics: Optional[List[str]] = None
+    user_id: Optional[str] = None
+    input: Optional[str] = None
+    updated_at: Optional[datetime] = None
+    feedback: Optional[str] = None
+
+    agent_id: Optional[str] = None
+    team_id: Optional[str] = None
+
+    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,
+            "input": self.input,
+            "user_id": self.user_id,
+            "agent_id": self.agent_id,
+            "team_id": self.team_id,
+            "feedback": self.feedback,
+        }
+        return {k: v for k, v in _dict.items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "UserMemory":
+        data = dict(data)
+
+        # Convert updated_at to datetime
+        if updated_at := data.get("updated_at"):
+            if isinstance(updated_at, (int, float)):
+                data["updated_at"] = datetime.fromtimestamp(updated_at, tz=timezone.utc)
+            else:
+                data["updated_at"] = datetime.fromisoformat(updated_at)
+
+        return cls(**data)

agno/db/singlestore/__init__.py

@@ -0,0 +1,3 @@
+from agno.db.singlestore.singlestore import SingleStoreDb
+
+__all__ = ["SingleStoreDb"]

agno/db/singlestore/schemas.py

@@ -0,0 +1,116 @@
+"""Table schemas and related utils used by the SingleStoreDb class"""
+
+from typing import Any
+
+try:
+    from sqlalchemy.types import JSON, BigInteger, Boolean, Date, String, Text
+except ImportError:
+    raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
+
+SESSION_TABLE_SCHEMA = {
+    "session_id": {"type": lambda: String(128), "nullable": False},
+    "session_type": {"type": lambda: String(20), "nullable": False, "index": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+    "workflow_id": {"type": lambda: String(128), "nullable": True},
+    "user_id": {"type": lambda: String(128), "nullable": True},
+    "session_data": {"type": JSON, "nullable": True},
+    "agent_data": {"type": JSON, "nullable": True},
+    "team_data": {"type": JSON, "nullable": True},
+    "workflow_data": {"type": JSON, "nullable": True},
+    "metadata": {"type": JSON, "nullable": True},
+    "runs": {"type": JSON, "nullable": True},
+    "summary": {"type": JSON, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "_unique_constraints": [
+        {
+            "name": "uq_session_id",
+            "columns": ["session_id"],
+        },
+    ],
+}
+
+USER_MEMORY_TABLE_SCHEMA = {
+    "memory_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "memory": {"type": JSON, "nullable": False},
+    "input": {"type": Text, "nullable": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+    "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "topics": {"type": JSON, "nullable": True},
+    "updated_at": {"type": BigInteger, "nullable": True, "index": True},
+}
+
+EVAL_TABLE_SCHEMA = {
+    "run_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "eval_type": {"type": lambda: String(50), "nullable": False},
+    "eval_data": {"type": JSON, "nullable": False},
+    "eval_input": {"type": JSON, "nullable": False},
+    "name": {"type": lambda: String(255), "nullable": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True},
+    "team_id": {"type": lambda: String(128), "nullable": True},
+    "workflow_id": {"type": lambda: String(128), "nullable": True},
+    "model_id": {"type": lambda: String(128), "nullable": True},
+    "model_provider": {"type": lambda: String(50), "nullable": True},
+    "evaluated_component_name": {"type": lambda: String(255), "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+}
+
+KNOWLEDGE_TABLE_SCHEMA = {
+    "id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "name": {"type": lambda: String(255), "nullable": False},
+    "description": {"type": Text, "nullable": False},
+    "metadata": {"type": JSON, "nullable": True},
+    "type": {"type": lambda: String(50), "nullable": True},
+    "size": {"type": BigInteger, "nullable": True},
+    "linked_to": {"type": lambda: String(128), "nullable": True},
+    "access_count": {"type": BigInteger, "nullable": True},
+    "status": {"type": lambda: String(50), "nullable": True},
+    "status_message": {"type": Text, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": True},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "external_id": {"type": lambda: String(128), "nullable": True},
+}
+
+METRICS_TABLE_SCHEMA = {
+    "id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "agent_runs_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "team_runs_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "workflow_runs_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "agent_sessions_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "team_sessions_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "workflow_sessions_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "users_count": {"type": BigInteger, "nullable": False, "default": 0},
+    "token_metrics": {"type": JSON, "nullable": False, "default": {}},
+    "model_metrics": {"type": JSON, "nullable": False, "default": {}},
+    "date": {"type": Date, "nullable": False, "index": True},
+    "aggregation_period": {"type": lambda: String(20), "nullable": False, "index": True},
+    "created_at": {"type": BigInteger, "nullable": False},
+    "updated_at": {"type": BigInteger, "nullable": True},
+    "completed": {"type": Boolean, "nullable": False, "default": False},
+}
+
+
+def get_table_schema_definition(table_type: str) -> dict[str, Any]:
+    """
+    Get the expected schema definition for the given table.
+    Args:
+        table_type (str): The type of table to get the schema for.
+    Returns:
+        Dict[str, Any]: Dictionary containing column definitions for the table
+    """
+    schemas = {
+        "sessions": SESSION_TABLE_SCHEMA,
+        "evals": EVAL_TABLE_SCHEMA,
+        "metrics": METRICS_TABLE_SCHEMA,
+        "memories": USER_MEMORY_TABLE_SCHEMA,
+        "knowledge_contents": KNOWLEDGE_TABLE_SCHEMA,
+    }
+    schema = schemas.get(table_type, {})
+
+    if not schema:
+        raise ValueError(f"Unknown table type: {table_type}")
+
+    return schema  # type: ignore[return-value]