Product Release
TurboMCP v1.0.5: Enterprise-Grade MCP with Elicitation & Sampling
Major release introducing elicitation protocol, LLM sampling, Axum integration, and comprehensive enterprise features for production deployments.
TurboMCP Team · · 15 min read
Release Overview
TurboMCP v1.0.5 represents a major milestone in our journey to provide the most comprehensive and performant MCP implementation available. This release introduces groundbreaking features that enable sophisticated AI interactions, enterprise-grade security, and production-ready infrastructure.
Key Highlights
- Elicitation Protocol: Server-initiated user input with rich form builders and type-safe responses
- Sampling Protocol: Bidirectional LLM communication for AI-powered assistance
- Axum Integration: Production web framework with advanced middleware and routing
- Enterprise Security: OAuth 2.0, CORS, rate limiting, security headers, and TLS 1.3
- Filesystem Roots: MCP-compliant boundaries with OS-aware defaults
Elicitation Protocol: Server-Initiated User Input
The elicitation protocol enables servers to request structured input from users during tool execution. This powerful feature allows for interactive workflows, configuration gathering, and dynamic decision-making.
World-Class Ergonomics
We’ve designed the elicitation API to be intuitive and type-safe, with builder patterns that make complex forms simple to create:
use turbomcp::prelude::*;
use turbomcp::elicitation_api::{elicit, text, checkbox, integer_field};
#[tool("Configure deployment")]
async fn deploy(&self, ctx: Context, project: String) -> McpResult<String> {
// Simple elicit macro for quick prompts
let confirmation = elicit!(ctx, "Deploy to production?")?;
// Advanced form with beautiful ergonomic builders
let config = elicit("Configure deployment")
.field("environment", text("Environment")
.options(&["dev", "staging", "production"]))
.field("auto_scale", checkbox("Enable Auto-scaling")
.default(true))
.field("replicas", integer_field("Replica Count")
.range(1.0, 10.0))
.require(vec!["environment"])
.send(&ctx.request)
.await?;
match config {
ElicitationResult::Accept(data) => {
let env = data.get::<String>("environment")?;
let replicas = data.get::<i64>("replicas").unwrap_or(1);
Ok(format!("Deployed {} to {} with {} replicas",
project, env, replicas))
}
_ => Err(mcp_error!("Deployment cancelled"))
}
}
Simple macro
- Quick yes/no prompts
- Minimal boilerplate
- Type-safe responses
- Automatic error handling
Advanced forms
- Multiple field types
- Validation & defaults
- Required fields
- Rich metadata
Sampling Protocol: Bidirectional LLM Communication
The sampling protocol enables servers to request LLM assistance from the client, creating powerful AI-enhanced workflows. This bidirectional communication allows tools to leverage AI capabilities for code generation, analysis, and intelligent assistance.
use turbomcp::prelude::*;
#[tool("Get AI code review")]
async fn code_review(&self, ctx: Context, code: String) -> McpResult<String> {
// Build sampling request with ergonomic JSON
let request = serde_json::json!({
"messages": [{
"role": "user",
"content": {
"type": "text",
"text": format!("Please review this code:\n\n{}", code)
}
}],
"maxTokens": 500,
"systemPrompt": "You are a senior code reviewer."
});
// Request LLM assistance through the client
match ctx.create_message(request).await {
Ok(response) => {
ctx.info("AI review completed successfully").await?;
Ok(format!("AI Review: {:?}", response))
}
Err(_) => {
// Graceful fallback if sampling unavailable
let issues = code.matches("TODO").count();
Ok(format!("Static analysis: {} issues found", issues))
}
}
}
Production features
- Multiple LLM provider support (OpenAI, Anthropic, local models)
- Graceful fallback for unavailable sampling
- Context-aware prompting with system messages
- Token limit management and streaming support
- Error recovery and timeout handling
Axum Integration: Production Web Framework
TurboMCP now provides first-class integration with Axum, Tokio’s production-ready web framework. This enables seamless integration of MCP servers into existing web applications with enterprise features.
use turbomcp_transport::{AxumMcpExt, McpServerConfig};
use axum::Router;
// Production security configuration
let config = McpServerConfig::production()
.with_cors_origins(vec!["https://app.example.com"])
.with_custom_csp("default-src 'self'; connect-src 'self' wss:")
.with_rate_limit(120, 20) // 120 requests/minute, 20 burst
.with_jwt_auth("your-secret-key");
let app = Router::new()
.route("/api/status", get(status_handler))
.merge(Router::<()>::turbo_mcp_routes_for_merge(
mcp_service,
config
));
- Middleware: Composable middleware stack with authentication, logging, and metrics
- Security: Built-in CORS, CSP headers, rate limiting, and JWT validation
- Performance: Circuit breakers, connection pooling, and graceful shutdown
Enterprise Security Features
Version 1.0.5 introduces comprehensive security features designed for production deployments in enterprise environments.
OAuth 2.0 Authentication
- Multiple providers (Google, GitHub, Microsoft)
- Always-on PKCE security
- All OAuth flows (Authorization Code, Client Credentials, Device Code)
- Session management with automatic cleanup
Security Headers & CORS
- Content Security Policy (CSP)
- HTTP Strict Transport Security (HSTS)
- X-Frame-Options and X-Content-Type-Options
- Environment-aware CORS policies
Rate Limiting & Protection
- Token bucket algorithm with burst capacity
- Per-endpoint and per-user limits
- DDoS protection
- TLS 1.3 with modern cipher suites
Filesystem Roots & Boundaries
TurboMCP now supports MCP-compliant filesystem roots, allowing servers to declare and enforce filesystem boundaries for secure operations:
#[server(
name = "filesystem-server",
version = "1.0.0",
root = "file:///workspace:Project Workspace",
root = "file:///tmp:Temporary Files",
root = "file:///Users/shared:Shared Documents"
)]
impl FileSystemServer {
#[tool("List files in directory")]
async fn list_files(&self, ctx: Context, path: String)
-> McpResult<Vec<String>> {
// File operations are bounded by configured roots
ctx.info(&format!("Listing files in: {}", path)).await?;
Ok(list_directory(&path)?)
}
}
OS-Aware Defaults
TurboMCP automatically configures platform-specific roots:
- Linux: Root filesystem (/)
- macOS: Root (/) and Volumes (/Volumes)
- Windows: All available drive letters
Developer Experience Improvements
We’ve made significant improvements to developer ergonomics based on community feedback.
Enhanced macros
elicit!for user inputctx_info!for loggingmcp_error!for errorsmcp_text!for responses
Context API
ctx.user_id()authenticationctx.roles()authorizationctx.create_message()samplingctx.info()structured logging
Performance Enhancements
Version 1.0.5 includes several performance optimizations.
Circuit breakers
- Automatic failure detection
- Exponential backoff retry
- Health monitoring
- Graceful degradation
Connection pooling
- Reusable connections
- Automatic cleanup
- Resource limits
- Memory efficiency
Migration Guide
Upgrading from v1.0.2 to v1.0.5 is straightforward:
# Update your Cargo.toml
[dependencies]
turbomcp = "1.0.5"
# Or with specific features
turbomcp = { version = "1.0.5", features = ["simd", "oauth"] }
Breaking Changes
- None! We’ve maintained full backward compatibility
- All new features are opt-in via feature flags or explicit usage
- Existing code will continue to work without modifications
What’s Next
We’re excited about the future of TurboMCP. Here’s what was planned at the time of this release:
- v1.1.0, Advanced Features: Streaming responses, batch operations, and advanced caching strategies
- v1.2.0, Observability: OpenTelemetry integration, distributed tracing, and comprehensive metrics
- v2.0.0, Ecosystem: Plugin system, marketplace integration, and cloud-native deployments
Get Started with TurboMCP v1.0.5
Experience the power of enterprise-grade MCP with elicitation, sampling, and production features. See the TurboMCP repository on GitHub and the documentation on docs.rs, or read more on the TurboMCP product page.
Related: Introducing TurboMCP.
- TurboMCP
- Rust
- MCP
- Elicitation
- Sampling
- Axum
- Enterprise
- Security