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 set_environment(&mut self, environment: Arc<dyn Environment>)

Set environment for visibility checks

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 subscription_manager(&self) -> &SubscriptionManager

Get subscription manager for resource subscriptions

pub fn completion_manager(&self) -> &CompletionManager

Get completion manager for argument value suggestions

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

Also cleans up any resource subscriptions for the session.

pub fn notify_resource_updated(&self, uri: &str)

Notify subscribers that a resource has been updated

Sends notifications/resources/updated to all sessions subscribed to the URI. Call this when a resource’s content changes.

Example

// After updating a file resource
server.notify_resource_updated("file:///path/to/file.txt");

pub fn notify_resources_updated(&self, uris: &[&str])

Notify subscribers for multiple resources (batch operation)

Convenience method for notifying about multiple resource updates at once.

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

Get the request multiplexer (for advanced use cases)

pub fn cancellation_manager(&self) -> &CancellationManager

Get the cancellation manager

Use this to register cancellable operations and check cancellation status.

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, sampling/createMessage, and elicitation/create.

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 request_elicitation( &self, session_id: &str, message: impl Into<String>, requested_schema: Value, timeout: Option<Duration>, ) -> Result<CreateElicitationResult, MultiplexerError>

Request structured user input from the client

Sends an elicitation/create request to the client. The client must have the elicitation capability advertised.

Arguments

• session_id - The session to check for elicitation capability
• message - The message to show the user
• requested_schema - JSON Schema for the structured input
• timeout - Optional timeout (defaults to 30 seconds)

Returns

The elicitation result (action + optional content), or an error if:

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

Example

use mcp_host::protocol::elicitation::ElicitationSchema;
use mcp_host::protocol::types::ElicitationAction;

let schema = ElicitationSchema::builder()
    .required_email("email")
    .required_integer("age", 0, 150)
    .optional_bool("newsletter", false)
    .build_unchecked();

let result = server.request_elicitation(
    "session-123",
    "Please provide your information",
    serde_json::to_value(&schema).unwrap(),
    None,
).await?;

match result.action {
    ElicitationAction::Accept => {
        if let Some(content) = result.content {
            let email = content["email"].as_str().unwrap();
            let age = content["age"].as_i64().unwrap();
            println!("User: {} (age {})", email, age);
        }
    }
    ElicitationAction::Decline => println!("User declined"),
    ElicitationAction::Cancel => println!("User cancelled"),
}

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