tachyonmcp/tachyon

Tachyon MCP is a Java 21+ server runtime for the Model Context Protocol. It implements MCP 2025-11-25 and 2026-07-28 over Streamable HTTP and passes the official conformance suites for both versions.

Build servers with synchronous Java handlers or a coroutine-first Kotlin DSL. Tachyon runs blocking handlers on virtual threads, keeps them off the Netty event loop, and requires no application framework.

Why Tachyon?

• Simple handlers -- write blocking Java code or suspending Kotlin code without reactive pipelines or manual thread pools.
• Stable application API -- protocol-version mappers isolate handlers from wire-format changes.
• Java annotations support -- adapt existing mcp-java, LangChain4j, or Spring AI annotated services into Tachyon MCP servers.
• Stateless by default -- opt into sessions only when you need resumable SSE, event replay, and TTL cleanup.
• Production transport -- Netty backpressure, graceful shutdown, DNS-rebinding protection, CORS, and native transport auto-detection (io_uring → epoll → kqueue → NIO).
• Built-in OpenTelemetry -- register tachyon-opentelemetry's listener for MCP semantic-convention spans and metrics, with an opt-in policy for payload capture.

Quickstart

Import the BOM once to pin the version, then add the core dependency:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>dev.tachyonmcp</groupId>
            <artifactId>tachyon-bom</artifactId>
            <version>${tachyon.version}</version> <!-- get latest version from Maven Central -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>dev.tachyonmcp</groupId>
        <artifactId>tachyon-core</artifactId>
    </dependency>
</dependencies>

Create and start a server:

import dev.tachyonmcp.api.server.features.tools.ToolResult;
import dev.tachyonmcp.core.server.TachyonServer;

public class WeatherMcpServer {
    public static void main(String... args) {
        var server = TachyonServer.builder()
            .name("weather-mcp")
            .withTools(tools -> tools.register(
                tool -> tool.name("get_forecast")
                    .description("Get weather forecast")
                    .inputSchema("""
                        {"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}
                        """),
                (context, request) -> ToolResult.text("☀️ 22°C")))
            .port(8080)
            .build();
        server.start();
    }
}

See the quickstart for Java and Kotlin examples plus a curl test.

Implemented features

Area	Support
MCP surface	Tools, resources and templates, prompts, completions, logging, sampling, form/URL elicitation, cancellation, subscriptions, pagination, and progress notifications
Annotations	Optional adapters for mcp-java, LangChain4j, and Spring AI, mapped onto Tachyon's standard registries
Tasks	Full tasks/* lifecycle, state validation, status notifications, retention, and TasksExtension for SEP-2663, with SEP-1686 compatibility for MCP 2025-11-25 clients
MCP Apps	AppsExtension implements the SEP-1865 draft: ui:// HTML views with _meta.ui CSP and permissions, tool-to-view linkage, and io.modelcontextprotocol/ui advertisement
Agent Skills	SkillsExtension implements the SEP-2640 draft: filesystem/classpath registries, skill:// resources, skills/list, skills/get, and directory reads
Extensions	SEP-2133 negotiation, custom JSON-RPC methods, capability advertisement, and extension-gated features
Runtime	Stateless or resumable sessions, Last-Event-ID replay, pluggable stores, virtual-thread handlers, request timeouts, and graceful draining
Observability	OpenTelemetry spans and metrics via tachyon-opentelemetry, following the MCP semantic conventions, plus an opt-in payload capture policy -- see docs
Java and Kotlin	Independent sync/async Java contracts and a coroutine-first Kotlin DSL
Testing	Official conformance suites plus a testkit for dynamic servers and fluent JSON-RPC assertions

Documentation and examples

• Configuration -- network, native I/O, sessions, CORS, and runtime limits
• Observability -- observation listeners, payload capture policy, and the bundled OpenTelemetry integration
• Tools, resources, and tasks -- feature APIs and examples
• Annotations -- mcp-java, LangChain4j, and Spring AI providers
• Extensions and MCP Skills, and MCP Apps -- custom protocol methods and SEP support
• Kotlin DSL -- builders, scopes, and suspending handlers
• Examples -- runnable Java and Kotlin servers
• FAQ -- frameworks, concurrency, deployment, and compatibility

Coding-agent skill

This repository also includes a skill that teaches coding agents how to build Tachyon servers. It is separate from the server-side SkillsExtension described above.

npx skills add tachyonmcp/tachyon --skill tachyon-mcp

Its Java and Kotlin examples are compiled during the project build to keep them current. See the agent skill guide for install options and example prompts.

License

Tachyon MCP is available under the terms of the Apache 2.0.