MCP Java SDK 由入门到精通

原创 于 2025-07-05 09:43:50 发布 · 592 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

MCP Java SDK 从由入门到精通

作者：王珂

邮箱：49186456@qq.com

文章目录

概述

官网

https://modelcontextprotocol.io/

项目

https://github.com/modelcontextprotocol/java-sdk

本文主要介绍模型上下文协议基于 Java SDK 如何开发 MCP Client 和 MCP Server。

模型上下文协议的 Java SDK 使用 AI 模型和工具进行了标准化的集成。

特点

  • MCP 客户端和服务端实现支持:

    • Prototol version compatibility negotiation

    • 工具 发现，执行，通知变化列表

    • 资源 URI 模板资源管理

    • Roots list management and notifications

    • 提示词 处理和管理

    • Sampling 支持与 AI 模型的交互

  • 多种传输实现:

    • 默认传输 (包含在 mcp 核心模块中, 不需要外部框架):

      • 基于进程间通信的标准输入输出传输

      • 基于 Java HttpClient 的 HTTP 服务器发送事件（SSE）客户端流式传输方案

      • 基于 Servlet 的 HTTP 服务器发送事件（SSE）服务端流式传输方案

    • 另一种基于 Spring 的传输 ( Spring Framework 便利使用):

      • WebFlux SSE client and server transports for reactive HTTP streaming

      • WebMVC SSE transport for servlet-based HTTP streaming

  • 支撑同步和异步的编程模式

The core io.modelcontextprotocol.sdk:mcp module provides default STDIO and SSE client and server transport implementations without requiring external web frameworks.

Spring-specific transports are available as optional dependencies for convenience when using the Spring Framework.

架构
在这里插入图片描述

  • 客户端/服务端层（McpClient/McpServer）

    客户端/服务端层均使用 McpSession 进行同步/异步操作。使用 McpClient 处理客户端协议的操作；McpServer管理服务端的协议操作

  • Session 层（McpSession）

    使用 DefaultMcpSession 管理通信模式和状态

  • 传输层（McpTransport）

    处理 JSON-RPC 消息的序列化和反序列化：

    • StdioTransport（stdin/stdout）in the core module

    • HTTP SSE transports 在专用的传输模块中传输（Java HttpClient, Spring WebFlux, Spring WebMvc）

MCP Client 在模型上下文协议（MCP）架构中是一个核心组件，负责与 MCP Servers 建立并管理连接，同时负责实现客户侧的协议
在这里插入图片描述
MCP Server

MCP Server 在模型上下文协议（MCP）的架构中是一个基础组件，它提供了工具、资源以及客户端连接的能力，它实现了服务侧的协议。
在这里插入图片描述

关键交互

  • 客户端/服务端初始化

    传输设置、协议兼容性检查、功能协商和实现细节交换

  • 消息流

    具有验证、类型安全响应处理和错误处理的JSON-RPC消息处理。

  • 资源管理

    资源发现、基于URI模板的访问、订阅系统和内容检索。

一、环境搭建

1.1 依赖

1.1.1 JavaSDK

  1. 依赖清单

    依赖清单（BOM）声明了给定发行版所使用的所有依赖项的推荐版本。

    <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.modelcontextprotocol.sdk</groupId>
            <artifactId>mcp-bom</artifactId>
            <version>0.10.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

    依赖清单管理以下依赖

    • 核心依赖

      • io.modelcontextprotocol.sdk:mcp

        核心包为模型上下文协议的实现提供了基础功能和 APIs。包括默认的 STDIO 和 SSE Client 以及服务传输实现。不需要外部 web 框架。

    • 可选的传输依赖

      • io.modelcontextprotocol.sdk:mcp-spring-webflux

        响应式应用程序是基于 WebFlux 实现的服务器事件发送（SSE）

      • io.modelcontextprotocol.sdk:mcp-spring-webmvc

        Servlet 应用程序是基于 WebMVC 实现的服务器事件发送（SSE）

    • 测试依赖

      • io.modelcontextprotocol.sdk:mcp-test

        测试实用程序和支持基于mcp的应用程序。

  2. MCP 核心包

    <dependency>
    <groupId>io.modelcontextprotocol.sdk</groupId>
    <artifactId>mcp</artifactId>
</dependency>

    核心mcp模块已经包含默认的STDIO和SSE传输实现，不需要外部web框架。

  3. Spring 框架的依赖包

    如果你正在使用Spring框架，并希望使用 Spring 特定的传输实现，请添加以下可选依赖项之一：

    <!-- Optional: Spring WebFlux-based SSE client and server transport -->
<dependency>
    <groupId>io.modelcontextprotocol.sdk</groupId>
    <artifactId>mcp-spring-webflux</artifactId>
</dependency>

<!-- Optional: Spring WebMVC-based SSE server transport -->
<dependency>
    <groupId>io.modelcontextprotocol.sdk</groupId>
    <artifactId>mcp-spring-webmvc</artifactId>
</dependency>

二、MCP 开发

2.1 MCP Client 开发

MCP Client

