feat: Add MCP server with Server stdio/sse transport improve MCP client

- Implement MCP server with async/sync support and builder pattern configuration
 - Add Server stdio/SSE transport layers with robust error handling
 - Convert McpClient and McpServer to interfaces for better extensibility
 - Add sampling capabilities for LLM interactions (text/image)
 - Implement dynamic root management and runtime tool management
 - Add comprehensive prompt and resource capabilities
 - Add support for dynamic root management (add/remove roots at runtime)

 Architecture Changes

 - Introduce registration records for tools, resources, and prompts
 - Improve thread safety with concurrent collections
 - Enhance resource template handling
 - Implement builder patterns for Server/Client capabilities
 - Add support for server capabilities and implementation info

Transport Layer:
 - Implement SseServerTransport with SSE endpoints
 - Add StdioServerTransport for process-based communication
 - Reorganize transport packages for better organization
 - Improve transport error handling and shutdown processes

Documentation:

 - Add detailed MCP reference documentation
 - Include architecture diagrams and API documentation
 - Add comprehensive test coverage for all components
 - Include sample projects demonstrating stdio/SSE transports

BREAKING CHANGES:

 Transport Package Reorganization

 - Move StdioClientTransport to o.s.ai.mcp.client.transport
 - Move SseClientTransport to o.s.ai.mcp.client.transport
 - Move ServerParameters to o.s.ai.mcp.client.transport
 - StdioClientTransport.errorHandler changed to private with
   setter method Migration: Use setErrorHandler() method
   instead of direct field access

 API Changes

 - Replace static factory methods with builder pattern
 - Update ServerCapabilities to use builder pattern
 - Make StdioClientTransport.errorHandler private with setter
 - Replace rootsListProvider with direct root management
 - Remove deprecated static factory methods

Resolves #27,#25,#24,#11
Related to #12
This commit is contained in:
Christian Tzolov 2024-12-19 19:38:38 +01:00
commit abd0facf4e
8 changed files with 5727 additions and 471 deletions

View file

