isolate mcp stuff

restore comment

remove old thing

weird

f the flakes

grrrrrrr

so annoying

clean up

name change

Author: zzstoatzz

docs/api-reference/marvin-agents-agent.mdx

@@ -19,7 +19,7 @@ T = TypeVar('T')
 
 ### `Agent`
 ```python
-class Agent(name: str = lambda: random.choice(AGENT_NAMES)(), instructions: str | None = None, description: str | None = None, verbose: bool = False, prompt: str | Path = Path('agent.jinja'), tools: list[Callable[..., Any]] = lambda: [](), memories: list[Memory] = list(), mcp_servers: list[MCPServer] = list(), model: KnownModelName | Model | None = None, model_settings: ModelSettings = ModelSettings())
+class Agent(name: str = lambda: random.choice(AGENT_NAMES)(), instructions: str | None = None, description: str | None = None, verbose: bool = False, prompt: str | Path = Path('agent.jinja'), tools: list[Callable[..., Any]] = lambda: [](), memories: list[Memory] = lambda: [](), mcp_servers: list[MCPServer] = lambda: [](), model: KnownModelName | Model | None = None, model_settings: ModelSettings = ModelSettings())
 ```
 An agent that can process tasks and maintain state.
 

docs/api-reference/marvin-engine-orchestrator.mdx

