agno 2.0.0a1__py3-none-any.whl → 2.0.0rc2__py3-none-any.whl

agno/os/app.py

@@ -1,5 +1,7 @@
+from contextlib import asynccontextmanager
+from functools import partial
 from os import getenv
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
 from fastapi import FastAPI, HTTPException
@@ -34,16 +36,31 @@ from agno.os.routers.session import get_session_router
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import generate_id
 from agno.team.team import Team
+from agno.tools.mcp import MCPTools, MultiMCPTools
 from agno.workflow.workflow import Workflow
 
 
-class AgentOS:
-    host_url: Optional[str] = None
+@asynccontextmanager
+async def mcp_lifespan(app, mcp_tools: List[Union[MCPTools, MultiMCPTools]]):
+    """Manage MCP connection lifecycle inside a FastAPI app"""
+    # Startup logic: connect to all contextual MCP servers
+    for tool in mcp_tools:
+        await tool.connect()
+
+    yield
+
+    # Shutdown logic: Close all contextual MCP connections
+    for tool in mcp_tools:
+        await tool.close()
 
+
+class AgentOS:
     def __init__(
         self,
         os_id: Optional[str] = None,
+        name: Optional[str] = None,
         description: Optional[str] = None,
+        version: Optional[str] = None,
         agents: Optional[List[Agent]] = None,
         teams: Optional[List[Team]] = None,
         workflows: Optional[List[Workflow]] = None,
@@ -51,13 +68,14 @@ class AgentOS:
         config: Optional[Union[str, AgentOSConfig]] = None,
         settings: Optional[AgnoAPISettings] = None,
         fastapi_app: Optional[FastAPI] = None,
+        lifespan: Optional[Any] = None,
+        enable_mcp: bool = False,
         telemetry: bool = True,
     ):
         if not agents and not workflows and not teams:
             raise ValueError("Either agents, teams or workflows must be provided.")
 
         self.config = self._load_yaml_config(config) if isinstance(config, str) else config
-        self.description = description
 
         self.agents: Optional[List[Agent]] = agents
         self.workflows: Optional[List[Workflow]] = workflows
@@ -65,19 +83,36 @@ class AgentOS:
         self.interfaces = interfaces or []
 
         self.settings: AgnoAPISettings = settings or AgnoAPISettings()
-        self.fastapi_app: Optional[FastAPI] = fastapi_app
+
+        self._app_set = False
+        self.fastapi_app: Optional[FastAPI] = None
+        if fastapi_app:
+            self.fastapi_app = fastapi_app
+            self._app_set = True
 
         self.interfaces = interfaces or []
 
         self.os_id: Optional[str] = os_id
+        self.name = name
+        self.version = version
         self.description = description
 
         self.telemetry = telemetry
 
-        self.interfaces_loaded: List[Tuple[str, str]] = []
+        self.enable_mcp = enable_mcp
+        self.lifespan = lifespan
+
+        # List of all MCP tools used inside the AgentOS
+        self.mcp_tools: List[Union[MCPTools, MultiMCPTools]] = []
 
         if self.agents:
             for agent in self.agents:
+                # Track all MCP tools to later handle their connection
+                if agent.tools:
+                    for tool in agent.tools:
+                        if isinstance(tool, MCPTools) or isinstance(tool, MultiMCPTools):
+                            self.mcp_tools.append(tool)
+
                 agent.initialize_agent()
 
                 # Required for the built-in routes to work
@@ -85,6 +120,12 @@ class AgentOS:
 
         if self.teams:
             for team in self.teams:
+                # Track all MCP tools to later handle their connection
+                if team.tools:
+                    for tool in team.tools:
+                        if isinstance(tool, MCPTools) or isinstance(tool, MultiMCPTools):
+                            self.mcp_tools.append(tool)
+
                 team.initialize_team()
 
                 # Required for the built-in routes to work
@@ -99,6 +140,7 @@ class AgentOS:
 
         if self.workflows:
             for workflow in self.workflows:
+                # TODO: track MCP tools in workflow members
                 if not workflow.id:
                     workflow.id = generate_id(workflow.name)
 
