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

agno/os/routers/memory/memory.py

@@ -0,0 +1,179 @@
+import logging
+import math
+from typing import List, Optional
+from uuid import uuid4
+
+from fastapi import Depends, HTTPException, Path, Query
+from fastapi.routing import APIRouter
+
+from agno.db.base import BaseDb
+from agno.db.schemas import UserMemory
+from agno.os.auth import get_authentication_dependency
+from agno.os.routers.memory.schemas import (
+    DeleteMemoriesRequest,
+    UserMemoryCreateSchema,
+    UserMemorySchema,
+    UserStatsSchema,
+)
+from agno.os.schema import PaginatedResponse, PaginationInfo, SortOrder
+from agno.os.settings import AgnoAPISettings
+from agno.os.utils import get_db
+
+logger = logging.getLogger(__name__)
+
+
+def get_memory_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoAPISettings(), **kwargs) -> APIRouter:
+    router = APIRouter(dependencies=[Depends(get_authentication_dependency(settings))], tags=["Memory"])
+    return attach_routes(router=router, dbs=dbs)
+
+
+def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
+    @router.post("/memories", response_model=UserMemorySchema, status_code=200)
+    async def create_memory(
+        payload: UserMemoryCreateSchema,
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> UserMemorySchema:
+        db = get_db(dbs, db_id)
+        user_memory = db.upsert_user_memory(
+            memory=UserMemory(
+                memory_id=str(uuid4()),
+                memory=payload.memory,
+                topics=payload.topics or [],
+                user_id=payload.user_id,
+            ),
+            deserialize=False,
+        )
+        if not user_memory:
+            raise HTTPException(status_code=500, detail="Failed to create memory")
+
+        return UserMemorySchema.from_dict(user_memory)  # type: ignore
+
+    @router.delete("/memories/{memory_id}", status_code=204)
+    async def delete_memory(
+        memory_id: str = Path(), db_id: Optional[str] = Query(default=None, description="The ID of the database to use")
+    ) -> None:
+        db = get_db(dbs, db_id)
+        db.delete_user_memory(memory_id=memory_id)
+
+    @router.delete("/memories", status_code=204)
+    async def delete_memories(
+        request: DeleteMemoriesRequest,
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> None:
+        db = get_db(dbs, db_id)
+        db.delete_user_memories(memory_ids=request.memory_ids)
+
+    @router.get("/memories", response_model=PaginatedResponse[UserMemorySchema], status_code=200)
+    async def get_memories(
+        user_id: Optional[str] = Query(default=None, description="Filter memories by user ID"),
+        agent_id: Optional[str] = Query(default=None, description="Filter memories by agent ID"),
+        team_id: Optional[str] = Query(default=None, description="Filter memories by team ID"),
+        topics: Optional[List[str]] = Depends(parse_topics),
+        search_content: Optional[str] = Query(default=None, description="Fuzzy search memory content"),
+        limit: Optional[int] = Query(default=20, description="Number of memories to return"),
+        page: Optional[int] = Query(default=1, description="Page number"),
+        sort_by: Optional[str] = Query(default="updated_at", description="Field to sort by"),
+        sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> PaginatedResponse[UserMemorySchema]:
+        db = get_db(dbs, db_id)
+        user_memories, total_count = db.get_user_memories(
+            limit=limit,
+            page=page,
+            user_id=user_id,
+            agent_id=agent_id,
+            team_id=team_id,
+            topics=topics,
+            search_content=search_content,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            deserialize=False,
+        )
+        return PaginatedResponse(
+            data=[UserMemorySchema.from_dict(user_memory) for user_memory in user_memories],  # type: ignore
+            meta=PaginationInfo(
+                page=page,
+                limit=limit,
+                total_count=total_count,  # type: ignore
+                total_pages=math.ceil(total_count / limit) if limit is not None and limit > 0 else 0,  # type: ignore
+            ),
+        )
+
+    @router.get("/memories/{memory_id}", response_model=UserMemorySchema, status_code=200)
+    async def get_memory(
+        memory_id: str = Path(),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> UserMemorySchema:
+        db = get_db(dbs, db_id)
+        user_memory = db.get_user_memory(memory_id=memory_id, deserialize=False)
+        if not user_memory:
+            raise HTTPException(status_code=404, detail=f"Memory with ID {memory_id} not found")
+
+        return UserMemorySchema.from_dict(user_memory)  # type: ignore
+
+    @router.get("/memories/topics", response_model=List[str], status_code=200)
+    async def get_topics(
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> List[str]:
+        db = get_db(dbs, db_id)
+        return db.get_all_memory_topics()
+
+    @router.patch("/memories/{memory_id}", response_model=UserMemorySchema, status_code=200)
+    async def update_memory(
+        payload: UserMemoryCreateSchema,
+        memory_id: str = Path(),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> UserMemorySchema:
+        db = get_db(dbs, db_id)
+        user_memory = db.upsert_user_memory(
+            memory=UserMemory(
+                memory_id=memory_id,
+                memory=payload.memory,
+                topics=payload.topics or [],
+                user_id=payload.user_id,
+            ),
+            deserialize=False,
+        )
+        if not user_memory:
+            raise HTTPException(status_code=500, detail="Failed to update memory")
+
+        return UserMemorySchema.from_dict(user_memory)  # type: ignore
+
+    @router.get("/user_memory_stats", response_model=PaginatedResponse[UserStatsSchema], status_code=200)
+    async def get_user_memory_stats(
+        limit: Optional[int] = Query(default=20, description="Number of items to return"),
+        page: Optional[int] = Query(default=1, description="Page number"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> PaginatedResponse[UserStatsSchema]:
+        db = get_db(dbs, db_id)
+        try:
+            user_stats, total_count = db.get_user_memory_stats(
+                limit=limit,
+                page=page,
+            )
+            return PaginatedResponse(
+                data=[UserStatsSchema.from_dict(stats) for stats in user_stats],
+                meta=PaginationInfo(
+                    page=page,
+                    limit=limit,
+                    total_count=total_count,
+                    total_pages=(total_count + limit - 1) // limit if limit is not None and limit > 0 else 0,
+                ),
+            )
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to get user statistics: {str(e)}")
+
+    return router
+
+
+def parse_topics(topics: Optional[List[str]] = Query(default=None)) -> Optional[List[str]]:
+    """Parse a comma-separated string of topics into a list of topics"""
+    if not topics:
+        return None
+
+    try:
+        return [topic.strip() for topic in topics[0].split(",") if topic.strip()]
+
+    except Exception as e:
+        raise HTTPException(status_code=422, detail=f"Invalid topics: {e}")

agno/os/routers/memory/schemas.py

@@ -0,0 +1,58 @@
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+
+class DeleteMemoriesRequest(BaseModel):
+    memory_ids: List[str]
+
+
+class UserMemorySchema(BaseModel):
+    memory_id: str
+    memory: str
+    topics: Optional[List[str]]
+
+    agent_id: Optional[str]
+    team_id: Optional[str]
+    user_id: Optional[str]
+
+    updated_at: Optional[datetime]
+
+    @classmethod
+    def from_dict(cls, memory_dict: Dict[str, Any]) -> "UserMemorySchema":
+        return cls(
+            memory_id=memory_dict["memory_id"],
+            user_id=str(memory_dict["user_id"]),
+            agent_id=memory_dict.get("agent_id"),
+            team_id=memory_dict.get("team_id"),
+            memory=memory_dict["memory"],
+            topics=memory_dict.get("topics", []),
+            updated_at=memory_dict["updated_at"],
+        )
+
+
+class UserMemoryCreateSchema(BaseModel):
+    """Define the payload expected for creating a new user memory"""
+
+    memory: str
+    user_id: str
+    topics: Optional[List[str]] = None
+
+
+class UserStatsSchema(BaseModel):
+    """Schema for user memory statistics"""
+
+    user_id: str
+    total_memories: int
+    last_memory_updated_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, user_stats_dict: Dict[str, Any]) -> "UserStatsSchema":
+        updated_at = user_stats_dict.get("last_memory_updated_at")
+
+        return cls(
+            user_id=str(user_stats_dict["user_id"]),
+            total_memories=user_stats_dict["total_memories"],
+            last_memory_updated_at=datetime.fromtimestamp(updated_at, tz=timezone.utc) if updated_at else None,
+        )

agno/os/routers/metrics/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.routers.metrics.metrics import get_metrics_router
+
+__all__ = ["get_metrics_router"]

agno/os/routers/metrics/metrics.py

@@ -0,0 +1,58 @@
+import logging
+from datetime import date, datetime, timezone
+from typing import List, Optional
+
+from fastapi import Depends, HTTPException, Query
+from fastapi.routing import APIRouter
+
+from agno.db.base import BaseDb
+from agno.os.auth import get_authentication_dependency
+from agno.os.routers.metrics.schemas import DayAggregatedMetrics, MetricsResponse
+from agno.os.settings import AgnoAPISettings
+from agno.os.utils import get_db
+
+logger = logging.getLogger(__name__)
+
+
+def get_metrics_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoAPISettings(), **kwargs) -> APIRouter:
+    router = APIRouter(dependencies=[Depends(get_authentication_dependency(settings))], tags=["Metrics"])
+    return attach_routes(router=router, dbs=dbs)
+
+
+def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
+    @router.get("/metrics", response_model=MetricsResponse, status_code=200)
+    async def get_metrics(
+        starting_date: Optional[date] = Query(default=None, description="Starting date to filter metrics (YYYY-MM-DD)"),
+        ending_date: Optional[date] = Query(default=None, description="Ending date to filter metrics (YYYY-MM-DD)"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> MetricsResponse:
+        try:
+            db = get_db(dbs, db_id)
+            metrics, latest_updated_at = db.get_metrics(starting_date=starting_date, ending_date=ending_date)
+
+            return MetricsResponse(
+                metrics=[DayAggregatedMetrics.from_dict(metric) for metric in metrics],
+                updated_at=datetime.fromtimestamp(latest_updated_at, tz=timezone.utc)
+                if latest_updated_at is not None
+                else None,
+            )
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error getting metrics: {str(e)}")
+
+    @router.post("/metrics/refresh", response_model=List[DayAggregatedMetrics], status_code=200)
+    async def calculate_metrics(
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> List[DayAggregatedMetrics]:
+        try:
+            db = get_db(dbs, db_id)
+            result = db.calculate_metrics()
+            if result is None:
+                return []
+
+            return [DayAggregatedMetrics.from_dict(metric) for metric in result]
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error refreshing metrics: {str(e)}")
+
+    return router

agno/os/routers/metrics/schemas.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+
+class DayAggregatedMetrics(BaseModel):
+    """Aggregated metrics for a given day"""
+
+    id: str
+
+    agent_runs_count: int
+    agent_sessions_count: int
+    team_runs_count: int
+    team_sessions_count: int
+    workflow_runs_count: int
+    workflow_sessions_count: int
+    users_count: int
+    token_metrics: Dict[str, Any]
+    model_metrics: List[Dict[str, Any]]
+
+    date: datetime
+    created_at: int
+    updated_at: int
+
+    @classmethod
+    def from_dict(cls, metrics_dict: Dict[str, Any]) -> "DayAggregatedMetrics":
+        return cls(
+            agent_runs_count=metrics_dict.get("agent_runs_count", 0),
+            agent_sessions_count=metrics_dict.get("agent_sessions_count", 0),
+            created_at=metrics_dict.get("created_at", 0),
+            date=metrics_dict.get("date", datetime.now()),
+            id=metrics_dict.get("id", ""),
+            model_metrics=metrics_dict.get("model_metrics", {}),
+            team_runs_count=metrics_dict.get("team_runs_count", 0),
+            team_sessions_count=metrics_dict.get("team_sessions_count", 0),
+            token_metrics=metrics_dict.get("token_metrics", {}),
+            updated_at=metrics_dict.get("updated_at", 0),
+            users_count=metrics_dict.get("users_count", 0),
+            workflow_runs_count=metrics_dict.get("workflow_runs_count", 0),
+            workflow_sessions_count=metrics_dict.get("workflow_sessions_count", 0),
+        )
+
+
+class MetricsResponse(BaseModel):
+    metrics: List[DayAggregatedMetrics]
+    updated_at: Optional[datetime]

agno/os/routers/session/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.routers.session.session import get_session_router
+
+__all__ = ["get_session_router"]

agno/os/routers/session/session.py

@@ -0,0 +1,163 @@
+import logging
+from typing import List, Optional, Union
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query
+
+from agno.db.base import BaseDb, SessionType
+from agno.os.auth import get_authentication_dependency
+from agno.os.schema import (
+    AgentSessionDetailSchema,
+    DeleteSessionRequest,
+    PaginatedResponse,
+    PaginationInfo,
+    RunSchema,
+    SessionSchema,
+    SortOrder,
+    TeamRunSchema,
+    TeamSessionDetailSchema,
+    WorkflowRunSchema,
+    WorkflowSessionDetailSchema,
+)
+from agno.os.settings import AgnoAPISettings
+from agno.os.utils import get_db
+
+logger = logging.getLogger(__name__)
+
+
+def get_session_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoAPISettings()) -> APIRouter:
+    session_router = APIRouter(dependencies=[Depends(get_authentication_dependency(settings))], tags=["Sessions"])
+    return attach_routes(router=session_router, dbs=dbs)
+
+
+def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
+    @router.get("/sessions", response_model=PaginatedResponse[SessionSchema], status_code=200)
+    async def get_sessions(
+        session_type: SessionType = Query(default=SessionType.AGENT, alias="type"),
+        component_id: Optional[str] = Query(default=None, description="Filter sessions by component ID"),
+        user_id: Optional[str] = Query(default=None, description="Filter sessions by user ID"),
+        session_name: Optional[str] = Query(default=None, description="Filter sessions by name"),
+        limit: Optional[int] = Query(default=20, description="Number of sessions to return"),
+        page: Optional[int] = Query(default=1, description="Page number"),
+        sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
+        sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> PaginatedResponse[SessionSchema]:
+        db = get_db(dbs, db_id)
+        sessions, total_count = db.get_sessions(
+            session_type=session_type,
+            component_id=component_id,
+            user_id=user_id,
+            session_name=session_name,
+            limit=limit,
+            page=page,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            deserialize=False,
+        )
+
+        return PaginatedResponse(
+            data=[SessionSchema.from_dict(session) for session in sessions],  # type: ignore
+            meta=PaginationInfo(
+                page=page,
+                limit=limit,
+                total_count=total_count,  # type: ignore
+                total_pages=(total_count + limit - 1) // limit if limit is not None and limit > 0 else 0,  # type: ignore
+            ),
+        )
+
+    @router.get(
+        "/sessions/{session_id}",
+        response_model=Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema],
+        status_code=200,
+    )
+    async def get_session_by_id(
+        session_id: str = Path(...),
+        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
+        db = get_db(dbs, db_id)
+        session = db.get_session(session_id=session_id, session_type=session_type)
+        if not session:
+            raise HTTPException(status_code=404, detail=f"Session with id '{session_id}' not found")
+
+        if session_type == SessionType.AGENT:
+            return AgentSessionDetailSchema.from_session(session)  # type: ignore
+        elif session_type == SessionType.TEAM:
+            return TeamSessionDetailSchema.from_session(session)  # type: ignore
+        else:
+            return WorkflowSessionDetailSchema.from_session(session)  # type: ignore
+
+    @router.get(
+        "/sessions/{session_id}/runs",
+        response_model=Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]],
+        status_code=200,
+    )
+    async def get_session_runs(
+        session_id: str = Path(..., description="Session ID", alias="session_id"),
+        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]]:
+        db = get_db(dbs, db_id)
+        session = db.get_session(session_id=session_id, session_type=session_type, deserialize=False)
+        if not session:
+            raise HTTPException(status_code=404, detail=f"Session with ID {session_id} not found")
+
+        runs = session.get("runs")  # type: ignore
+        if not runs:
+            raise HTTPException(status_code=404, detail=f"Session with ID {session_id} has no runs")
+
+        if session_type == SessionType.AGENT:
+            return [RunSchema.from_dict(run) for run in runs]
+
+        elif session_type == SessionType.TEAM:
+            return [TeamRunSchema.from_dict(run) for run in runs]
+
+        elif session_type == SessionType.WORKFLOW:
+            return [WorkflowRunSchema.from_dict(run) for run in runs]
+
+        else:
+            return [RunSchema.from_dict(run) for run in runs]
+
+    @router.delete("/sessions/{session_id}", status_code=204)
+    async def delete_session(
+        session_id: str = Path(...),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> None:
+        db = get_db(dbs, db_id)
+        db.delete_session(session_id=session_id)
+
+    @router.delete("/sessions", status_code=204)
+    async def delete_sessions(
+        request: DeleteSessionRequest,
+        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> None:
+        if len(request.session_ids) != len(request.session_types):
+            raise HTTPException(status_code=400, detail="Session IDs and session types must have the same length")
+
+        db = get_db(dbs, db_id)
+        db.delete_sessions(session_ids=request.session_ids)
+
+    @router.post(
+        "/sessions/{session_id}/rename",
+        response_model=Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema],
+    )
+    async def rename_session(
+        session_id: str = Path(...),
+        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
+        session_name: str = Body(embed=True),
+        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+    ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
+        db = get_db(dbs, db_id)
+        session = db.rename_session(session_id=session_id, session_type=session_type, session_name=session_name)
+        if not session:
+            raise HTTPException(status_code=404, detail=f"Session with id '{session_id}' not found")
+
+        if session_type == SessionType.AGENT:
+            return AgentSessionDetailSchema.from_session(session)  # type: ignore
+        elif session_type == SessionType.TEAM:
+            return TeamSessionDetailSchema.from_session(session)  # type: ignore
+        else:
+            return WorkflowSessionDetailSchema.from_session(session)  # type: ignore
+
+    return router