MCP Client 用于和 MCP Server 端进行交互。

2.1.1 客户端传输

STDIO

ServerParameters params = ServerParameters.builder("npx")
    .args("-y", "@modelcontextprotocol/server-everything", "dir")
    .build();

McpTransport transport = new StdioClientTransport(params);

SSE (HttpClient)

McpClientTransport transport = HttpClientSseClientTransport
                .builder("http://your-mcp-server")
                .build();

http://your-mcp-server 写法示例：http://127.0.0.1:8080/sse

下面这种通过构造函数创建的方式在将来版本中会被已移除，不建议继续使用

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

SSE (WebFlux)

WebClient.Builder webClientBuilder = WebClient.builder()
    .baseUrl("http://your-mcp-server");
McpTransport transport = new WebFluxSseClientTransport(webClientBuilder);

2.1.2 模型上下文协议客户端

MCP Client 在模型上下文协议（MCP）架构中是一个核心组件，负责与 MCP Servers 建立并管理连接，同时负责实现客户侧的协议

  • 协议版本协商，确保与服务器的兼容性

  • 能力协商以确定可用的特性

  • 消息传输 和 JSON-RPC 通信

  • 发现工具和执行

  • 资源访问和管理

  • 提示词系统交互

  • 可选功能，比如 roots 管理和采样支撑

The core io.modelcontextprotocol.sdk:mcp module provides STDIO and SSE client transport implementations without requiring external web frameworks.

Spring-specific transport implementations are available as an optional dependency io.modelcontextprotocol.sdk:mcp-spring-webflux for Spring Framework users.

客户端为不同的应用上下文提供了同步和异步的 APIs。

同步接口

// Create a sync client with custom configuration
McpSyncClient client = McpClient.sync(transport)
    .requestTimeout(Duration.ofSeconds(10))
    .capabilities(ClientCapabilities.builder()
        .roots(true)      // Enable roots capability
        .sampling()       // Enable sampling capability
        .build())
    .sampling(request -> new CreateMessageResult(response))
    .build();

// Initialize connection
client.initialize();

// List available tools
ListToolsResult tools = client.listTools();

// Call a tool
CallToolResult result = client.callTool(
    new CallToolRequest("calculator", 
        Map.of("operation", "add", "a", 2, "b", 3))
);

// List and read resources
ListResourcesResult resources = client.listResources();
ReadResourceResult resource = client.readResource(
    new ReadResourceRequest("resource://uri")
);

// List and use prompts
ListPromptsResult prompts = client.listPrompts();
GetPromptResult prompt = client.getPrompt(
    new GetPromptRequest("greeting", Map.of("name", "Spring"))
);

// Add/remove roots
client.addRoot(new Root("file:///path", "description"));
client.removeRoot("file:///path");

// Close client
client.closeGracefully();

异步接口

// Create an async client with custom configuration
McpAsyncClient client = McpClient.async(transport)
    .requestTimeout(Duration.ofSeconds(10))
    .capabilities(ClientCapabilities.builder()
        .roots(true)      // Enable roots capability
        .sampling()       // Enable sampling capability
        .build())
    .sampling(request -> Mono.just(new CreateMessageResult(response)))
    .toolsChangeConsumer(tools -> Mono.fromRunnable(() -> {
        logger.info("Tools updated: {}", tools);
    }))
    .resourcesChangeConsumer(resources -> Mono.fromRunnable(() -> {
        logger.info("Resources updated: {}", resources);
    }))
    .promptsChangeConsumer(prompts -> Mono.fromRunnable(() -> {
        logger.info("Prompts updated: {}", prompts);
    }))
    .build();

// Initialize connection and use features
client.initialize()
    .flatMap(initResult -> client.listTools())
    .flatMap(tools -> {
        return client.callTool(new CallToolRequest(
            "calculator", 
            Map.of("operation", "add", "a", 2, "b", 3)
        ));
    })
    .flatMap(result -> {
        return client.listResources()
            .flatMap(resources -> 
                client.readResource(new ReadResourceRequest("resource://uri"))
            );
    })
    .flatMap(resource -> {
        return client.listPrompts()
            .flatMap(prompts ->
                client.getPrompt(new GetPromptRequest(
                    "greeting", 
                    Map.of("name", "Spring")
                ))
            );
    })
    .flatMap(prompt -> {
        return client.addRoot(new Root("file:///path", "description"))
            .then(client.removeRoot("file:///path"));            
    })
    .doFinally(signalType -> {
        client.closeGracefully().subscribe();
    })
    .subscribe();

2.1.3 客户端的能力

客户端可以被配置多种能力

var capabilities = ClientCapabilities.builder()
    .roots(true)      // Enable filesystem roots support with list changes notifications
    .sampling()       // Enable LLM sampling support
    .build();
2.1.3.1 Roots 支持

根定义服务器在操作文件系统中可以操作的边界

// Add a root dynamically
client.addRoot(new Root("file:///path", "description"));

// Remove a root
client.removeRoot("file:///path");

// Notify server of roots changes
client.rootsListChangedNotification();

