Merge pull request #527 from jlowin/mcp-config

Support creating clients from MCP config dicts, including multi-server clients

README.md

@@ -253,6 +253,29 @@ async def main():
         # ... use the client
 ```
 
+FastMCP also supports connecting to multiple servers through a single unified client using the standard MCP configuration format:
+
+```python
+from fastmcp import Client
+
+# Standard MCP configuration with multiple servers
+config = {
+    "mcpServers": {
+        "weather": {"url": "https://weather-api.example.com/mcp"},
+        "assistant": {"command": "python", "args": ["./assistant_server.py"]}
+    }
+}
+
+# Create a client that connects to all servers
+client = Client(config)
+
+async def main():
+    async with client:
+        # Access tools and resources with server prefixes
+        forecast = await client.call_tool("weather_get_forecast", {"city": "London"})
+        answer = await client.call_tool("assistant_answer_question", {"query": "What is MCP?"})
+```
+
 Learn more in the [**Client Documentation**](https://gofastmcp.com/clients/client) and [**Transports Documentation**](https://gofastmcp.com/clients/transports).
 
 ## Advanced Features

docs/clients/client.mdx

@@ -43,7 +43,8 @@ The following inference rules are used to determine the appropriate `ClientTrans
     *   If it ends with `.js`: Creates a `NodeStdioTransport` to run the script using `node`.
 4.  **`AnyUrl` or `str` pointing to a URL that begins with `http://` or `https://`**:
     *   Creates a `StreamableHttpTransport`
-5.  **Other**: Raises a `ValueError` if the type cannot be inferred.
+5.  **`MCPConfig` or dictionary matching MCPConfig schema**: Creates a client that connects to one or more MCP servers specified in the config.
+6.  **Other**: Raises a `ValueError` if the type cannot be inferred.
 
 ```python
 import asyncio
@@ -52,30 +53,100 @@ from fastmcp import Client, FastMCP
 # Example transports (more details in Transports page)
 server_instance = FastMCP(name="TestServer") # In-memory server
 http_url = "https://example.com/mcp"        # HTTP server URL
-ws_url = "ws://localhost:9000"             # WebSocket server URL
 server_script = "my_mcp_server.py"         # Path to a Python server file
 
 # Client automatically infers the transport type
 client_in_memory = Client(server_instance)
 client_http = Client(http_url)
-client_ws = Client(ws_url)
+
 client_stdio = Client(server_script)
 
 print(client_in_memory.transport)
 print(client_http.transport)
-print(client_ws.transport)
 print(client_stdio.transport)
 
 # Expected Output (types may vary slightly based on environment):
 # <FastMCP(server='TestServer')>
 # <StreamableHttp(url='https://example.com/mcp')>
-# <WebSocket(url='ws://localhost:9000')>
 # <PythonStdioTransport(command='python', args=['/path/to/your/my_mcp_server.py'])>
 ```
+
+You can also initialize a client from an MCP configuration dictionary or `MCPConfig` file:
+
+```python
+from fastmcp import Client
+
+config = {
+    "mcpServers": {
+        "local": {"command": "python", "args": ["local_server.py"]},
+        "remote": {"url": "https://example.com/mcp"},
+    }
+}
+
+client_config = Client(config)
+```
 <Tip>
 For more control over connection details (like headers for SSE, environment variables for Stdio), you can instantiate the specific `ClientTransport` class yourself and pass it to the `Client`. See the [Transports](/clients/transports) page for details.
 </Tip>
 