@@ -26,7 +26,7 @@ class Orchestrator(tasks: list[Task[Any]], thread: Thread | str | None = None, h
   ```
 - **`get_all_tasks`**
   ```python
-  def get_all_tasks(self, filter: Literal['incomplete', 'ready'] | None = None) -> list[Task[Any]]
+  def get_all_tasks(self, _filter: Literal['incomplete', 'ready'] | None = None) -> list[Task[Any]]
   ```
   Get all tasks, optionally filtered by status.
 

examples/agent_mcp.py

@@ -1,5 +1,4 @@
 import asyncio
-import os
 from pathlib import Path
 
 from pydantic_ai.mcp import MCPServerStdio
@@ -11,25 +10,23 @@
 run_python_server = MCPServerStdio(
     command="deno",
     args=["run", "-A", "jsr:@pydantic/mcp-run-python", "stdio"],
-    env=dict(os.environ),
 )
 
 # Requires uv: `uvx mcp-server-git`
 git_server = MCPServerStdio(
     command="uvx",
     args=["mcp-server-git"],
-    env=dict(os.environ),
 )
 
 
 def write_summary_of_work(description: str, file_path: str) -> str:
-    """log your efforts"""
+    """log your efforts in your own style"""
     Path(file_path).write_text(description)
     return f"Summary written to {file_path}"
 
 
-git_agent = Agent(
-    name="Git Agent",
+linus = Agent(
+    name="Linus",
     instructions="Use the available tools as needed to accomplish the user's goal.",
     mcp_servers=[run_python_server, git_server],
     tools=[write_summary_of_work],
@@ -38,13 +35,12 @@ def write_summary_of_work(description: str, file_path: str) -> str:
 
 async def main():
     task = (
-        "Get the latest commit hash from this repository (path '.') and report how many characters long it is."
-        " Finally, report the square root of that number and write a summary of your work to a file called 'summary.txt'"
+        "Get the latest commit hash from this repo and report how many characters long it is."
+        " Then, report the square root of that number and write a 'summary.txt' based on your work."
     )
     pprint(f"--- Running task: ---\n{task}\n" + "-" * 20)
-
     pprint("\n--- Starting Agent Run ---")
-    result = await git_agent.run_async(task)
+    result = await linus.run_async(task)
     pprint("\n--- Final Result ---")
     pprint(result)
 

pyproject.toml

@@ -45,13 +45,7 @@ dev = [
 [project.optional-dependencies]
 audio = ["pyaudio>=0.2.14"]
 
-slackbot = [
-    "pydantic-ai",
-    "prefect",
-    "numpy",
-    "raggy",
-    "turbopuffer==0.1.23",
-]
+slackbot = ["pydantic-ai", "prefect", "numpy", "raggy", "turbopuffer==0.1.23"]
 
 [project.scripts]
 marvin = "marvin.cli.main:app"
@@ -69,6 +63,9 @@ asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"
 timeout = 60
 testpaths = ["tests"]
+filterwarnings = [
+    "ignore:.*search.*method is deprecated.*:DeprecationWarning:qdrant_client\\.async_qdrant_fastembed",
+]
 norecursedirs = [
     "*.egg-info",
     ".git",
@@ -102,4 +99,4 @@ requires = ["hatchling>=1.21.0", "hatch-vcs>=0.4.0"]
 build-backend = "hatchling.build"
 
 [tool.uv.workspace]
-members = ["examples/fastmcp"]
+members = ["examples/fastmcp"]

src/marvin/_internal/integrations/mcp.py

@@ -1,16 +1,16 @@
 """
-Module for integrating Model Context Protocol (MCP) servers with Marvin.
-
-**Status:** Experimental
+Experimental module for integrating Model Context Protocol (MCP) servers with Marvin.
 """
 
 import asyncio
+import os
 import uuid
+from contextlib import AsyncExitStack, asynccontextmanager
 from functools import partial
-from typing import TYPE_CHECKING, Any, Coroutine
+from typing import TYPE_CHECKING, Any, AsyncIterator, Coroutine
 
 from mcp.types import CallToolResult
-from pydantic_ai.mcp import MCPServer
+from pydantic_ai.mcp import MCPServer, MCPServerStdio
 from pydantic_ai.messages import ToolCallPart, ToolReturnPart
 from pydantic_ai.tools import Tool, ToolDefinition
 
@@ -20,6 +20,7 @@
 from marvin.utilities.logging import get_logger
 
 if TYPE_CHECKING:
+    import marvin.agents.agent
     import marvin.engine.orchestrator
 
 logger = get_logger(__name__)
@@ -169,10 +170,9 @@ async def discover_mcp_tools(
             # Use a default argument to capture the current value of wrapped_func
             # This prevents the closure from capturing the loop variable by reference.
             async def async_wrapped_func_fixed(
-                _bound_partial=wrapped_func,  # No type hint here for Pydantic inspection
+                _bound_partial=wrapped_func,  # TODO: investigate type hinting here # pyright: ignore
                 **kwargs: Any,
             ) -> Any:
-                # Call the captured partial, not the loop variable
                 return await _bound_partial(**kwargs)
 
             mcp_tools.append(
@@ -185,3 +185,77 @@ async def async_wrapped_func_fixed(
             )
 
     return mcp_tools
+
+
+@asynccontextmanager
+async def manage_mcp_servers(
+    actor: "marvin.agents.agent.Agent | Actor",
+) -> AsyncIterator[list["MCPServer"]]:
+    """Context manager to start and stop MCP servers for a given actor."""
+    from marvin.agents.agent import Agent
+
+    logger.debug(f"[manage_mcp_servers] Preparing MCP servers for {actor.name}...")
+    mcp_exit_stack = AsyncExitStack()
+    active_servers: list["MCPServer"] = []
+    servers_started = False
+
+    if not isinstance(actor, Agent) or not hasattr(actor, "get_mcp_servers"):
+        logger.debug(
+            f"[manage_mcp_servers] Actor {actor.name} is not an Agent or does not have get_mcp_servers method."
+        )
+        yield active_servers
+        return
+
+    servers_to_manage = actor.get_mcp_servers()
+
+    if not servers_to_manage:
+        logger.debug(
+            f"[manage_mcp_servers] Actor {actor.name} has no configured MCP servers."
+        )
+        yield active_servers
+        return
+
+    logger.debug(
+        f"[manage_mcp_servers] Found {len(servers_to_manage)} server configurations."
+    )
+    for i, server in enumerate(servers_to_manage):
+        logger.debug(f"[manage_mcp_servers] Processing server #{i + 1}: {server!r}")
+        try:
+            # Set environment variables for stdio servers if not already set
+            if isinstance(server, MCPServerStdio) and server.env is None:
+                logger.debug(
+                    f"[manage_mcp_servers] Server #{i + 1} is MCPServerStdio with no env set. Setting env=dict(os.environ)."
+                )
+                server.env = dict(os.environ)
+
+            logger.debug(
+                f"[manage_mcp_servers] Entering context for server #{i + 1}..."
+            )
+            await mcp_exit_stack.enter_async_context(server)
+            active_servers.append(server)
+            logger.debug(
+                f"[manage_mcp_servers] Context entered successfully for server #{i + 1}."
+            )
+            servers_started = True
+        except Exception as e:
+            logger.error(
+                f"[manage_mcp_servers] Failed to start MCP server #{i + 1} ({server!r}): {e}",
+                exc_info=True,
+            )
+            # Optionally re-raise or handle specific errors? For now, just log.
+
+    if servers_started:
+        logger.debug(
+            f"[manage_mcp_servers] Yielding control with {len(active_servers)} active servers."
+        )
+    else:
+        logger.debug(
+            "[manage_mcp_servers] No servers were successfully started, yielding control."
+        )
+
+    try:
+        yield active_servers
+    finally:
+        logger.debug("[manage_mcp_servers] Cleaning up MCP servers...")
+        await mcp_exit_stack.aclose()
+        logger.debug("[manage_mcp_servers] MCP server cleanup complete.")

src/marvin/agents/agent.py

@@ -61,12 +61,12 @@ class Agent(Actor):
     )
 
     memories: list[Memory] = field(
-        default_factory=list,
+        default_factory=lambda: [],
         metadata={"description": "List of memory modules available to the agent"},
     )
 
     mcp_servers: list["MCPServer"] = field(
-        default_factory=list,
+        default_factory=lambda: [],
         metadata={"description": "List of MCP servers available to the agent"},
         repr=False,
     )
@@ -157,25 +157,19 @@ async def get_agentlet(
             else:
                 logger.warning(f"Ignoring non-callable, non-EndTurn item: {item}")
 
-        # --- Wrap standard Marvin tools --- #
         unique_marvin_tools = [wrap_tool_errors(tool) for tool in marvin_tool_callables]
 
-        # --- Discover MCP tools --- #
-        mcp_tools_instances: list[Tool] = []
+        mcp_tool_instances: list[Tool] = []
         if active_mcp_servers:
             orchestrator = marvin.engine.orchestrator.get_current_orchestrator()
-            mcp_tools_instances = await discover_mcp_tools(
+            mcp_tool_instances = await discover_mcp_tools(
                 mcp_servers=active_mcp_servers,
                 actor=self,
                 orchestrator=orchestrator,
             )
 
-        # --- Combine standard tools for 'tools' arg --- #
-        combined_standard_tools: list[Callable | Tool] = (
-            unique_marvin_tools + mcp_tools_instances
-        )
+        combined_tools: list[Any] = unique_marvin_tools + mcp_tool_instances
 
-        # --- Determine EndTurn ToolOutput --- #
         tool_output_name = "EndTurn"
         tool_output_description = "Ends the current turn."
         if len(final_end_turn_defs) == 1:
@@ -199,27 +193,22 @@ async def get_agentlet(
             description=tool_output_description,
         )
 
-        # --- Create the pydantic_ai.Agent --- #
         agent_kwargs = {
             "model": self.get_model(),
             "model_settings": self.get_model_settings(),
             "output_type": final_tool_output,  # Use the constructed ToolOutput
             "name": self.name,
-            # "tools": combined_standard_tools, # Add conditionally below
-            # "mcp_servers": active_mcp_servers, # Add conditionally below
         }
 
-        # Conditionally add standard tools
-        if combined_standard_tools:
-            agent_kwargs["tools"] = combined_standard_tools
+        if combined_tools:
+            agent_kwargs["tools"] = combined_tools
 
-        # Conditionally add mcp_servers
         if active_mcp_servers:
             agent_kwargs["mcp_servers"] = active_mcp_servers
 
         agentlet = pydantic_ai.Agent[Any, Any](**agent_kwargs)
 
-        # --- Assign Marvin-specific attributes for internal use --- #
+        # for internal use
         agentlet._marvin_tools = unique_marvin_tools  # Store wrapped callables
         agentlet._marvin_end_turn_tools = final_end_turn_defs  # Store original defs