根的功能允许服务器：

  • 请求可以访问文件系统的根列表
  • 当跟列表发生变化时接受通知
  • 明白哪些目录和文件是可以访问的
2.1.3.2 采样支持

采样允许服务器通过客户端去请求与大语言模型进行交互（“完成” 或 “生成”）

// Configure sampling handler
Function<CreateMessageRequest, CreateMessageResult> samplingHandler = request -> {
    // Sampling implementation that interfaces with LLM
    return new CreateMessageResult(response);
};

// Create client with sampling support
var client = McpClient.sync(transport)
    .capabilities(ClientCapabilities.builder()
        .sampling()
        .build())
    .sampling(samplingHandler)
    .build();

这个功能允许：

  • 服务器不需要 API keys 就可以利用 AI 的能力
  • 客户端维持对模型访问和权限的控制
  • 同时支持对文本和图像的交互
  • 可选择在提示词中包括 MCP 服务器上下文中
2.1.3.3 日志支持

客户端允许注册一个自定义日志器从服务端接收日志消息，并且设置日志级别来过滤日志

var mcpClient = McpClient.sync(transport)
        .loggingConsumer(notification -> {
            System.out.println("Received log message: " + notification.data());
        })
        .build();

mcpClient.initialize();

mcpClient.setLoggingLevel(McpSchema.LoggingLevel.INFO);

// Call the tool that can sends logging notifications
CallToolResult result = mcpClient.callTool(new McpSchema.CallToolRequest("logging-test", Map.of()));

客户端可用通过mcpClient.setLoggingLevel(level)来控制可用接收的最新日志级别。低于这个级别的日志会被过滤掉。支持的日志级别（按升序排序）：DEBUG (0), INFO (1), NOTICE (2), WARNING (3), ERROR (4), CRITICAL (5), ALERT (6), EMERGENCY (7)

2.1.4 MCP 客户端的使用

2.1.4.1 工具执行

工具是服务端的功能，客户端能够发现工具和执行工具。MCP 的客户端提供了一个方法列出所有可用的工具，给他指定参数并执行。每一个工具有一个唯一的名字和一个可用的参数。

  • 同步接口

    // List available tools and their names
var tools = client.listTools();
tools.forEach(tool -> System.out.println(tool.getName()));

// Execute a tool with parameters
var result = client.callTool("calculator", Map.of(
    "operation", "add",
    "a", 1,
    "b", 2
));

  • 异步接口

    传统写法

    // List available tools asynchronously
client.listTools()
		.doOnNext(result -> {
			List<McpSchema.Tool> tools = result.tools();
			for (McpSchema.Tool tool : tools) {
				System.out.println(tool.name());
			}
		})
		.subscribe();

    或

    // List available tools asynchronously
client.listTools()
    .doOnNext(tools -> tools.forEach(tool -> 
        System.out.println(tool.getName())))
    .subscribe();

// Execute a tool asynchronously
client.callTool("calculator", Map.of(
        "operation", "add",
        "a", 1,
        "b", 2
    ))
    .subscribe();
2.1.4.2 资源访问

资源代表服务端的数据源，客户端可以通过 URI 模板访问。MCP 客户端提供了一个方法可以发现可用的资源，通过标准接口接收他们的内容。

  • 同步接口

    McpSchema.ListResourcesResult resources = client.listResources();
resources.resources().forEach(resource -> System.out.println("Resource: " + resource.name()));

    或

    // 获取可用资源以及资源名称
var resources = client.listResources();
resources.forEach(resource -> System.out.println(resource.getName()));

// 使用 URI 模板获取资源内容
var content = client.getResource("file", Map.of(
    "path", "/path/to/file.txt"
));

  • 异步接口

    // 异步列出可用资源
client.listResources()
    .doOnNext(resources -> resources.forEach(resource -> 
        System.out.println(resource.getName())))
    .subscribe();

// 异步获取资源内容
client.getResource("file", Map.of(
        "path", "/path/to/file.txt"
    ))
    .subscribe();
2.1.4.3 提示词系统

提示词系统允许与服务端的提示词模板进行交互。这些模板能通过自定义参数被发现和执行，允许基于预定义模式动态生成文本。

  • 同步接口

    McpSchema.ListPromptsResult prompts = client.listPrompts();
prompts.prompts().forEach(prompt -> System.out.println(prompt.name()));

    或

    // List available prompt templates
var prompts = client.listPrompts();
prompts.forEach(prompt -> System.out.println(prompt.getName()));

// Execute a prompt template with parameters
var response = client.executePrompt("echo", Map.of(
    "text", "Hello, World!"
));

  • 异步接口

    // List available prompt templates asynchronously
client.listPrompts()
    .doOnNext(prompts -> prompts.forEach(prompt -> 
        System.out.println(prompt.getName())))
    .subscribe();

// Execute a prompt template asynchronously
client.executePrompt("echo", Map.of(
        "text", "Hello, World!"
    ))
    .subscribe();
2.1.4.4 使用补全

