# Epistates/TurboMCP [Health: Active]

**Category:** 🛠️ Other Tools and Integrations  
**Repository:** https://github.com/Epistates/turbomcp  
**GitHub Stars:** 96  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/epistates-turbomcp

## Description
TurboMCP SDK: Enterprise MCP SDK in Rust

## Claude Desktop Quick Installation
Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):

```json
"mcpServers": {
  "turbomcp": {
    "command": "npx",
    "args": ["-y","epistates-turbomcp"]
  }
}
```

## Documentation

## What Epistates/TurboMCP MCP server does

Epistates/TurboMCP MCP server provides a Rust implementation toolkit for both sides of the Model Context Protocol. The main `turbomcp` facade exposes the SDK’s common APIs, while workspace crates cover protocol types, codecs, server dispatch, client behavior, transports, authentication, and telemetry.

A server implementation can place `#[server]` on an `impl` block and mark methods as tools, resources, or prompts. The macros derive JSON schemas from method signatures and calculate advertised capabilities from the markers in use. This keeps the public MCP description tied to the implementation rather than requiring separate capability configuration.

The SDK supports protocol revisions `2025-06-18`, `2025-11-25`, and the `2026-07-28` draft. Application handlers use version-neutral types, while revision-specific wire representations and conversions are generated separately. Servers can restrict the revisions they advertise through the server macro.

## How it works

Epistates/TurboMCP MCP server places transport selection behind a common builder-style API. A server can run over standard input/output with `run_stdio()`, Streamable HTTP through Axum with `run_http`, or WebSocket using the WebSocket serving API. Standard output carries protocol frames in stdio mode, so application logging must use standard error.

The client API performs the MCP handshake, negotiates a protocol version, and exposes a typed interface based on the same neutral model used by servers. The project includes interoperability testing with the official Rust SDK, `rmcp`, in both client-to-server directions.

Optional components provide OAuth 2.1 support, identity-based rate limiting, OpenTelemetry tracing and metrics, progress and logging, subscriptions, response caching, and bidirectional elicitation. These capabilities are enabled through feature flags rather than being mandatory for every application. The workspace also includes a `no_std` foundation and supports building its core, codec, and protocol crates for `wasm32-unknown-unknown`.

## Setup and configuration

TurboMCP is distributed as a Cargo workspace, with the `turbomcp` crate serving as the usual dependency for application code. The documented quickstart uses Rust edition 2024 and requires Rust 1.88 or newer. A minimal server derives `Clone`, defines an annotated implementation, and starts with the asynchronous `run_stdio()` method.

The SDK is currently in the 4.0.0-alpha.2 prerelease line. The 3.x line is identified as the stable line in the project documentation. Feature flags control optional facilities such as HTTP, authentication, telemetry, and other extensions, so configuration depends on which parts of the workspace an application enables.

## Tools and capabilities

Epistates/TurboMCP MCP server supports:

- Macro-defined tools, resources, and prompts
- Compile-time JSON schema generation from Rust signatures
- Stdio, Streamable HTTP, and WebSocket transports
- Typed MCP client and server APIs
- Negotiation across three documented protocol revisions
- Composite servers with prefixed or flat tool names
- Per-caller visibility for server components
- Tower-style middleware at the protocol frame boundary
- OAuth 2.1 resource-server and client authentication features
- OpenTelemetry tracing and metrics
- Progress, logging, subscriptions, caching, and elicitation

The workspace is tested with the official MCP conformance harness, cross-SDK interoperability tests, unit tests, fuzzing targets, and dependency policy checks. The README reports passing and informational conformance results rather than claiming every check passes.

## Limitations and notes

The project does not support the older MCP revisions `2024-11-05` and `2025-03-26`; applications requiring those revisions are directed to `rmcp`. Version 4 is a prerelease for community testing, so its APIs may not have the stability of the 3.x line. OAuth, telemetry, rate limiting, caching, and related production features are opt-in and may require selecting the corresponding Cargo features.

The repository is an SDK, not a hosted MCP endpoint or a standalone server package. Developers must implement the application handlers and choose a transport when integrating Epistates/TurboMCP MCP server into a Rust project. It is released under the MIT license.

_Full upstream README: https://allmcps.com/mcp/epistates-turbomcp/readme_