+### Multi-Server Clients
+
+<VersionBadge version="2.3.6" />
+
+FastMCP supports creating clients that connect to multiple MCP servers through a single client interface using a standard MCP configuration format (`MCPConfig`). This configuration approach makes it easy to connect to multiple specialized servers or create composable systems with a simple, declarative syntax.
+
+<Note>
+The MCP configuration format follows an emerging standard and may evolve as the specification matures. FastMCP will strive to maintain compatibility with future versions, but be aware that field names or structure might change.
+</Note>
+
+When you create a client with an `MCPConfig` containing multiple servers:
+
+1. FastMCP creates a composite client that internally mounts all servers using their config names as prefixes
+2. Tools and resources from each server are accessible with appropriate prefixes in the format `servername_toolname` and `protocol://servername/resource/path`
+3. You interact with this as a single unified client, with requests automatically routed to the appropriate server
+
+```python
+from fastmcp import Client
+
+# Create a standard MCP configuration with multiple servers
+config = {
+    "mcpServers": {
+        # A remote HTTP server
+        "weather": {
+            "url": "https://weather-api.example.com/mcp",
+            "transport": "streamable-http"
+        },
+        # A local server running via stdio
+        "assistant": {
+            "command": "python",
+            "args": ["./my_assistant_server.py"],
+            "env": {"DEBUG": "true"}
+        }
+    }
+}
+
+# Create a client that connects to both servers
+client = Client(config)
+
+async def main():
+    async with client:
+        # Access tools from different servers with prefixes
+        weather_data = await client.call_tool("weather_get_forecast", {"city": "London"})
+        response = await client.call_tool("assistant_answer_question", {"question": "What's the capital of France?"})
+        
+        # Access resources with prefixed URIs
+        weather_icons = await client.read_resource("weather://weather/icons/sunny")
+        templates = await client.read_resource("resource://assistant/templates/list")
+        
+        print(f"Weather: {weather_data}")
+        print(f"Assistant: {response}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+If your configuration has only a single server, FastMCP will create a direct client to that server without any prefixing.
+
 ## Client Usage
 
 ### Connection Lifecycle

docs/clients/transports.mdx

@@ -317,4 +317,64 @@ async def main():
 asyncio.run(main())
 ```
 
-Communication happens through efficient in-memory queues, making it very fast and ideal for unit testing. 
+Communication happens through efficient in-memory queues, making it very fast and ideal for unit testing. 
+
+## Configuration-Based Transports
+
+### MCPConfig Transport
+
+<VersionBadge version="2.3.6" />
+
+- **Class:** `fastmcp.client.transports.MCPConfigTransport`
+- **Inferred From:** An instance of `MCPConfig` or a dictionary matching the MCPConfig schema
+- **Use Case:** Connecting to one or more MCP servers defined in a configuration object
+
+MCPConfig follows an emerging standard for MCP server configuration but is subject to change as the specification evolves. The standard supports both local servers (running via stdio) and remote servers (accessed via HTTP).
+
+```python
+from fastmcp import Client
+
+# Configuration for multiple MCP servers (both local and remote)
+config = {
+    "mcpServers": {
+        # Remote HTTP server
+        "weather": {
+            "url": "https://weather-api.example.com/mcp",
+            "transport": "streamable-http"
+        },
+        # Local stdio server
+        "assistant": {
+            "command": "python",
+            "args": ["./assistant_server.py"],
+            "env": {"DEBUG": "true"}
+        },
+        # Another remote server
+        "calendar": {
+            "url": "https://calendar-api.example.com/mcp",
+            "transport": "streamable-http"
+        }
+    }
+}
+
+# Create a transport from the config (happens automatically with Client)
+client = Client(config)
+
+async def main():
+    async with client:
+        # Tools are accessible with server name prefixes
+        weather = await client.call_tool("weather_get_forecast", {"city": "London"})
+        answer = await client.call_tool("assistant_answer_question", {"query": "What is MCP?"})
+        events = await client.call_tool("calendar_list_events", {"date": "2023-06-01"})
+        
+        # Resources use prefixed URI paths
+        icons = await client.read_resource("weather://weather/icons/sunny")
+        docs = await client.read_resource("resource://assistant/docs/mcp")
+
+asyncio.run(main())
+```
+
+If your configuration has only a single server, the client will connect directly to that server without any prefixing. This makes it convenient to switch between single and multi-server configurations without changing your client code.
+
+<Note>
+The MCPConfig format is an emerging standard for MCP server configuration and may change as the MCP ecosystem evolves. While FastMCP aims to maintain compatibility with future versions, be aware that field names or structure might change.
+</Note> 

docs/docs.json