As part of the Completion capabilities, MCP provides a provides a standardized way for servers to offer argument autocompletion suggestions for prompts and resource URIs.

Check the Server Completion capabilities to learn how to enable and configure completions on the server side.

On the client side, the MCP client provides methods to request auto-completions:

  • 同步接口

    CompleteRequest request = new CompleteRequest(
        new PromptReference("code_review"),
        new CompleteRequest.CompleteArgument("language", "py"));

CompleteResult result = syncMcpClient.completeCompletion(request);

  • 异步接口

    CompleteRequest request = new CompleteRequest(
        new PromptReference("code_review"),
        new CompleteRequest.CompleteArgument("language", "py"));

Mono<CompleteResult> result = mcpClient.completeCompletion(request);

2.2 MCP Server 开发

我们讲介绍如何实现和配置一个 MCP server。

2.2.1 服务端传输提供者

MCP SDK 传输层的负责处理客户端与服务端直接的通信。它提供了多种传输协议和模式。SDK 包括了几种内置的传输提供者的实现

  • STDID

    StdioServerTransportProvider transportProvider = new StdioServerTransportProvider(new ObjectMapper());

  • SSE（WebFlux）

    创建基于 WebFlux 的 SSE 服务传输

    需要 mcp-spring-webflux 依赖

    @Configuration
class McpConfig {
    @Bean
    WebFluxSseServerTransportProvider webFluxSseServerTransportProvider(ObjectMapper mapper) {
        return new WebFluxSseServerTransportProvider(mapper, "/mcp/message");
    }

    @Bean
    RouterFunction<?> mcpRouterFunction(WebFluxSseServerTransportProvider transportProvider) {
        return transportProvider.getRouterFunction();
    }
}

    通过 SSE 传输规范实现了 MCP HTTP，提供：

    • 通过 WebFlux 响应 Http streaming

    • 通过 SSE 端点实现当前客户端连接

    • 消息路由和 Session 管理

    • 优雅关机功能

  • SSE（WebMvc）

    创建基于 WebMvc 的 SSE 服务传输

    需要 mcp-spring-webmvc 依赖

    @Configuration
@EnableWebMvc
class McpConfig {
    @Bean
    WebMvcSseServerTransportProvider webMvcSseServerTransportProvider(ObjectMapper mapper) {
        return new WebMvcSseServerTransportProvider(mapper, "/mcp/message");
    }

    @Bean
    RouterFunction<ServerResponse> mcpRouterFunction(WebMvcSseServerTransportProvider transportProvider) {
        return transportProvider.getRouterFunction();
    }
}

  • SSE（Servlet）

    创建了一个基于 Servlet 的 SSE 服务器传输。它包含了核心包 mcp ，类 HttpServletSseServerTransport 可以被用于任何 Servlet 容器。它和 Spring Web 应用一块使用时，需要把它注册成一个 Servlt bean。

    @Configuration
@EnableWebMvc
public class McpServerConfig implements WebMvcConfigurer {

    @Bean
    public HttpServletSseServerTransportProvider servletSseServerTransportProvider() {
        return new HttpServletSseServerTransportProvider(new ObjectMapper(), "/mcp/message");
    }

    @Bean
    public ServletRegistrationBean customServletBean(HttpServletSseServerTransportProvider transportProvider) {
        return new ServletRegistrationBean(transportProvider);
    }
}

    使用传统的 Servlet API，用 SSE 传输规范实现了 MCP HTTP，提供如下功能：

    • 使用 Servlet6.0 的异步支持实现 异步消息处理

    • 对于多个客户端连接使用 Session 管理器

    • 两种类型的端点

      • SSE 类型的端点(/sse) for 服务 对 客户 事件

      • Message 类型的端点（可配置）对客户端向服务端的请求

    • 错误处理和响应格式化

    • 优雅的关机支持

2.2.2 服务能力

服务能力（Server Capabilities）

可以为服务配置多种能力

var capabilities = 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
    .logging()              // Enable logging support (enabled by default with logging level INFO)
    .build();
2.2.2.1 日志支持

服务提供了结构化的日志能力，允许发送给客户端的日志使用不同的级别

// Send a log message to clients
server.loggingNotification(LoggingMessageNotification.builder()
    .level(LoggingLevel.INFO)
    .logger("custom-logger")
    .data("Custom log message")
    .build());

DEBUG (0),

INFO (1),

NOTICE (2),

WARNING (3),

ERROR (4),

CRITICAL (5),

ALERT (6),

EMERGENCY (7)

2.2.2.2 工具规范

模型上下文协议允许服务端暴漏工具给大模型调用。Java SDK使用处理函数来实现工具规范。工具允许大模型来执行计算，访问外部 APIs，查询数据库，和操作文件。

  • 同步

    // Sync tool specification
var schema = """
            {
              "type" : "object",
              "id" : "urn:jsonschema:Operation",
              "properties" : {
                "operation" : {
                  "type" : "string"
                },
                "a" : {
                  "type" : "number"
                },
                "b" : {
                  "type" : "number"
                }
              }
            }
            """;
