Support creating clients from mcpconfig

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,50 @@ 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 running MCPConfig."""
+
+    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(
@@ -519,16 +557,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
@@ -1203,6 +1204,7 @@ class FastMCP(Generic[LifespanResultT]):
         | FastMCP[Any]
         | AnyUrl
         | Path
+        | MCPConfig
         | dict[str, Any]
         | str,
         **settings: Any,

src/fastmcp/utilities/exceptions.py

@@ -18,6 +18,7 @@ def iter_exc(group: BaseExceptionGroup):
 
 
 def _exception_handler(group: BaseExceptionGroup):
+    print(list(iter_exc(group)))
     for leaf in iter_exc(group):
         if isinstance(leaf, httpx.ConnectTimeout):
             raise McpError(

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"