@@ -107,6 +149,117 @@ class AgentOS:
 
             log_os_telemetry(launch=OSLaunch(os_id=self.os_id, data=self._get_telemetry_data()))
 
+    def _make_app(self, lifespan: Optional[Any] = None) -> FastAPI:
+        # Adjust the FastAPI app lifespan to handle MCP connections if relevant
+        app_lifespan = lifespan
+        if self.mcp_tools is not None:
+            mcp_tools_lifespan = partial(mcp_lifespan, mcp_tools=self.mcp_tools)
+            # If there is already a lifespan, combine it with the MCP lifespan
+            if lifespan is not None:
+                # Combine both lifespans
+                @asynccontextmanager
+                async def combined_lifespan(app: FastAPI):
+                    # Run both lifespans
+                    async with lifespan(app):  # type: ignore
+                        async with mcp_tools_lifespan(app):  # type: ignore
+                            yield
+
+                app_lifespan = combined_lifespan  # type: ignore
+            else:
+                app_lifespan = mcp_tools_lifespan
+
+        return FastAPI(
+            title=self.name or "Agno AgentOS",
+            version=self.version or "1.0.0",
+            description=self.description or "An agent operating system.",
+            docs_url="/docs" if self.settings.docs_enabled else None,
+            redoc_url="/redoc" if self.settings.docs_enabled else None,
+            openapi_url="/openapi.json" if self.settings.docs_enabled else None,
+            lifespan=app_lifespan,
+        )
+
+    def get_app(self) -> FastAPI:
+        if not self.fastapi_app:
+            if self.enable_mcp:
+                from contextlib import asynccontextmanager
+
+                from agno.os.mcp import get_mcp_server
+
+                self.mcp_app = get_mcp_server(self)
+
+                final_lifespan = self.mcp_app.lifespan
+                if self.lifespan is not None:
+                    # Combine both lifespans
+                    @asynccontextmanager
+                    async def combined_lifespan(app: FastAPI):
+                        # Run both lifespans
+                        async with self.lifespan(app):  # type: ignore
+                            async with self.mcp_app.lifespan(app):  # type: ignore
+                                yield
+
+                    final_lifespan = combined_lifespan  # type: ignore
+
+                self.fastapi_app = self._make_app(lifespan=final_lifespan)
+            else:
+                self.fastapi_app = self._make_app(lifespan=self.lifespan)
+
+        # Add routes
+        self.fastapi_app.include_router(get_base_router(self, settings=self.settings))
+
+        for interface in self.interfaces:
+            interface_router = interface.get_router()
+            self.fastapi_app.include_router(interface_router)
+
+        self._auto_discover_databases()
+        self._auto_discover_knowledge_instances()
+        self._setup_routers()
+
+        # Mount MCP if needed
+        if self.enable_mcp and self.mcp_app:
+            self.fastapi_app.mount("/", self.mcp_app)
+
+        # Add middleware (only if app is not set)
+        if not self._app_set:
+
+            @self.fastapi_app.exception_handler(HTTPException)
+            async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+                return JSONResponse(
+                    status_code=exc.status_code,
+                    content={"detail": str(exc.detail)},
+                )
+
+            async def general_exception_handler(request: Request, call_next):
+                try:
+                    return await call_next(request)
+                except Exception as e:
+                    return JSONResponse(
+                        status_code=e.status_code if hasattr(e, "status_code") else 500,  # type: ignore
+                        content={"detail": str(e)},
+                    )
+
+            self.fastapi_app.middleware("http")(general_exception_handler)
+
+            self.fastapi_app.add_middleware(
+                CORSMiddleware,
+                allow_origins=self.settings.cors_origin_list,  # type: ignore
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"],
+                expose_headers=["*"],
+            )
+
+        return self.fastapi_app
+
+    def get_routes(self) -> List[Any]:
+        """Retrieve all routes from the FastAPI app.
+
+        Returns:
+            List[Any]: List of routes included in the FastAPI app.
+        """
+        app = self.get_app()
+
+        return app.routes
+
     def _get_telemetry_data(self) -> Dict[str, Any]:
         """Get the telemetry data for the OS"""
         return {
@@ -187,7 +340,7 @@ class AgentOS:
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=SessionDomainConfig(
-                            display_name="Sessions" if not multiple_dbs else "Sessions " + db_id
+                            display_name="Sessions" if not multiple_dbs else "Sessions in database '" + db_id + "'"
                         ),
                     )
                 )
