Building production-grade AI applications requires reliable infrastructure. The Model Context Protocol (MCP) has emerged as the standard for connecting AI assistants to external tools, APIs, and data sources. However, implementing MCP efficiently requires carefully balancing performance, developer experience, security, and deployment flexibility.
TurboMCP v2.2.2 is a production-ready Rust SDK that makes building enterprise-grade MCP servers straightforward. With zero-boilerplate development, automatic schema generation, 5 transport protocols, OAuth 2.1 security, and 29 working examples, TurboMCP eliminates infrastructure complexity so you can focus on building great AI experiences.
What is TurboMCP v2.2.2?
TurboMCP is a high-performance Rust SDK for the Model Context Protocol built on three core principles:
Zero-Boilerplate
Write MCP servers in minutes with automatic JSON schema generation from Rust function signatures. No manual schema construction, no argument parsing boilerplate.
5 Transports
Deploy anywhere: STDIO for local tools, HTTP/SSE for web, WebSocket for bidirectional streams, TCP for network services, Unix sockets for IPC.
Enterprise Security
OAuth 2.1 with multiple providers, RFC 9449 DPoP token binding, rate limiting, CORS protection, and comprehensive security headers.
Zero-Boilerplate Development
The biggest difference TurboMCP makes is eliminating boilerplate. Traditional MCP implementations require you to write JSON schemas manually, handle parameter validation, and manage message routing. TurboMCP automates all of this.
Procedural Macro System
TurboMCP provides ergonomic procedural macros for every MCP capability:
- @serverDefine server with name, version, and capabilities
- @toolCreate tools with automatic schema generation from function signatures
- @resourceDefine resources with URI template support (RFC 6570)
- @promptCreate dynamic prompt templates with parameter substitution
- @completionImplement intelligent autocompletion handlers
- @elicitationBuild interactive forms for user input with validation
Automatic Schema Generation
This 25-line example demonstrates the power of zero-boilerplate development:
use turbomcp::prelude::*;
#[derive(Clone)]
struct Calculator;
#[server(name = "calculator", version = "1.0.0")]
impl Calculator {
#[tool("Add two numbers")]
async fn add(&self, a: f64, b: f64) -> McpResult<f64> {
Ok(a + b)
}
#[tool("Multiply two numbers")]
async fn multiply(&self, a: f64, b: f64) -> McpResult<f64> {
Ok(a * b)
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
Calculator.run_stdio().await?;
Ok(())
}What TurboMCP Generates Automatically
- JSON-RPC 2.0 message handler
- JSON Schema for both tools with parameter types
- Parameter validation at compile time & runtime
- Type-safe handlers with automatic deserialization
- Error handling with detailed error messages
5 Transport Protocols for Every Use Case
Different scenarios require different transports. TurboMCP supports all major transport protocols out of the box:
📟 STDIO (Standard Input/Output)
Use case: Local process spawning, Claude Desktop, development, testing
The MCP standard for local tools. Your server runs as a child process and communicates via standard input/output. Zero network overhead, perfect for development and Claude Desktop integration.
server.run_stdio().await?;🌐 HTTP/SSE (Server-Sent Events)
Use case: Web applications, cloud services, browser integrations
HTTP-based with Server-Sent Events for server-to-client streaming. Ideal for web applications and cloud deployments. Includes built-in CORS protection and security headers.
🔌 WebSocket
Use case: Real-time bidirectional communication, live updates, streaming
Full-duplex WebSocket for low-latency, bidirectional streaming. Perfect for real-time applications where the server needs to send unsolicited messages to clients.
🖧 TCP (Raw Sockets)
Use case: Network services, microservices, internal APIs
Raw TCP socket communication for network services. Lower overhead than HTTP, perfect for internal microservice communication and high-throughput scenarios.
🔗 Unix Sockets
Use case: Inter-process communication, local services, single-machine deployments
Ultra-low-latency IPC on Unix systems. Perfect for local services that need to communicate with each other on the same machine without network overhead.
Enterprise Security Features
TurboMCP v2.2.2 includes comprehensive security features designed for production deployments:
OAuth 2.1 with Multi-Provider Support
Built-in OAuth 2.1 authentication with support for multiple providers:
Social Providers
- ✓ GitHub
- ✓ Apple Sign In
Enterprise Providers
- ✓ Microsoft
- ✓ Okta
- ✓ Keycloak
All providers support PKCE (Proof Key for Code Exchange) for enhanced security in mobile and SPA environments.
RFC 9449 DPoP Token Binding
Demonstration of Proof-of-Possession (DPoP) binds access tokens to the requesting client, preventing token theft and misuse. TurboMCP v2.2.2 provides a dedicated turbomcp-dpop crate with:
- ✓ECDSA P-256 signing (ES256) - faster and more secure than RSA
- ✓Nonce validation with configurable storage backends
- ✓HSM integration (PKCS#11, YubiHSM) for hardware key storage
- ✓Redis storage for distributed nonce tracking
use turbomcp::prelude::*;
use turbomcp_dpop::DpopKeyPair;
// Generate P-256 key pair for DPoP
let key_pair = DpopKeyPair::generate_p256()?;
// Create DPoP proof
let proof = key_pair.create_proof(
"POST",
"https://api.example.com/oauth/token"
)?;
// Include proof in OAuth request
// Server validates proof binds token to this client29 Production Examples
TurboMCP comes with 29 working examples covering every transport protocol and MCP feature:
Transport Examples (13)
- ✓ STDIO server & client
- ✓ HTTP/SSE server & client
- ✓ WebSocket server & client
- ✓ TCP server & client
- ✓ Unix socket server & client
- ✓ Transport selection demo
Protocol Features (10)
- ✓ Tools with full lifecycle
- ✓ Resources & prompts
- ✓ Elicitation forms
- ✓ Sampling server
- ✓ Structured output
- ✓ Rich descriptions
Complete Apps (6)
- ✓ Hello world
- ✓ Macro server
- ✓ STDIO app
- ✓ HTTP app
- ✓ Type-state demo
- ✓ Comprehensive
All examples are production-ready, fully documented, and demonstrate best practices for building MCP servers.
Getting Started (5 Minutes)
Add TurboMCP to your project:
[dependencies]
turbomcp = "2.2"
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }Copy an example and customize it:
# View all 29 examples
cd crates/turbomcp/examples
# Run hello world
cargo run --example hello_world
# Run HTTP server
cargo run --example http_serverProduction Deployment Patterns
TurboMCP v2.2.2 supports multiple deployment patterns:
Claude Desktop Integration (STDIO)
Configure in Claude Desktop settings for instant AI integration:
{
"mcpServers": {
"my-server": {
"command": "cargo",
"args": ["run", "--manifest-path", "/path/to/Cargo.toml"]
}
}
}Docker Container (HTTP)
Deploy as containerized HTTP service with OAuth 2.1 authentication and security headers.
Kubernetes (WebSocket)
Horizontal scaling with WebSocket for real-time bidirectional communication across replicas.
Why TurboMCP v2.2.2 Matters
Building AI applications with MCP should be straightforward. TurboMCP v2.2.2 removes infrastructure complexity by providing:
- Zero boilerplate - Write MCP servers in minutes, not days
- 5 transport protocols - Deploy anywhere: local, web, cloud, or internal services
- Enterprise security - OAuth 2.1, DPoP, rate limiting, and comprehensive headers by default
- 29 production examples - Copy, customize, deploy. No guessing required.
- Production-ready - Zero known vulnerabilities, comprehensive tests, and ongoing updates
Ready to Build?
Start building production-grade MCP servers today. TurboMCP v2.2.2 is production-ready and actively maintained.