var syncToolSpecification = new McpServerFeatures.SyncToolSpecification(
    new Tool("calculator", "Basic calculator", schema),
    (exchange, arguments) -> {
        // Tool implementation
        return new CallToolResult(result, false);
    }
);

    工具规范包含 name, description 定义和参数模式，通过被调用来实现工具的逻辑。函数的第一个参数是 McpAsynServerExchange和客户端交互，第二个参数是一个工具参数的映射。

  • 异步

    // Async tool specification
var schema = """
            {
              "type" : "object",
              "id" : "urn:jsonschema:Operation",
              "properties" : {
                "operation" : {
                  "type" : "string"
                },
                "a" : {
                  "type" : "number"
                },
                "b" : {
                  "type" : "number"
                }
              }
            }
            """;
var asyncToolSpecification = new McpServerFeatures.AsyncToolSpecification(
    new Tool("calculator", "Basic calculator", schema),
    (exchange, arguments) -> {
        // Tool implementation
        return Mono.just(new CallToolResult(result, false));
    }
);
2.2.2.3 资源规范

规范资源的处理方法。资源给 AI 模型提供一个暴漏数据的上下文：如文件内容，数据记录，API 响应，系统信息，应用状态。示例资源描述：

  • 同步

    // Sync resource specification
var syncResourceSpecification = new McpServerFeatures.SyncResourceSpecification(
    new Resource("custom://resource", "name", "description", "mime-type", null),
    (exchange, request) -> {
        // Resource read implementation
        return new ReadResourceResult(contents);
    }
);

    The resource specification comprised 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.

  • 异步

    // Async resource specification
var asyncResourceSpecification = new McpServerFeatures.AsyncResourceSpecification(
    new Resource("custom://resource", "name", "description", "mime-type", null),
    (exchange, request) -> {
        // Resource read implementation
        return Mono.just(new ReadResourceResult(contents));
    }
);

    The resource specification comprised 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.

2.2.2.4 提示词规范

做为提示功能的一部分，MCP 为服务端暴漏提示词模板给客户端提供了一种标准途径。提示词模板规范是一个结构化的模板用于和 AI 模型交互，他可以格式化消息，参数替换，内容注入，响应格式化以及指令模板。

  • 同步

    // Sync prompt specification
var syncPromptSpecification = new McpServerFeatures.SyncPromptSpecification(
    new Prompt("greeting", "description", List.of(
        new PromptArgument("name", "description", true)
    )),
    (exchange, request) -> {
        // Prompt implementation
        return new GetPromptResult(description, messages);
    }
);

    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.

  • 异步

    // Async prompt specification
var asyncPromptSpecification = new McpServerFeatures.AsyncPromptSpecification(
    new Prompt("greeting", "description", List.of(
        new PromptArgument("name", "description", true)
    )),
    (exchange, request) -> {
        // Prompt implementation
        return Mono.just(new GetPromptResult(description, messages));
    }
);

    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.

2.2.2.5 补全规范

做为自动补全功能的一部分，MCP 为服务的提示词、资源 URIs 的参数自动补全建议提供了一种标准途径

  • 同步

    // Sync completion specification
var syncCompletionSpecification = new McpServerFeatures.SyncCompletionSpecification(
			new McpSchema.PromptReference("code_review"), (exchange, request) -> {
        
        // completion implementation ...
        
        return new McpSchema.CompleteResult(
            new CompleteResult.CompleteCompletion(
              List.of("python", "pytorch", "pyside"), 
              10, // total
              false // hasMore
            ));
      }
);

// Create a sync server with completion capabilities
var mcpServer = McpServer.sync(mcpServerTransportProvider)
  .capabilities(ServerCapabilities.builder()
    .completions() // enable completions support
      // ...
    .build())
  // ...
  .completions(new McpServerFeatures.SyncCompletionSpecification( // register completion specification
      new McpSchema.PromptReference("code_review"), syncCompletionSpecification))
  .build();

  • 异步

    // Async prompt specification
var asyncCompletionSpecification = new McpServerFeatures.AsyncCompletionSpecification(
			new McpSchema.PromptReference("code_review"), (exchange, request) -> {

        // completion implementation ...

        return Mono.just(new McpSchema.CompleteResult(
            new CompleteResult.CompleteCompletion(
              List.of("python", "pytorch", "pyside"), 
              10, // total
              false // hasMore
            )));
      }
);

// Create a async server with completion capabilities
var mcpServer = McpServer.async(mcpServerTransportProvider)
  .capabilities(ServerCapabilities.builder()
    .completions() // enable completions support
      // ...
    .build())
  // ...
  .completions(new McpServerFeatures.AsyncCompletionSpecification( // register completion specification
      new McpSchema.PromptReference("code_review"), asyncCompletionSpecification))
  .build();

2.2.1 模型上下文协议服务端

MCP Server 在模型上下文协议中架构中是一个基础组件，它给客户端提供了工具、资源和能力。它实现了服务的协议，具备以下职责

  • 给客户端暴漏工具让其调用和执行

  • 通过 URL访问的模式来管理资源

  • 提供提示词模板并且处理提示词请求

  • Supporting capability negotiation with clients

  • 实现服务侧的协议操作

  • 管理当前客户端连接

  • 提供结构化的日志和通知

