Struct UnifiedMcpServer 

pub struct UnifiedMcpServer { /* private fields */ }

A unified MCP server that aggregates multiple tools

The UnifiedMcpServer implements the ToolProtocol trait and routes tool execution requests to the appropriate underlying tool protocol implementation based on the tool name.

This allows a single server instance to expose multiple tools with different implementations, making it suitable for deployment as an MCP HTTP service that can be accessed by multiple agents.

Thread Safety

The server is thread-safe and can be shared across multiple concurrent tool executions using Arc<UnifiedMcpServer>.

Implementations

impl UnifiedMcpServer

pub fn new() -> Self

Create a new empty unified MCP server

pub async fn register_tool( &mut self, tool_name: &str, protocol: Arc<dyn ToolProtocol>, )

Register a tool with the server

Arguments

• tool_name - The identifier for the tool (e.g., “memory”, “bash”)
• protocol - The ToolProtocol implementation for this tool

Example

use cloudllm::mcp_server::UnifiedMcpServer;
use cloudllm::tools::Memory;
use cloudllm::tool_protocols::MemoryProtocol;
use std::sync::Arc;

let memory = Arc::new(Memory::new());
let memory_protocol = Arc::new(MemoryProtocol::new(memory));

let mut server = UnifiedMcpServer::new();
server.register_tool("memory", memory_protocol).await;

pub async fn unregister_tool(&mut self, tool_name: &str)

Unregister a tool from the server

pub async fn has_tool(&self, tool_name: &str) -> bool

Check if a tool is registered

pub async fn tool_count(&self) -> usize

Get the number of registered tools

Trait Implementations

impl Clone for UnifiedMcpServer

fn clone(&self) -> UnifiedMcpServer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for UnifiedMcpServer

fn default() -> Self

Returns the “default value” for a type.

impl ToolProtocol for UnifiedMcpServer

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, tool_name: &'life1 str, parameters: Value, ) -> Pin<Box<dyn Future<Output = Result<ToolResult, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a tool by routing to the appropriate protocol

Routing Logic

1. Look up the tool name in the registry
2. If found, delegate to that tool’s protocol
3. If not found, return NotFound error

fn list_tools<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ToolMetadata>, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List all available tools across all registered protocols

This aggregates tool metadata from all registered tool protocols. Each protocol is queried at most once even if multiple tool names are registered to the same protocol instance.

fn get_tool_metadata<'life0, 'life1, 'async_trait>( &'life0 self, tool_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ToolMetadata, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get metadata for a specific tool

This searches across all registered protocols to find the tool.

fn protocol_name(&self) -> &str

Protocol identifier

fn initialize<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Initialize the server (initializes all registered protocols)

fn shutdown<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Shutdown the server (shuts down all registered protocols)

fn list_resources<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ResourceMetadata>, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List available resources (MCP Resource support)

fn read_resource<'life0, 'life1, 'async_trait>( &'life0 self, uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read the content of a resource by URI (MCP Resource support)

fn supports_resources(&self) -> bool

Check if this protocol supports resources