Struct McpServer 

pub struct McpServer { /* private fields */ }

Main MCP server following the Axum/Tower Clone pattern

Sharing Pattern

McpServer implements Clone like Axum’s Router. All heavy state is Arc-wrapped internally, making cloning cheap (just atomic reference count increments).

use turbomcp_server::ServerBuilder;

let server = ServerBuilder::new().build();

// Clone for passing to functions (cheap - just Arc increments)
let server1 = server.clone();
let server2 = server.clone();

// Access config and health
let config = server1.config();
println!("Server: {}", config.name);

let health = server2.health().await;
println!("Health: {:?}", health);

Architecture Notes

The service field contains BoxCloneService which is Send + Clone but NOT Sync. This is intentional and follows Tower’s design - users clone the server instead of Arc-wrapping it.

Architecture Note: The service field provides tower::Service integration for advanced middleware patterns. The request processing pipeline currently uses the RequestRouter directly. Tower integration can be added via custom middleware layers when needed for specific use cases (e.g., custom rate limiting, advanced tracing).

Implementations

impl McpServer

pub fn new(config: ServerConfig) -> Self

Create a new server

pub const fn config(&self) -> &ServerConfig

Get server configuration

pub const fn registry(&self) -> &Arc<HandlerRegistry>

Get handler registry

pub const fn router(&self) -> &Arc<RequestRouter>

Get request router

pub const fn lifecycle(&self) -> &Arc<ServerLifecycle>

Get server lifecycle

pub const fn metrics(&self) -> &Arc<ServerMetrics>

Get server metrics

pub fn shutdown_handle(&self) -> ShutdownHandle

Get a shutdown handle for graceful server termination

This handle enables external control over server shutdown, essential for:

• Production deployments: Graceful shutdown on SIGTERM/SIGINT
• Container orchestration: Kubernetes graceful pod termination
• Load balancer integration: Health check coordination
• Multi-component systems: Coordinated shutdown sequences
• Maintenance operations: Planned downtime and updates

Examples

Basic shutdown coordination

let server = ServerBuilder::new().build();
let shutdown_handle = server.shutdown_handle();

// Coordinate with other services
tokio::spawn(async move {
    // Wait for external shutdown signal
    tokio::signal::ctrl_c().await.expect("Failed to install Ctrl+C handler");
    println!("Shutdown signal received, terminating gracefully...");
    shutdown_handle.shutdown().await;
});

// Server will gracefully shut down when signaled
// server.run_stdio().await?;

Container/Kubernetes deployment

let server = ServerBuilder::new().build();
let shutdown_handle = server.shutdown_handle();
let shutdown_handle_clone = shutdown_handle.clone();

// Handle multiple signal types with proper platform support
tokio::spawn(async move {
    #[cfg(unix)]
    {
        use tokio::signal::unix::{signal, SignalKind};
        let mut sigterm = signal(SignalKind::terminate()).unwrap();
        tokio::select! {
            _ = tokio::signal::ctrl_c() => {
                println!("SIGINT received");
            }
            _ = sigterm.recv() => {
                println!("SIGTERM received");
            }
        }
    }
    #[cfg(not(unix))]
    {
        tokio::signal::ctrl_c().await.expect("Failed to install Ctrl+C handler");
        println!("SIGINT received");
    }
    shutdown_handle_clone.shutdown().await;
});

// Server handles graceful shutdown automatically
// server.run_tcp("0.0.0.0:8080").await?;

pub async fn run_stdio(self) -> ServerResult<()>

Run the server with STDIO transport

Errors

Returns crate::ServerError::Transport if:

• STDIO transport connection fails
• Message sending/receiving fails
• Transport disconnection fails

pub async fn health(&self) -> HealthStatus

Get health status

Trait Implementations

impl Clone for McpServer

fn clone(&self) -> McpServer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for McpServer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.