Java MCP 客户端

// 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
        .elicitation()    // Enable elicitation capability
        .build())
    .sampling(request -> Mono.just(new CreateMessageResult(response)))
    .elicitation(elicitRequest -> Mono.just(ElicitResult.builder()...build()))
    .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)))
    .loggingConsumer(notification -> Mono.fromRunnable(() -> logger.info("Log: {}", notification.data())))
    .progressConsumer(progress -> Mono.fromRunnable(() -> logger.info("Progress update: {}", progress.data())))
    .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();

var requestBuilder = HttpRequest
    .newBuilder()
    .header("X-Custom-Header", "some header value");

HttpClientStreamableHttpTransport
    .builder("https://mcp.example.com")
    .requestBuilder(requestBuilder)
    .build();

// Sync
class MyRequestCustomizer implements McpSyncHttpClientRequestCustomizer {
    @Override
    public void customize(HttpRequest.Builder builder, String method,
        URI endpoint, String body, McpTransportContext context) {
        // ... custom logic ...
        var token = obtainAccessToken(context);
        builder.header("Authorization", "Bearer " + token);
    }
}

// Async
class MyAsyncRequestCustomizer implements McpAsyncHttpClientRequestCustomizer {
    @Override
    public Publisher<HttpRequest.Builder> customize(HttpRequest.Builder builder,
        String method, URI endpoint, String body, McpTransportContext context) {
        // ... custom logic ...
        Mono<String> token = obtainAccessToken(context);
        return token.map(t ->
            builder.copy()
                .header("Authorization", "Bearer " + t)
        );
    }
}

HttpClientStreamableHttpTransport
    .builder("https://mcp.example.com")
    .httpRequestCustomizer(new MyRequestCustomizer()) // sync
    .asyncHttpRequestCustomizer(new MyAsyncRequestCustomizer()) // OR async
    .build();

var webClientBuilder = WebClient.builder()
    .defaultHeader("X-Custom-Header", "some header value");

McpTransport transport = WebClientStreamableHttpTransport
                            .builder(webClientBuilder)
                            .build();

WebClient.builder()
    .filter((request, next) -> {
        return Mono.deferContextual(ctx -> {
            var transportContext = ctx.get(McpTransportContext.KEY);
            var otherInfo = ctx.get("your-context-key");
            Mono<String> token = obtainAccessToken(transportContext, otherInfo);
            return token.map(t -> {
                var newRequest = ClientRequest.from(request)
                    .header("Authorization", "Bearer " + t)
                    .build();
                // Ensure you call next.exchange to execute the HTTP request
                return next.exchange(newRequest);
            });
        });
    });

// 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();

// List available resources asynchronously
client.listResources()
    .doOnNext(resources -> resources.forEach(resource ->
        System.out.println(resource.getName())))
    .subscribe();

// Retrieve resource content asynchronously
client.getResource("file", Map.of(
        "path", "/path/to/file.txt"
    ))
    .subscribe();

// 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();

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

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

var client = McpClient.async(transport)
    // ...
    .build();

Mono<McpSchema.ListToolsResult> toolList = client
    .listTools()
    .contextWrite(ctx -> {
        var transportContext = McpTransportContext.create(
            Map.of("some-key", "some value")
        );
        return ctx.put(McpTransportContext.KEY, transportContext)
            .put("reactor-context-key", "some reactor value");
    });

WebClient.builder()
    .filter((request, next) -> {
        return Mono.deferContextual(ctx -> {
            var transportContext = ctx.get(McpTransportContext.KEY);
            var someReactorValue = ctx.get("reactor-context-key");
            // ... use context values ...
        });
    });