Introducing TurboMCP: Fast Rust SDK for Model Context Protocol

// TurboMCP automatically uses SIMD acceleration under the hood
use turbomcp::prelude::*;
use std::sync::atomic::AtomicU64;

#[derive(Clone)]
struct HighThroughputServer {
    request_count: std::sync::Arc<AtomicU64>,
}

#[server]
impl HighThroughputServer {
    #[tool("Process data with SIMD acceleration")]
    async fn process_data(&self, data: Vec<f64>) -> McpResult<f64> {
        self.request_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        // Your business logic here - JSON processing is automatically optimized
        Ok(data.iter().sum::<f64>() / data.len() as f64)
    }
}

use turbomcp::prelude::*;
use std::sync::{atomic::AtomicU64, Arc};

#[derive(Clone)]
struct Calculator {
    operations: Arc<AtomicU64>,
}

#[server]
impl Calculator {
    #[tool("Add two numbers")]
    async fn add(&self, a: i32, b: i32) -> McpResult<i32> {
        self.operations
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        Ok(a + b)
    }

    #[tool("Get server statistics")]  
    async fn stats(&self) -> McpResult<String> {
        let ops = self.operations.load(std::sync::atomic::Ordering::Relaxed);
        Ok(format!("Operations performed: {}", ops))
    }

    #[resource("calc://history")]
    async fn history_resource(&self, _uri: String) -> McpResult<String> {
        Ok("No calculations yet".to_string())
    }
}

// High-level ergonomic usage
use turbomcp::prelude::*;
// Uses all the crates together for maximum productivity

// Selective usage for specific needs
use turbomcp_core::{Message, Context};
use turbomcp_transport::stdio::StdioTransport;
// Use only the components you need

// Custom transport implementations
use turbomcp_core::{Message, Handler};
use turbomcp_protocol::JsonRpcMessage;
// Build custom transport layers while reusing core infrastructure

use turbomcp::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = FileServer::new();
    
    // Runtime transport selection
    match std::env::var("TRANSPORT").as_deref() {
        Ok("tcp") => {
            let port: u16 = std::env::var("PORT")
                .unwrap_or_else(|_| "8080".to_string())
                .parse()
                .unwrap_or(8080);
            server.run_tcp(format!("127.0.0.1:{}", port)).await?
        }
        Ok("unix") => {
            let path = std::env::var("SOCKET_PATH")
                .unwrap_or_else(|_| "/tmp/mcp.sock".to_string());
            server.run_unix(path).await?
        }
        _ => server.run_stdio().await?  // Default fallback
    }
    Ok(())
}

# Feature Selection Examples

# Full experience (default)
turbomcp = "1.0"  # All features: schema-generation, context-injection, uri-templates, database, SIMD

# Deployment-optimized builds
turbomcp = { version = "1.0", default-features = false, features = ["minimal"] }     # STDIO only
turbomcp = { version = "1.0", default-features = false, features = ["network"] }     # STDIO + TCP
turbomcp = { version = "1.0", default-features = false, features = ["server-only"] }  # TCP + Unix

# Feature-specific builds
turbomcp = { version = "1.0", features = ["simd", "schema-generation"] }  # Performance + schemas
turbomcp = { version = "1.0", features = ["database", "uri-templates"] }   # DB + URI matching

# Complete feature reference: https://github.com/Epistates/turbomcp