核心模块 io.modelcontextprotocol.sdk:mcp 提供的STDIO 和 SSE 服务传输，并且这是不需要额外的 web 框架的。

可选的 Spring 框架的实现 io.modelcontextprotocol.sdk:mcp-spring-webflux,io.modelcontextprotocol.sdk:mcp-spring-webmvc

服务器同时支持同步和异步两种 API，根据不同的应用上下文进行选择

  • Sync API 同步 API

    // Create a server with custom configuration
McpSyncServer syncServer = McpServer.sync(transportProvider)
    .serverInfo("my-server", "1.0.0")
    .capabilities(ServerCapabilities.builder()
        .resources(true, true)     // Enable resource support
        .tools(true)         // Enable tool support
        .prompts(true)       // Enable prompt support
        .logging()           // Enable logging support
        .completions()      // Enable completions support
        .build())
    .build();

// Register tools, resources, and prompts
syncServer.addTool(syncToolSpecification);
syncServer.addResource(syncResourceSpecification);
syncServer.addPrompt(syncPromptSpecification);

// Close the server when done
syncServer.close();

  • Async 异步 API

    // Create an async server with custom configuration
McpAsyncServer asyncServer = McpServer.async(transportProvider)
    .serverInfo("my-server", "1.0.0")
    .capabilities(ServerCapabilities.builder()
        .resources(true, true)     // Enable resource support
        .tools(true)         // Enable tool support
        .prompts(true)       // Enable prompt support
        .logging()           // Enable logging support
        .build())
    .build();

// Register tools, resources, and prompts
asyncServer.addTool(asyncToolSpecification)
    .doOnSuccess(v -> logger.info("Tool registered"))
    .subscribe();

asyncServer.addResource(asyncResourceSpecification)
    .doOnSuccess(v -> logger.info("Resource registered"))
    .subscribe();

asyncServer.addPrompt(asyncPromptSpecification)
    .doOnSuccess(v -> logger.info("Prompt registered"))
    .subscribe();

// Close the server when done
asyncServer.close()
    .doOnSuccess(v -> logger.info("Server closed"))
    .subscribe();

服务端使用案例
yncServer asyncServer = McpServer.async(transportProvider)
.serverInfo(“my-server”, “1.0.0”)
.capabilities(ServerCapabilities.builder()
.resources(true, true) // Enable resource support
.tools(true) // Enable tool support
.prompts(true) // Enable prompt support
.logging() // Enable logging support
.build())
.build();

// Register tools, resources, and prompts
asyncServer.addTool(asyncToolSpecification)
.doOnSuccess(v -> logger.info(“Tool registered”))
.subscribe();

asyncServer.addResource(asyncResourceSpecification)
.doOnSuccess(v -> logger.info(“Resource registered”))
.subscribe();

asyncServer.addPrompt(asyncPromptSpecification)
.doOnSuccess(v -> logger.info(“Prompt registered”))
.subscribe();

// Close the server when done
asyncServer.close()
.doOnSuccess(v -> logger.info(“Server closed”))
.subscribe();




