Implement Client and create_in_memory_transport

- Client class wraps ClientSession with transport management
- Client.from_server() provides ergonomic in-memory testing
- create_in_memory_transport() reuses existing memory stream logic
- All 23 Client tests pass

Github-Issue:#1728

Author: felixweinberger

src/mcp/client/client.py

@@ -4,7 +4,7 @@
 
 import logging
 from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager
 from typing import Any
 
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
@@ -19,6 +19,7 @@
     MessageHandlerFnT,
     SamplingFnT,
 )
+from mcp.client.transports.memory import create_in_memory_transport
 from mcp.server import Server
 from mcp.server.fastmcp import FastMCP
 from mcp.shared.message import SessionMessage
@@ -35,14 +36,14 @@ class Client:
     using different transports (in-memory, stdio, HTTP, etc.) and exposes
     all ClientSession functionality with simpler lifecycle management.
 
-    Example with in-memory transport:
+    Example with in-memory transport (for testing):
         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"})
 
-    Example with custom transport:
+    Example with custom streams:
         async with Client(read_stream, write_stream) as client:
             await client.initialize()
             # Use client...
@@ -74,7 +75,18 @@ def __init__(
             client_info: Client implementation info to send to server
             elicitation_callback: Callback for handling elicitation requests
         """
-        raise NotImplementedError("Client.__init__ is not yet implemented")
+        self._read_stream = read_stream
+        self._write_stream = write_stream
+        self._read_timeout_seconds = read_timeout_seconds
+        self._sampling_callback = sampling_callback
+        self._list_roots_callback = list_roots_callback
+        self._logging_callback = logging_callback
+        self._message_handler = message_handler
+        self._client_info = client_info
+        self._elicitation_callback = elicitation_callback
+
+        self._session: ClientSession | None = None
+        self._exit_stack: AsyncExitStack | None = None
 
     @classmethod
     @asynccontextmanager
@@ -120,16 +132,43 @@ def my_tool(arg: str) -> str:
             async with Client.from_server(server) as client:
                 result = await client.call_tool("my_tool", {"arg": "value"})
         """
-        # Silence unused parameter warnings in stub
-        _ = (server, read_timeout_seconds, sampling_callback, list_roots_callback,
-             logging_callback, message_handler, client_info, raise_exceptions, elicitation_callback)
-        # Stub: yield fake value, actual implementation will provide real client
-        yield None  # type: ignore[misc]
-        raise NotImplementedError("Client.from_server is not yet implemented")
+        async with create_in_memory_transport(
+            server, raise_exceptions=raise_exceptions
+        ) 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."""
-        raise NotImplementedError("Client.__aenter__ is not yet implemented")
+        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,
+            )
+        )
+        return self
 
     async def __aexit__(
         self,
@@ -138,7 +177,23 @@ async def __aexit__(
         exc_tb: Any,
     ) -> None:
         """Exit the async context manager."""
-        raise NotImplementedError("Client.__aexit__ is not yet implemented")
+        if self._exit_stack:
+            await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
+        self._session = None
+
+    @property
+    def session(self) -> ClientSession:
+        """
+        Get the underlying ClientSession.
+
+        This provides access to the full ClientSession API for advanced use cases.
+
+        Raises:
+            RuntimeError: If accessed before entering the context manager.
+        """
+        if self._session is None:
+            raise RuntimeError("Client must be used within an async context manager")
+        return self._session
 
     async def initialize(self) -> types.InitializeResult:
         """
@@ -149,7 +204,7 @@ async def initialize(self) -> types.InitializeResult:
         Returns:
             The initialization result from the server
         """
-        raise NotImplementedError("Client.initialize is not yet implemented")
+        return await self.session.initialize()
 
     def get_server_capabilities(self) -> types.ServerCapabilities | None:
         """
@@ -158,11 +213,11 @@ def get_server_capabilities(self) -> types.ServerCapabilities | None:
         Returns:
             The server capabilities, or None if not yet initialized
         """
-        raise NotImplementedError("Client.get_server_capabilities is not yet implemented")
+        return self.session.get_server_capabilities()
 
     async def send_ping(self) -> types.EmptyResult:
         """Send a ping request to the server."""
-        raise NotImplementedError("Client.send_ping is not yet implemented")
+        return await self.session.send_ping()
 
     async def send_progress_notification(
         self,
@@ -172,11 +227,16 @@ async def send_progress_notification(
         message: str | None = None,
     ) -> None:
         """Send a progress notification to the server."""
-        raise NotImplementedError("Client.send_progress_notification is not yet implemented")
+        await self.session.send_progress_notification(
+            progress_token=progress_token,
+            progress=progress,
+            total=total,
+            message=message,
+        )
 
     async def set_logging_level(self, level: types.LoggingLevel) -> types.EmptyResult:
         """Set the logging level on the server."""
-        raise NotImplementedError("Client.set_logging_level is not yet implemented")
+        return await self.session.set_logging_level(level)
 
     async def list_resources(
         self,
@@ -194,7 +254,12 @@ async def list_resources(
         Returns:
             List of available resources
         """
-        raise NotImplementedError("Client.list_resources is not yet implemented")
+        if params is not None:
+            return await self.session.list_resources(params=params)
+        elif cursor is not None:
+            return await self.session.list_resources(cursor)
+        else:
+            return await self.session.list_resources()
 
     async def list_resource_templates(
         self,
@@ -212,7 +277,12 @@ async def list_resource_templates(
         Returns:
             List of available resource templates
         """
-        raise NotImplementedError("Client.list_resource_templates is not yet implemented")
+        if params is not None:
+            return await self.session.list_resource_templates(params=params)
+        elif cursor is not None:
+            return await self.session.list_resource_templates(cursor)
+        else:
+            return await self.session.list_resource_templates()
 
     async def read_resource(self, uri: AnyUrl) -> types.ReadResourceResult:
         """
@@ -224,15 +294,15 @@ async def read_resource(self, uri: AnyUrl) -> types.ReadResourceResult:
         Returns:
             The resource content
         """
-        raise NotImplementedError("Client.read_resource is not yet implemented")
+        return await self.session.read_resource(uri)
 
     async def subscribe_resource(self, uri: AnyUrl) -> types.EmptyResult:
         """Subscribe to resource updates."""
-        raise NotImplementedError("Client.subscribe_resource is not yet implemented")
+        return await self.session.subscribe_resource(uri)
 
     async def unsubscribe_resource(self, uri: AnyUrl) -> types.EmptyResult:
         """Unsubscribe from resource updates."""
-        raise NotImplementedError("Client.unsubscribe_resource is not yet implemented")
+        return await self.session.unsubscribe_resource(uri)
 
     async def call_tool(
         self,
@@ -256,7 +326,13 @@ async def call_tool(
         Returns:
             The tool result
         """
-        raise NotImplementedError("Client.call_tool is not yet implemented")
+        return await self.session.call_tool(
+            name=name,
+            arguments=arguments,
+            read_timeout_seconds=read_timeout_seconds,
+            progress_callback=progress_callback,
+            meta=meta,
+        )
 
     async def list_prompts(
         self,
@@ -274,7 +350,12 @@ async def list_prompts(
         Returns:
             List of available prompts
         """
-        raise NotImplementedError("Client.list_prompts is not yet implemented")
+        if params is not None:
+            return await self.session.list_prompts(params=params)
+        elif cursor is not None:
+            return await self.session.list_prompts(cursor)
+        else:
+            return await self.session.list_prompts()
 
     async def get_prompt(
         self,
@@ -291,7 +372,7 @@ async def get_prompt(
         Returns:
             The prompt content
         """
-        raise NotImplementedError("Client.get_prompt is not yet implemented")
+        return await self.session.get_prompt(name=name, arguments=arguments)
 
     async def complete(
         self,
@@ -310,7 +391,11 @@ async def complete(
         Returns:
             Completion suggestions
         """
-        raise NotImplementedError("Client.complete is not yet implemented")
+        return await self.session.complete(
+            ref=ref,
+            argument=argument,
+            context_arguments=context_arguments,
+        )
 
     async def list_tools(
         self,
@@ -328,17 +413,13 @@ async def list_tools(
         Returns:
             List of available tools
         """
-        raise NotImplementedError("Client.list_tools is not yet implemented")
+        if params is not None:
+            return await self.session.list_tools(params=params)
+        elif cursor is not None:
+            return await self.session.list_tools(cursor)
+        else:
+            return await self.session.list_tools()
 
     async def send_roots_list_changed(self) -> None:
         """Send a notification that the roots list has changed."""
-        raise NotImplementedError("Client.send_roots_list_changed is not yet implemented")
-
-    @property
-    def session(self) -> ClientSession:
-        """
-        Get the underlying ClientSession.
-
-        This provides access to the full ClientSession API for advanced use cases.
-        """
-        raise NotImplementedError("Client.session is not yet implemented")
+        await self.session.send_roots_list_changed()

src/mcp/client/transports/__init__.py

@@ -1,5 +1,5 @@
-"""In-memory transport implementations for MCP clients."""
+"""Transport implementations for MCP clients."""
 
-from mcp.client.transports.memory import InMemoryTransport
+from mcp.client.transports.memory import create_in_memory_transport
 
-__all__ = ["InMemoryTransport"]
+__all__ = ["create_in_memory_transport"]