Java MCP 服务器

// 使用自定义配置创建异步服务器
McpAsyncServer asyncServer = McpServer.async(transportProvider)
    .serverInfo("my-server", "1.0.0")
    .capabilities(ServerCapabilities.builder()
        .resources(false, true)     // 启用资源支持
        .tools(true)                // 启用工具支持
        .prompts(true)              // 启用提示支持
        .logging()                  // 启用日志支持
        .completions()              // 启用补全支持
        .build())
    .build();

// 注册工具、资源和提示
asyncServer.addTool(asyncToolSpecification)
    .doOnSuccess(v -> logger.info("工具已注册"))
    .subscribe();

asyncServer.addResource(asyncResourceSpecification)
    .doOnSuccess(v -> logger.info("资源已注册"))
    .subscribe();

asyncServer.addPrompt(asyncPromptSpecification)
    .doOnSuccess(v -> logger.info("提示已注册"))
    .subscribe();

// 完成后关闭服务器
asyncServer.close()
    .doOnSuccess(v -> logger.info("服务器已关闭"))
    .subscribe();

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

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

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

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

@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);
    }
}

// 异步工具规范
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", "基础计算器", schema),
    (exchange, arguments) -> {
        // 工具实现
        return Mono.just(new CallToolResult(result, false));
    }
);

// 异步资源规范
var asyncResourceSpecification = new McpServerFeatures.AsyncResourceSpecification(
    new Resource("custom://resource", "name", "description", "mime-type", null),
    (exchange, request) -> {
        // 资源读取实现
        return Mono.just(new ReadResourceResult(contents));
    }
);

// 异步提示规范
var asyncPromptSpecification = new McpServerFeatures.AsyncPromptSpecification(
    new Prompt("greeting", "描述", List.of(
        new PromptArgument("name", "描述", true)
    )),
    (exchange, request) -> {
        // 提示实现
        return Mono.just(new GetPromptResult(description, messages));
    }
);

// 异步补全规范
var asyncCompletionSpecification = new McpServerFeatures.AsyncCompletionSpecification(
			new McpSchema.PromptReference("code_review"), (exchange, request) -> {

        // 补全实现 ...

        return Mono.just(new McpSchema.CompleteResult(
            new CompleteResult.CompleteCompletion(
              List.of("python", "pytorch", "pyside"),
              10, // 总数
              false // 是否还有更多
            )));
      }
);

// 创建具备补全能力的异步服务器
var mcpServer = McpServer.async(mcpServerTransportProvider)
  .capabilities(ServerCapabilities.builder()
    .completions() // 启用补全支持
      // ...
    .build())
  // ...
  .completions(new McpServerFeatures.AsyncCompletionSpecification( // 注册补全规范
      new McpSchema.PromptReference("code_review"), asyncCompletionSpecification))
  .build();

// 创建服务器
McpAsyncServer server = McpServer.async(transportProvider)
    .serverInfo("my-server", "1.0.0")
    .build();

// 定义一个使用采样的工具
var calculatorTool = new McpServerFeatures.AsyncToolSpecification(
    new Tool("ai-calculator", "使用 AI 执行计算", schema),
    (exchange, arguments) -> {
        // 检查客户端是否支持采样
        if (exchange.getClientCapabilities().sampling() == null) {
            return Mono.just(new CallToolResult("客户端不支持 AI 功能", false));
        }

        // 创建采样请求
        McpSchema.CreateMessageRequest request = McpSchema.CreateMessageRequest.builder()
            .content(new McpSchema.TextContent("计算：" + arguments.get("expression")))
            .modelPreferences(McpSchema.ModelPreferences.builder()
                .hints(List.of(
                    McpSchema.ModelHint.of("claude-3-sonnet"),
                    McpSchema.ModelHint.of("claude")
                ))
                .intelligencePriority(0.8)  // 优先考虑智能
                .speedPriority(0.5)         // 中等速度重要性
                .build())
            .systemPrompt("你是一个有用的计算器助手。请只提供数值答案。")
            .maxTokens(100)
            .build();

        // 向客户端请求采样
        return exchange.createMessage(request)
            .map(result -> {
                // 处理结果
                String answer = result.content().text();
                return new CallToolResult(answer, false);
            });
    }
);

// 将工具添加到服务器
server.addTool(calculatorTool)
    .subscribe();