@ -0,0 +1,257 @@
# Spring AI MCP Sample Project
This sample project demonstrates the usage of the Spring AI Model Context Protocol (MCP) implementation. It showcases how to create and use MCP servers and clients with different transport modes and capabilities.
## Overview
The sample provides:
- Two transport mode implementations: Stdio and SSE (Server-Sent Events)
- Server capabilities:
- Tools support with list changes notifications
- Resources support with list changes notifications (no subscribe support)
- Prompts support with list changes notifications
- Sample implementations:
- Two MCP tools: Weather and Calculator
- One MCP resource: System Information
- One MCP prompt: Greeting
## Building the Project
```bash
./mvnw clean package
```
## Running the Server
The server can be started in two transport modes, controlled by the `transport.mode` property:
### Stdio Mode (Default)
```bash
java -Dtransport.mode=stdio -jar target/spring-ai-mcp-sample-0.3.0-SNAPSHOT.jar
```
The Stdio mode server is automatically started by the client - no explicit server startup is needed.
But you have to build the server jar first: `./mvnw clean install -DskipTests`.
In Stdio mode the server must not emit any messages/logs to the console (e.g. standard out) but the JSON messages produced by the server.
### SSE Mode
```bash
java -Dtransport.mode=sse -jar target/spring-ai-mcp-sample-0.3.0-SNAPSHOT.jar
```
## Sample Clients
The project includes example clients for both transport modes:
### Stdio Client (ClientStdio.java)
```java
var stdioParams = ServerParameters.builder("java")
.args("-Dtransport.mode=stdio", "-jar",
"target/spring-ai-mcp-sample-0.3.0-SNAPSHOT.jar")
.build();
var transport = new StdioClientTransport(stdioParams);
var client = McpClient.using(transport).sync();
```
### SSE Client (ClientSse.java)
```java
var transport = new SseClientTransport(WebClient.builder().baseUrl("http://localhost:8080"));
var client = McpClient.using(transport).sync();
```
## Available Tools
### Weather Tool
- Name: `weather`
- Description: Weather forecast tool by location
- Parameters:
- `city`: String - The city to get weather for
- Example:
```java
CallToolResult response = client.callTool(
new CallToolRequest("weather", Map.of("city", "Sofia"))
);
```
### Calculator Tool
- Name: `calculator`
- Description: Performs basic arithmetic operations
- Parameters (JSON Schema):
```json
{
"operation": {
"type": "string",
"enum": ["add", "subtract", "multiply", "divide"],
"description": "The arithmetic operation to perform"
},
"a": {
"type": "number",
"description": "First operand"
},
"b": {
"type": "number",
"description": "Second operand"
}
}
```
- Example:
```java
CallToolResult response = client.callTool(
new CallToolRequest("calculator",
Map.of("operation", "multiply", "a", 2.0, "b", 3.0))
);
```
## Available Resources
### System Information Resource
- URI: `system://info`
- Description: Provides basic system information including Java version, OS, etc.
- MIME Type: application/json
- Returns: JSON object containing: javaVersion, osName, osVersion, osArch, processors, timestamp
## Available Prompts
### Greeting Prompt
- Name: `greeting`
- Description: A friendly greeting prompt
- Parameters:
- `name`: String (required) - The name to greet
- Returns: A personalized greeting message from an assistant
## Client Usage Example
```java
// Initialize client
client.initialize();
// Test connection
client.ping();
// List available tools
ListToolsResult tools = client.listTools();
System.out.println("Available tools: " + tools);
// Call weather tool
CallToolResult weather = client.callTool(
new CallToolRequest("weather", Map.of("city", "Sofia"))
);
System.out.println("Weather: " + weather);
// Call calculator tool
CallToolResult calc = client.callTool(
new CallToolRequest("calculator",
Map.of("operation", "multiply", "a", 2.0, "b", 3.0))
);
System.out.println("Calculation: " + calc);
// Access system info resource
ReadResourceResult sysInfo = client.readResource(
new ReadResourceRequest("system://info")
);
System.out.println("System Info: " + sysInfo);
// Use greeting prompt
GetPromptResult greeting = client.getPrompt(
new GetPromptRequest("greeting", Map.of("name", "John"))
);
System.out.println("Greeting: " + greeting);
// Close client
client.closeGracefully();
```
## Server Usage Example
```java
@Configuration
public class CustomMcpServerConfig {
@Bean
public McpAsyncServer mcpServer(McpTransport transport) {
// Configure server capabilities
var capabilities = McpSchema.ServerCapabilities.builder()
.resources(false, true) // Resource support with list changes notifications
.tools(true) // Tool support with list changes notifications
.prompts(true) // Prompt support with list changes notifications
.build();
// Create custom tool
var customTool = new ToolRegistration(
new McpSchema.Tool("custom-tool", "Description", Map.of("param", "String")),
(arguments) -> {
String param = (String) arguments.get("param");
return new CallToolResult(
List.of(new TextContent("Result: " + param)),
false
);
}
);
// Create custom resource
var customResource = new ResourceRegistration(
new McpSchema.Resource(
"custom://resource",
"Custom Resource",
"Description",
"application/json",
null
),
(request) -> new ReadResourceResult(
List.of(new TextResourceContents(
request.uri(),
"application/json",
"{\"data\": \"example\"}"
))
)
);
// Create custom prompt
var customPrompt = new PromptRegistration(
new McpSchema.Prompt(
"custom-prompt",
"Description",
List.of(new McpSchema.PromptArgument("input", "Description", true))
),
request -> {
String input = (String) request.arguments().get("input");
var message = new PromptMessage(
Role.ASSISTANT,
new TextContent("Response to: " + input)
);
return new GetPromptResult("Result", List.of(message));
}
);
// Create and configure the server
return McpServer.using(transport)
.info("Custom MCP Server", "1.0.0")
.capabilities(capabilities)
.tools(List.of(customTool))
.resources(Map.of("custom://resource", customResource))
.prompts(List.of(customPrompt))
.async();
}
}
```
## Configuration
The application can be configured through `application.properties`:
- `transport.mode`: Transport mode to use (stdio/sse)
- `server.port`: Server port for SSE mode (default: 8080)
- Various logging configurations are available for debugging
## Implementation Details
The sample demonstrates:
- Creating an MCP server with custom tools, resources, and prompts
- Configuring different transport modes
- Implementing tool handlers with JSON schema validation
- Resource implementations with dynamic content generation
- Prompt implementations with parameter handling
- Error handling and response formatting
- Synchronous client usage patterns

View file