@@ -209,7 +362,7 @@ class AgentOS:
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=MemoryDomainConfig(
-                            display_name="Memory" if not multiple_dbs else "Memory " + db_id
+                            display_name="Memory" if not multiple_dbs else "Memory in database '" + db_id + "'"
                         ),
                     )
                 )
@@ -231,7 +384,7 @@ class AgentOS:
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=KnowledgeDomainConfig(
-                            display_name="Knowledge" if not multiple_dbs else "Knowledge " + db_id
+                            display_name="Knowledge" if not multiple_dbs else "Knowledge in database " + db_id
                         ),
                     )
                 )
@@ -253,7 +406,7 @@ class AgentOS:
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=MetricsDomainConfig(
-                            display_name="Metrics" if not multiple_dbs else "Metrics " + db_id
+                            display_name="Metrics" if not multiple_dbs else "Metrics in database '" + db_id + "'"
                         ),
                     )
                 )
@@ -274,7 +427,9 @@ class AgentOS:
                 evals_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
-                        domain_config=EvalsDomainConfig(display_name="Evals" if not multiple_dbs else "Evals " + db_id),
+                        domain_config=EvalsDomainConfig(
+                            display_name="Evals" if not multiple_dbs else "Evals in database '" + db_id + "'"
+                        ),
                     )
                 )
 
@@ -303,58 +458,6 @@ class AgentOS:
 
         return self.os_id
 
-    def get_app(self) -> FastAPI:
-        if not self.fastapi_app:
-            self.fastapi_app = FastAPI(
-                title=self.settings.title,
-                docs_url="/docs" if self.settings.docs_enabled else None,
-                redoc_url="/redoc" if self.settings.docs_enabled else None,
-                openapi_url="/openapi.json" if self.settings.docs_enabled else None,
-            )
-
-        if not self.fastapi_app:
-            raise Exception("API App could not be created.")
-
-        @self.fastapi_app.exception_handler(HTTPException)
-        async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-            return JSONResponse(
-                status_code=exc.status_code,
-                content={"detail": str(exc.detail)},
-            )
-
-        async def general_exception_handler(request: Request, call_next):
-            try:
-                return await call_next(request)
-            except Exception as e:
-                return JSONResponse(
-                    status_code=e.status_code if hasattr(e, "status_code") else 500,  # type: ignore
-                    content={"detail": str(e)},
-                )
-
-        self.fastapi_app.middleware("http")(general_exception_handler)
-
-        self.fastapi_app.include_router(get_base_router(self, settings=self.settings))
-
-        for interface in self.interfaces:
-            interface_router = interface.get_router()
-            self.fastapi_app.include_router(interface_router)
-            self.interfaces_loaded.append((interface.type, interface.router_prefix))
-
-        self._auto_discover_databases()
-        self._auto_discover_knowledge_instances()
-        self._setup_routers()
-
-        self.fastapi_app.add_middleware(
-            CORSMiddleware,
-            allow_origins=self.settings.cors_origin_list,  # type: ignore
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-            expose_headers=["*"],
-        )
-
-        return self.fastapi_app
-
     def serve(
         self,
         app: Union[str, FastAPI],
@@ -362,6 +465,7 @@ class AgentOS:
         host: str = "localhost",
         port: int = 7777,
         reload: bool = False,
+        workers: Optional[int] = None,
         **kwargs,
     ):
         import uvicorn
@@ -390,4 +494,4 @@ class AgentOS:
             )
         )
 
-        uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)
+        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, **kwargs)

agno/os/interfaces/agui/agui.py

@@ -22,7 +22,7 @@ class AGUI(BaseInterface):
         if not self.agent and not self.team:
             raise ValueError("AGUI requires an agent and a team")
 
