Simplify API: Client(server) instead of Client.from_server(server)

- Refactor Client constructor to accept Server/FastMCP directly
- Remove from_server() classmethod (simpler, matches FastMCP pattern)
- Update all tests and examples to use new pattern

Github-Issue:#1728

Author: felixweinberger

examples/fastmcp/weather_structured.py

@@ -157,7 +157,7 @@ async def test() -> None:
         print("Testing Weather Service Tools (via MCP protocol)\n")
         print("=" * 80)
 
-        async with Client.from_server(mcp) as client:
+        async with Client(mcp) as client:
             # Test get_weather
             result = await client.call_tool("get_weather", {"city": "London"})
             print("\nWeather in London:")

src/mcp/client/client.py

@@ -3,11 +3,9 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import AsyncGenerator
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AsyncExitStack
 from typing import Any
 
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from pydantic import AnyUrl
 
 import mcp.types as types
@@ -22,37 +20,35 @@
 from mcp.client.transports.memory import InMemoryTransport
 from mcp.server import Server
 from mcp.server.fastmcp import FastMCP
-from mcp.shared.message import SessionMessage
 from mcp.shared.session import ProgressFnT
 
 logger = logging.getLogger(__name__)
 
 
 class Client:
     """
-    A high-level MCP client that manages transport and session lifecycle.
+    A high-level MCP client for connecting to MCP servers.
 
-    The Client class provides a unified interface for connecting to MCP servers
-    using different transports (in-memory, stdio, HTTP, etc.) and exposes
-    all ClientSession functionality with simpler lifecycle management.
+    The Client class provides a simple interface for testing MCP servers
+    using in-memory transport. Pass a Server or FastMCP instance directly
+    to the constructor.
 
-    Example with in-memory transport (for testing):
+    Example:
         server = FastMCP("test")
 
-        async with Client.from_server(server) as client:
-            tools = await client.list_tools()
-            result = await client.call_tool("my_tool", {"arg": "value"})
+        @server.tool()
+        def add(a: int, b: int) -> int:
+            return a + b
 
-    Example with custom streams:
-        async with Client(read_stream, write_stream) as client:
-            await client.initialize()
-            # Use client...
+        async with Client(server) as client:
+            result = await client.call_tool("add", {"a": 1, "b": 2})
     """
 
     def __init__(
         self,
-        read_stream: MemoryObjectReceiveStream[SessionMessage | Exception],
-        write_stream: MemoryObjectSendStream[SessionMessage],
+        server: Server[Any] | FastMCP,
+        *,
+        raise_exceptions: bool = False,
         read_timeout_seconds: float | None = None,
         sampling_callback: SamplingFnT | None = None,
         list_roots_callback: ListRootsFnT | None = None,
@@ -62,11 +58,11 @@ def __init__(
         elicitation_callback: ElicitationFnT | None = None,
     ) -> None:
         """
-        Initialize the client with transport streams.
+        Initialize the client with a server.
 
         Args:
-            read_stream: Stream for receiving messages from the server
-            write_stream: Stream for sending messages to the server
+            server: The MCP server to connect to (Server or FastMCP instance)
+            raise_exceptions: Whether to raise exceptions from the server
             read_timeout_seconds: Timeout for read operations
             sampling_callback: Callback for handling sampling requests
             list_roots_callback: Callback for handling list roots requests
@@ -75,8 +71,8 @@ def __init__(
             client_info: Client implementation info to send to server
             elicitation_callback: Callback for handling elicitation requests
         """
-        self._read_stream = read_stream
-        self._write_stream = write_stream
+        self._server = server
+        self._raise_exceptions = raise_exceptions
         self._read_timeout_seconds = read_timeout_seconds
         self._sampling_callback = sampling_callback
         self._list_roots_callback = list_roots_callback
@@ -88,86 +84,40 @@ def __init__(
         self._session: ClientSession | None = None
         self._exit_stack: AsyncExitStack | None = None
 
-    @classmethod
-    @asynccontextmanager
-    async def from_server(
-        cls,
-        server: Server[Any] | FastMCP,
-        read_timeout_seconds: float | None = None,
-        sampling_callback: SamplingFnT | None = None,
-        list_roots_callback: ListRootsFnT | None = None,
-        logging_callback: LoggingFnT | None = None,
-        message_handler: MessageHandlerFnT | None = None,
-        client_info: types.Implementation | None = None,
-        raise_exceptions: bool = False,
-        elicitation_callback: ElicitationFnT | None = None,
-    ) -> AsyncGenerator[Client, None]:
-        """
-        Create a client connected to an in-memory server.
-
-        This is a convenience method that creates an in-memory transport,
-        starts the server, and returns an initialized client.
-
-        Args:
-            server: The MCP server to connect to (Server or FastMCP instance)
-            read_timeout_seconds: Timeout for read operations
-            sampling_callback: Callback for handling sampling requests
-            list_roots_callback: Callback for handling list roots requests
-            logging_callback: Callback for handling logging notifications
-            message_handler: Callback for handling raw messages
-            client_info: Client implementation info to send to server
-            raise_exceptions: Whether to raise exceptions from the server
-            elicitation_callback: Callback for handling elicitation requests
-
-        Yields:
-            An initialized Client connected to the server
-
-        Example:
-            server = FastMCP("test")
-
-            @server.tool()
-            def my_tool(arg: str) -> str:
-                return f"Result: {arg}"
-
-            async with Client.from_server(server) as client:
-                result = await client.call_tool("my_tool", {"arg": "value"})
-        """
-        transport = InMemoryTransport(server, raise_exceptions=raise_exceptions)
-        async with transport.connect() as (read_stream, write_stream):
-            client = cls(
-                read_stream=read_stream,
-                write_stream=write_stream,
-                read_timeout_seconds=read_timeout_seconds,
-                sampling_callback=sampling_callback,
-                list_roots_callback=list_roots_callback,
-                logging_callback=logging_callback,
-                message_handler=message_handler,
-                client_info=client_info,
-                elicitation_callback=elicitation_callback,
-            )
-            async with client:
-                await client.initialize()
-                yield client
-
     async def __aenter__(self) -> Client:
         """Enter the async context manager."""
         self._exit_stack = AsyncExitStack()
         await self._exit_stack.__aenter__()
 
-        self._session = await self._exit_stack.enter_async_context(
-            ClientSession(
-                read_stream=self._read_stream,
-                write_stream=self._write_stream,
-                read_timeout_seconds=self._read_timeout_seconds,
-                sampling_callback=self._sampling_callback,
-                list_roots_callback=self._list_roots_callback,
-                logging_callback=self._logging_callback,
-                message_handler=self._message_handler,
-                client_info=self._client_info,
-                elicitation_callback=self._elicitation_callback,
+        try:
+            # Create transport and connect
+            transport = InMemoryTransport(self._server, raise_exceptions=self._raise_exceptions)
+            read_stream, write_stream = await self._exit_stack.enter_async_context(
+                transport.connect()
+            )
+
+            # Create session
+            self._session = await self._exit_stack.enter_async_context(
+                ClientSession(
+                    read_stream=read_stream,
+                    write_stream=write_stream,
+                    read_timeout_seconds=self._read_timeout_seconds,
+                    sampling_callback=self._sampling_callback,
+                    list_roots_callback=self._list_roots_callback,
+                    logging_callback=self._logging_callback,
+                    message_handler=self._message_handler,
+                    client_info=self._client_info,
+                    elicitation_callback=self._elicitation_callback,
+                )
             )
-        )
-        return self
+
+            # Initialize the session
+            await self._session.initialize()
+
+            return self
+        except Exception:
+            await self._exit_stack.__aexit__(None, None, None)
+            raise
 
     async def __aexit__(
         self,
@@ -194,17 +144,6 @@ def session(self) -> ClientSession:
             raise RuntimeError("Client must be used within an async context manager")
         return self._session
 
-    async def initialize(self) -> types.InitializeResult:
-        """
-        Initialize the MCP session with the server.
-
-        This must be called before using other client methods.
-
-        Returns:
-            The initialization result from the server
-        """
-        return await self.session.initialize()
-
     def get_server_capabilities(self) -> types.ServerCapabilities | None:
         """
         Return the server capabilities received during initialization.

tests/client/test_client.py

@@ -56,26 +56,26 @@ def greeting_prompt(name: str) -> str:
 
 
 class TestClientFromServer:
-    """Tests for Client.from_server() class method."""
+    """Tests for Client() class method."""
 
     @pytest.mark.anyio
     async def test_creates_client(self, fastmcp_server: FastMCP):
         """Test that from_server creates a connected client."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             assert client is not None
 
     @pytest.mark.anyio
     async def test_client_is_initialized(self, fastmcp_server: FastMCP):
         """Test that the client is initialized after entering context."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             caps = client.get_server_capabilities()
             assert caps is not None
             assert caps.tools is not None
 
     @pytest.mark.anyio
     async def test_with_simple_server(self, simple_server: Server):
         """Test that from_server works with a basic Server instance."""
-        async with Client.from_server(simple_server) as client:
+        async with Client(simple_server) as client:
             assert client is not None
             caps = client.get_server_capabilities()
             assert caps is not None
@@ -87,7 +87,7 @@ class TestClientPing:
     @pytest.mark.anyio
     async def test_ping_returns_empty_result(self, fastmcp_server: FastMCP):
         """Test that ping returns an EmptyResult."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.send_ping()
             assert isinstance(result, EmptyResult)
 
@@ -98,7 +98,7 @@ class TestClientTools:
     @pytest.mark.anyio
     async def test_list_tools(self, fastmcp_server: FastMCP):
         """Test listing tools."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.list_tools()
             assert result.tools is not None
             tool_names = [t.name for t in result.tools]
@@ -110,14 +110,14 @@ async def test_list_tools_with_pagination(self, fastmcp_server: FastMCP):
         """Test listing tools with pagination params."""
         from mcp.types import PaginatedRequestParams
 
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.list_tools(params=PaginatedRequestParams())
             assert result.tools is not None
 
     @pytest.mark.anyio
     async def test_call_tool(self, fastmcp_server: FastMCP):
         """Test calling a tool."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.call_tool("greet", {"name": "World"})
             assert result.content is not None
             assert len(result.content) > 0
@@ -127,7 +127,7 @@ async def test_call_tool(self, fastmcp_server: FastMCP):
     @pytest.mark.anyio
     async def test_call_tool_with_multiple_args(self, fastmcp_server: FastMCP):
         """Test calling a tool with multiple arguments."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.call_tool("add", {"a": 5, "b": 3})
             assert result.content is not None
             content_str = str(result.content[0])
@@ -140,15 +140,15 @@ class TestClientResources:
     @pytest.mark.anyio
     async def test_list_resources(self, fastmcp_server: FastMCP):
         """Test listing resources."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.list_resources()
             # FastMCP may have different resource listing behavior
             assert result is not None
 
     @pytest.mark.anyio
     async def test_read_resource(self, fastmcp_server: FastMCP):
         """Test reading a resource."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.read_resource(AnyUrl("test://resource"))
             assert result.contents is not None
             assert len(result.contents) > 0
@@ -160,15 +160,15 @@ class TestClientPrompts:
     @pytest.mark.anyio
     async def test_list_prompts(self, fastmcp_server: FastMCP):
         """Test listing prompts."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.list_prompts()
             prompt_names = [p.name for p in result.prompts]
             assert "greeting_prompt" in prompt_names
 
     @pytest.mark.anyio
     async def test_get_prompt(self, fastmcp_server: FastMCP):
         """Test getting a prompt."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             result = await client.get_prompt("greeting_prompt", {"name": "Alice"})
             assert result.messages is not None
             assert len(result.messages) > 0
@@ -182,14 +182,14 @@ async def test_session_property(self, fastmcp_server: FastMCP):
         """Test that the session property returns the ClientSession."""
         from mcp.client.session import ClientSession
 
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             session = client.session
             assert isinstance(session, ClientSession)
 
     @pytest.mark.anyio
     async def test_session_is_same_as_internal(self, fastmcp_server: FastMCP):
         """Test that session property returns consistent instance."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             session1 = client.session
             session2 = client.session
             assert session1 is session2
@@ -206,7 +206,7 @@ async def test_logging_callback(self, fastmcp_server: FastMCP):
         async def logging_callback(params):
             log_messages.append(params)
 
-        async with Client.from_server(
+        async with Client(
             fastmcp_server,
             logging_callback=logging_callback,
         ) as client:
@@ -221,7 +221,7 @@ class TestClientContextManager:
     @pytest.mark.anyio
     async def test_enters_and_exits_cleanly(self, fastmcp_server: FastMCP):
         """Test that the client enters and exits cleanly."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             # Should be able to use client
             await client.send_ping()
         # After exiting, resources should be cleaned up
@@ -230,7 +230,7 @@ async def test_enters_and_exits_cleanly(self, fastmcp_server: FastMCP):
     async def test_exception_during_use(self, fastmcp_server: FastMCP):
         """Test that exceptions during use don't prevent cleanup."""
         with pytest.raises(Exception):  # May be wrapped in ExceptionGroup by anyio
-            async with Client.from_server(fastmcp_server) as client:
+            async with Client(fastmcp_server) as client:
                 await client.send_ping()
                 raise ValueError("Test exception")
         # Should exit cleanly despite exception
@@ -242,7 +242,7 @@ class TestClientServerCapabilities:
     @pytest.mark.anyio
     async def test_get_server_capabilities_after_init(self, fastmcp_server: FastMCP):
         """Test getting server capabilities after initialization."""
-        async with Client.from_server(fastmcp_server) as client:
+        async with Client(fastmcp_server) as client:
             caps = client.get_server_capabilities()
             assert caps is not None
             # FastMCP should advertise tools capability