Struct Server 

pub struct Server { /* private fields */ }

Main MCP server

Implementations

impl Server

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

Create new server

pub fn name(&self) -> &str

Get server name

pub fn version(&self) -> &str

Get server version

pub fn capabilities(&self) -> Arc<ServerCapabilities>

Get current capabilities

pub fn set_capabilities(&self, capabilities: ServerCapabilities)

Update server capabilities

pub fn instructions(&self) -> Option<String>

Get current instructions

pub fn set_instructions(&self, instructions: Option<String>)

Set server instructions for LLMs

pub fn add_middleware(&mut self, middleware: MiddlewareFn)

Add middleware to the chain

pub fn tool_registry(&self) -> &ToolRegistry

Get tool registry

pub fn resource_manager(&self) -> &ResourceManager

Get resource manager

pub fn prompt_manager(&self) -> &PromptManager

Get prompt manager

pub fn logger(&self) -> &McpLogger

Get global logger

pub fn notification_sender(&self) -> UnboundedSender<JsonRpcNotification>

Get notification sender (for background tasks)

pub fn send_notification( &self, method: impl Into<String>, params: Option<Value>, ) -> Result<(), Box<dyn Error>>

Send a notification to the client

pub fn get_session(&self, session_id: &str) -> Option<Session>

Get session by ID

pub fn remove_session(&self, session_id: &str) -> Option<Session>

Remove session

pub fn multiplexer(&self) -> Arc<RequestMultiplexer>

Get the request multiplexer (for advanced use cases)

pub fn create_client_requester( &self, session_id: &str, ) -> Option<ClientRequester>

Create a client requester for the given session

The client requester allows tools to make server→client requests like roots/list and sampling/createMessage.

pub async fn request_roots( &self, session_id: &str, timeout: Option<Duration>, ) -> Result<Vec<Root>, MultiplexerError>

Request workspace roots from the client

Sends a roots/list request to the client and waits for the response. The client must have the roots capability advertised.

Arguments

• session_id - The session to check for roots capability
• timeout - Optional timeout (defaults to 30 seconds)

Returns

List of workspace roots, or an error if:

• Client doesn’t support roots capability
• Request times out
• Client returns an error

Example

let roots = server.request_roots("session-123", None).await?;
for root in roots {
    println!("Root: {} ({})", root.name.unwrap_or_default(), root.uri);
}

pub async fn request_sampling( &self, session_id: &str, params: CreateMessageParams, timeout: Option<Duration>, ) -> Result<CreateMessageResult, MultiplexerError>

Request an LLM completion from the client

Sends a sampling/createMessage request to the client. The client must have the sampling capability advertised.

Arguments

• session_id - The session to check for sampling capability
• params - The sampling parameters
• timeout - Optional timeout (defaults to 30 seconds)

Returns

The completion result, or an error if:

• Client doesn’t support sampling capability
• Request times out
• Client returns an error

Example

use mcp_host::server::multiplexer::{CreateMessageParams, SamplingContent, SamplingMessage};

let params = CreateMessageParams {
    messages: vec![SamplingMessage {
        role: "user".to_string(),
        content: SamplingContent::Text { text: "Hello!".to_string() },
    }],
    max_tokens: 1000,
    ..Default::default()
};

let result = server.request_sampling("session-123", params, None).await?;
println!("Response: {:?}", result.content);

pub async fn run<T: Transport>( &self, transport: T, ) -> Result<(), Box<dyn Error>>

Run server with the given transport

This is the main event loop that reads requests from the transport, processes them, and writes responses back.

Supports bidirectional communication:

• Incoming client requests are handled and responses sent
• Server-initiated requests are sent via channels and responses routed back

pub async fn handle_request( &self, session_id: &str, request: JsonRpcRequest, ) -> JsonRpcResponse

Handle incoming JSON-RPC request