-    def get_router(self, use_async: bool = True, **kwargs) -> APIRouter:
+    def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden
         self.router = APIRouter(tags=["AGUI"])
 

agno/os/interfaces/agui/utils.py

@@ -27,6 +27,7 @@ from agno.models.message import Message
 from agno.run.agent import RunContentEvent, RunEvent, RunOutputEvent, RunPausedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunEvent, TeamRunOutputEvent
+from agno.utils.message import get_text_from_message
 
 
 @dataclass
@@ -106,17 +107,23 @@ def extract_team_response_chunk_content(response: TeamRunContentEvent) -> str:
                     members_content.append(f"Team member: {member_content}")
     members_response = "\n".join(members_content) if members_content else ""
 
-    return str(response.content) + members_response
+    # Handle structured outputs
+    main_content = get_text_from_message(response.content) if response.content is not None else ""
+
+    return main_content + members_response
 
 
 def extract_response_chunk_content(response: RunContentEvent) -> str:
     """Given a response stream chunk, find and extract the content."""
+
     if hasattr(response, "messages") and response.messages:  # type: ignore
         for msg in reversed(response.messages):  # type: ignore
             if hasattr(msg, "role") and msg.role == "assistant" and hasattr(msg, "content") and msg.content:
-                return str(msg.content)
+                # Handle structured outputs from messages
+                return get_text_from_message(msg.content)
 
