From 6e1bbc4e30f4ab3f420a301afc209f1a23cfb5c6 Mon Sep 17 00:00:00 2001 From: Christian Tzolov <1351573+tzolov@users.noreply.github.com> Date: Fri, 21 Mar 2025 19:10:49 +0100 Subject: [PATCH] feat(java): Update the Java SDK to 0.8.0 (#190) * feat(java): Update the Java SDK to 0.8.0 - Update Java SDK version from 0.7.0 to 0.8.0 - Refactor transport layer to use transportProvider pattern - Rename registrations to specifications in server API - Add exchange parameter to callback functions - Add breaking changes note - Enhance MCP Java SDK documentation with sampling * Add documentation for sampling capabilities in MCP Server * Expand documentation for Tool, Resource, and Prompt specifications * Add Spring AI integration to the client/server docs Signed-off-by: Christian Tzolov * refactor(java-sdk): improve API usage example - Replace Content builder pattern with direct TextContent constructor - Replace ModelHint builder pattern with static factory method Signed-off-by: Christian Tzolov --------- Signed-off-by: Christian Tzolov --- sdk/java/.DS_Store | Bin 0 -> 6148 bytes sdk/java/mcp-client.mdx | 8 +- sdk/java/mcp-overview.mdx | 14 ++- sdk/java/mcp-server.mdx | 252 +++++++++++++++++++++++++++++++------- 4 files changed, 226 insertions(+), 48 deletions(-) create mode 100644 sdk/java/.DS_Store diff --git a/sdk/java/.DS_Store b/sdk/java/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 +The [Spring-AI MCP Client](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-client-boot-starter-docs.html) integration extends the MCP Java SDK to +provide auto-configuration for MCP client functionality in Spring Boot applications and integrating with Spring AI’s [tool execution framework](https://docs.spring.io/spring-ai/reference/api/tools.html). + + The client provides both synchronous and asynchronous APIs for flexibility in different application contexts. @@ -182,7 +187,6 @@ The roots capability allows servers to: - Receive notifications when the roots list changes - Understand which directories and files they have access to - ### Sampling Support Sampling enables servers to request LLM interactions ("completions" or "generations") through the client: @@ -209,7 +213,6 @@ This capability allows: - Support for both text and image-based interactions - Optional inclusion of MCP server context in prompts - ## Using MCP Clients ### Tool Execution @@ -320,3 +323,4 @@ client.executePrompt("echo", Map.of( ``` + diff --git a/sdk/java/mcp-overview.mdx b/sdk/java/mcp-overview.mdx index ed1eb47..9c6a2e0 100644 --- a/sdk/java/mcp-overview.mdx +++ b/sdk/java/mcp-overview.mdx @@ -6,6 +6,12 @@ description: Introduction to the Model Context Protocol (MCP) Java SDK Java SDK for the [Model Context Protocol](https://modelcontextprotocol.org/docs/concepts/architecture) enables standardized integration between AI models and tools. + +### Breaking Changes in 0.8.0 ⚠️ +**Note:** Version 0.8.0 introduces several breaking changes including a new session-based architecture. +If you're upgrading from 0.7.0, please refer to the [Migration Guide](https://github.com/modelcontextprotocol/java-sdk/blob/main/migration-0.8.0.md) for detailed instructions. + + ## Features - MCP Client and MCP Server implementations supporting: @@ -25,6 +31,10 @@ enables standardized integration between AI models and tools. - WebMVC SSE transport for servlet-based HTTP streaming - Supports Synchronous and Asynchronous programming paradigms +[Spring AI MCP](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-overview.html) extends the MCP Java SDK with Spring Boot integration, +providing both [Client](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-client-boot-starter-docs.html) and [Server](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-server-boot-starter-docs.html) Boot Starters. +You can bootstrap your AI Spring applications using the [Spring Initializer](https://start.spring.io/). + ## Architecture The SDK follows a layered architecture with clear separation of concerns: @@ -129,7 +139,7 @@ Add the BOM to your project: io.modelcontextprotocol.sdk mcp-bom - 0.7.0 + 0.8.0 pom import @@ -141,7 +151,7 @@ Add the BOM to your project: ```groovy dependencies { - implementation platform("io.modelcontextprotocol.sdk:mcp-bom:0.7.0") + implementation platform("io.modelcontextprotocol.sdk:mcp-bom:0.8.0") //... } ``` diff --git a/sdk/java/mcp-server.mdx b/sdk/java/mcp-server.mdx index d7047f9..182ccbe 100644 --- a/sdk/java/mcp-server.mdx +++ b/sdk/java/mcp-server.mdx @@ -3,6 +3,12 @@ title: MCP Server description: Learn how to implement and configure a Model Context Protocol (MCP) server --- + +### Breaking Changes in 0.8.0 ⚠️ +**Note:** Version 0.8.0 introduces several breaking changes including a new session-based architecture. +If you're upgrading from 0.7.0, please refer to the [Migration Guide](https://github.com/modelcontextprotocol/java-sdk/blob/main/migration-0.8.0.md) for detailed instructions. + + ## Overview The MCP Server is a foundational component in the Model Context Protocol (MCP) architecture that provides tools, resources, and capabilities to clients. It implements the server-side of the protocol, responsible for: @@ -15,13 +21,18 @@ The MCP Server is a foundational component in the Model Context Protocol (MCP) a - Managing concurrent client connections - Providing structured logging and notifications + +The [Spring-AI MCP Server](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-server-boot-starter-docs.html) integration extends the MCP Java SDK to +provide auto-configuration for MCP servdr functionality in Spring Boot applications. + + The server supports both synchronous and asynchronous APIs, allowing for flexible integration in different application contexts. ```java // Create a server with custom configuration -McpSyncServer syncServer = McpServer.sync(transport) +McpSyncServer syncServer = McpServer.sync(transportProvider) .serverInfo("my-server", "1.0.0") .capabilities(ServerCapabilities.builder() .resources(true) // Enable resource support @@ -32,9 +43,9 @@ McpSyncServer syncServer = McpServer.sync(transport) .build(); // Register tools, resources, and prompts -syncServer.addTool(syncToolRegistration); -syncServer.addResource(syncResourceRegistration); -syncServer.addPrompt(syncPromptRegistration); +syncServer.addTool(syncToolSpecification); +syncServer.addResource(syncResourceSpecification); +syncServer.addPrompt(syncPromptSpecification); // Send logging notifications syncServer.loggingNotification(LoggingMessageNotification.builder() @@ -51,7 +62,7 @@ syncServer.close(); ```java // Create an async server with custom configuration -McpAsyncServer asyncServer = McpServer.async(transport) +McpAsyncServer asyncServer = McpServer.async(transportProvider) .serverInfo("my-server", "1.0.0") .capabilities(ServerCapabilities.builder() .resources(true) // Enable resource support @@ -62,15 +73,15 @@ McpAsyncServer asyncServer = McpServer.async(transport) .build(); // Register tools, resources, and prompts -asyncServer.addTool(asyncToolRegistration) +asyncServer.addTool(asyncToolSpecification) .doOnSuccess(v -> logger.info("Tool registered")) .subscribe(); -asyncServer.addResource(asyncResourceRegistration) +asyncServer.addResource(asyncResourceSpecification) .doOnSuccess(v -> logger.info("Resource registered")) .subscribe(); -asyncServer.addPrompt(asyncPromptRegistration) +asyncServer.addPrompt(asyncPromptSpecification) .doOnSuccess(v -> logger.info("Prompt registered")) .subscribe(); @@ -90,9 +101,11 @@ asyncServer.close() -## Server Transport +## Server Transport Providers -The transport layer in the MCP SDK is responsible for handling the communication between clients and servers. It provides different implementations to support various communication protocols and patterns. The SDK includes several built-in transport implementations: +The transport layer in the MCP SDK is responsible for handling the communication between clients and servers. +It provides different implementations to support various communication protocols and patterns. +The SDK includes several built-in transport provider implementations: @@ -101,7 +114,7 @@ The transport layer in the MCP SDK is responsible for handling the communication Create in-process based transport: ```java - StdioServerTransport transport = new StdioServerTransport(new ObjectMapper()); + StdioServerTransportProvider transportProvider = new StdioServerTransportProvider(new ObjectMapper()); ``` Provides bidirectional JSON-RPC message handling over standard input/output streams with non-blocking message processing, serialization/deserialization, and graceful shutdown support. @@ -124,13 +137,13 @@ The transport layer in the MCP SDK is responsible for handling the communication @Configuration class McpConfig { @Bean - WebFluxSseServerTransport webFluxSseServerTransport(ObjectMapper mapper) { - return new WebFluxSseServerTransport(mapper, "/mcp/message"); + WebFluxSseServerTransportProvider webFluxSseServerTransportProvider(ObjectMapper mapper) { + return new WebFluxSseServerTransportProvider(mapper, "/mcp/message"); } @Bean - RouterFunction mcpRouterFunction(WebFluxSseServerTransport transport) { - return transport.getRouterFunction(); + RouterFunction mcpRouterFunction(WebFluxSseServerTransportProvider transportProvider) { + return transportProvider.getRouterFunction(); } } ``` @@ -155,13 +168,13 @@ The transport layer in the MCP SDK is responsible for handling the communication @EnableWebMvc class McpConfig { @Bean - WebMvcSseServerTransport webMvcSseServerTransport(ObjectMapper mapper) { - return new WebMvcSseServerTransport(mapper, "/mcp/message"); + WebMvcSseServerTransportProvider webMvcSseServerTransportProvider(ObjectMapper mapper) { + return new WebMvcSseServerTransportProvider(mapper, "/mcp/message"); } @Bean - RouterFunction mcpRouterFunction(WebMvcSseServerTransport transport) { - return transport.getRouterFunction(); + RouterFunction mcpRouterFunction(WebMvcSseServerTransportProvider transportProvider) { + return transportProvider.getRouterFunction(); } } ``` @@ -191,13 +204,13 @@ The transport layer in the MCP SDK is responsible for handling the communication public class McpServerConfig implements WebMvcConfigurer { @Bean - public HttpServletSseServerTransport servletSseServerTransport() { - return new HttpServletSseServerTransport(new ObjectMapper(), "/mcp/message"); + public HttpServletSseServerTransportProvider servletSseServerTransportProvider() { + return new HttpServletSseServerTransportProvider(new ObjectMapper(), "/mcp/message"); } @Bean - public ServletRegistrationBean customServletBean(HttpServletSseServerTransport servlet) { - return new ServletRegistrationBean(servlet); + public ServletRegistrationBean customServletBean(HttpServletSseServerTransportProvider transportProvider) { + return new ServletRegistrationBean(transportProvider); } } ``` @@ -253,12 +266,16 @@ server.loggingNotification(LoggingMessageNotification.builder() Clients can control the minimum logging level they receive through the `mcpClient.setLoggingLevel(level)` request. Messages below the set level will be filtered out. Supported logging levels (in order of increasing severity): DEBUG (0), INFO (1), NOTICE (2), WARNING (3), ERROR (4), CRITICAL (5), ALERT (6), EMERGENCY (7) -### Tool Registration +### Tool Specification + +The Model Context Protocol allows servers to [expose tools](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/tools/) that can be invoked by language models. +The Java SDK allows implementing a Tool Specifications with their handler functions. +Tools enable AI models to perform calculations, access external APIs, query databases, and manipulate files: ```java -// Sync tool registration +// Sync tool specification var schema = """ { "type" : "object", @@ -276,9 +293,9 @@ var schema = """ } } """; -var syncToolRegistration = new McpServerFeatures.SyncToolRegistration( +var syncToolSpecification = new McpServerFeatures.SyncToolSpecificaiton( new Tool("calculator", "Basic calculator", schema), - arguments -> { + (exchange, arguments) -> { // Tool implementation return new CallToolResult(result, false); } @@ -288,7 +305,7 @@ var syncToolRegistration = new McpServerFeatures.SyncToolRegistration( ```java -// Async tool registration +// Async tool specification var schema = """ { "type" : "object", @@ -306,9 +323,9 @@ var schema = """ } } """; -var asyncToolRegistration = new McpServerFeatures.AsyncToolRegistration( +var asyncToolSpecification = new McpServerFeatures.AsyncToolSpecificaiton( new Tool("calculator", "Basic calculator", schema), - arguments -> { + (exchange, arguments) -> { // Tool implementation return Mono.just(new CallToolResult(result, false)); } @@ -317,15 +334,22 @@ var asyncToolRegistration = new McpServerFeatures.AsyncToolRegistration( -### Resource Registration +The Tool specification includes a Tool definition with `name`, `description`, and `parameter schema` followed by a call handler that implements the tool's logic. +The function's first argument is `McpAsyncServerExchange` for client interaction, and the second is a map of tool arguments. + +### Resource Specification + +Specification of a resource with its handler function. +Resources provide context to AI models by exposing data such as: File contents, Database records, API responses, System information, Application state. +Example resource specification: ```java -// Sync resource registration -var syncResourceRegistration = new McpServerFeatures.SyncResourceRegistration( +// Sync resource specification +var syncResourceSpecification = new McpServerFeatures.syncResourceSpecification( new Resource("custom://resource", "name", "description", "mime-type", null), - request -> { + (exchange, request) -> { // Resource read implementation return new ReadResourceResult(contents); } @@ -335,10 +359,10 @@ var syncResourceRegistration = new McpServerFeatures.SyncResourceRegistration( ```java -// Async resource registration -var asyncResourceRegistration = new McpServerFeatures.AsyncResourceRegistration( +// Async resource specification +var asyncResourceSpecification = new McpServerFeatures.asyncResourceSpecification( new Resource("custom://resource", "name", "description", "mime-type", null), - request -> { + (exchange, request) -> { // Resource read implementation return Mono.just(new ReadResourceResult(contents)); } @@ -347,17 +371,26 @@ var asyncResourceRegistration = new McpServerFeatures.AsyncResourceRegistration( -### Prompt Registration +The resource specification compriese of resource definitions and resource read handler. +The resource definition including `name`, `description`, and `MIME type`. +The first argument of the function that handles resource read requests is an `McpAsyncServerExchange` upon which the server can +interact with the connected client. +The second arguments is a `McpSchema.ReadResourceRequest`. + +### Prompt Specification + +As part of the [Prompting capabilities](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/prompts/), MCP provides a standardized way for servers to expose prompt templates to clients. +The Prompt Specification is a structured template for AI model interactions that enables consistent message formatting, parameter substitution, context injection, response formatting, and instruction templating. ```java -// Sync prompt registration -var syncPromptRegistration = new McpServerFeatures.SyncPromptRegistration( +// Sync prompt specification +var syncPromptSpecification = new McpServerFeatures.syncPromptSpecification( new Prompt("greeting", "description", List.of( new PromptArgument("name", "description", true) )), - request -> { + (exchange, request) -> { // Prompt implementation return new GetPromptResult(description, messages); } @@ -367,12 +400,12 @@ var syncPromptRegistration = new McpServerFeatures.SyncPromptRegistration( ```java -// Async prompt registration -var asyncPromptRegistration = new McpServerFeatures.AsyncPromptRegistration( +// Async prompt specification +var asyncPromptSpecification = new McpServerFeatures.asyncPromptSpecification( new Prompt("greeting", "description", List.of( new PromptArgument("name", "description", true) )), - request -> { + (exchange, request) -> { // Prompt implementation return Mono.just(new GetPromptResult(description, messages)); } @@ -381,6 +414,137 @@ var asyncPromptRegistration = new McpServerFeatures.AsyncPromptRegistration( +The prompt definition includes name (identifier for the prompt), description (purpose of the prompt), and list of arguments (parameters for templating). +The handler function processes requests and returns formatted templates. +The first argument is `McpAsyncServerExchange` for client interaction, and the second argument is a `GetPromptRequest` instance. + +### Using Sampling from a Server + +To use [Sampling capabilities](https://spec.modelcontextprotocol.io/specification/2024-11-05/client/sampling/), connect to a client that supports sampling. +No special server configuration is needed, but verify client sampling support before making requests. +Learn about [client sampling support](./mcp-client#sampling-support). + +Once connected to a compatible client, the server can request language model generations: + + + +```java +// Create a server +McpSyncServer server = McpServer.sync(transportProvider) + .serverInfo("my-server", "1.0.0") + .build(); + +// Define a tool that uses sampling +var calculatorTool = new McpServerFeatures.SyncToolSpecification( + new Tool("ai-calculator", "Performs calculations using AI", schema), + (exchange, arguments) -> { + // Check if client supports sampling + if (exchange.getClientCapabilities().sampling() == null) { + return new CallToolResult("Client does not support AI capabilities", false); + } + + // Create a sampling request + McpSchema.CreateMessageRequest request = McpSchema.CreateMessageRequest.builder() + .content(new McpSchema.TextContent("Calculate: " + arguments.get("expression"))) + .modelPreferences(McpSchema.ModelPreferences.builder() + .hints(List.of( + McpSchema.ModelHint.of("claude-3-sonnet"), + McpSchema.ModelHint.of("claude") + )) + .intelligencePriority(0.8) // Prioritize intelligence + .speedPriority(0.5) // Moderate speed importance + .build()) + .systemPrompt("You are a helpful calculator assistant. Provide only the numerical answer.") + .maxTokens(100) + .build(); + + // Request sampling from the client + McpSchema.CreateMessageResult result = exchange.createMessage(request); + + // Process the result + String answer = result.content().text(); + return new CallToolResult(answer, false); + } +); + +// Add the tool to the server +server.addTool(calculatorTool); +``` + + + +```java +// Create a server +McpAsyncServer server = McpServer.async(transportProvider) + .serverInfo("my-server", "1.0.0") + .build(); + +// Define a tool that uses sampling +var calculatorTool = new McpServerFeatures.AsyncToolSpecification( + new Tool("ai-calculator", "Performs calculations using AI", schema), + (exchange, arguments) -> { + // Check if client supports sampling + if (exchange.getClientCapabilities().sampling() == null) { + return Mono.just(new CallToolResult("Client does not support AI capabilities", false)); + } + + // Create a sampling request + McpSchema.CreateMessageRequest request = McpSchema.CreateMessageRequest.builder() + .content(McpSchema.Content.builder() + .type("text") + .text("Calculate: " + arguments.get("expression")) + .build()) + .modelPreferences(McpSchema.ModelPreferences.builder() + .hints(List.of( + McpSchema.ModelHint.builder().name("claude-3-sonnet").build(), + McpSchema.ModelHint.builder().name("claude").build() + )) + .intelligencePriority(0.8) // Prioritize intelligence + .speedPriority(0.5) // Moderate speed importance + .build()) + .systemPrompt("You are a helpful calculator assistant. Provide only the numerical answer.") + .maxTokens(100) + .build(); + + // Request sampling from the client + return exchange.createMessage(request) + .map(result -> { + // Process the result + String answer = result.content().text(); + return new CallToolResult(answer, false); + }); + } +); + +// Add the tool to the server +server.addTool(calculatorTool) + .subscribe(); +``` + + + +The `CreateMessageRequest` object allows you to specify: `Content` - the input text or image for the model, +`Model Preferences` - hints and priorities for model selection, `System Prompt` - instructions for the model's behavior and `Max Tokens` - maximum length of the generated response + +```java +McpSchema.CreateMessageRequest request = McpSchema.CreateMessageRequest.builder() + .content(McpSchema.Content.builder() + .type("text") + .text("What is the capital of France?") + .build()) + .modelPreferences(McpSchema.ModelPreferences.builder() + .hints(List.of( + McpSchema.ModelHint.builder().name("claude-3-sonnet").build(), + McpSchema.ModelHint.builder().name("claude").build() + )) + .intelligencePriority(0.8) + .speedPriority(0.5) + .build()) + .systemPrompt("You are a helpful assistant.") + .maxTokens(100) + .build(); +``` + ## Error Handling The SDK provides comprehensive error handling through the McpError class, covering protocol compatibility, transport communication, JSON-RPC messaging, tool execution, resource management, prompt handling, timeouts, and connection issues. This unified error handling approach ensures consistent and reliable error management across both synchronous and asynchronous operations.