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:mcpmodule 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
-
依赖清单
依赖清单（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的应用程序。
-
-
-
MCP 核心包
<dependency> <groupId>io.modelcontextprotocol.sdk</groupId> <artifactId>mcp</artifactId> </dependency>核心mcp模块已经包含默认的STDIO和SSE传输实现，不需要外部web框架。
-
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, andMIME type. The first argument of the function that handles resource read requests is anMcpAsyncServerExchangeupon which the server can interact with the connected client. The second arguments is aMcpSchema.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, andMIME type. The first argument of the function that handles resource read requests is anMcpAsyncServerExchangeupon which the server can interact with the connected client. The second arguments is aMcpSchema.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
McpAsyncServerExchangefor client interaction, and the second argument is aGetPromptRequestinstance. -
异步
// 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
McpAsyncServerExchangefor client interaction, and the second argument is aGetPromptRequestinstance.
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();
**服务端使用案例**
扫一扫
6469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
