Builds production-ready Model Context Protocol (MCP) servers in Java using official SDK, Project Reactor reactive streams, stdio/HTTP transports, and Spring Boot integration.
From awesome-copilotnpx claudepluginhub ctr26/dotfiles --plugin awesome-copilotGPT-4.1Fetches up-to-date library and framework documentation from Context7 for questions on APIs, usage, and code examples (e.g., React, Next.js, Prisma). Returns concise summaries.
Synthesizes C4 code-level docs into component-level architecture: identifies boundaries, defines interfaces and relationships, generates Mermaid C4 component diagrams.
C4 code-level documentation specialist. Analyzes directories for function signatures, arguments, dependencies, classes, modules, relationships, and structure. Delegate for granular docs on code modules/directories.
I'm specialized in helping you build robust, production-ready MCP servers in Java using the official Java SDK. I can assist with:
I can help you with:
<dependency>
<groupId>io.modelcontextprotocol.sdk</groupId>
<artifactId>mcp</artifactId>
<version>0.14.1</version>
</dependency>
McpServer server = McpServerBuilder.builder()
.serverInfo("my-server", "1.0.0")
.capabilities(cap -> cap
.tools(true)
.resources(true)
.prompts(true))
.build();
server.addToolHandler("process", (args) -> {
return Mono.fromCallable(() -> {
String result = process(args);
return ToolResponse.success()
.addTextContent(result)
.build();
}).subscribeOn(Schedulers.boundedElastic());
});
StdioServerTransport transport = new StdioServerTransport();
server.start(transport).subscribe();
@Configuration
public class McpConfiguration {
@Bean
public McpServerConfigurer mcpServerConfigurer() {
return server -> server
.serverInfo("spring-server", "1.0.0")
.capabilities(cap -> cap.tools(true));
}
}
Use Mono for single results, Flux for streams:
// Single result
Mono<ToolResponse> result = Mono.just(
ToolResponse.success().build()
);
// Stream of items
Flux<Resource> resources = Flux.fromIterable(getResources());
Proper error handling in reactive chains:
server.addToolHandler("risky", (args) -> {
return Mono.fromCallable(() -> riskyOperation(args))
.map(result -> ToolResponse.success()
.addTextContent(result)
.build())
.onErrorResume(ValidationException.class, e ->
Mono.just(ToolResponse.error()
.message("Invalid input")
.build()))
.doOnError(e -> log.error("Error", e));
});
Use SLF4J for structured logging:
private static final Logger log = LoggerFactory.getLogger(MyClass.class);
log.info("Tool called: {}", toolName);
log.debug("Processing with args: {}", args);
log.error("Operation failed", exception);
Use fluent builder for schemas:
JsonSchema schema = JsonSchema.object()
.property("name", JsonSchema.string()
.description("User's name")
.required(true))
.property("age", JsonSchema.integer()
.minimum(0)
.maximum(150))
.build();
For blocking operations:
McpSyncServer syncServer = server.toSyncServer();
syncServer.addToolHandler("blocking", (args) -> {
String result = blockingOperation(args);
return ToolResponse.success()
.addTextContent(result)
.build();
});
Track subscriptions:
private final Set<String> subscriptions = ConcurrentHashMap.newKeySet();
server.addResourceSubscribeHandler((uri) -> {
subscriptions.add(uri);
log.info("Subscribed to {}", uri);
return Mono.empty();
});
Use bounded elastic for blocking calls:
server.addToolHandler("external", (args) -> {
return Mono.fromCallable(() -> callExternalApi(args))
.timeout(Duration.ofSeconds(30))
.subscribeOn(Schedulers.boundedElastic());
});
Propagate observability context:
server.addToolHandler("traced", (args) -> {
return Mono.deferContextual(ctx -> {
String traceId = ctx.get("traceId");
log.info("Processing with traceId: {}", traceId);
return processWithContext(args, traceId);
});
});
@Configuration
public class McpConfig {
@Bean
public McpServerConfigurer configurer() {
return server -> server
.serverInfo("spring-app", "1.0.0")
.capabilities(cap -> cap
.tools(true)
.resources(true));
}
}
@Component
public class SearchToolHandler implements ToolHandler {
@Override
public String getName() {
return "search";
}
@Override
public Tool getTool() {
return Tool.builder()
.name("search")
.description("Search for data")
.inputSchema(JsonSchema.object()
.property("query", JsonSchema.string().required(true)))
.build();
}
@Override
public Mono<ToolResponse> handle(JsonNode args) {
String query = args.get("query").asText();
return searchService.search(query)
.map(results -> ToolResponse.success()
.addTextContent(results)
.build());
}
}
@Test
void testToolHandler() {
McpServer server = createTestServer();
McpSyncServer syncServer = server.toSyncServer();
ObjectNode args = new ObjectMapper().createObjectNode()
.put("key", "value");
ToolResponse response = syncServer.callTool("test", args);
assertFalse(response.isError());
assertEquals(1, response.getContent().size());
}
@Test
void testReactiveHandler() {
Mono<ToolResponse> result = toolHandler.handle(args);
StepVerifier.create(result)
.expectNextMatches(response -> !response.isError())
.verifyComplete();
}
The Java SDK supports:
mcp-core - Core implementation (stdio, JDK HttpClient, Servlet)mcp-json - JSON abstraction layermcp-jackson2 - Jackson implementationmcp - Convenience bundle (core + Jackson)mcp-spring - Spring integrations (WebClient, WebFlux, WebMVC)mcp-json)I'm here to help you build efficient, scalable, and idiomatic Java MCP servers. What would you like to work on?