Skip to content
Back to search

turbomcp

A full featured, enterprise grade rust MCP SDK

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Epistates/turbomcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Epistates/turbomcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/epistates--turbomcp/badge.svg)](/listings/epistates--turbomcp)

HTML

<a href="/listings/epistates--turbomcp"><img src="/api/listings/epistates--turbomcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

use turbomcp::prelude::*;

#[derive(Clone)]
struct Hello;

#[server(name = "hello", version = "1.0.0")]
impl Hello {
    /// Say hello to someone.
    #[tool(description = "Say hello to someone")]
    async fn hello(&self, name: String) -> McpResult<String> {
        Ok(format!("Hello, {name}!"))
    }
}

#[tokio::main]
async fn main() -> Result<(), turbomcp::ProtocolError> {
    // Logs MUST go to stderr — stdout carries the MCP protocol framing.
    Hello.run_stdio().await
}

See the [`turbomcp` crate README](crates/turbomcp/README.md) for the full API tour (tools/resources/prompts, structured output, HTTP, feature flags) and the [`examples/`](crates/turbomcp/examples/).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 158 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # TurboMCP
  2. [![Crates.io](https://img.shields.io/crates/v/turbomcp.svg)](https://crates.io/crates/turbomcp)
  3. [![Documentation](https://docs.rs/turbomcp/badge.svg)](https://docs.rs/turbomcp)
  4. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
  5. A ground-up Rust SDK for the [Model Context Protocol](https://modelcontextprotocol.io) —
  6. both halves of the protocol, server **and** client — with a macro-driven,
  7. zero-boilerplate surface and strict spec compliance as a feature.
  8. > **Status: `4.0.0-alpha.5` — a prerelease for community testing.** v4 is a
  9. > from-scratch rewrite of TurboMCP; the stable line is `3.x`. Edition 2024,
  10. > MSRV 1.88. It interoperates with the official Rust, TypeScript, Python and Go
  11. > SDKs in both directions, on both revisions, and both halves are scored against the official MCP conformance
  12. > suite: 232 successful server assertions and 534 distinct successful client
  13. > scenario/check pairs using pinned client fixture corrections, with zero failures, skips, or warnings. All three advertised revisions (`2025-06-18`, `2025-11-25`,
  14. > `2026-07-28`) are dated and frozen; `2026-07-28` is generated from the
  15. > released `schema/2026-07-28/`, not the RC.
  16. > **Found something broken or unergonomic? Please open an issue.**
  17. ## What you get
  18. - **One macro defines a server.** `#[server]` over an `impl` block turns
  19. `#[tool]` / `#[resource]` / `#[prompt]` methods into a fully-wired MCP server.
  20. The macro generates schema derivation code; schema values are initialized once at runtime and cloned for callers, and
  21. the advertised capabilities are *derived* from which markers are present — they
  22. can't drift from the implementation.
  23. - **Three protocol revisions, one handler.** The same server answers
  24. `2025-06-18`, `2025-11-25`, and `2026-07-28`. Your handlers speak
  25. version-neutral types; the version-specific wire shapes are conversions, not
  26. signature changes — including dropping, per session, the fields a revision
  27. predates. Pin the set with `#[server(protocols("2025-11-25", …))]`.
  28. - **Transports behind one builder.** stdio (default), Streamable HTTP (axum),
  29. and WebSocket. `MyServer.run_stdio()`, or
  30. `.into_server().layer(…).serve(Http::bind(addr))`: one runtime wires
  31. sessions, `DELETE` and graceful shutdown, with or without middleware.
  32. WebSocket rides the HTTP endpoint as a route, behind the same guards.
  33. - **The client too.** A typed `Client` runs the handshake, negotiates the
  34. version, and speaks the same neutral API — interoperating with the official
  35. Rust SDK (rmcp) in both directions.
  36. - **Production seams.** OAuth 2.1 on both halves (resource-server bearer
  37. validation and the client auth-code + PKCE flow), identity-keyed rate
  38. limiting, OpenTelemetry tracing + metrics, progress/logging, subscriptions,
  39. response caching (SEP-2549), and bidirectional elicitation — each opt-in
  40. behind a feature flag.
  41. ## How this relates to `rmcp`, the official Rust SDK
  42. [`rmcp`](https://github.com/modelcontextprotocol/rust-sdk) is the official SDK,
  43. maintained in the `modelcontextprotocol` organization. It is the reasonable
  44. default, and this project is tested against it — cross-SDK interop tests run in
  45. both directions, a TurboMCP client against an rmcp server and the reverse, on
  46. every change, alongside the same matrix over HTTP against the official
  47. TypeScript (v2), Python and Go SDKs.
  48. TurboMCP's interoperability tests pin `rmcp` 3.5. TurboMCP serves three
  49. revisions (`2025-06-18`, `2025-11-25`, `2026-07-28`) using separate generated
  50. wire types and exhaustive conversions to a neutral handler API. It does not
  51. serve `2024-11-05` or `2025-03-26`.
  52. The distinguishing APIs are macro-derived capabilities, typed per-RPC contexts,
  53. composition, caller-specific visibility, and Tower middleware. Conformance and
  54. interoperability are compatibility evidence; they do not establish performance
  55. superiority over another SDK. See [deployment and migration](docs/DEPLOYMENT.md)
  56. for the limits and security contracts.
  57. ## Quickstart
  58. ```rust
  59. use turbomcp::prelude::*;
  60. #[derive(Clone)]
  61. struct Hello;
  62. #[server(name = "hello", version = "1.0.0")]
  63. impl Hello {
  64. /// Say hello to someone.
  65. #[tool(description = "Say hello to someone")]
  66. async fn hello(&self, name: String) -> McpResult<String> {
  67. Ok(format!("Hello, {name}!"))
  68. }
  69. }
  70. #[tokio::main]
  71. async fn main() -> Result<(), turbomcp::ProtocolError> {
  72. // Logs MUST go to stderr — stdout carries the MCP protocol framing.
  73. Hello.run_stdio().await
  74. }
  75. ```
  76. See the [`turbomcp` crate README](crates/turbomcp/README.md) for the full API
  77. tour (tools/resources/prompts, structured output, HTTP, feature flags) and the
  78. [`examples/`](crates/turbomcp/examples/).
  79. ## Workspace layout
  80. The SDK is a Cargo workspace; the `turbomcp` facade re-exports the pieces most
  81. users need, so a typical dependency is just `turbomcp`.
  82. | Crate | Role |
  83. |---|---|
  84. | `turbomcp` | Main SDK facade — re-exports, prelude, examples |
  85. | `turbomcp-macros` | `#[server]` / `#[tool]` / `#[resource]` / `#[prompt]` |
  86. | `turbomcp-core` | `no_std` foundation: `McpError`, `ProtocolVersion`, JSON-RPC, `_meta`, the wire codec (serde_json, opt-in SIMD via sonic-rs) |
  87. | `turbomcp-protocol` | MCP protocol: neutral types, date-versioned wire shapes, version dispatch |
  88. | `turbomcp-service` | The `tower`-shaped protocol seam, transport trait, shared RPC middleware, stdio / line-delimited transport |
  89. | `turbomcp-server` | Handler registry, dispatcher, `ServerBuilder`, graceful shutdown |
  90. | `turbomcp-client` | Typed client: handshake, version negotiation, neutral API; transport-agnostic |
  91. | `turbomcp-transport-http` | Streamable HTTP, both halves: the axum server endpoint (`server`) and the client transport (`client`, `oauth`); WebSocket as a route on the same endpoint and its client (`websocket`) |
  92. | `turbomcp-auth` | OAuth 2.1 resource-server auth (bearer validation, RFC 9728) |
  93. | `turbomcp-telemetry` | OpenTelemetry tracing (W3C `_meta` propagation, PII-safe spans) |
  94. | `turbomcp-ext-tasks` | Draft Tasks extension (`io.modelcontextprotocol/tasks`, SEP-2663) |
  95. | `turbomcp-proxy` | The embeddable gateway: remote MCP servers as mountable, version-translating servers |
  96. | `turbomcp-cli` | The `turbomcp` command: the gateway over an `mcpServers` config, and protocol operations (`tools`, `call`, `probe`, …) against any server |
  97. ## Verification
  98. Compliance is tested, not asserted:
  99. - **Official conformance suite, both halves** — the
  100. `@modelcontextprotocol/conformance` harness runs in both directions on both
  101. scored revisions. As the *server*, it drives a full-featured TurboMCP server
  102. over Streamable HTTP: **237 checks, 232 pass, 0 fail, 5 informational**. As the
  103. *client*, it stands up a deliberately awkward mock server per scenario and
  104. referees what our client did on the wire: **534 distinct successful scenario/check pairs, 0 failures**, including the
  105. OAuth scenarios through the public `OAuthSession` coordinator. The client gate
  106. uses [hash-pinned fixture corrections](crates/turbomcp-conformance/fixtures/README.md)
  107. and reports zero failures, skips, or warnings. The unmodified upstream mode
  108. remains available with its original fixture limitations. Neither side has
  109. failure waivers (`crates/turbomcp-conformance`).
  110. - **Cross-SDK interop** — a TurboMCP client drives an official-Rust-SDK
  111. (rmcp 3.5) server and vice-versa, in-process, on `2025-11-25` *and* the
  112. stateless `2026-07-28`; and over Streamable HTTP the same, both ways and both
  113. eras, against the official TypeScript (v2.3), Python (2.3) and Go (1.8) SDKs
  114. (`crates/turbomcp-interop`, `sdks/`).
  115. - **Workspace regression tests** (also run against the
  116. `no_std` foundation configs) — dual-version dispatch, transport hardening
  117. (Origin/auth/size caps/idle reaping), handler-panic containment, MRTR
  118. elicitation, tasks (including in-execution input), subscriptions, pagination,
  119. response caching, auth negative paths, client failure semantics against
  120. misbehaving servers, and byte-level codec interchangeability
  121. (serde_json ↔ sonic-rs).
  122. - **Fuzzing + supply chain** — cargo-fuzz targets for every untrusted-input
  123. decoder (JSON-RPC codec, `Mcp-Param` header sentinel, URI templates, and a
  124. sonic-vs-serde differential), run out of band via `just fuzz`; `cargo-deny`
  125. (advisories/bans/licenses/sources) runs in CI on every push.
  126. - **wasm-portable foundation** — `turbomcp-core`/`-codec`/`-protocol` build
  127. `no_std` for `wasm32-unknown-unknown` on every gate run.
  128. ## Migrating from v3
  129. The macro surface is intentionally source-compatible for the common case; see
  130. [`crates/turbomcp/MIGRATION.md`](crates/turbomcp/MIGRATION.md) for the v3 → v4
  131. deltas.
  132. ## License
  133. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.