@ -0,0 +1,71 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.experimental</groupId>
<artifactId>mcp-parent</artifactId>
<version>0.3.0-SNAPSHOT</version>
</parent>
<artifactId>spring-ai-mcp-sample</artifactId>
<name>Spring AI MCP Sample</name>
<description>Sample Spring Boot application demonstrating MCP server usage</description>
<properties>
<spring-boot.version>3.4.1</spring-boot.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.experimental</groupId>
<artifactId>mcp</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>${spring-boot.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>io.spring.javaformat</groupId>
<artifactId>spring-javaformat-maven-plugin</artifactId>
<version>0.0.43</version>
<executions>
<execution>
<phase>validate</phase>
<inherited>true</inherited>
<goals>
<goal>validate</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

View file

@ -0,0 +1,33 @@
/*
* Copyright 2024 - 2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ai.mcp.sample.client;
import org.springframework.ai.mcp.client.transport.SseClientTransport;
import org.springframework.web.reactive.function.client.WebClient;
/**
* @author Christian Tzolov
*/
public class ClientSse {
public static void main(String[] args) {
var transport = new SseClientTransport(WebClient.builder().baseUrl("http://localhost:8080"));
new SampleClient(transport).run();
}
}

View file

@ -0,0 +1,39 @@
/*
* Copyright 2024 - 2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ai.mcp.sample.client;
import org.springframework.ai.mcp.client.transport.ServerParameters;
import org.springframework.ai.mcp.client.transport.StdioClientTransport;
/**
* @author Christian Tzolov
*/
public class ClientStdio {
public static void main(String[] args) {
var stdioParams = ServerParameters.builder("java")
.args("-Dtransport.mode=stdio", "-jar",
"spring-ai-mcp-sample/target/spring-ai-mcp-sample-0.3.0-SNAPSHOT.jar")
.build();
var transport = new StdioClientTransport(stdioParams);
new SampleClient(transport).run();
}
}

View file

@ -0,0 +1,80 @@
/*
* Copyright 2024 - 2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ai.mcp.sample.client;
import java.util.Map;
import org.springframework.ai.mcp.client.McpClient;
import org.springframework.ai.mcp.spec.McpSchema.CallToolRequest;
import org.springframework.ai.mcp.spec.McpSchema.CallToolResult;
import org.springframework.ai.mcp.spec.McpSchema.GetPromptRequest;
import org.springframework.ai.mcp.spec.McpSchema.ListPromptsResult;
import org.springframework.ai.mcp.spec.McpSchema.ListToolsResult;
import org.springframework.ai.mcp.spec.McpSchema.ReadResourceRequest;
import org.springframework.ai.mcp.spec.McpTransport;
/**
* @author Christian Tzolov
*/
public class SampleClient {
private final McpTransport transport;
public SampleClient(McpTransport transport) {
this.transport = transport;
}
public void run() {
var client = McpClient.using(this.transport).sync();
client.initialize();
client.ping();
// List and demonstrate tools
ListToolsResult toolsList = client.listTools();
System.out.println("Available Tools = " + toolsList);
CallToolResult weatherResponse = client.callTool(new CallToolRequest("weather", Map.of("city", "Sofia")));
System.out.println("Weather Response = " + weatherResponse);
CallToolResult calcResponse = client
.callTool(new CallToolRequest("calculator", Map.of("operation", "multiply", "a", 2.0, "b", 3.0)));
System.out.println("Calculator Response = " + calcResponse);
// List and demonstrate resources
var resourcesList = client.listResources();
System.out.println("\nAvailable Resources = " + resourcesList);
// Read the system info resource
var systemInfo = client.readResource(new ReadResourceRequest("system://info"));
System.out.println("System Info = " + systemInfo);
// List and demonstrate prompts
ListPromptsResult promptsList = client.listPrompts();
System.out.println("\nAvailable Prompts = " + promptsList);
// Try the greeting prompt
var greetingResponse = client.getPrompt(new GetPromptRequest("greeting", Map.of("name", "Spring")));
System.out.println("Greeting Response = " + greetingResponse);
client.closeGracefully();
}
}

View file

@ -0,0 +1,13 @@
package org.springframework.ai.mcp.sample.server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class McpServerApplication {
public static void main(String[] args) {
SpringApplication.run(McpServerApplication.class, args);
}
}

View file

@ -0,0 +1,187 @@
package org.springframework.ai.mcp.sample.server;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.ai.mcp.server.McpAsyncServer;
import org.springframework.ai.mcp.server.McpServer;
import org.springframework.ai.mcp.server.McpServer.PromptRegistration;
import org.springframework.ai.mcp.server.McpServer.ResourceRegistration;
import org.springframework.ai.mcp.server.McpServer.ToolRegistration;
import org.springframework.ai.mcp.server.transport.SseServerTransport;
import org.springframework.ai.mcp.server.transport.StdioServerTransport;
import org.springframework.ai.mcp.spec.McpSchema;
import org.springframework.ai.mcp.spec.McpSchema.CallToolResult;
import org.springframework.ai.mcp.spec.McpSchema.GetPromptResult;
import org.springframework.ai.mcp.spec.McpSchema.PromptMessage;
import org.springframework.ai.mcp.spec.McpSchema.Role;
import org.springframework.ai.mcp.spec.McpSchema.TextContent;
import org.springframework.ai.mcp.spec.McpTransport;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
@Configuration
public class McpServerConfig {
@Bean
@ConditionalOnProperty(prefix = "transport", name = "mode", havingValue = "stdio")
public StdioServerTransport stdioServerTransport() {
return new StdioServerTransport();
}
@Bean
@ConditionalOnProperty(prefix = "transport", name = "mode", havingValue = "sse")
public SseServerTransport sseServerTransport() {
return new SseServerTransport(new ObjectMapper(), "/mcp/message");
}
@Bean
@ConditionalOnProperty(prefix = "transport", name = "mode", havingValue = "sse")
public RouterFunction<?> mcpRouterFunction(SseServerTransport transport) {
return transport.getRouterFunction();
}
@Bean
public McpAsyncServer mcpServer(McpTransport transport) { // @formatter:off
// Configure server capabilities with resource support
var capabilities = McpSchema.ServerCapabilities.builder()
.resources(false, true) // No subscribe support, but list changes notifications
.tools(true) // Tool support with list changes notifications
.prompts(true) // Prompt support with list changes notifications
.build();
// Create the server with both tool and resource capabilities
return McpServer.using(transport)
.info("MCP Demo Server", "1.0.0")
.capabilities(capabilities)
.tools(List.of(weatherTool(), calculatorTool()))
.resources(Map.of("system://info", systemInfoResource()))
.prompts(List.of(greetingPrompt()))
.async();
} // @formatter:on
private static ResourceRegistration systemInfoResource() {
// Create a resource registration for system information
var systemInfoResource = new McpSchema.Resource( // @formatter:off
"system://info",
"System Information",
"Provides basic system information including Java version, OS, etc.",
"application/json", null
);
var resourceRegistration = new ResourceRegistration(systemInfoResource, (request) -> {
try {
var systemInfo = Map.of(
"javaVersion", System.getProperty("java.version"),
"osName", System.getProperty("os.name"),
"osVersion", System.getProperty("os.version"),
"osArch", System.getProperty("os.arch"),
"processors", Runtime.getRuntime().availableProcessors(),
"timestamp", System.currentTimeMillis());
String jsonContent = new ObjectMapper().writeValueAsString(systemInfo);
return new McpSchema.ReadResourceResult(
List.of(new McpSchema.TextResourceContents(request.uri(), "application/json", jsonContent)));
}
catch (Exception e) {
throw new RuntimeException("Failed to generate system info", e);
}
}); // @formatter:on
return resourceRegistration;
}
private static ToolRegistration weatherTool() {
return new ToolRegistration(
new McpSchema.Tool("weather", "Weather forecast tool by location", Map.of("city", "String")),
(arguments) -> {
String city = (String) arguments.get("city");
TextContent content = new TextContent("Weather forecast for " + city + " is sunny");
return new CallToolResult(List.of(content), false);
});
}
private static ToolRegistration calculatorTool() {
return new ToolRegistration(new McpSchema.Tool("calculator",
"Performs basic arithmetic operations (add, subtract, multiply, divide)", """
{
"type": "object",
"properties": {
"operation": {
"type": "string",
"enum": ["add", "subtract", "multiply", "divide"],
"description": "The arithmetic operation to perform"
},
"a": {
"type": "number",
"description": "First operand"
},
"b": {
"type": "number",
"description": "Second operand"
}
},
"required": ["operation", "a", "b"]
}
"""), arguments -> {
String operation = (String) arguments.get("operation");
double a = (Double) arguments.get("a");
double b = (Double) arguments.get("b");
double result;
switch (operation) {
case "add":
result = a + b;
break;
case "subtract":
result = a - b;
break;
case "multiply":
result = a * b;
break;
case "divide":
if (b == 0) {
return new McpSchema.CallToolResult(
java.util.List.of(new McpSchema.TextContent("Division by zero")), true);
}
result = a / b;
break;
default:
return new McpSchema.CallToolResult(
java.util.List.of(new McpSchema.TextContent("Unknown operation: " + operation)),
true);
}
return new McpSchema.CallToolResult(
java.util.List.of(new McpSchema.TextContent(String.valueOf(result))), false);
});
}
private static PromptRegistration greetingPrompt() {
var nameArg = new McpSchema.PromptArgument("name", "The name to greet", true // required
// parameter
);
var prompt = new McpSchema.Prompt("greeting", "A friendly greeting prompt", List.of(nameArg));
return new PromptRegistration(prompt, request -> {
String name = (String) request.arguments().get("name");
if (name == null) {
name = "friend";
}
var assistantMessage = new PromptMessage(Role.ASSISTANT,
new TextContent("Hello " + name + "! How can I assist you today?"));
return new GetPromptResult("A personalized greeting message", List.of(assistantMessage));
});
}
}

View file

@ -0,0 +1,16 @@
# Server port
# server.port=8080
# Logging
# logging.level.org.springframework.ai.mcp=DEBUG
# logging.level.org.springframework.web=INFO
spring.main.banner-mode=off
# logging.level.root=OFF
# spring.main.web-application-type=none
# logging.pattern.console=
logging.level.org.springframework.ai.mcp.*=OFF
logging.level.org.springframework.ai.mcp.spec.*=OFF
logging.level.org.springframework.**=OFF
transport.mode=sse