-    return str(response.content) if response.content else ""
+    # Handle structured outputs
+    return get_text_from_message(response.content) if response.content is not None else ""
 
 
 def _create_events_from_chunk(
@@ -212,11 +219,11 @@ def _create_events_from_chunk(
 
     # Handle reasoning
     elif chunk.event == RunEvent.reasoning_started:
-        step_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")  # type: ignore
-        events_to_emit.append(step_event)  # type: ignore
+        step_started_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")  # type: ignore
+        events_to_emit.append(step_started_event)  # type: ignore
     elif chunk.event == RunEvent.reasoning_completed:
-        step_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")  # type: ignore
-        events_to_emit.append(step_event)  # type: ignore
+        step_started_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")  # type: ignore
+        events_to_emit.append(step_started_event)  # type: ignore
 
     return events_to_emit, message_started  # type: ignore
 
@@ -230,7 +237,7 @@ def _create_completion_events(
     run_id: str,
 ) -> List[BaseEvent]:
     """Create events for run completion."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     # End remaining active tool calls if needed
     for tool_call_id in list(event_buffer.active_tool_call_ids):
@@ -308,7 +315,7 @@ def _create_completion_events(
 
 def _emit_event_logic(event: BaseEvent, event_buffer: EventBuffer) -> List[BaseEvent]:
     """Process an event through the buffer and return events to actually emit."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     if event_buffer.is_blocked():
         # Handle events related to the current blocking tool call

agno/os/interfaces/slack/slack.py

@@ -23,10 +23,9 @@ class Slack(BaseInterface):
         if not self.agent and not self.team:
             raise ValueError("Slack requires an agent and a team")
 
-    def get_router(self, use_async: bool = True, **kwargs) -> APIRouter:
+    def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden
-        self.router_prefix = "/slack"
-        self.router = APIRouter(prefix=self.router_prefix, tags=["Slack"])
+        self.router = APIRouter(prefix="/slack", tags=["Slack"])
 
         self.router = attach_routes(router=self.router, agent=self.agent, team=self.team)
 

agno/os/interfaces/whatsapp/whatsapp.py

@@ -20,10 +20,9 @@ class Whatsapp(BaseInterface):
         if not self.agent and not self.team:
             raise ValueError("Whatsapp requires an agent and a team")
 
-    def get_router(self, use_async: bool = True, **kwargs) -> APIRouter:
+    def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden
-        self.router_prefix = "/whatsapp"
-        self.router = APIRouter(prefix=self.router_prefix, tags=["Whatsapp"])
+        self.router = APIRouter(prefix="/whatsapp", tags=["Whatsapp"])
 
         self.router = attach_routes(router=self.router, agent=self.agent, team=self.team)
 

agno/os/mcp.py

@@ -0,0 +1,235 @@
+"""Router for MCP interface providing Model Context Protocol endpoints."""
+
+import logging
+from typing import TYPE_CHECKING, List, Optional
+from uuid import uuid4
+
+from fastmcp import FastMCP
+from fastmcp.server.http import (
+    StarletteWithLifespan,
+)
+
+from agno.db.base import SessionType
+from agno.db.schemas import UserMemory
+from agno.os.routers.memory.schemas import (
+    UserMemorySchema,
+)
+from agno.os.schema import (
+    AgentSummaryResponse,
+    ConfigResponse,
+    InterfaceResponse,
+    SessionSchema,
+    TeamSummaryResponse,
+    WorkflowSummaryResponse,
+)
+from agno.os.utils import (
+    get_agent_by_id,
+    get_db,
+    get_team_by_id,
+    get_workflow_by_id,
+)
+from agno.run.agent import RunOutput
+from agno.run.team import TeamRunOutput
+from agno.run.workflow import WorkflowRunOutput
+
+if TYPE_CHECKING:
+    from agno.os.app import AgentOS
+
+logger = logging.getLogger(__name__)
+
+
+def get_mcp_server(
+    os: "AgentOS",
+) -> StarletteWithLifespan:
+    """Attach MCP routes to the provided router."""
+
+    # Create an MCP server
+    mcp = FastMCP(os.name or "AgentOS")
+
+    @mcp.tool(
+        name="get_agentos_config",
+        description="Get the configuration of the AgentOS",
+        tags={"core"},
+        output_schema=ConfigResponse.model_json_schema(),
+    )  # type: ignore
+    async def config() -> ConfigResponse:
+        return ConfigResponse(
+            os_id=os.os_id or "AgentOS",
+            description=os.description,
+            available_models=os.config.available_models if os.config else [],
+            databases=[db.id for db in os.dbs.values()],
+            chat=os.config.chat if os.config else None,
+            session=os._get_session_config(),
+            memory=os._get_memory_config(),
+            knowledge=os._get_knowledge_config(),
+            evals=os._get_evals_config(),
+            metrics=os._get_metrics_config(),
+            agents=[AgentSummaryResponse.from_agent(agent) for agent in os.agents] if os.agents else [],
+            teams=[TeamSummaryResponse.from_team(team) for team in os.teams] if os.teams else [],
+            workflows=[WorkflowSummaryResponse.from_workflow(w) for w in os.workflows] if os.workflows else [],
+            interfaces=[
+                InterfaceResponse(type=interface.type, version=interface.version, route=interface.router_prefix)
+                for interface in os.interfaces
+            ],
+        )
+
+    @mcp.tool(name="run_agent", description="Run an agent", tags={"core"})  # type: ignore
+    async def run_agent(agent_id: str, message: str) -> RunOutput:
+        agent = get_agent_by_id(agent_id, os.agents)
+        if agent is None:
+            raise Exception(f"Agent {agent_id} not found")
+        return agent.run(message)
+
+    @mcp.tool(name="run_team", description="Run a team", tags={"core"})  # type: ignore
+    async def run_team(team_id: str, message: str) -> TeamRunOutput:
+        team = get_team_by_id(team_id, os.teams)
+        if team is None:
+            raise Exception(f"Team {team_id} not found")
+        return team.run(message)
+
+    @mcp.tool(name="run_workflow", description="Run a workflow", tags={"core"})  # type: ignore
+    async def run_workflow(workflow_id: str, message: str) -> WorkflowRunOutput:
+        workflow = get_workflow_by_id(workflow_id, os.workflows)
+        if workflow is None:
+            raise Exception(f"Workflow {workflow_id} not found")
+        return workflow.run(message)
+
+    # Session Management Tools
+    @mcp.tool(name="get_sessions_for_agent", description="Get list of sessions for an agent", tags={"session"})  # type: ignore
+    async def get_sessions_for_agent(
+        agent_id: str,
+        db_id: str,
+        user_id: Optional[str] = None,
+        sort_by: str = "created_at",
+        sort_order: str = "desc",
+    ):
+        db = get_db(os.dbs, db_id)
+        sessions, _ = db.get_sessions(
+            session_type=SessionType.AGENT,
+            component_id=agent_id,
+            user_id=user_id,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            deserialize=False,
+        )
+
+        return {
+            "data": [SessionSchema.from_dict(session) for session in sessions],  # type: ignore
+        }
+
+    @mcp.tool(name="get_sessions_for_team", description="Get list of sessions for a team", tags={"session"})  # type: ignore
+    async def get_sessions_for_team(
+        team_id: str,
+        db_id: str,
+        user_id: Optional[str] = None,
+        sort_by: str = "created_at",
+        sort_order: str = "desc",
+    ):
+        db = get_db(os.dbs, db_id)
+        sessions, _ = db.get_sessions(
+            session_type=SessionType.TEAM,
+            component_id=team_id,
+            user_id=user_id,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            deserialize=False,
+        )
+
+        return {
+            "data": [SessionSchema.from_dict(session) for session in sessions],  # type: ignore
+        }
+
+    @mcp.tool(name="get_sessions_for_workflow", description="Get list of sessions for a workflow", tags={"session"})  # type: ignore
+    async def get_sessions_for_workflow(
+        workflow_id: str,
+        db_id: str,
+        user_id: Optional[str] = None,
+        sort_by: str = "created_at",
+        sort_order: str = "desc",
+    ):
+        db = get_db(os.dbs, db_id)
+        sessions, _ = db.get_sessions(
+            session_type=SessionType.WORKFLOW,
+            component_id=workflow_id,
+            user_id=user_id,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            deserialize=False,
+        )
+
+        return {
+            "data": [SessionSchema.from_dict(session) for session in sessions],  # type: ignore
+        }
+
+    # Memory Management Tools
+    @mcp.tool(name="create_memory", description="Create a new user memory", tags={"memory"})  # type: ignore
+    async def create_memory(
+        db_id: str,
+        memory: str,
+        user_id: str,
+        topics: Optional[List[str]] = None,
+    ) -> UserMemorySchema:
+        db = get_db(os.dbs, db_id)
+        user_memory = db.upsert_user_memory(
+            memory=UserMemory(
+                memory_id=str(uuid4()),
+                memory=memory,
+                topics=topics or [],
+                user_id=user_id,
+            ),
+            deserialize=False,
+        )
+        if not user_memory:
+            raise Exception("Failed to create memory")
+
+        return UserMemorySchema.from_dict(user_memory)  # type: ignore
+
+    @mcp.tool(name="get_memories_for_user", description="Get a list of memories for a user", tags={"memory"})  # type: ignore
+    async def get_memories_for_user(
+        user_id: str,
+        sort_by: str = "updated_at",
+        sort_order: str = "desc",
+        db_id: Optional[str] = None,
+    ):
+        db = get_db(os.dbs, db_id)
+        user_memories, _ = db.get_user_memories(
+            user_id=user_id,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            deserialize=False,
+        )
+        return {
+            "data": [UserMemorySchema.from_dict(user_memory) for user_memory in user_memories],  # type: ignore
+        }
+
+    @mcp.tool(name="update_memory", description="Update a memory", tags={"memory"})  # type: ignore
+    async def update_memory(
+        db_id: str,
+        memory_id: str,
+        memory: str,
+        user_id: str,
+    ) -> UserMemorySchema:
+        db = get_db(os.dbs, db_id)
+        user_memory = db.upsert_user_memory(
+            memory=UserMemory(
+                memory_id=memory_id,
+                memory=memory,
+                user_id=user_id,
+            ),
+            deserialize=False,
+        )
+        if not user_memory:
+            raise Exception("Failed to update memory")
+
+        return UserMemorySchema.from_dict(user_memory)  # type: ignore
+
+    @mcp.tool(name="delete_memory", description="Delete a memory by ID", tags={"memory"})  # type: ignore
+    async def delete_memory(
+        db_id: str,
+        memory_id: str,
+    ) -> None:
+        db = get_db(os.dbs, db_id)
+        db.delete_user_memory(memory_id=memory_id)
+
+    mcp_app = mcp.http_app(path="/mcp")
+    return mcp_app