Struct McpServerHub 

pub struct McpServerHub { /* private fields */ }

A hub that aggregates multiple MCP servers into a single MCP server.

This allows you to:

• Connect to multiple external MCP servers
• Expose all their tools through a single unified server
• Wrap the hub with McpStdioServer or McpHttpServer
• Automatically restart servers on failure
• Parallel tool discovery for performance

Tools from connected servers are automatically discovered and made available through the hub’s server interface.

Implementations

impl McpServerHub

pub fn new(name: impl Into<String>) -> Self

Create a new hub with the given name.

pub fn with_timeout(name: impl Into<String>, timeout: Duration) -> Self

Create a hub with a custom timeout.

pub async fn connect( self: &Arc<Self>, config: McpServerConnectionConfig, ) -> Result<(), McpTransportError>

Connect to an external MCP server.

This method:

1. Creates the appropriate transport based on config
2. Initializes the connection
3. Discovers tools and creates proxy tools for them
4. Starts a restart monitor if restart policy is enabled

pub fn trigger_restart(&self, server_name: &str)

Trigger an immediate restart for a specific server.

pub async fn call_tool( &self, name: &str, args: Value, ) -> Result<Value, McpTransportError>

Call a tool by name, routing to the correct server.

If the server restarts while a request is pending, the request will immediately fail with a ServerRestarting error rather than timing out. Uses circuit breaker to prevent cascading failures.

pub async fn list_tools( &self, ) -> Result<Vec<(String, McpToolDefinition)>, McpTransportError>

List all tools from all connected servers.

pub async fn list_all_tools( &self, ) -> Result<Vec<McpToolDefinition>, McpTransportError>

List all tool definitions.

pub async fn discover_tools_parallel( &self, ) -> Result<Vec<(String, McpToolDefinition)>, McpTransportError>

Discover tools from all servers in parallel.

pub async fn refresh_tools(&self) -> Result<(), McpTransportError>

Refresh tool cache by re-querying all servers (parallel).

pub fn list_servers(&self) -> Vec<String>

Get list of connected server names.

pub fn is_connected(&self, server_name: &str) -> bool

Check if a server is connected.

pub async fn is_alive(&self, server_name: &str) -> bool

Check if a server is connected and alive.

pub async fn health_check(&self) -> Vec<(String, bool)>

Get health status of all servers.

pub fn server_for_tool(&self, tool_name: &str) -> Option<String>

Get the server name that provides a specific tool.

pub async fn disconnect( &self, server_name: &str, ) -> Result<(), McpTransportError>

Disconnect a specific server (stops restart monitor).

pub async fn shutdown_all(&self) -> Result<(), McpTransportError>

Shutdown all connected servers.

pub fn into_config(self, version: &str) -> McpServerConfig

Convert this hub into an McpServerConfig that can be used with McpStdioServer or McpHttpServer.

This creates proxy tools that route calls to the connected external servers.

pub fn to_config(self: &Arc<Self>, version: &str) -> McpServerConfig

Create an McpServerConfig from this hub (keeps hub accessible).

Use this when you need to keep a reference to the hub for direct access.

pub fn proxy_tools(self: &Arc<Self>) -> Vec<DynTool>

Get proxy tools for all connected servers.

Use this when you want to combine hub tools with local tools:

let config = McpServerConfig::builder()
    .name("my-server")
    .version("1.0.0")
    .register_tools_in_group("local")  // Local tools
    .with_tools(hub.proxy_tools())     // Proxied tools
    .build();

pub fn circuit_breaker_stats( &self, server_name: &str, ) -> Option<CircuitBreakerStats>

Get circuit breaker statistics for a server.

pub fn reset_circuit_breaker(&self, server_name: &str)

Reset circuit breaker for a server.