Java MCP SDK

Implements a blocking MCP client that sends protocol messages and waits for responses using Java's traditional synchronous threading model. Built on Jackson JSON serialization and JSON Schema validation, it handles request correlation, timeout management, and error handling through standard Java exception mechanisms. Developers call methods directly and receive results immediately, with no reactive overhead.

Implements a non-blocking MCP client using Project Reactor's reactive streams (Mono for single responses, Flux for streaming). Each protocol method returns a Mono<Response> that can be composed, chained, and transformed using reactive operators. Internally uses async I/O (HTTP async clients, non-blocking socket channels) to avoid thread blocking, enabling efficient multiplexing of thousands of concurrent requests with a small thread pool.

Validates all incoming MCP protocol messages against JSON Schema specifications using the JSON Schema Validator library (1.5.7). Validates request parameters, response structures, and streaming message formats before processing. Provides detailed validation error messages indicating which fields failed validation and why. Integrated into both client and server message processing pipelines.

Manages MCP client-server sessions by correlating requests with responses using unique message IDs. Tracks in-flight requests, enforces timeouts (default configurable), and cleans up abandoned sessions. Supports both stateful sessions (persistent connection) and stateless sessions (HTTP request-response). Handles connection lifecycle events (connect, disconnect, error) with callbacks.

Implements stateless MCP server design where each request is processed independently with no shared state between requests. Handlers receive request parameters and return responses without access to previous requests or session data. Enables horizontal scaling (multiple server instances) without session affinity. Supports request isolation via context variables (ThreadLocal or reactive context) for per-request metadata.

Uses Jackson 2.17.0 for JSON serialization/deserialization of MCP protocol messages with support for custom type handling, polymorphic types (tool results, resource types), and streaming JSON parsing. Configures ObjectMapper with MCP-specific modules for handling protocol-specific types. Supports both eager deserialization (full message parsing) and streaming deserialization (incremental parsing for large responses).

Provides mcp-bom module that centralizes version management for all MCP SDK dependencies (Jackson, Project Reactor, Spring Framework, SLF4J, etc.). Projects import the BOM to inherit consistent versions across all modules without specifying individual versions. Prevents version conflicts and ensures all MCP components use compatible dependency versions.

Implements a blocking MCP server that registers handler functions for protocol methods (tools, resources, prompts) and processes incoming requests synchronously. Handlers are registered as Java functions/lambdas that receive request parameters and return responses. The server validates incoming messages against JSON Schema, routes to appropriate handlers, and sends responses back through the transport layer. Supports both single-request and streaming response patterns.

Implements a non-blocking MCP server using Project Reactor where handlers return Mono<Response> or Flux<StreamedResponse>. Handlers are composed using reactive operators (flatMap, zip, retry, timeout) enabling complex async workflows. The server processes requests without blocking threads, multiplexing thousands of concurrent requests efficiently. Built-in support for streaming responses via Flux, with automatic backpressure handling.

Implements MCP message transport over HTTP using Server-Sent Events for server-to-client streaming and HTTP POST for client-to-server requests. Maintains a persistent SSE connection for responses while using separate POST requests for each client message. Handles session management, message correlation, and connection lifecycle. Built on Spring WebMVC or WebFlux depending on sync/async variant.

Implements MCP message transport over HTTP with support for chunked transfer encoding and streaming responses. Client sends requests via HTTP POST; server responds with chunked HTTP responses that stream large results without buffering. Handles connection pooling, request pipelining, and automatic decompression. Optimized for scenarios where responses are large or generated incrementally.

Implements MCP message transport over standard input/output (stdin/stdout), enabling MCP servers to run as subprocesses and communicate with parent processes via line-delimited JSON. Handles process lifecycle management, signal handling, and error stream routing. Commonly used for local tool integration and development. Built on Java ProcessBuilder with async I/O to prevent deadlocks.

Provides Spring WebMVC controller and configuration classes that expose MCP servers as HTTP endpoints. Integrates with Spring's servlet-based request handling, dependency injection, and configuration management. Developers annotate handler methods with @MCP annotations or register handlers via Spring beans. Automatically handles HTTP request routing, JSON serialization via Jackson, and error responses.

Provides Spring WebFlux router and handler functions that expose MCP servers as reactive HTTP endpoints. Integrates with Spring's reactive request handling, Project Reactor, and functional endpoint configuration. Handlers return Mono<Response> or Flux<StreamedResponse> enabling non-blocking I/O and efficient multiplexing. Supports both annotation-based and functional routing styles.

Provides Spring Boot starter modules (mcp-spring-boot-starter-webmvc, mcp-spring-boot-starter-webflux) that auto-configure MCP client and server components based on classpath and properties. Developers add a single dependency and configure MCP via application.properties or application.yml. Starters handle bean creation, transport selection, and lifecycle management automatically.