**服务端使用案例**
大模型系列——正式推出 Spring AI MCP：用于 MCP（模型上下文协议）的 Java SDK
02-27 6518
我们很高兴推出 Spring AI MCP，它是模型上下文协议（Model Context Protocol，）的强大 Java SDK 实现。Spring AI生态系统的这一新成员为 Java 平台带来了标准化的 AI 模型集成能力。
初步认识Model Context Protocol (MCP) Java SDK
RodJohnsonDoctor的专栏
04-16 532
在您的文件中添加以下依赖： <dependencyManagement>    <dependencies>        <dependency>            <groupId>io.modelcontextprotocol.sdk</groupId>         &
Java MCP SDK 开发笔记（一）
zhangxin09的专栏
04-06 3836
在开发前，首先带大家熟悉一下MCP协议和所有可能需要进行协商的功能。通过这些机制，MCP协议实现了高效、灵活且可扩展的通信能力，适用于多样化的应用场景。
MCP Java SDK 使用指南
gitblog_01167的博客
04-05 888
MCP Java SDK 使用指南 1. 项目目录结构及介绍 MCP Java SDK 的目录结构如下： modelcontextprotocol/java-sdk ├── .github # GitHub 工作流和配置文件 ├── .mvn/ # Maven Wrapper 配置 ├── mcp-bom ...
MCP Java SDK 介绍与使用指南
oscar999的专栏
04-29 1607
io.modelcontextprotocol.sdk:mcp-spring-webmvc - 用于基于 servlet 的应用的基于 WebMVC 的服务器发送事件 (SSE) 传输实现。io.modelcontextprotocol.sdk:mcp-spring-webflux - 用于响应式应用的基于 WebFlux 的服务器发送事件 (SSE) 传输实现。io.modelcontextprotocol.sdk:mcp-test - MCP 应用的测试工具和支持。
Java MCP客户端SDK实现
weixin_47233946的博客
04-22 917
System.out.println("异步分析结果: " + response)System.out.println("基本生成结果: " + response);System.out.println("高级分析结果: " + response);"分析这些症状可能代表什么情况：头痛、发热、咳嗽","分析这些症状可能代表什么情况：头痛、发热、咳嗽","生成一篇关于人工智能发展历史的文章",4. **类型安全**：使用枚举和强类型确保API使用正确。"标记所有医疗信息为参考","解释量子计算的基本原理",
MCP：基于Mcp Java SDK 开发一个 Mcp Client
Q2024107的博客
03-24 5390
在文章介绍了 MCP 协议的核心概念，有些内容可能还是有点晦涩难懂，后续文章将通过实现一些实际的案例，深入理解并清楚其使用的场景和效果。MCP Client 理解为可以支持 MCP 协议的客户端，本文重点在于如何使用 SDK 开发一个 MCP Client。我们直入主题，直接看 Java SDK 源码以及如何开发一个 MCP Client。
探究理解大语言模型的训练和推理复杂度
Code1994的博客
02-14 1045
先来看看最基本的 Self-Attention为了最终计算出z, 需要一步一步来, 这里面就产生了计算时中间结果占用内存. 我们知道计算机 (无论是 GPU 还是 CPU) 的内存都是分级的, 如果能够优化内存占用, 就可以尽可能减少内存的存取, 这个对于 latency 的降低帮助很大.
MCP客户端Java SDK实现
04-11
Java MCP客户端SDK的实现，涵盖了其核心功能和使用方式。 SDK采用面向对象设计，提供同步、异步和流式处理三种调用方式，适用于不同应用场景。主要类包括MCPClient（用于常规请求）和MCPStreamingClient（用于流式...
【2025大模型最新教程】MCP协议由入门到精通
最新发布
qq_38196449的博客
05-14 962
MCP（Model Context Protocol，译作：模型上下文协议）是由Anthropic公司（Claude大模型的母公司）于2024年11月25日发布的一种开放通信标准协议，旨在解决目前AI大模型因为数据孤岛限制而无法充分发挥潜力的问题，统一大模型语言（LLM）与外界数据源和工具之间的通信协议，它就像 USB-C 接口一样，提供了一种标准化的方法，将 AI 模型连接到各种数据源和工具，为 AI 应用提供了连接万物的接口。
用 MCP 平台玩转 AI 开发：从入门到精通
分享平时的学习心得和笔记
05-06 644
在当今的 AI 开发领域，MCP（模型上下文协议）服务器就像一个魔法盒子，为 AI 助手打开了通往海量数据和工具的大门。本文将带您深入了解如何利用 MCP 平台，特别是国内开发者 idoubi 开发的友好平台，以及如何在 Cursor 等工具中配置和使用 MCP 服务，让您的 AI 开发之旅更加顺畅。
mcp java sdk
03-22
- **GitHub 仓库**: 很多云服务平台会将其 SDK 开源并托管到 GitHub 上，可以搜索 `mcp java sdk` 关键词定位具体项目。 #### 使用前准备事项 在实际使用之前，请确认已满足如下条件： 1. 已经安装 JDK 版本符合...
【亲测免费】 Model Context Protocol Java SDK 使用教程
gitblog_00159的博客
04-05 1081
Model Context Protocol Java SDK 使用教程 1. 项目介绍 Model Context Protocol（MCP）Java SDK 是一个开源项目，旨在为 Java 应用程序提供一个标准化的接口，以与 AI 模型和工具进行交互。该 SDK 支持同步和异步通信模式，使得 Java 应用可以轻松集成 AI 功能。 2. 项目快速启动 以下是快速启动 MCP Java SD...
Java开发SDK详解
askuld的博客
05-26 1万+
1）首先我们开发一下服务端： 服务端是一个SpringBoot项目提供了一个用户列表查询的接口。入参包含调用方分唯一编号（appId），加密的入参信息（data）,入参的加解密方式使用RSA非对称加密算法。2）其次开发SDK： SDK是一个普通的maven项目，提供用户列表查询接口的Http调用方法，还有接口的参数校验，入参的加密，返回信息的解密。最后将项目打成jar包。3）最后开发客户端调试： 客户端是一个SpringBoot项目，项目中引入上面打包好的SDK，组装参数，调用用户列表查询接口。
Java SDK 开发指南
热门推荐
私聊前往站内信：https://i.csdn.net/#/msg/chat/weixin_44976692
08-08 1万+
Java SDK是开发者为简化某个特定任务或功能的集成而提供的一组工具和库。库（Libraries）：包含用于执行特定任务的预编译代码。文档（Documentation）：详细描述库的使用方法、接口和示例。示例代码（Sample Code）：展示如何使用SDK进行开发的实际代码示例。工具（Tools）：辅助开发的工具，如调试器、测试工具等。
Java SDK安装及配置流程详解
weixin_33431149的博客
05-09 1713
Java Software Development Kit (SDK) 是开发者用来构建Java应用程序和applets的开发环境。它包含了编写、编译、测试和部署Java应用所需的一系列工具，包括Java运行时环境（JRE）、Java虚拟机（JVM）和编译器（javac）。Java SDK是开发Android应用和企业级应用的核心组件。Android SDK（Software Development Kit）是为Android平台开发应用程序的官方开发工具包。
实操干货！MCP 全解析，手把手教你基于 MCP 开发 Agent
EnjoyEDU的博客
03-25 8701
随着 Manus 推动 Agent 应用的火爆，MCP（模型上下文协议）成为众多社区热议的焦点。今天，我们将深入解析 MCP 并提供实操应用指南。相信读完这篇文章，你就能立刻上手 MCP。
实操干货！MCP全解析，一步步教你借助第三方MCP Server开发Agent
2401_85375151的博客
03-20 3629
随着最近Manus带动Agent应用的火热，MCP（模型上下文协议）成为很多社区热议的话题。今天为带大家带来深度的MCP解析与实操应用指南，相信看完这篇你应该可以立刻上手MCP。本文目录：MCP概念与架构全解析让我们从一个实际的开发样例开始。假如你开发了一个AI应用，无论是ChatBot还是复杂的Agent，都不会再局限于简单的LLM对话，很多时候你需要与外部世界连接，以访问数据源或使用工具。比如：操控浏览器实现自动化；访问本地文件访问数据库结构，以更好的让AI做编程。
java mcp sdk 实现 mcp client
04-02
<think>好的，我现在需要帮用户解决如何使用Java MCP SDK实现MCP客户端的问题。首先，我需要理解用户的需求。用户提到了“Java MCP SDK”和“MCP客户端示例教程”，但根据提供的引用，特别是引用[1]中的Spring AI MCP GitHub仓库，可能MCP指的是Spring AI的一个项目模块。不过，用户提到的MCP也可能与邮件传输协议（MTP）或消息传递部分（MTP）相关，但引用[3]中的MTP是邮件传输协议，可能不太相关。需要进一步确认。 接下来，我需要查看用户提供的引用内容。引用[1]提到了Spring AI MCP的GitHub仓库和Maven依赖，这应该是关键。用户可能想使用Spring AI MCP SDK来构建客户端。引用[2]看起来像是某种蓝牙服务的代码，可能与当前问题无关。引用[3]涉及邮件传输协议，但用户的问题是关于MCP客户端，所以可能还是以引用[1]为主。 因此，我应该基于Spring AI MCP SDK来提供示例。由于Spring AI可能是一个实验性项目，文档可能有限，所以需要参考GitHub仓库中的示例或文档结构。假设用户需要创建一个MCP客户端，可能需要配置连接参数、调用API等步骤。 接下来，我需要确保回答结构清晰，分步骤说明，并提供一个简单的代码示例。可能需要包括添加Maven依赖、配置客户端、调用服务等步骤。同时，需要检查是否引用了正确的来源，比如引用[1]的GitHub链接和Maven依赖。 用户可能遇到的问题包括依赖配置错误、连接设置不正确或API调用方式不对，因此在回答中应提及常见问题和解决方法。此外，需要生成相关问题，如性能优化、错误处理等，以帮助用户进一步学习。 最后，确保使用正确的中文表达，避免技术术语错误，并遵循系统级指令中的格式要求，比如数学表达式使用$...$，独立公式用$$...$$，但在这个问题中可能不需要数学公式。代码块需要用反引号包裹，并指定语言为Java。</think>以下是基于Spring AI MCP SDK实现MCP客户端的步骤说明和示例： ### 一、环境准备 1. 添加Maven依赖（参考引用[1]）： ```xml <dependency> <groupId>org.springframework.experimental.ai</groupId> <artifactId>spring-ai-mcp</artifactId> <version>最新版本</version> </dependency> ``` ### 二、基础客户端实现 ```java import org.springframework.ai.mcp.McpClient; import org.springframework.ai.mcp.McpConnectionConfig; public class McpClientExample { public static void main(String[] args) { // 1. 配置连接参数 McpConnectionConfig config = new McpConnectionConfig() .setApiEndpoint("https://api.mcp-service.com") .setApiKey("your-api-key"); // 2. 创建客户端实例 McpClient mcpClient = new McpClient(config); // 3. 调用服务示例 String response = mcpClient.sendRequest("your_request_payload"); System.out.println("服务响应: " + response); } } ``` ### 三、高级配置 1. 异常处理： ```java try { mcpClient.verifyConnection(); // 连接健康检查 } catch (McpConnectionException e) { System.err.println("连接异常: " + e.getErrorCode()); // 实现重试逻辑... } ``` 2. 超时设置： ```java config.setConnectTimeout(Duration.ofSeconds(10)) .setReadTimeout(Duration.ofSeconds(30)); ``` ### 四、最佳实践建议 1. 建议使用连接池管理客户端实例 2. 敏感配置应使用加密存储 3. 重要操作建议添加审计日志[^1]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值