The transport layer handles the communication between MCP clients and servers, providing different implementations for various use cases. The client transport manages message serialization, connection establishment, and protocol-specific communication patterns.

<Tabs>

<Tab title="STDIO">

Creates transport for in-process based communication

```java

ServerParameters params = ServerParameters.builder("npx")

.args("-y", "@modelcontextprotocol/server-everything", "dir")

.build();

McpTransport transport = new StdioClientTransport(params);

```

</Tab>

<Tab title="SSE (HttpClient)">

Creates a framework agnostic (pure Java API) SSE client transport. Included in the core mcp module.

```java

McpTransport transport = new HttpClientSseClientTransport("http://your-mcp-server");

```

</Tab>

<Tab title="SSE (WebFlux)">

Creates WebFlux-based SSE client transport. Requires the mcp-webflux-sse-transport dependency.

```java

WebClient.Builder webClientBuilder = WebClient.builder()

.baseUrl("http://your-mcp-server");

McpTransport transport = new WebFluxSseClientTransport(webClientBuilder);

```

</Tab>

</Tabs>

The client can be configured with various capabilities:

var capabilities = ClientCapabilities.builder()

.roots(true) // Enable filesystem roots support with list changes notifications

.sampling() // Enable LLM sampling support

.build();

Roots define the boundaries of where servers can operate within the filesystem:

client.addRoot(new Root("file:///path", "description"));

client.removeRoot("file:///path");

client.rootsListChangedNotification();

The roots capability allows servers to:

- Request the list of accessible filesystem roots

- Receive notifications when the root list changes

- Understand which directories and files they have access to

Sampling enables servers to request LLM interactions ("completions" or "generations") through the client:

Function<CreateMessageRequest, CreateMessageResult> samplingHandler = request -> {

// Sampling implementation that interfaces with LLM

return new CreateMessageResult(response);

};

var client = McpClient.sync(transport)

.capabilities(ClientCapabilities.builder()

.sampling()

.build())

.sampling(samplingHandler)

.build();

This capability allows:

- Servers to leverage AI capabilities without requiring API keys

- Clients to maintain control over model access and permissions

- Support for both text and image-based interactions

- Optional inclusion of MCP server context in prompts

var result = client.callTool("calculator", Map.of(

client.callTool("calculator", Map.of(