@@ -67,8 +67,8 @@
                 "group": "Clients",
                 "pages": [
                     "clients/client",
-                    "clients/features",
-                    "clients/transports"
+                    "clients/transports",
+                    "clients/advanced-features"
                 ]
             },
             {

docs/servers/composition.mdx

@@ -35,6 +35,10 @@ The choice of importing or mounting depends on your use case and requirements.
 
 FastMCP supports [MCP proxying](/patterns/proxy), which allows you to mirror a local or remote server in a local FastMCP instance. Proxies are fully compatible with both importing and mounting.
 
+<VersionBadge version="2.3.6" />
+
+You can also create proxies from configuration dictionaries that follow the MCPConfig schema, which is useful for quickly connecting to one or more remote servers. See the [Proxy Servers documentation](/servers/proxy#configuration-based-proxies) for details on configuration-based proxying. Note that MCPConfig follows an emerging standard and its format may evolve over time.
+
 ## Importing (Static Composition)
 
 The `import_server()` method copies all components (tools, resources, templates, prompts) from one `FastMCP` instance (the *subserver*) into another (the *main server*). A `prefix` is added to avoid naming conflicts.

docs/servers/proxy.mdx

@@ -10,7 +10,7 @@ import { VersionBadge } from '/snippets/version-badge.mdx'
 
 FastMCP provides a powerful proxying capability that allows one FastMCP server instance to act as a frontend for another MCP server (which could be remote, running on a different transport, or even another FastMCP instance). This is achieved using the `FastMCP.as_proxy()` class method.
 
-`as_proxy()` accepts either an existing `Client` or any argument that can be passed to a `Client` as its `transport` parameter—such as another `FastMCP` instance or a URL to a remote server.
+`as_proxy()` accepts either an existing `Client` or any argument that can be passed to a `Client` as its `transport` parameter—such as another `FastMCP` instance, a URL to a remote server, or an MCP configuration dictionary.
 
 ## What is Proxying?
 
@@ -46,7 +46,7 @@ from fastmcp import FastMCP
 
 # Provide the backend in any form accepted by Client
 proxy_server = FastMCP.as_proxy(
-    "backend_server.py",  # Could also be a FastMCP instance or a remote URL
+    "backend_server.py",  # Could also be a FastMCP instance, config dict, or a remote URL
     name="MyProxyServer"  # Optional settings for the proxy
 )
 
@@ -104,6 +104,64 @@ proxy = FastMCP.as_proxy(
 # requests to original_server
 ```
 
+### Configuration-Based Proxies
+
+<VersionBadge version="2.3.6" />
+
+You can create a proxy directly from a configuration dictionary that follows the MCPConfig schema. This is useful for quickly setting up proxies to remote servers without manually configuring each connection detail.
+
+```python
+from fastmcp import FastMCP
+
+# Create a proxy directly from a config dictionary
+config = {
+    "mcpServers": {
+        "default": {  # For single server configs, 'default' is commonly used
+            "url": "https://example.com/mcp",
+            "transport": "streamable-http"
+        }
+    }
+}
+
+# Create a proxy to the configured server
+proxy = FastMCP.as_proxy(config, name="Config-Based Proxy")
+
+# Run the proxy with stdio transport for local access
+if __name__ == "__main__":
+    proxy.run()
+```
+
+<Note>
+The MCPConfig format follows an emerging standard for MCP server configuration and may evolve as the specification matures. While FastMCP aims to maintain compatibility with future versions, be aware that field names or structure might change.
+</Note>
+
+You can also use MCPConfig to create a proxy to multiple servers. When multiple servers are specified, they are automatically mounted with their config names as prefixes, providing a unified interface to all servers:
+
+```python
+from fastmcp import FastMCP
+
+# Multi-server configuration
+config = {
+    "mcpServers": {
+        "weather": {
+            "url": "https://weather-api.example.com/mcp",
+            "transport": "streamable-http"
+        },
+        "calendar": {
+            "url": "https://calendar-api.example.com/mcp",
+            "transport": "streamable-http"
+        }
+    }
+}
+
+# Create a proxy to multiple servers
+composite_proxy = FastMCP.as_proxy(config, name="Composite Proxy")
+
+# Tools and resources are accessible with prefixes:
+# - weather_get_forecast, calendar_add_event 
+# - weather://weather/icons/sunny, calendar://calendar/events/today
+```
+
 ## `FastMCPProxy` Class
 
 Internally, `FastMCP.as_proxy()` uses the `FastMCPProxy` class. You generally don't need to interact with this class directly, but it's available if needed.

src/fastmcp/client/client.py

@@ -25,6 +25,7 @@ from fastmcp.client.sampling import SamplingHandler, create_sampling_callback
 from fastmcp.exceptions import ToolError
 from fastmcp.server import FastMCP
 from fastmcp.utilities.exceptions import get_catch_handlers
+from fastmcp.utilities.mcp_config import MCPConfig
 
 from .transports import ClientTransport, SessionKwargs, infer_transport
 
@@ -53,6 +54,7 @@ class Client:
             - FastMCP: In-process FastMCP server
             - AnyUrl | str: URL to connect to
             - Path: File path for local socket
+            - MCPConfig: MCP server configuration
             - dict: Transport configuration
         roots: Optional RootsList or RootsHandler for filesystem access
         sampling_handler: Optional handler for sampling requests
@@ -77,7 +79,13 @@ class Client:
 
     def __init__(
         self,
-        transport: ClientTransport | FastMCP | AnyUrl | Path | dict[str, Any] | str,
+        transport: ClientTransport
+        | FastMCP
+        | AnyUrl
+        | Path
+        | MCPConfig
+        | dict[str, Any]
+        | str,
         # Common args
         roots: RootsList | RootsHandler | None = None,
         sampling_handler: SamplingHandler | None = None,

src/fastmcp/client/transports.py

@@ -24,6 +24,7 @@ from pydantic import AnyUrl
 from typing_extensions import Unpack
 
 from fastmcp.server import FastMCP as FastMCPServer
+from fastmcp.server.server import FastMCP
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_config import MCPConfig, infer_transport_type_from_url
 
@@ -74,7 +75,7 @@ class ClientTransport(abc.ABC):
             A mcp.ClientSession instance.
         """
         raise NotImplementedError
-        yield None  # type: ignore
+        yield  # type: ignore
 
     def __repr__(self) -> str:
         # Basic representation for subclasses
@@ -455,7 +456,7 @@ class FastMCPTransport(ClientTransport):
     """
 
     def __init__(self, mcp: FastMCPServer):
-        self._fastmcp = mcp  # Can be FastMCP or MCPServer
+        self.server = mcp  # Can be FastMCP or MCPServer
 
     @contextlib.asynccontextmanager
     async def connect_session(
@@ -463,13 +464,95 @@ class FastMCPTransport(ClientTransport):
     ) -> AsyncIterator[ClientSession]:
         # create_connected_server_and_client_session manages the session lifecycle itself
         async with create_connected_server_and_client_session(
-            server=self._fastmcp._mcp_server,
+            server=self.server._mcp_server,
             **session_kwargs,
         ) as session:
             yield session
 
     def __repr__(self) -> str:
-        return f"<FastMCP(server='{self._fastmcp.name}')>"
+        return f"<FastMCP(server='{self.server.name}')>"
+
+
+class MCPConfigTransport(ClientTransport):
+    """Transport for connecting to one or more MCP servers defined in an MCPConfig.
+
+    This transport provides a unified interface to multiple MCP servers defined in an MCPConfig
+    object or dictionary matching the MCPConfig schema. It supports two key scenarios:
+
+    1. If the MCPConfig contains exactly one server, it creates a direct transport to that server.
+    2. If the MCPConfig contains multiple servers, it creates a composite client by mounting
+       all servers on a single FastMCP instance, with each server's name used as its mounting prefix.
+
+    In the multi-server case, tools are accessible with the prefix pattern `{server_name}_{tool_name}`
+    and resources with the pattern `protocol://{server_name}/path/to/resource`.
+
+    This is particularly useful for creating clients that need to interact with multiple specialized
+    MCP servers through a single interface, simplifying client code.
+
+    Examples:
+        ```python
+        from fastmcp import Client
+        from fastmcp.utilities.mcp_config import MCPConfig
+
+        # Create a config with multiple servers
+        config = {
+            "mcpServers": {
+                "weather": {
+                    "url": "https://weather-api.example.com/mcp",
+                    "transport": "streamable-http"
+                },
+                "calendar": {
+                    "url": "https://calendar-api.example.com/mcp",
+                    "transport": "streamable-http"
+                }
+            }
+        }
+
+        # Create a client with the config
+        client = Client(config)
+
+        async with client:
+            # Access tools with prefixes
+            weather = await client.call_tool("weather_get_forecast", {"city": "London"})
+            events = await client.call_tool("calendar_list_events", {"date": "2023-06-01"})
+
+            # Access resources with prefixed URIs
+            icons = await client.read_resource("weather://weather/icons/sunny")
+        ```
+    """
+
+    def __init__(self, config: MCPConfig | dict):
+        from fastmcp.client.client import Client
+
+        if isinstance(config, dict):
+            config = MCPConfig.from_dict(config)
+        self.config = config
+
+        # if there's exactly one server, create a client for that server
+        if len(self.config.mcpServers) == 1:
+            self.transport = list(self.config.mcpServers.values())[0].to_transport()
+
+        # otherwise create a composite client
+        else:
+            composite_server = FastMCP()
+
+            for name, server in self.config.mcpServers.items():
+                server_client = Client(transport=server.to_transport())
+                composite_server.mount(
+                    prefix=name, server=FastMCP.as_proxy(server_client)
+                )
+
+            self.transport = FastMCPTransport(mcp=composite_server)
+
+    @contextlib.asynccontextmanager
+    async def connect_session(
+        self, **session_kwargs: Unpack[SessionKwargs]
+    ) -> AsyncIterator[ClientSession]:
+        async with self.transport.connect_session(**session_kwargs) as session:
+            yield session
+
+    def __repr__(self) -> str:
+        return f"<MCPConfig(config='{self.config}')>"
 
 
 def infer_transport(
@@ -488,7 +571,38 @@ def infer_transport(
     argument, handling various input types and converting them to the appropriate
     ClientTransport subclass.
 
+    The function supports these input types:
+    - ClientTransport: Used directly without modification
+    - FastMCPServer: Creates an in-memory FastMCPTransport
+    - Path or str (file path): Creates PythonStdioTransport (.py) or NodeStdioTransport (.js)
+    - AnyUrl or str (URL): Creates StreamableHttpTransport (default) or SSETransport (for /sse endpoints)
+    - MCPConfig or dict: Creates MCPConfigTransport, potentially connecting to multiple servers
+
     For HTTP URLs, they are assumed to be Streamable HTTP URLs unless they end in `/sse`.
+
+    For MCPConfig with multiple servers, a composite client is created where each server
+    is mounted with its name as prefix. This allows accessing tools and resources from multiple
+    servers through a single unified client interface, using naming patterns like
+    `servername_toolname` for tools and `protocol://servername/path` for resources.
+    If the MCPConfig contains only one server, a direct connection is established without prefixing.
+
+    Examples:
+        ```python
+        # Connect to a local Python script
+        transport = infer_transport("my_script.py")
+
+        # Connect to a remote server via HTTP
+        transport = infer_transport("http://example.com/mcp")
+
+        # Connect to multiple servers using MCPConfig
+        config = {
+            "mcpServers": {
+                "weather": {"url": "http://weather.example.com/mcp"},
+                "calendar": {"url": "http://calendar.example.com/mcp"}
+            }
+        }
+        transport = infer_transport(config)
+        ```
     """
     from fastmcp.utilities.mcp_config import MCPConfig
 
@@ -519,16 +633,7 @@ def infer_transport(
 
     # if the transport is a config dict or MCPConfig
     elif isinstance(transport, dict | MCPConfig):
-        if isinstance(transport, dict):
-            config = MCPConfig.from_dict(transport)
-        else:
-            config = transport
-        inferred_transports = config.to_transports()
-        if len(inferred_transports) > 1:
-            raise ValueError(
-                "Invalid transport dictionary: multiple servers found - only one expected"
-            )
-        inferred_transport = list(inferred_transports.values())[0]
+        inferred_transport = MCPConfigTransport(config=transport)
 
     # the transport is an unknown type
     else:

src/fastmcp/server/proxy.py

@@ -25,7 +25,6 @@ from fastmcp.server.context import Context
 from fastmcp.server.server import FastMCP
 from fastmcp.tools.tool import Tool
 from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig
 
 if TYPE_CHECKING:
     from fastmcp.server import Context
@@ -178,13 +177,6 @@ class FastMCPProxy(FastMCP):
         super().__init__(**kwargs)
         self.client = client
 
-    @classmethod
-    async def from_mcp_config(cls, config: MCPConfig | dict) -> FastMCPProxy:
-        if isinstance(config, dict):
-            config = MCPConfig.from_dict(config)
-        clients = config.to_clients()
-        return cls(client=clients[list(clients.keys())[0]])
-
     async def get_tools(self) -> dict[str, Tool]:
         tools = await super().get_tools()
 

src/fastmcp/server/server.py

@@ -58,6 +58,7 @@ from fastmcp.tools.tool import Tool
 from fastmcp.utilities.cache import TimedCache
 from fastmcp.utilities.decorators import DecoratedFunction
 from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.mcp_config import MCPConfig
 
 if TYPE_CHECKING:
     from fastmcp.client import Client
@@ -1206,6 +1207,7 @@ class FastMCP(Generic[LifespanResultT]):
         | FastMCP[Any]
         | AnyUrl
         | Path
+        | MCPConfig
         | dict[str, Any]
         | str,
         **settings: Any,

src/fastmcp/utilities/mcp_config.py

@@ -6,7 +6,6 @@ from urllib.parse import urlparse
 from pydantic import AnyUrl, BaseModel, Field
 
 if TYPE_CHECKING:
-    from fastmcp.client.client import Client
     from fastmcp.client.transports import (
         SSETransport,
         StdioTransport,
@@ -75,16 +74,3 @@ class MCPConfig(BaseModel):
     @classmethod
     def from_dict(cls, config: dict[str, Any]) -> MCPConfig:
         return cls(mcpServers=config.get("mcpServers", config))
-
-    def to_transports(
-        self,
-    ) -> dict[str, StdioTransport | StreamableHttpTransport | SSETransport]:
-        return {name: server.to_transport() for name, server in self.mcpServers.items()}
-
-    def to_clients(self) -> dict[str, Client]:
-        from fastmcp.client.client import Client
-
-        return {
-            name: Client(transport=transport)
-            for name, transport in self.to_transports().items()
-        }

tests/client/test_client.py

@@ -9,6 +9,7 @@ from pydantic import AnyUrl
 from fastmcp.client import Client
 from fastmcp.client.transports import (
     FastMCPTransport,
+    MCPConfigTransport,
     SSETransport,
     StdioTransport,
     StreamableHttpTransport,
@@ -652,9 +653,10 @@ class TestInferTransport:
             }
         }
         transport = infer_transport(config)
-        assert isinstance(transport, SSETransport)
-        assert transport.url == "http://localhost:8000/sse"
-        assert transport.headers == {"Authorization": "Bearer 123"}
+        assert isinstance(transport, MCPConfigTransport)
+        assert isinstance(transport.transport, SSETransport)
+        assert transport.transport.url == "http://localhost:8000/sse"
+        assert transport.transport.headers == {"Authorization": "Bearer 123"}
 
     def test_infer_local_transport_from_config(self):
         config = {
@@ -666,6 +668,25 @@ class TestInferTransport:
             }
         }
         transport = infer_transport(config)
-        assert isinstance(transport, StdioTransport)
-        assert transport.command == "echo"
-        assert transport.args == ["hello"]
+        assert isinstance(transport, MCPConfigTransport)
+        assert isinstance(transport.transport, StdioTransport)
+        assert transport.transport.command == "echo"
+        assert transport.transport.args == ["hello"]
+
+    def test_infer_composite_client(config):
+        config = {
+            "mcpServers": {
+                "local": {
+                    "command": "echo",
+                    "args": ["hello"],
+                },
+                "remote": {
+                    "url": "http://localhost:8000/sse",
+                    "headers": {"Authorization": "Bearer 123"},
+                },
+            }
+        }
+        transport = infer_transport(config)
+        assert isinstance(transport, MCPConfigTransport)
+        assert isinstance(transport.transport, FastMCPTransport)
+        assert len(transport.transport.server._mounted_servers) == 2

tests/utilities/test_mcp_config.py

@@ -1,3 +1,9 @@
+import inspect
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from fastmcp.client.client import Client
 from fastmcp.client.transports import (
     SSETransport,
     StdioTransport,
@@ -90,3 +96,47 @@ def test_parse_multiple_servers():
     assert mcp_config.mcpServers["test_server_2"].command == "echo"
     assert mcp_config.mcpServers["test_server_2"].args == ["hello"]
     assert mcp_config.mcpServers["test_server_2"].env == {"TEST": "test"}
+
+
+async def test_multi_client(tmp_path: Path):
+    server_script = inspect.cleandoc("""
+        from fastmcp import FastMCP
+
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def add(a: int, b: int) -> int:
+            return a + b
+
+        if __name__ == '__main__':
+            mcp.run()
+        """)
+
+    script_path = tmp_path / "test.py"
+    script_path.write_text(server_script)
+
+    config = {
+        "mcpServers": {
+            "test_1": {
+                "command": "python",
+                "args": [str(script_path)],
+            },
+            "test_2": {
+                "command": "python",
+                "args": [str(script_path)],
+            },
+        }
+    }
+
+    client = Client(config)
+
+    async with client:
+        tools = await client.list_tools()
+        assert len(tools) == 2
+
+        result_1 = await client.call_tool("test_1_add", {"a": 1, "b": 2})
+        result_2 = await client.call_tool("test_2_add", {"a": 1, "b": 2})
+        assert isinstance(result_1[0], TextContent)
+        assert result_1[0].text == "3"
+        assert isinstance(result_2[0], TextContent)
+        assert result_2[0].text == "3"