A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
feat: MCP presets: marimo docs and context7 (#6619)
Myles Scolnick309964ed5b12
diff --git a/frontend/src/components/app-config/ai-config.tsx b/frontend/src/components/app-config/ai-config.tsxindex e9bc68f3c0..65079a56c8 100644--- a/frontend/src/components/app-config/ai-config.tsx+++ b/frontend/src/components/app-config/ai-config.tsx@@ -77,6 +77,7 @@ import { SettingSubtitle } from "./common";import { AWS_REGIONS } from "./constants";import { IncorrectModelId } from "./incorrect-model-id";import { IsOverridden } from "./is-overridden";+import { MCPConfig } from "./mcp-config";const formItemClasses = "flex flex-row items-center space-x-1 space-y-0";@@ -1364,12 +1365,15 @@ export const AiConfig: React.FC<AiConfigProps> = ({config,onSubmit,}) => {+ // MCP is not supported in WASM+ const wasm = isWasm();return (<Tabs defaultValue="ai-features" className="flex-1"><TabsList className="mb-2"><TabsTrigger value="ai-features">AI Features</TabsTrigger><TabsTrigger value="ai-providers">AI Providers</TabsTrigger><TabsTrigger value="ai-models">AI Models</TabsTrigger>+ {!wasm && <TabsTrigger value="mcp">MCP</TabsTrigger>}</TabsList><TabsContent value="ai-features">@@ -1386,6 +1390,11 @@ export const AiConfig: React.FC<AiConfigProps> = ({<TabsContent value="ai-models"><AiModelDisplayConfig form={form} config={config} onSubmit={onSubmit} /></TabsContent>+ {!wasm && (+ <TabsContent value="mcp">+ <MCPConfig form={form} onSubmit={onSubmit} />+ </TabsContent>+ )}</Tabs>);};diff --git a/frontend/src/components/app-config/mcp-config.tsx b/frontend/src/components/app-config/mcp-config.tsxnew file mode 100644index 0000000000..253d3bdd59--- /dev/null+++ b/frontend/src/components/app-config/mcp-config.tsx@@ -0,0 +1,128 @@+/* Copyright 2024 Marimo. All rights reserved. */++import { CheckSquareIcon } from "lucide-react";+import React from "react";+import type { UseFormReturn } from "react-hook-form";+import {+ Card,+ CardContent,+ CardDescription,+ CardHeader,+ CardTitle,+} from "@/components/ui/card";+import { FormField, FormItem } from "@/components/ui/form";+import type { UserConfig } from "@/core/config/config-schema";+import { Button } from "../ui/button";+import { Kbd } from "../ui/kbd";+import { SettingSubtitle } from "./common";+import { useOpenSettingsToTab } from "./state";++interface MCPConfigProps {+ form: UseFormReturn<UserConfig>;+ onSubmit: (values: UserConfig) => void;+}++type MCPPreset = "marimo" | "context7";++interface PresetConfig {+ id: MCPPreset;+ title: string;+ description: string;+}++const PRESET_CONFIGS: PresetConfig[] = [+ {+ id: "marimo",+ title: "marimo (docs)",+ description: "Access marimo documentation",+ },+ {+ id: "context7",+ title: "Context7",+ description: "Connect to Context7 MCP server",+ },+];++export const MCPConfig: React.FC<MCPConfigProps> = ({ form, onSubmit }) => {+ const { handleClick } = useOpenSettingsToTab();++ return (+ <div className="flex flex-col gap-4">+ <SettingSubtitle>MCP Servers</SettingSubtitle>+ <p className="text-sm text-muted-foreground">+ Enable Model Context Protocol (MCP) servers to provide additional+ capabilities and data sources for AI features.+ </p>+ <p className="text-sm text-muted-foreground">+ This feature requires the <Kbd className="inline">marimo[mcp]</Kbd>{" "}+ package. See{" "}+ <Button+ variant="link"+ onClick={() => handleClick("optionalDeps")}+ size="xs"+ >+ Optional Features+ </Button>{" "}+ for more details.+ </p>++ <FormField+ control={form.control}+ name="mcp.presets"+ render={({ field }) => {+ const presets = field.value || [];++ const togglePreset = (preset: MCPPreset) => {+ const newPresets = presets.includes(preset)+ ? presets.filter((p: string) => p !== preset)+ : [...presets, preset];+ field.onChange(newPresets);+ onSubmit(form.getValues());+ };++ return (+ <FormItem>+ <div className="grid grid-cols-1 md:grid-cols-2 gap-4">+ {PRESET_CONFIGS.map((config) => {+ const isChecked = presets.includes(config.id);++ return (+ <Card+ key={config.id}+ className={`cursor-pointer transition-all ${+ isChecked+ ? "border-[var(--blue-9)] bg-[var(--blue-2)]"+ : "hover:border-[var(--blue-7)]"+ }`}+ onClick={() => togglePreset(config.id)}+ >+ <CardHeader>+ <div className="flex items-start justify-between">+ <CardTitle className="text-base">+ {config.title}+ </CardTitle>+ <span+ className={`h-5 w-5 flex items-center justify-center rounded border ${+ isChecked+ ? "border-[var(--blue-7)] bg-[var(--blue-7)] text-foreground"+ : "border-muted bg-background text-muted-foreground"+ }`}+ >+ {isChecked ? <CheckSquareIcon /> : null}+ </span>+ </div>+ </CardHeader>+ <CardContent>+ <CardDescription>{config.description}</CardDescription>+ </CardContent>+ </Card>+ );+ })}+ </div>+ </FormItem>+ );+ }}+ />+ </div>+ );+};diff --git a/frontend/src/components/app-config/optional-features.tsx b/frontend/src/components/app-config/optional-features.tsxindex 2ccdc3f4c6..9fd716b294 100644--- a/frontend/src/components/app-config/optional-features.tsx+++ b/frontend/src/components/app-config/optional-features.tsx@@ -75,6 +75,12 @@ const OPTIONAL_DEPENDENCIES: OptionalFeature[] = [additionalPackageInstalls: [],description: "AI features",},+ {+ id: "mcp",+ packagesRequired: [{ name: "mcp", minVersion: "1" }],+ additionalPackageInstalls: [{ name: "pydantic", minVersion: "2" }],+ description: "Connect to MCP servers",+ },{id: "ipy-export",packagesRequired: [{ name: "nbformat" }],diff --git a/frontend/src/components/chat/tool-call-accordion.tsx b/frontend/src/components/chat/tool-call-accordion.tsxindex e09623d7a8..dfb53a8f04 100644--- a/frontend/src/components/chat/tool-call-accordion.tsx+++ b/frontend/src/components/chat/tool-call-accordion.tsx@@ -106,7 +106,7 @@ const ResultRenderer: React.FC<{ result: unknown }> = ({ result }) => {// Otherwise, fall back to the current JSON viewerreturn (- <div className="text-xs font-medium text-muted-foreground mb-1">+ <div className="text-xs font-medium text-muted-foreground mb-1 max-h-64 overflow-y-auto scrollbar-thin">{typeof result === "string" ? result : JSON.stringify(result, null, 2)}</div>);diff --git a/frontend/src/core/config/__tests__/config-schema.test.ts b/frontend/src/core/config/__tests__/config-schema.test.tsindex 7cfbfcbf27..fd3e803989 100644--- a/frontend/src/core/config/__tests__/config-schema.test.ts+++ b/frontend/src/core/config/__tests__/config-schema.test.ts@@ -75,6 +75,7 @@ test("default UserConfig - empty", () => {"overrides": {},"preset": "default",},+ "mcp": {},"package_management": {"manager": "pip",},@@ -139,6 +140,7 @@ test("default UserConfig - one level", () => {"overrides": {},"preset": "default",},+ "mcp": {},"package_management": {"manager": "pip",},diff --git a/frontend/src/core/config/config-schema.ts b/frontend/src/core/config/config-schema.tsindex b630a4a6e6..0e3122fef4 100644--- a/frontend/src/core/config/config-schema.ts+++ b/frontend/src/core/config/config-schema.ts@@ -188,6 +188,12 @@ export const UserConfigSchema = zwasm: z.boolean().optional(),}).optional(),+ mcp: z+ .looseObject({+ presets: z.array(z.enum(["marimo", "context7"])).optional(),+ })+ .optional()+ .prefault({}),}).partial().prefault(() => ({@@ -201,6 +207,7 @@ export const UserConfigSchema = zserver: {},ai: {},package_management: {},+ mcp: {},}));export type UserConfig = MarimoConfig;export type SaveConfig = UserConfig["save"];@@ -302,6 +309,7 @@ export function defaultUserConfig(): UserConfig {server: {},ai: {},package_management: {},+ mcp: {},};return UserConfigSchema.parse(defaultConfig) as UserConfig;}diff --git a/frontend/src/core/config/feature-flag.tsx b/frontend/src/core/config/feature-flag.tsxindex adb669be43..11c6b2131c 100644--- a/frontend/src/core/config/feature-flag.tsx+++ b/frontend/src/core/config/feature-flag.tsx@@ -11,7 +11,6 @@ export interface ExperimentalFeatures {wasm_layouts: boolean; // Used in playground (community cloud)rtc_v2: boolean;performant_table_charts: boolean;- mcp_docs: boolean;chat_modes: boolean;sql_linter: boolean;external_agents: boolean;@@ -25,7 +24,6 @@ const defaultValues: ExperimentalFeatures = {wasm_layouts: false,rtc_v2: false,performant_table_charts: false,- mcp_docs: false,chat_modes: false,sql_linter: true,external_agents: import.meta.env.DEV,diff --git a/marimo/_config/config.py b/marimo/_config/config.pyindex a699668826..3587f10b98 100644--- a/marimo/_config/config.py+++ b/marimo/_config/config.py@@ -14,6 +14,7 @@ else:from typing import NotRequiredfrom typing import (+ TYPE_CHECKING,Any,Literal,Optional,@@ -508,7 +509,6 @@ class ExperimentalConfig(TypedDict, total=False):wasm_layouts: bool # Used in playground (community cloud)rtc_v2: boolperformant_table_charts: bool- mcp_docs: boolchat_modes: boolsql_linter: boolsql_mode: bool@@ -543,8 +543,7 @@ class MarimoConfig(TypedDict):snippets: NotRequired[SnippetsConfig]datasources: NotRequired[DatasourcesConfig]sharing: NotRequired[SharingConfig]- # We don't support configuring MCP servers yet- # mcp: NotRequired[MCPConfig]+ mcp: NotRequired[MCPConfig]@mddoc@@ -570,7 +569,12 @@ class MCPServerStreamableHttpConfig(TypedDict):disabled: NotRequired[Optional[bool]]-MCPServerConfig = Union[MCPServerStdioConfig, MCPServerStreamableHttpConfig]+if TYPE_CHECKING:+ MCPServerConfig = Union[+ MCPServerStdioConfig, MCPServerStreamableHttpConfig+ ]+else:+ MCPServerConfig = dict[str, Any]@mddoc@@ -584,16 +588,7 @@ class MCPConfig(TypedDict):"""mcpServers: dict[str, MCPServerConfig]---DEFAULT_MCP_CONFIG: MCPConfig = MCPConfig(- mcpServers={- "marimo": MCPServerStreamableHttpConfig(- url="https://mcp.marimo.app/mcp"- ),- # TODO(bjoaquinc): add more Marimo MCP servers here after they are implemented- }-)+ presets: NotRequired[list[Literal["marimo", "context7"]]]@mddoc@@ -677,6 +672,10 @@ DEFAULT_CONFIG: MarimoConfig = {"custom_paths": [],"include_default_snippets": True,},+ "mcp": {+ "mcpServers": {},+ "presets": [],+ },}diff --git a/marimo/_server/ai/mcp/__init__.py b/marimo/_server/ai/mcp/__init__.pynew file mode 100644index 0000000000..8829b78618--- /dev/null+++ b/marimo/_server/ai/mcp/__init__.py@@ -0,0 +1,48 @@+# Copyright 2024 Marimo. All rights reserved.+"""MCP (Model Context Protocol) client implementation for marimo."""++from marimo._server.ai.mcp.client import (+ MCPClient,+ MCPServerConnection,+ MCPServerStatus,+ get_mcp_client,+)+from marimo._server.ai.mcp.config import (+ MCP_PRESETS,+ MCPConfigComparator,+ MCPConfigDiff,+ MCPServerDefinition,+ MCPServerDefinitionFactory,+ append_presets,+)+from marimo._server.ai.mcp.transport import (+ MCPTransportConnector,+ MCPTransportRegistry,+ MCPTransportType,+ StdioTransportConnector,+ StreamableHTTPTransportConnector,+)+from marimo._server.ai.mcp.types import MCPToolArgs++__all__ = [+ # Client classes+ "MCPClient",+ "MCPServerConnection",+ "MCPServerStatus",+ "get_mcp_client",+ # Config classes+ "MCP_PRESETS",+ "MCPConfigComparator",+ "MCPConfigDiff",+ "MCPServerDefinition",+ "MCPServerDefinitionFactory",+ "append_presets",+ # Transport classes+ "MCPTransportConnector",+ "MCPTransportRegistry",+ "MCPTransportType",+ "StdioTransportConnector",+ "StreamableHTTPTransportConnector",+ # Types+ "MCPToolArgs",+]diff --git a/marimo/_server/ai/mcp.py b/marimo/_server/ai/mcp/client.pysimilarity index 79%rename from marimo/_server/ai/mcp.pyrename to marimo/_server/ai/mcp/client.pyindex db12f974aa..3961b2708e 100644--- a/marimo/_server/ai/mcp.py+++ b/marimo/_server/ai/mcp/client.py@@ -2,31 +2,32 @@from __future__ import annotationsimport asyncio-import osimport time-from abc import ABC, abstractmethodfrom contextlib import AsyncExitStackfrom dataclasses import dataclass, fieldfrom enum import Enum-from typing import TYPE_CHECKING, Any, Optional, Union, cast+from typing import TYPE_CHECKING, Optional, Unionfrom marimo import _loggers-from marimo._config.config import (- DEFAULT_MCP_CONFIG,- MCPConfig,- MCPServerConfig,- MCPServerStdioConfig,- MCPServerStreamableHttpConfig,-)+from marimo._config.config import MCPConfigfrom marimo._dependencies.dependencies import DependencyManager+from marimo._server.ai.mcp.config import (+ MCPConfigComparator,+ MCPServerDefinition,+ MCPServerDefinitionFactory,+ append_presets,+)+from marimo._server.ai.mcp.transport import (+ MCPTransportRegistry,+)+from marimo._server.ai.mcp.types import MCPToolArgsif TYPE_CHECKING:- from typing import Protocol, TypedDict-from anyio.streams.memory import (MemoryObjectReceiveStream,MemoryObjectSendStream,)+from mcp import ClientSession # type: ignore[import-not-found]from mcp.shared.message import SessionMessagefrom mcp.types import ( # type: ignore[import-not-found]@@ -36,41 +37,9 @@ if TYPE_CHECKING:Tool,)- class MCPToolMeta(TypedDict):- """Metadata that marimo adds to MCP tools."""-- server_name: str- namespaced_name: str-- class MCPToolWithMeta(Protocol):- """MCP Tool with marimo-specific metadata."""-- name: str- description: str | None- inputSchema: dict[str, Any]- meta: MCPToolMeta---# Type alias that matches the MCP SDK's CallToolRequestParams.arguments type-MCPToolArgs = Optional[dict[str, Any]]--# Type alias for MCP transport connection streams-TransportConnectorResponse = tuple[- "MemoryObjectReceiveStream[Union[SessionMessage, Exception]]",- "MemoryObjectSendStream[SessionMessage]",-]-LOGGER = _loggers.marimo_logger()-class MCPTransportType(str, Enum):- """Supported MCP transport types."""-- # based on https://modelcontextprotocol.io/docs/concepts/transports- STDIO = "stdio"- STREAMABLE_HTTP = "streamable_http"--class MCPServerStatus(Enum):"""Status of an MCP server connection."""@@ -80,160 +49,6 @@ class MCPServerStatus(Enum):ERROR = "error"-@dataclass-class MCPServerDefinition:- """Runtime server definition wrapping config with computed fields."""-- name: str- transport: MCPTransportType- config: MCPServerConfig- timeout: float = 30.0---class MCPServerDefinitionFactory:- """Factory for creating transport-specific server definitions."""-- @classmethod- def from_config(- cls, name: str, config: MCPServerConfig- ) -> MCPServerDefinition:- """Create server definition with automatic transport detection.-- Args:- name: Server name- config: Server configuration from config file-- Returns:- Server definition with detected transport type-- Raises:- ValueError: If configuration type is not supported- """- # Import here to avoid circular imports-- if "command" in config:- return MCPServerDefinition(- name=name,- transport=MCPTransportType.STDIO,- config=config,- timeout=30.0, # default timeout for STDIO- )- elif "url" in config:- return MCPServerDefinition(- name=name,- transport=MCPTransportType.STREAMABLE_HTTP,- config=config,- timeout=config.get("timeout") or 30.0,- )- else:- raise ValueError(f"Unsupported config type: {type(config)}")---class MCPTransportConnector(ABC):- """Abstract base class for MCP transport connectors."""-- @abstractmethod- async def connect(- self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack- ) -> TransportConnectorResponse:- """Connect to the MCP server and return read/write streams.-- Args:- server_def: Server definition with transport-specific parameters- exit_stack: Async exit stack for resource management-- Returns:- Tuple of (read_stream, write_stream) for the ClientSession- """- pass---class StdioTransportConnector(MCPTransportConnector):- """STDIO transport connector for process-based MCP servers."""-- async def connect(- self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack- ) -> TransportConnectorResponse:- # Import MCP SDK components for stdio transport- from mcp import StdioServerParameters- from mcp.client.stdio import stdio_client-- # Type narrowing for mypy- assert "command" in server_def.config- config = cast(MCPServerStdioConfig, server_def.config)-- # Set up environment variables for the server process- env = os.environ.copy()- env.update(config.get("env") or {})-- # Configure server parameters- server_params = StdioServerParameters(- command=config["command"],- args=config.get("args") or [],- env=env,- )-- # Establish connection with proper resource management- read, write, *_ = await exit_stack.enter_async_context(- stdio_client(server_params)- )-- return read, write---class StreamableHTTPTransportConnector(MCPTransportConnector):- """Streamable HTTP transport connector for modern HTTP-based MCP servers."""-- async def connect(- self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack- ) -> TransportConnectorResponse:- # Import MCP SDK components for streamable HTTP transport- from mcp.client.streamable_http import streamablehttp_client-- # Type narrowing for mypy- assert "url" in server_def.config- config = cast(MCPServerStreamableHttpConfig, server_def.config)-- # Establish streamable HTTP connection- read, write, *_ = await exit_stack.enter_async_context(- streamablehttp_client(- config["url"],- headers=config.get("headers") or {},- timeout=server_def.timeout,- )- )-- return read, write---class MCPTransportRegistry:- """Registry for MCP transport connectors."""-- def __init__(self) -> None:- self._connectors: dict[MCPTransportType, MCPTransportConnector] = {- MCPTransportType.STDIO: StdioTransportConnector(),- MCPTransportType.STREAMABLE_HTTP: StreamableHTTPTransportConnector(),- }-- def get_connector(- self, transport_type: MCPTransportType- ) -> MCPTransportConnector:- """Get the appropriate transport connector for the given transport type.-- Args:- transport_type: The type of transport to connect with-- Returns:- Transport connector instance-- Raises:- ValueError: If transport type is not supported- """- if transport_type not in self._connectors:- raise ValueError(f"Unsupported transport type: {transport_type}")- return self._connectors[transport_type]--@dataclassclass MCPServerConnection:"""Represents a connection to an MCP server."""@@ -259,9 +74,12 @@ class MCPServerConnection:class MCPClient:"""Client for managing connections to multiple MCP servers."""- def __init__(self, config: Optional[MCPConfig] = None):- """Initialize MCP client with server configuration."""- self.config: MCPConfig = config or MCPConfig(mcpServers={})+ def __init__(self) -> None:+ """Initialize MCP client.++ Note: For dynamic reconfiguration, use await client.configure(new_config)+ which will handle adding/removing/updating connections automatically.+ """self.servers: dict[str, MCPServerDefinition] = {}self.connections: dict[str, MCPServerConnection] = {}self.tool_registry: dict[str, Tool] = {}@@ -274,15 +92,108 @@ class MCPClient:self.health_check_timeout: float = (5.0 # seconds - shorter timeout for health checks)- self._parse_config()- def _parse_config(self) -> None:+ async def configure(self, config: MCPConfig) -> None:+ """Configure the MCP client with the given configuration.++ This method:+ 1. Parses the new configuration+ 2. Compares it with current configuration+ 3. Disconnects from removed servers+ 4. Disconnects and reconnects to updated servers+ 5. Connects to new servers++ Args:+ config: MCP configuration to apply+ """+ # Parse new configuration+ new_servers = self._parse_config(config)++ # Compute differences+ diff = MCPConfigComparator.compute_diff(self.servers, new_servers)++ # Early return if no changes+ if not diff.has_changes():+ LOGGER.debug(+ "MCP configuration unchanged, skipping reconfiguration"+ )+ return++ LOGGER.info(+ f"MCP configuration changed: "+ f"{len(diff.servers_to_add)} to add, "+ f"{len(diff.servers_to_remove)} to remove, "+ f"{len(diff.servers_to_update)} to update, "+ f"{len(diff.servers_unchanged)} unchanged"+ )++ # Disconnect from removed servers+ for server_name in diff.servers_to_remove:+ LOGGER.info(f"Removing server: {server_name}")+ await self.disconnect_from_server(server_name)+ # Clean up from servers and connections registries+ if server_name in self.servers:+ del self.servers[server_name]+ if server_name in self.connections:+ del self.connections[server_name]++ # Disconnect from servers that need to be updated (will reconnect below)+ for server_name in diff.servers_to_update.keys():+ LOGGER.info(f"Updating server: {server_name}")+ await self.disconnect_from_server(server_name)+ # Clean up old connection, will be recreated below+ if server_name in self.connections:+ del self.connections[server_name]++ # Update servers registry with new configuration+ # Add new servers+ self.servers.update(diff.servers_to_add)+ # Update modified servers+ self.servers.update(diff.servers_to_update)++ # Connect to new and updated servers+ servers_to_connect = {**diff.servers_to_add, **diff.servers_to_update}++ if servers_to_connect:+ # Connect to servers concurrently+ tasks = [+ self.connect_to_server(server_name)+ for server_name in servers_to_connect.keys()+ ]+ connection_results = await asyncio.gather(+ *tasks, return_exceptions=True+ )++ for server_name, result in zip(+ servers_to_connect.keys(), connection_results+ ):+ if isinstance(result, Exception):+ LOGGER.error(+ f"Failed to connect to {server_name}: {result}"+ )+ elif not result:+ LOGGER.warning(+ f"Connection to {server_name} did not succeed"+ )++ def _parse_config(+ self, config: MCPConfig+ ) -> dict[str, MCPServerDefinition]:"""Parse MCP server configuration.- Note: Servers with invalid configurations are logged but excluded from self.servers,+ Note: Servers with invalid configurations are logged but excluded from returned dict,making them unavailable for connection attempts.++ Args:+ config: MCP configuration to parse++ Returns:+ Dictionary of server name to server definition for valid servers"""- mcp_servers = self.config.get("mcpServers", {})+ # Apply presets before parsing+ config = append_presets(config)+ mcp_servers = config.get("mcpServers", {})+ parsed_servers: dict[str, MCPServerDefinition] = {}for server_name, server_config in mcp_servers.items():try:@@ -290,20 +201,22 @@ class MCPClient:server_name, server_config)- self.servers[server_name] = server_def+ parsed_servers[server_name] = server_defLOGGER.debug(- f"Registered MCP server: {server_name} (transport: {server_def.transport})"+ f"Parsed MCP server: {server_name} (transport: {server_def.transport})")except KeyError as e:LOGGER.error(f"Invalid configuration for server {server_name}: missing {e}")- # Note: Server with invalid configuration is not added to self.servers+ # Note: Server with invalid configuration is not added to parsed_serversexcept ValueError as e:LOGGER.error(f"Invalid configuration for server {server_name}: {e}")- # Note: Server with invalid configuration is not added to self.servers+ # Note: Server with invalid configuration is not added to parsed_servers++ return parsed_serversasync def _connection_lifecycle(self, server_name: str) -> None:"""Minimal wrapper to run existing connection and disconnection logic in task-owned AsyncExitStack."""@@ -498,8 +411,12 @@ class MCPClient:return f"mcp_{server_name}{counter}_{tool_name}"async def connect_to_all_servers(self) -> dict[str, bool]:- """Connect to all configured MCP servers."""- results = {}+ """Connect to all configured MCP servers.++ Returns:+ Dictionary mapping server names to connection success status+ """+ results: dict[str, bool] = {}# Connect to servers concurrentlytasks = [@@ -545,7 +462,9 @@ class MCPClient:return hasattr(result, "isError") and result.isError is Trueasync def invoke_tool(- self, namespaced_tool_name: str, params: CallToolRequestParams+ self,+ namespaced_tool_name: str,+ params: CallToolRequestParams,) -> CallToolResult:"""Invoke an MCP tool using properly typed CallToolRequestParams."""tool = self.tool_registry.get(namespaced_tool_name)@@ -619,7 +538,9 @@ class MCPClient:)def create_tool_params(- self, namespaced_tool_name: str, arguments: MCPToolArgs = None+ self,+ namespaced_tool_name: str,+ arguments: MCPToolArgs = None,) -> CallToolRequestParams:"""Create properly typed CallToolRequestParams for a tool."""from mcp.types import CallToolRequestParams@@ -890,13 +811,21 @@ class MCPClient:# Wait for all tasks to completeawait asyncio.gather(- *self.health_check_tasks.values(), return_exceptions=True+ *self.health_check_tasks.values(),+ return_exceptions=True,)self.health_check_tasks.clear()LOGGER.debug("Cancelled all health monitoring tasks")async def disconnect_from_server(self, server_name: str) -> bool:- """Disconnect from a specific MCP server."""+ """Disconnect from a specific MCP server.++ Args:+ server_name: Name of the server to disconnect from++ Returns:+ True if disconnection was successful or server wasn't connected, False otherwise+ """connection = self.connections.get(server_name)if not connection:return True@@ -942,19 +871,22 @@ class MCPClient:_MCP_CLIENT: Optional[MCPClient] = None-def get_mcp_client(config: Optional[MCPConfig] = None) -> MCPClient:- """Get the global MCP client instance, initializing it if needed."""+def get_mcp_client() -> MCPClient:+ """Get the global MCP client instance, initializing it if needed.++ Note: The client must be configured using await client.configure(config)+ before connecting to servers.+ """global _MCP_CLIENTif _MCP_CLIENT is None:if not DependencyManager.mcp.has():- LOGGER.info("MCP SDK not available")- raise ModuleNotFoundError("MCP SDK not available")+ msg = "MCP dependencies not available. Install with `pip install marimo[mcp]` or `uv add marimo[mcp]`"+ LOGGER.info(msg)+ raise ModuleNotFoundError(+ msg,+ name="mcp",+ )- _MCP_CLIENT = MCPClient(config or _get_default_config())+ _MCP_CLIENT = MCPClient()LOGGER.info("MCP client initialized")return _MCP_CLIENT---def _get_default_config() -> MCPConfig:- """Get default MCP configuration."""- return DEFAULT_MCP_CONFIGdiff --git a/marimo/_server/ai/mcp/config.py b/marimo/_server/ai/mcp/config.pynew file mode 100644index 0000000000..0073adea7e--- /dev/null+++ b/marimo/_server/ai/mcp/config.py@@ -0,0 +1,197 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from dataclasses import dataclass+from typing import TYPE_CHECKING++from marimo import _loggers+from marimo._server.ai.mcp.transport import MCPTransportType++if TYPE_CHECKING:+ from marimo._config.config import (+ MCPConfig,+ MCPServerConfig,+ )++LOGGER = _loggers.marimo_logger()+++# MCP Server Presets+MCP_PRESETS: dict[str, MCPServerConfig] = {+ "marimo": {+ "url": "https://mcp.marimo.app/mcp",+ },+ "context7": {+ "url": "https://mcp.context7.com/mcp",+ },+}+++def append_presets(config: MCPConfig) -> MCPConfig:+ """Append preset MCP servers to the configuration.++ Presets are added to the mcpServers dict if they are specified in the+ 'presets' list and not already present in mcpServers.++ Args:+ config: MCP configuration potentially containing a presets list++ Returns:+ Updated configuration with presets appended to mcpServers+ """+ from marimo._config.config import MCPConfig++ presets_to_add = config.get("presets", [])+ if not presets_to_add:+ return config++ # Create a copy to avoid mutating the original+ updated_config = MCPConfig(mcpServers=config["mcpServers"].copy())++ # Add preset servers if not already present+ for preset_name in presets_to_add:+ if preset_name not in updated_config["mcpServers"]:+ if preset_name in MCP_PRESETS:+ updated_config["mcpServers"][preset_name] = MCP_PRESETS[+ preset_name+ ]++ return updated_config+++def is_mcp_config_empty(config: MCPConfig | None) -> bool:+ """Check if the MCP configuration is empty."""+ if config is None:+ return True+ return not config.get("mcpServers") and not config.get("presets")+++@dataclass+class MCPServerDefinition:+ """Runtime server definition wrapping config with computed fields."""++ name: str+ transport: MCPTransportType+ config: MCPServerConfig+ timeout: float = 30.0++ def __eq__(self, other: object) -> bool:+ """Check if two server definitions are equal based on config content."""+ if not isinstance(other, MCPServerDefinition):+ return NotImplemented+ return (+ self.name == other.name+ and self.transport == other.transport+ and self.config == other.config+ and self.timeout == other.timeout+ )++ def __hash__(self) -> int:+ """Hash based on name for use in sets/dicts."""+ return hash(self.name)+++class MCPServerDefinitionFactory:+ """Factory for creating transport-specific server definitions."""++ @classmethod+ def from_config(+ cls, name: str, config: MCPServerConfig+ ) -> MCPServerDefinition:+ """Create server definition with automatic transport detection.++ Args:+ name: Server name+ config: Server configuration from config file++ Returns:+ Server definition with detected transport type++ Raises:+ ValueError: If configuration type is not supported+ """+ if "command" in config:+ return MCPServerDefinition(+ name=name,+ transport=MCPTransportType.STDIO,+ config=config,+ timeout=30.0, # default timeout for STDIO+ )+ elif "url" in config:+ return MCPServerDefinition(+ name=name,+ transport=MCPTransportType.STREAMABLE_HTTP,+ config=config,+ timeout=config.get("timeout") or 30.0,+ )+ else:+ raise ValueError(f"Unsupported config type: {type(config)}")+++@dataclass+class MCPConfigDiff:+ """Represents changes between two MCP configurations."""++ servers_to_add: dict[str, MCPServerDefinition]+ servers_to_remove: set[str]+ servers_to_update: dict[str, MCPServerDefinition]+ servers_unchanged: set[str]++ def has_changes(self) -> bool:+ """Check if there are any changes in the configuration."""+ return bool(+ self.servers_to_add+ or self.servers_to_remove+ or self.servers_to_update+ )+++class MCPConfigComparator:+ """Utility for comparing MCP configurations and computing differences."""++ @staticmethod+ def compute_diff(+ current_servers: dict[str, MCPServerDefinition],+ new_servers: dict[str, MCPServerDefinition],+ ) -> MCPConfigDiff:+ """Compare current and new server configurations.++ Args:+ current_servers: Currently configured servers+ new_servers: New server configuration++ Returns:+ MCPConfigDiff describing the changes needed+ """+ current_names = set(current_servers.keys())+ new_names = set(new_servers.keys())++ # Servers that need to be removed+ servers_to_remove = current_names - new_names++ # Servers that need to be added+ servers_to_add = {+ name: new_servers[name] for name in (new_names - current_names)+ }++ # Servers that might need to be updated+ common_servers = current_names & new_names+ servers_to_update: dict[str, MCPServerDefinition] = {}+ servers_unchanged: set[str] = set()++ for name in common_servers:+ current_def = current_servers[name]+ new_def = new_servers[name]++ # Check if server definition has changed+ if current_def != new_def:+ servers_to_update[name] = new_def+ else:+ servers_unchanged.add(name)++ return MCPConfigDiff(+ servers_to_add=servers_to_add,+ servers_to_remove=servers_to_remove,+ servers_to_update=servers_to_update,+ servers_unchanged=servers_unchanged,+ )diff --git a/marimo/_server/ai/mcp/transport.py b/marimo/_server/ai/mcp/transport.pynew file mode 100644index 0000000000..724247ffd5--- /dev/null+++ b/marimo/_server/ai/mcp/transport.py@@ -0,0 +1,130 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++import os+from abc import ABC, abstractmethod+from enum import Enum+from typing import TYPE_CHECKING, cast++if TYPE_CHECKING:+ from contextlib import AsyncExitStack++ from marimo._config.config import (+ MCPServerStdioConfig,+ MCPServerStreamableHttpConfig,+ )+ from marimo._server.ai.mcp.config import MCPServerDefinition+ from marimo._server.ai.mcp.types import TransportConnectorResponse+++class MCPTransportType(str, Enum):+ """Supported MCP transport types."""++ # based on https://modelcontextprotocol.io/docs/concepts/transports+ STDIO = "stdio"+ STREAMABLE_HTTP = "streamable_http"+++class MCPTransportConnector(ABC):+ """Abstract base class for MCP transport connectors."""++ @abstractmethod+ async def connect(+ self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack+ ) -> TransportConnectorResponse:+ """Connect to the MCP server and return read/write streams.++ Args:+ server_def: Server definition with transport-specific parameters+ exit_stack: Async exit stack for resource management++ Returns:+ Tuple of (read_stream, write_stream) for the ClientSession+ """+ pass+++class StdioTransportConnector(MCPTransportConnector):+ """STDIO transport connector for process-based MCP servers."""++ async def connect(+ self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack+ ) -> TransportConnectorResponse:+ # Import MCP SDK components for stdio transport+ from mcp import StdioServerParameters+ from mcp.client.stdio import stdio_client++ # Type narrowing for mypy+ assert "command" in server_def.config+ config = cast("MCPServerStdioConfig", server_def.config)++ # Set up environment variables for the server process+ env = os.environ.copy()+ env.update(config.get("env") or {})++ # Configure server parameters+ server_params = StdioServerParameters(+ command=config["command"],+ args=config.get("args") or [],+ env=env,+ )++ # Establish connection with proper resource management+ read, write, *_ = await exit_stack.enter_async_context(+ stdio_client(server_params)+ )++ return read, write+++class StreamableHTTPTransportConnector(MCPTransportConnector):+ """Streamable HTTP transport connector for modern HTTP-based MCP servers."""++ async def connect(+ self, server_def: MCPServerDefinition, exit_stack: AsyncExitStack+ ) -> TransportConnectorResponse:+ # Import MCP SDK components for streamable HTTP transport+ from mcp.client.streamable_http import streamablehttp_client++ # Type narrowing for mypy+ assert "url" in server_def.config+ config = cast("MCPServerStreamableHttpConfig", server_def.config)++ # Establish streamable HTTP connection+ read, write, *_ = await exit_stack.enter_async_context(+ streamablehttp_client(+ config["url"],+ headers=config.get("headers", {}),+ timeout=server_def.timeout,+ )+ )++ return read, write+++class MCPTransportRegistry:+ """Registry for MCP transport connectors."""++ def __init__(self) -> None:+ self._connectors: dict[MCPTransportType, MCPTransportConnector] = {+ MCPTransportType.STDIO: StdioTransportConnector(),+ MCPTransportType.STREAMABLE_HTTP: StreamableHTTPTransportConnector(),+ }++ def get_connector(+ self, transport_type: MCPTransportType+ ) -> MCPTransportConnector:+ """Get the appropriate transport connector for the given transport type.++ Args:+ transport_type: The type of transport to connect with++ Returns:+ Transport connector instance++ Raises:+ ValueError: If transport type is not supported+ """+ if transport_type not in self._connectors:+ raise ValueError(f"Unsupported transport type: {transport_type}")+ return self._connectors[transport_type]diff --git a/marimo/_server/ai/mcp/types.py b/marimo/_server/ai/mcp/types.pynew file mode 100644index 0000000000..502b7310d1--- /dev/null+++ b/marimo/_server/ai/mcp/types.py@@ -0,0 +1,24 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from typing import TYPE_CHECKING, Any, Optional++if TYPE_CHECKING:+ from typing import Union++ from anyio.streams.memory import (+ MemoryObjectReceiveStream,+ MemoryObjectSendStream,+ )++ from mcp.shared.message import SessionMessage+++# Type alias that matches the MCP SDK's CallToolRequestParams.arguments type+MCPToolArgs = Optional[dict[str, Any]]++# Type alias for MCP transport connection streams+TransportConnectorResponse = tuple[+ "MemoryObjectReceiveStream[Union[SessionMessage, Exception]]",+ "MemoryObjectSendStream[SessionMessage]",+]diff --git a/marimo/_server/ai/tools/tool_manager.py b/marimo/_server/ai/tools/tool_manager.pyindex 2843d08d79..cc616057e9 100644--- a/marimo/_server/ai/tools/tool_manager.py+++ b/marimo/_server/ai/tools/tool_manager.py@@ -1,7 +1,6 @@# Copyright 2024 Marimo. All rights reserved.from __future__ import annotations-from functools import cached_propertyfrom typing import TYPE_CHECKING, Any, Callable, Optionalfrom starlette.applications import (@@ -12,7 +11,7 @@ from marimo import _loggersfrom marimo._ai._tools.base import ToolBase, ToolContextfrom marimo._ai._tools.tools_registry import SUPPORTED_BACKEND_AND_MCP_TOOLSfrom marimo._config.config import CopilotMode-from marimo._server.ai.mcp import get_mcp_client+from marimo._server.ai.mcp.client import get_mcp_clientfrom marimo._server.ai.tools.types import (FunctionArgs,ToolCallResult,@@ -20,7 +19,6 @@ from marimo._server.ai.tools.types import (ToolSource,ValidationFunction,)-from marimo._server.api.deps import AppStatefrom marimo._utils.once import onceif TYPE_CHECKING:@@ -42,13 +40,6 @@ class ToolManager:self._validation_functions: dict[str, ValidationFunction] = {}self.app: Starlette = app- @cached_property- def _enable_mcp_tools(self) -> bool:- # This may be stale but it is ok, since we want to enable MCP on startup- app_state = AppState.from_app(self.app)- config = app_state.config_manager.get_config()- return bool(config.get("experimental", {}).get("mcp_docs", False))-@oncedef _init_backend_tools(self) -> None:"""Initialize backend tools. We lazily register tools here instead of in the constructor for performance"""@@ -161,9 +152,6 @@ class ToolManager:def _list_mcp_tools(self) -> list[ToolDefinition]:"""Get all MCP tools from the MCP client."""- if not self._enable_mcp_tools:- return []-try:mcp_client = get_mcp_client()mcp_tools = mcp_client.get_all_tools()diff --git a/marimo/_server/api/endpoints/config.py b/marimo/_server/api/endpoints/config.pyindex 4ef88ef8b7..ffdc1c8922 100644--- a/marimo/_server/api/endpoints/config.py+++ b/marimo/_server/api/endpoints/config.py@@ -1,7 +1,7 @@# Copyright 2024 Marimo. All rights reserved.from __future__ import annotations-from typing import TYPE_CHECKING, Optional, cast+from typing import TYPE_CHECKING, castfrom starlette.authentication import requiresfrom starlette.background import BackgroundTask@@ -9,8 +9,12 @@ from starlette.responses import JSONResponsefrom marimo import _loggersfrom marimo._config.config import PartialMarimoConfig+from marimo._dependencies.dependencies import DependencyManagerfrom marimo._messaging.msgspec_encoder import asdict+from marimo._messaging.ops import MissingPackageAlert+from marimo._runtime.packages.utils import is_python_isolatedfrom marimo._runtime.requests import SetUserConfigRequest+from marimo._server.ai.mcp.config import is_mcp_config_emptyfrom marimo._server.api.deps import AppStatefrom marimo._server.api.utils import parse_requestfrom marimo._server.models.models import (@@ -18,6 +22,7 @@ from marimo._server.models.models import (SuccessResponse,)from marimo._server.router import APIRouter+from marimo._server.sessions import send_message_to_consumerfrom marimo._types.ids import ConsumerIdif TYPE_CHECKING:@@ -50,6 +55,8 @@ async def save_user_config($ref: "#/components/schemas/SuccessResponse"""" # noqa: E501app_state = AppState(request)+ session_id = app_state.get_current_session_id()+ session = app_state.get_current_session()# Allow unknown keys to handle backward/forward compatibilitybody = await parse_request(request, cls=SaveUserConfigurationRequest, allow_unknown_keys=True@@ -60,13 +67,45 @@ async def save_user_config(cast(PartialMarimoConfig, body.config))- background_task: Optional[BackgroundTask] = None- # Update the server's view of the config- if config["completion"]["copilot"]:- LOGGER.debug("Starting copilot server")- background_task = BackgroundTask(- app_state.session_manager.start_lsp_server- )+ async def handle_background_tasks() -> None:+ # Update the server's view of the config+ if config["completion"]["copilot"]:+ LOGGER.debug("Starting copilot server")+ await app_state.session_manager.start_lsp_server()++ # Reconfigure MCP servers if config changed+ mcp_config = config.get("mcp")++ # Handle missing MCP dependencies+ if (+ not is_mcp_config_empty(mcp_config)+ and not DependencyManager.mcp.has()+ ):+ # If we're in an edit session, send an package installation request+ if session_id is not None and session is not None:+ send_message_to_consumer(+ session=session,+ operation=MissingPackageAlert(+ packages=["mcp"],+ isolated=is_python_isolated(),+ ),+ consumer_id=ConsumerId(session_id),+ )++ try:+ from marimo._server.ai.mcp import get_mcp_client++ if mcp_config:+ LOGGER.debug("Reconfiguring MCP servers with updated config")+ mcp_client = get_mcp_client()+ await mcp_client.configure(mcp_config)+ LOGGER.info(+ f"MCP servers reconfigured: {list(mcp_client.servers.keys())}"+ )+ except Exception as e:+ LOGGER.warning(f"Failed to reconfigure MCP servers: {e}")++ background_task = BackgroundTask(handle_background_tasks)# Update the kernel's view of the config# Session could be None if the user is on the home pagediff --git a/marimo/_server/api/lifespans.py b/marimo/_server/api/lifespans.pyindex 58e1f758e1..c8a65c9387 100644--- a/marimo/_server/api/lifespans.py+++ b/marimo/_server/api/lifespans.py@@ -7,6 +7,7 @@ import socketfrom typing import TYPE_CHECKING, Any, Optionalfrom marimo import _loggers+from marimo._server.ai.mcp.config import is_mcp_config_emptyfrom marimo._server.ai.tools.tool_manager import setup_tool_managerfrom marimo._server.api.deps import AppState, AppStateBasefrom marimo._server.api.interrupt import InterruptHandler@@ -16,7 +17,8 @@ from marimo._server.lsp import any_lsp_server_runningfrom marimo._server.model import SessionModefrom marimo._server.print import (print_experimental_features,- print_mcp,+ print_mcp_client,+ print_mcp_server,print_shutdown,print_startup,)@@ -87,29 +89,32 @@ async def mcp(app: Starlette) -> AsyncIterator[None]:state = AppState.from_app(app)session_mgr = state.session_manageruser_config = state.config_manager.get_config()- mcp_docs_enabled = user_config.get("experimental", {}).get(- "mcp_docs", False- )+ mcp_config = user_config.get("mcp")# Only start MCP servers in Edit mode- if session_mgr.mode != SessionMode.EDIT or not mcp_docs_enabled:+ if session_mgr.mode != SessionMode.EDIT:yieldreturn- LOGGER.warning("MCP servers are experimental and may not work as expected")+ # Only start MCP servers if the config is not empty+ if not mcp_config or is_mcp_config_empty(mcp_config):+ yield+ returnasync def background_connect_mcp_servers() -> Optional[MCPClient]:try:from marimo._server.ai.mcp import get_mcp_clientmcp_client = get_mcp_client()- await mcp_client.connect_to_all_servers()+ print_mcp_client(mcp_config)+ await mcp_client.configure(mcp_config)+LOGGER.info(f"MCP servers connected: {list(mcp_client.servers.keys())}")return mcp_clientexcept Exception as e:- LOGGER.warning(f"Failed to connect MCP servers in background: {e}")+ LOGGER.warning(f"Failed to connect MCP servers: {e}")return Nonetask = asyncio.create_task(background_connect_mcp_servers())@@ -173,7 +178,7 @@ async def logging(app: Starlette) -> AsyncIterator[None]:server_token = Noneif skew_protection_enabled:server_token = str(state.session_manager.skew_protection_token)- print_mcp(mcp_url, server_token)+ print_mcp_server(mcp_url, server_token)yielddiff --git a/marimo/_server/print.py b/marimo/_server/print.pyindex 944a304506..c5b818b8ec 100644--- a/marimo/_server/print.py+++ b/marimo/_server/print.py@@ -6,7 +6,7 @@ import sysfrom typing import Optionalfrom marimo._cli.print import bold, green, muted-from marimo._config.config import MarimoConfig+from marimo._config.config import MarimoConfig, MCPConfigfrom marimo._server.utils import print_, print_tabbedUTF8_SUPPORTED = False@@ -146,6 +146,7 @@ def print_experimental_features(config: MarimoConfig) -> None:"reactive_tests","toplevel_defs","setup_cell",+ "mcp_docs",}keys = keys - finished_experiments@@ -157,7 +158,7 @@ def print_experimental_features(config: MarimoConfig) -> None:)-def print_mcp(mcp_url: str, server_token: str | None) -> None:+def print_mcp_server(mcp_url: str, server_token: str | None) -> None:"""Print MCP server configuration when MCP is enabled."""print_()print_tabbed(@@ -171,3 +172,15 @@ def print_mcp(mcp_url: str, server_token: str | None) -> None:f"{_utf8('➜')} {green('Add Header')}: Marimo-Server-Token: {muted(server_token)}")print_()+++def print_mcp_client(config: MCPConfig) -> None:+ keys = set(config.get("mcpServers", {}).keys()) | set(+ config.get("presets", [])+ )+ if len(keys) == 0:+ return++ print_tabbed(+ f"{_utf8('🌐')} {green('MCP servers', bold=True)}: {', '.join(keys)}"+ )diff --git a/packages/openapi/api.yaml b/packages/openapi/api.yamlindex f09c60427e..f8fd8558d3 100644--- a/packages/openapi/api.yaml+++ b/packages/openapi/api.yaml@@ -2037,6 +2037,29 @@ components:- keystitle: ListSecretKeysResponsetype: object+ MCPConfig:+ description: 'Configuration for MCP servers+++ Note: the field name `mcpServers` is camelCased to match MCP server++ config conventions used by popular AI applications (e.g. Cursor, Claude Desktop,+ etc.)'+ properties:+ mcpServers:+ additionalProperties:+ type: object+ type: object+ presets:+ items:+ enum:+ - context7+ - marimo+ type: array+ required:+ - mcpServers+ title: MCPConfig+ type: objectMarimoAncestorPreventedError:properties:blamed_cell:@@ -2093,6 +2116,8 @@ components:$ref: '#/components/schemas/KeymapConfig'language_servers:$ref: '#/components/schemas/LanguageServersConfig'+ mcp:+ $ref: '#/components/schemas/MCPConfig'package_management:$ref: '#/components/schemas/PackageManagementConfig'runtime:@@ -3586,7 +3611,7 @@ components:type: objectinfo:title: marimo API- version: 0.16.2+ version: 0.16.3openapi: 3.1.0paths:/@file/{filename_and_length}:diff --git a/packages/openapi/src/api.ts b/packages/openapi/src/api.tsindex 40bb0f6888..3ee67d9b42 100644--- a/packages/openapi/src/api.ts+++ b/packages/openapi/src/api.ts@@ -3737,6 +3737,19 @@ export interface components {ListSecretKeysResponse: {keys: components["schemas"]["SecretKeysWithProvider"][];};+ /**+ * MCPConfig+ * @description Configuration for MCP servers+ *+ * Note: the field name `mcpServers` is camelCased to match MCP server+ * config conventions used by popular AI applications (e.g. Cursor, Claude Desktop, etc.)+ */+ MCPConfig: {+ mcpServers: {+ [key: string]: Record<string, any>;+ };+ presets?: ("context7" | "marimo")[];+ };/** MarimoAncestorPreventedError */MarimoAncestorPreventedError: {blamed_cell: string | null;@@ -3766,6 +3779,7 @@ export interface components {formatting: components["schemas"]["FormattingConfig"];keymap: components["schemas"]["KeymapConfig"];language_servers?: components["schemas"]["LanguageServersConfig"];+ mcp?: components["schemas"]["MCPConfig"];package_management: components["schemas"]["PackageManagementConfig"];runtime: components["schemas"]["RuntimeConfig"];save: components["schemas"]["SaveConfig"];diff --git a/tests/_server/ai/test_mcp.py b/tests/_server/ai/test_mcp.pyindex 70f68f7987..6b48ef5be0 100644--- a/tests/_server/ai/test_mcp.py+++ b/tests/_server/ai/test_mcp.py@@ -11,7 +11,9 @@ from marimo._config.config import ()from marimo._dependencies.dependencies import DependencyManagerfrom marimo._server.ai.mcp import (+ MCP_PRESETS,MCPClient,+ MCPConfigComparator,MCPServerConnection,MCPServerDefinition,MCPServerDefinitionFactory,@@ -20,6 +22,7 @@ from marimo._server.ai.mcp import (MCPTransportType,StdioTransportConnector,StreamableHTTPTransportConnector,+ append_presets,get_mcp_client,)@@ -197,6 +200,275 @@ class TestMCPServerDefinition:assert server_def.timeout == config_kwargs["timeout"]+class TestMCPConfigComparator:+ """Test cases for MCPConfigComparator utility class."""++ def test_compute_diff_no_changes(self):+ """Test that compute_diff detects no changes when configs are identical."""+ server1 = MCPServerDefinition(+ name="server1",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test", args=[], env={}),+ timeout=30.0,+ )++ current = {"server1": server1}+ new = {"server1": server1}++ diff = MCPConfigComparator.compute_diff(current, new)++ assert not diff.has_changes()+ assert len(diff.servers_to_add) == 0+ assert len(diff.servers_to_remove) == 0+ assert len(diff.servers_to_update) == 0+ assert "server1" in diff.servers_unchanged++ def test_compute_diff_add_servers(self):+ """Test that compute_diff detects new servers."""+ server1 = MCPServerDefinition(+ name="server1",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test1", args=[], env={}),+ timeout=30.0,+ )+ server2 = MCPServerDefinition(+ name="server2",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test2", args=[], env={}),+ timeout=30.0,+ )++ current = {"server1": server1}+ new = {"server1": server1, "server2": server2}++ diff = MCPConfigComparator.compute_diff(current, new)++ assert diff.has_changes()+ assert "server2" in diff.servers_to_add+ assert len(diff.servers_to_remove) == 0+ assert len(diff.servers_to_update) == 0+ assert "server1" in diff.servers_unchanged++ def test_compute_diff_remove_servers(self):+ """Test that compute_diff detects removed servers."""+ server1 = MCPServerDefinition(+ name="server1",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test1", args=[], env={}),+ timeout=30.0,+ )+ server2 = MCPServerDefinition(+ name="server2",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test2", args=[], env={}),+ timeout=30.0,+ )++ current = {"server1": server1, "server2": server2}+ new = {"server1": server1}++ diff = MCPConfigComparator.compute_diff(current, new)++ assert diff.has_changes()+ assert "server2" in diff.servers_to_remove+ assert len(diff.servers_to_add) == 0+ assert len(diff.servers_to_update) == 0+ assert "server1" in diff.servers_unchanged++ def test_compute_diff_update_servers(self):+ """Test that compute_diff detects modified servers."""+ server1_old = MCPServerDefinition(+ name="server1",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(+ command="test", args=["--old"], env={}+ ),+ timeout=30.0,+ )+ server1_new = MCPServerDefinition(+ name="server1",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(+ command="test", args=["--new"], env={}+ ),+ timeout=30.0,+ )++ current = {"server1": server1_old}+ new = {"server1": server1_new}++ diff = MCPConfigComparator.compute_diff(current, new)++ assert diff.has_changes()+ assert "server1" in diff.servers_to_update+ assert len(diff.servers_to_add) == 0+ assert len(diff.servers_to_remove) == 0+ assert len(diff.servers_unchanged) == 0++ def test_compute_diff_mixed_changes(self):+ """Test compute_diff with multiple types of changes."""+ server1 = MCPServerDefinition(+ name="unchanged",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test1", args=[], env={}),+ timeout=30.0,+ )+ server2_old = MCPServerDefinition(+ name="updated",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(+ command="test2", args=["--old"], env={}+ ),+ timeout=30.0,+ )+ server2_new = MCPServerDefinition(+ name="updated",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(+ command="test2", args=["--new"], env={}+ ),+ timeout=30.0,+ )+ server3 = MCPServerDefinition(+ name="removed",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test3", args=[], env={}),+ timeout=30.0,+ )+ server4 = MCPServerDefinition(+ name="added",+ transport=MCPTransportType.STDIO,+ config=MCPServerStdioConfig(command="test4", args=[], env={}),+ timeout=30.0,+ )++ current = {+ "unchanged": server1,+ "updated": server2_old,+ "removed": server3,+ }+ new = {"unchanged": server1, "updated": server2_new, "added": server4}++ diff = MCPConfigComparator.compute_diff(current, new)++ assert diff.has_changes()+ assert "unchanged" in diff.servers_unchanged+ assert "updated" in diff.servers_to_update+ assert "removed" in diff.servers_to_remove+ assert "added" in diff.servers_to_add+++class TestMCPPresets:+ """Test cases for MCP preset configuration system."""++ def test_preset_definitions_exist(self):+ """Test that expected presets are defined."""+ assert "marimo" in MCP_PRESETS+ assert "context7" in MCP_PRESETS++ # Verify preset structure+ assert "url" in MCP_PRESETS["marimo"]+ assert "url" in MCP_PRESETS["context7"]++ def test_append_presets_no_presets_list(self):+ """Test append_presets with config that has no presets list."""+ config = MCPConfig(+ mcpServers={+ "custom": MCPServerStdioConfig(command="test", args=[])+ }+ )++ result = append_presets(config)++ # Should return config unchanged+ assert "custom" in result["mcpServers"]+ assert len(result["mcpServers"]) == 1++ def test_append_presets_empty_presets_list(self):+ """Test append_presets with empty presets list."""+ config = MCPConfig(mcpServers={}, presets=[])++ result = append_presets(config)++ assert len(result["mcpServers"]) == 0++ def test_append_presets_adds_marimo_preset(self):+ """Test that marimo preset is added when specified."""+ config = MCPConfig(mcpServers={}, presets=["marimo"])++ result = append_presets(config)++ assert "marimo" in result["mcpServers"]+ assert (+ result["mcpServers"]["marimo"]["url"]+ == MCP_PRESETS["marimo"]["url"]+ )++ def test_append_presets_adds_context7_preset(self):+ """Test that context7 preset is added when specified."""+ config = MCPConfig(mcpServers={}, presets=["context7"])++ result = append_presets(config)++ assert "context7" in result["mcpServers"]+ assert (+ result["mcpServers"]["context7"]["url"]+ == MCP_PRESETS["context7"]["url"]+ )++ def test_append_presets_adds_multiple_presets(self):+ """Test that multiple presets can be added."""+ config = MCPConfig(mcpServers={}, presets=["marimo", "context7"])++ result = append_presets(config)++ assert "marimo" in result["mcpServers"]+ assert "context7" in result["mcpServers"]+ assert len(result["mcpServers"]) == 2++ def test_append_presets_preserves_existing_servers(self):+ """Test that existing servers are preserved when adding presets."""+ config = MCPConfig(+ mcpServers={+ "custom": MCPServerStdioConfig(command="test", args=[])+ },+ presets=["marimo"],+ )++ result = append_presets(config)++ assert "custom" in result["mcpServers"]+ assert "marimo" in result["mcpServers"]+ assert len(result["mcpServers"]) == 2++ def test_append_presets_does_not_override_existing(self):+ """Test that presets don't override existing servers with same name."""+ custom_url = "https://custom.marimo.app/mcp"+ config = MCPConfig(+ mcpServers={+ "marimo": MCPServerStreamableHttpConfig(url=custom_url)+ },+ presets=["marimo"],+ )++ result = append_presets(config)++ # Original server should be preserved+ assert result["mcpServers"]["marimo"]["url"] == custom_url+ assert len(result["mcpServers"]) == 1++ def test_append_presets_does_not_mutate_original(self):+ """Test that append_presets doesn't mutate the original config."""+ config = MCPConfig(mcpServers={}, presets=["marimo"])++ result = append_presets(config)++ # Original config should be unchanged+ assert "marimo" not in config["mcpServers"]+ # Result should have the preset+ assert "marimo" in result["mcpServers"]++class TestMCPTransportConnectors:"""Test cases for transport connector classes."""@@ -288,8 +560,7 @@ class TestMCPClientConfiguration:def test_init_with_empty_config(self):"""Test MCPClient initialization with empty config."""- config = MCPConfig(mcpServers={})- client = MCPClient(config)+ client = MCPClient()assert client.servers == {}assert client.connections == {}assert client.tool_registry == {}@@ -337,7 +608,11 @@ class TestMCPClientConfiguration:):"""Test parsing valid server configurations."""config = MCPConfig(mcpServers=server_configs)- client = MCPClient(config)+ client = MCPClient()++ # Parse the config to populate servers+ parsed_servers = client._parse_config(config)+ client.servers = parsed_serversassert len(client.servers) == len(expected_servers)for server_name in expected_servers:@@ -346,12 +621,275 @@ class TestMCPClientConfiguration:assert server_def.name == server_name+ not DependencyManager.mcp.has(), reason="MCP SDK not available"+)+class TestMCPClientReconfiguration:+ """Test cases for MCPClient dynamic reconfiguration functionality."""++ async def test_configure_noop_when_no_changes(self, mock_session_setup):+ """Test that configure() does nothing when config hasn't changed."""+ del mock_session_setup+ config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test", args=[], env={}+ )+ }+ )+ client = MCPClient()++ # Initial configure+ await client.configure(config)++ # Track calls to connect_to_server+ original_connect = client.connect_to_server+ connect_calls = []++ async def track_connect(server_name: str):+ connect_calls.append(server_name)+ return await original_connect(server_name)++ client.connect_to_server = track_connect++ # Configure with same config+ await client.configure(config)++ # Should not have called connect_to_server+ assert len(connect_calls) == 0++ async def test_configure_adds_new_servers(self, mock_session_setup):+ """Test that configure() adds new servers."""+ del mock_session_setup+ initial_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=[], env={}+ )+ }+ )+ client = MCPClient()+ await client.configure(initial_config)++ # New config with additional server+ new_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=[], env={}+ ),+ "server2": MCPServerStdioConfig(+ command="test2", args=[], env={}+ ),+ }+ )++ # Mock the connection methods+ mock_connect = AsyncMock(return_value=True)+ with patch.object(client, "connect_to_server", mock_connect):+ await client.configure(new_config)++ # Verify server2 was added+ assert "server1" in client.servers+ assert "server2" in client.servers+ assert mock_connect.called+ # Should only connect to server2 (the new one)+ assert mock_connect.call_count == 1+ mock_connect.assert_called_with("server2")++ async def test_configure_removes_old_servers(self, mock_session_setup):+ """Test that configure() removes servers not in new config."""+ del mock_session_setup+ initial_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=[], env={}+ ),+ "server2": MCPServerStdioConfig(+ command="test2", args=[], env={}+ ),+ }+ )+ client = MCPClient()+ await client.configure(initial_config)++ # Create mock connections+ client.connections["server1"] = create_test_server_connection(+ "server1", MCPServerStatus.CONNECTED+ )+ client.connections["server2"] = create_test_server_connection(+ "server2", MCPServerStatus.CONNECTED+ )++ # New config with only server1+ new_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=[], env={}+ )+ }+ )++ # Mock disconnect_from_server+ mock_disconnect = AsyncMock(return_value=True)+ with patch.object(client, "disconnect_from_server", mock_disconnect):+ await client.configure(new_config)++ # Verify server2 was removed+ assert "server1" in client.servers+ assert "server2" not in client.servers+ assert "server2" not in client.connections++ # Should have called disconnect for server2+ mock_disconnect.assert_called_once_with("server2")++ async def test_configure_updates_modified_servers(+ self, mock_session_setup+ ):+ """Test that configure() reconnects to servers with changed config."""+ del mock_session_setup+ initial_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=["--old"], env={}+ )+ }+ )+ client = MCPClient()+ await client.configure(initial_config)++ # Create mock connection+ client.connections["server1"] = create_test_server_connection(+ "server1", MCPServerStatus.CONNECTED+ )++ # New config with modified server1+ new_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=["--new"], env={}+ )+ }+ )++ # Mock methods+ mock_disconnect = AsyncMock(return_value=True)+ mock_connect = AsyncMock(return_value=True)+ with (+ patch.object(client, "disconnect_from_server", mock_disconnect),+ patch.object(client, "connect_to_server", mock_connect),+ ):+ await client.configure(new_config)++ # Should have disconnected and reconnected to server1+ mock_disconnect.assert_called_once_with("server1")+ mock_connect.assert_called_once_with("server1")++ # Verify config was updated+ assert client.servers["server1"].config["args"] == ["--new"]++ async def test_configure_mixed_changes(self, mock_session_setup):+ """Test configure() with add, remove, and update operations."""+ del mock_session_setup+ initial_config = MCPConfig(+ mcpServers={+ "keep_unchanged": MCPServerStdioConfig(+ command="test1", args=[], env={}+ ),+ "to_update": MCPServerStdioConfig(+ command="test2", args=["--old"], env={}+ ),+ "to_remove": MCPServerStdioConfig(+ command="test3", args=[], env={}+ ),+ }+ )+ client = MCPClient()+ await client.configure(initial_config)++ # Create mock connections+ for name in ["keep_unchanged", "to_update", "to_remove"]:+ client.connections[name] = create_test_server_connection(+ name, MCPServerStatus.CONNECTED+ )++ # New config+ new_config = MCPConfig(+ mcpServers={+ "keep_unchanged": MCPServerStdioConfig(+ command="test1", args=[], env={}+ ),+ "to_update": MCPServerStdioConfig(+ command="test2", args=["--new"], env={}+ ),+ "to_add": MCPServerStdioConfig(+ command="test4", args=[], env={}+ ),+ }+ )++ # Mock methods+ mock_disconnect = AsyncMock(return_value=True)+ mock_connect = AsyncMock(return_value=True)+ with (+ patch.object(client, "disconnect_from_server", mock_disconnect),+ patch.object(client, "connect_to_server", mock_connect),+ ):+ await client.configure(new_config)++ # Verify results+ assert "keep_unchanged" in client.servers+ assert "to_update" in client.servers+ assert "to_add" in client.servers+ assert "to_remove" not in client.servers+ assert "to_remove" not in client.connections++ # Verify disconnect was called for removed and updated+ assert mock_disconnect.call_count == 2+ disconnect_calls = [+ call[0][0] for call in mock_disconnect.call_args_list+ ]+ assert "to_remove" in disconnect_calls+ assert "to_update" in disconnect_calls++ # Verify connect was called for added and updated+ assert mock_connect.call_count == 2+ connect_calls = [call[0][0] for call in mock_connect.call_args_list]+ assert "to_add" in connect_calls+ assert "to_update" in connect_calls++ async def test_configure_connection_failures_logged(+ self, mock_session_setup+ ):+ """Test that configure() handles connection failures gracefully."""+ del mock_session_setup+ initial_config = MCPConfig(mcpServers={})+ client = MCPClient()+ await client.configure(initial_config)++ new_config = MCPConfig(+ mcpServers={+ "server1": MCPServerStdioConfig(+ command="test1", args=[], env={}+ )+ }+ )++ # Mock connect_to_server to fail+ mock_connect = AsyncMock(side_effect=Exception("Connection failed"))+ with patch.object(client, "connect_to_server", mock_connect):+ # Should not raise, just log+ await client.configure(new_config)++ # Server should still be in registry even if connection failed+ assert "server1" in client.servers++class TestMCPClientToolManagement:"""Test cases for MCPClient tool management functionality."""def test_create_namespaced_tool_name_no_conflict(self):"""Test creating namespaced tool name without conflicts."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()name = client._create_namespaced_tool_name("github", "create_issue")assert name == "mcp_github_create_issue"@@ -360,7 +898,7 @@ class TestMCPClientToolManagement:)def test_create_namespaced_tool_name_with_conflicts(self):"""Test creating namespaced tool name with conflicts and counter resolution."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import Tool@@ -393,7 +931,7 @@ class TestMCPClientToolManagement:)def test_add_server_tools(self):"""Test adding tools from a server to registry and connection."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import Tool# Create server connection@@ -433,7 +971,7 @@ class TestMCPClientToolManagement:)def test_remove_server_tools(self):"""Test removing tools from a server."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import Tool# Create tools from different servers@@ -519,7 +1057,7 @@ class TestMCPClientToolManagement:)def test_get_tools_by_server(self, server_name, expected_tool_count):"""Test getting tools by server name."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import Tool# Add tools from different servers@@ -554,7 +1092,7 @@ class TestMCPClientToolExecution:def test_create_tool_params(self):"""Test creating properly typed CallToolRequestParams."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Add a mock tool to the registrymock_tool = create_test_tool()@@ -603,7 +1141,7 @@ class TestMCPClientToolExecution:self, tool_setup, connection_setup, expected_error_pattern):"""Test invoke_tool error handling scenarios."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import Tool# Setup tool if provided@@ -655,7 +1193,7 @@ class TestMCPClientToolExecution:async def test_invoke_tool_success(self):"""Test successful tool invocation."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import CallToolResult, TextContent# Setup tool@@ -694,7 +1232,7 @@ class TestMCPClientToolExecution:async def test_invoke_tool_timeout(self):"""Test tool invocation timeout handling."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup toolmock_tool = create_test_tool()@@ -757,7 +1295,7 @@ class TestMCPClientToolExecution:"""Test CallToolResult helper methods."""from mcp.types import CallToolResult, TextContent- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Create resultcontent = [TextContent(**item) for item in result_content]@@ -784,7 +1322,7 @@ class TestMCPClientConnectionManagement:async def test_discover_tools_success(self):"""Test successful tool discovery from an MCP server."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()from mcp.types import ListToolsResult, Tool# Create mock connection with session@@ -820,7 +1358,7 @@ class TestMCPClientConnectionManagement:async def test_discover_tools_no_session(self):"""Test tool discovery with no active session."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Create connection without sessionconnection = create_test_server_connection(session=None)@@ -864,7 +1402,8 @@ class TestMCPClientConnectionManagement:)})- client = MCPClient(config)+ client = MCPClient()+ await client.configure(config)# Test connectionresult = await client.connect_to_server("test_server")@@ -893,7 +1432,8 @@ class TestMCPClientConnectionManagement:command="python", args=["test.py"])- client = MCPClient(config)+ client = MCPClient()+ await client.configure(config)if already_connected:# Setup existing connection@@ -942,7 +1482,8 @@ class TestMCPClientConnectionManagement:),})- client = MCPClient(config)+ client = MCPClient()+ await client.configure(config)results = await client.connect_to_all_servers()@@ -960,7 +1501,7 @@ class TestMCPClientDisconnectionManagement:async def test_disconnect_from_server_success(self):"""Test successful disconnection from a connected server."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup a connected server using existing patternsconnection = create_test_server_connection(@@ -988,7 +1529,7 @@ class TestMCPClientDisconnectionManagement:async def test_disconnect_from_server_already_disconnected(self):"""Test disconnection from server that's already disconnected."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Call disconnect on non-existent serverresult = await client.disconnect_from_server("nonexistent_server")@@ -998,7 +1539,7 @@ class TestMCPClientDisconnectionManagement:async def test_disconnect_from_server_with_exception(self):"""Test disconnection failure handling (validates our new comment)."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup connection with task that will raise exception when awaitedconnection = create_test_server_connection(@@ -1031,7 +1572,7 @@ class TestMCPClientDisconnectionManagement:async def test_disconnect_from_server_cleanup_verification(self):"""Test that disconnection properly cleans up server state."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup connected server with tools and monitoringconnection = create_test_server_connection(@@ -1098,7 +1639,7 @@ class TestMCPClientDisconnectionManagement:)async def test_disconnect_from_all_servers_scenarios(self, server_setups):"""Test disconnect_from_all_servers with various success/failure combinations."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup connections based on test parametersfor setup in server_setups:@@ -1130,7 +1671,7 @@ class TestMCPClientDisconnectionManagement:async def test_disconnect_from_all_servers_with_health_monitoring(self):"""Test that disconnect_from_all_servers cancels health monitoring first."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup connections with health monitoring tasksserver_names = ["server1", "server2"]@@ -1160,7 +1701,7 @@ class TestMCPClientDisconnectionManagement:async def test_disconnect_cross_task_scenario(self):"""Test disconnection in cross-task scenarios (like server shutdown)."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Setup connection that simulates cross-task issuesconnection = create_test_server_connection(@@ -1203,7 +1744,7 @@ class TestMCPClientHealthMonitoring:)async def test_perform_health_check_success(self):"""Test successful health check."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Create connection with mock sessionserver_def = MCPServerDefinitionFactory.from_config(@@ -1242,7 +1783,7 @@ class TestMCPClientHealthMonitoring:self, session_setup, ping_behavior, expected_result):"""Test health check failure scenarios."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()# Create connectionserver_def = MCPServerDefinitionFactory.from_config(@@ -1264,7 +1805,7 @@ class TestMCPClientHealthMonitoring:async def test_perform_health_check_timeout(self):"""Test health check timeout handling."""- client = MCPClient(MCPConfig(mcpServers={}))+ client = MCPClient()client.health_check_timeout = 0.1 # Very short timeout# Create connection with session that hangs@@ -1329,12 +1870,12 @@ class TestMCPUtilities:@pytest.mark.skipif(not DependencyManager.mcp.has(), reason="MCP SDK not available")- def test_get_mcp_client_with_custom_config(self):+ async def test_get_mcp_client_with_custom_config(self):"""Test get_mcp_client with custom configuration."""# Reset global client for this test- import marimo._server.ai.mcp as mcp_module+ import marimo._server.ai.mcp.client as client_module- mcp_module._MCP_CLIENT = None+ client_module._MCP_CLIENT = Nonecustom_config = MCPConfig(mcpServers={@@ -1344,5 +1885,6 @@ class TestMCPUtilities:})- client = get_mcp_client(custom_config)+ client = get_mcp_client()+ await client.configure(custom_config)assert "custom_server" in client.serversdiff --git a/tests/_server/templates/snapshots/export1.txt b/tests/_server/templates/snapshots/export1.txtindex 0784795937..961492ac90 100644--- a/tests/_server/templates/snapshots/export1.txt+++ b/tests/_server/templates/snapshots/export1.txt@@ -59,7 +59,7 @@"mode": "read","version": "0.0.0","serverToken": "token",- "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},+ "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "mcp": {"mcpServers": {}, "presets": []}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},"configOverrides": {"formatting": {"line_length": 100}},"appConfig": {"sql_output": "auto", "width": "compact"},"view": {"showAppCode": true},diff --git a/tests/_server/templates/snapshots/export2.txt b/tests/_server/templates/snapshots/export2.txtindex 535eb3d9b9..abb8a2ac66 100644--- a/tests/_server/templates/snapshots/export2.txt+++ b/tests/_server/templates/snapshots/export2.txt@@ -59,7 +59,7 @@"mode": "read","version": "0.0.0","serverToken": "token",- "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},+ "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "mcp": {"mcpServers": {}, "presets": []}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},"configOverrides": {"formatting": {"line_length": 100}},"appConfig": {"sql_output": "auto", "width": "compact"},"view": {"showAppCode": true},diff --git a/tests/_server/templates/snapshots/export3.txt b/tests/_server/templates/snapshots/export3.txtindex 1ff6b8a8f5..658b38ef27 100644--- a/tests/_server/templates/snapshots/export3.txt+++ b/tests/_server/templates/snapshots/export3.txt@@ -59,7 +59,7 @@"mode": "read","version": "0.0.0","serverToken": "token",- "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},+ "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "mcp": {"mcpServers": {}, "presets": []}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},"configOverrides": {"formatting": {"line_length": 100}},"appConfig": {"sql_output": "auto", "width": "compact"},"view": {"showAppCode": true},diff --git a/tests/_server/templates/snapshots/export4.txt b/tests/_server/templates/snapshots/export4.txtindex 84621c4bfd..1e14288908 100644--- a/tests/_server/templates/snapshots/export4.txt+++ b/tests/_server/templates/snapshots/export4.txt@@ -59,7 +59,7 @@"mode": "read","version": "0.0.0","serverToken": "token",- "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},+ "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "mcp": {"mcpServers": {}, "presets": []}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},"configOverrides": {"formatting": {"line_length": 100}},"appConfig": {"css_file": "custom.css", "sql_output": "auto", "width": "compact"},"view": {"showAppCode": true},diff --git a/tests/_server/templates/snapshots/export5.txt b/tests/_server/templates/snapshots/export5.txtindex 9f61f9a0ae..80ba99eae4 100644--- a/tests/_server/templates/snapshots/export5.txt+++ b/tests/_server/templates/snapshots/export5.txt@@ -59,7 +59,7 @@"mode": "read","version": "0.0.0","serverToken": "token",- "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},+ "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "mcp": {"mcpServers": {}, "presets": []}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},"configOverrides": {"formatting": {"line_length": 100}},"appConfig": {"app_title": "My App", "html_head_file": "head.html", "sql_output": "auto", "width": "compact"},"view": {"showAppCode": true},diff --git a/tests/_server/templates/snapshots/export6.txt b/tests/_server/templates/snapshots/export6.txtindex 6b1e2e64c6..88891f7c39 100644--- a/tests/_server/templates/snapshots/export6.txt+++ b/tests/_server/templates/snapshots/export6.txt@@ -59,7 +59,7 @@"mode": "read","version": "0.0.0","serverToken": "token",- "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "custom_css": ["custom1.css", "custom2.css"], "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},+ "config": {"ai": {"models": {"custom_models": [], "displayed_models": []}}, "completion": {"activate_on_typing": true, "copilot": false}, "display": {"cell_output": "below", "code_editor_font_size": 14, "custom_css": ["custom1.css", "custom2.css"], "dataframes": "rich", "default_table_max_columns": 50, "default_table_page_size": 10, "default_width": "medium", "reference_highlighting": false, "theme": "light"}, "formatting": {"line_length": 79}, "keymap": {"overrides": {}, "preset": "default"}, "language_servers": {"pylsp": {"enable_flake8": false, "enable_mypy": true, "enable_pydocstyle": false, "enable_pyflakes": false, "enable_pylint": false, "enable_ruff": true, "enabled": true}}, "mcp": {"mcpServers": {}, "presets": []}, "package_management": {"manager": "pixi"}, "runtime": {"auto_instantiate": true, "auto_reload": "off", "default_sql_output": "auto", "on_cell_change": "autorun", "output_max_bytes": 8000000, "reactive_tests": true, "std_stream_max_bytes": 1000000, "watcher_on_save": "lazy"}, "save": {"autosave": "after_delay", "autosave_delay": 1000, "format_on_save": false}, "server": {"browser": "default", "follow_symlink": false}, "snippets": {"custom_paths": [], "include_default_snippets": true}},"configOverrides": {"formatting": {"line_length": 100}},"appConfig": {"sql_output": "auto", "width": "compact"},"view": {"showAppCode": true},