Struct McpServer 

pub struct McpServer { /* private fields */ }

MCP Server implementation

The main server struct that handles MCP protocol communication, manages resources, tools, and prompts, and processes client requests.

Examples

Basic Server Creation

use prism_mcp_rs::server::McpServer;

let server = McpServer::new("my-server".to_string(), "1.0.0".to_string());

Using ServerBuilder

use prism_mcp_rs::server::ServerBuilder;

let server = ServerBuilder::new()
    .name("my-server")
    .version("1.0.0")
    .with_tools()
    .with_resources()
    .build();

Adding Tools

use prism_mcp_rs::server::McpServer;
use prism_mcp_rs::core::{Tool, ToolHandler};
use prism_mcp_rs::core::error::McpError;
use serde_json::{json, Value};
use async_trait::async_trait;
use std::collections::HashMap;

struct MyTool;

#[async_trait]
impl ToolHandler for MyTool {
    async fn call(&self, _args: HashMap<String, Value>)
        -> Result<prism_mcp_rs::protocol::ToolResult, McpError>
    {
        Ok(prism_mcp_rs::protocol::ToolResult {
            content: vec![],
            is_error: Some(false),
            structured_content: None,
            meta: None,
        })
    }
}

let mut server = McpServer::new("server".to_string(), "1.0.0".to_string());

// Add tool using the add_tool method directly
server.add_tool(
    "my_tool",
    Some("My custom tool"),
    json!({}),
    MyTool
).await?;

Main MCP server implementation

Implementations

impl McpServer

pub async fn process_message( &self, msg: JsonRpcMessage, ) -> McpResult<JsonRpcMessage>

Process any JSON-RPC message asynchronously

This method handles all types of JSON-RPC messages (requests, responses, notifications, errors) and returns an appropriate response.

Arguments

• msg - The JSON-RPC message to process

Returns

A result containing the response message or an error

Examples

let server = McpServer::new("server".to_string(), "1.0.0".to_string());
let request = JsonRpcRequest::new(
    json!(1),
    "ping".to_string(),
    None::<serde_json::Value>
)?;
let message = JsonRpcMessage::Request(request);
let response = server.process_message(message).await?;

pub async fn handle_notification( &self, notification: JsonRpcNotification, ) -> McpResult<()>

Handle a JSON-RPC notification asynchronously

Notifications are one-way messages that don’t expect a response.

Arguments

• notification - The notification to handle

Returns

A result indicating success or failure of handling the notification

pub async fn handle_requests_parallel( &self, requests: Vec<JsonRpcRequest>, ) -> Vec<McpResult<JsonRpcResponse>>

Handle multiple requests in parallel

This method processes multiple requests concurrently and returns all responses once they’re complete.

Arguments

• requests - A vector of JSON-RPC requests to process

Returns

A vector of results, one for each request

Examples

let server = McpServer::new("server".to_string(), "1.0.0".to_string());
let requests = vec![
    JsonRpcRequest::new(json!(1), "ping".to_string(), None::<serde_json::Value>)?,
    JsonRpcRequest::new(json!(2), "tools/list".to_string(), None::<serde_json::Value>)?,
];
let responses = server.handle_requests_parallel(requests).await;

pub async fn handle_request_with_processor<F, Fut>( &self, request: JsonRpcRequest, processor: F, ) -> McpResult<JsonRpcResponse>

where F: FnOnce(JsonRpcRequest) -> Fut, Fut: Future<Output = McpResult<JsonRpcRequest>>,

Handle requests with a custom async processor

This method allows you to provide a custom processor function that can modify or filter requests before they’re handled.

Arguments

• request - The request to process
• processor - An async function that processes the request

Returns

The processed response

pub async fn run_with_processor<F, Fut>(&self, _processor: F) -> McpResult<()>

where F: FnMut(JsonRpcMessage) -> Fut + Send + 'static, Fut: Future<Output = McpResult<JsonRpcMessage>> + Send,

Run the server with a custom message processor

This method allows you to run the server with a custom async message processor that can handle incoming messages with custom logic.

Arguments

• processor - An async function that processes messages

Returns

A result indicating success or failure

pub async fn handle_batch(&self, batch: Vec<Value>) -> McpResult<Vec<Value>>

Handle a batch of JSON-RPC requests

This method processes a batch of requests according to the JSON-RPC batch specification.

Arguments

• batch - A JSON array of requests

Returns

A JSON array of responses

pub async fn handle_request_streaming<F>( &self, request: JsonRpcRequest, progress_callback: F, ) -> McpResult<JsonRpcResponse>

where F: FnMut(f32, String) + Send,

Stream responses for long-running operations

This method provides a way to stream responses for operations that may take a long time to complete.

Arguments

• request - The request to process
• progress_callback - A callback function for progress updates

Returns

The final response

pub async fn handle_request_with_timeout( &self, request: JsonRpcRequest, timeout_ms: u64, ) -> McpResult<JsonRpcResponse>

Handle a request with timeout

This method processes a request with a specified timeout.

Arguments

• request - The request to process
• timeout - The timeout duration in milliseconds

Returns

The response or a timeout error

pub async fn handle_request_with_retry( &self, request: JsonRpcRequest, max_retries: u32, retry_delay_ms: u64, ) -> McpResult<JsonRpcResponse>

Handle a request with retry logic

This method attempts to process a request with automatic retry on failure.

Arguments

• request - The request to process
• max_retries - Maximum number of retry attempts
• retry_delay_ms - Delay between retries in milliseconds

Returns

The response or the last error after all retries

pub async fn process_with_middleware<M>( &self, message: JsonRpcMessage, middleware: Vec<M>, ) -> McpResult<JsonRpcMessage>

where M: Fn(JsonRpcMessage) -> Pin<Box<dyn Future<Output = McpResult<JsonRpcMessage>> + Send>> + Send + Sync,

Process a message with middleware chain

This method allows you to process messages through a chain of middleware functions.

Arguments

• message - The message to process
• middleware - A vector of middleware functions

Returns

The processed message

impl McpServer

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

Create a new MCP server with the given name and version

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

Create a new MCP server with ergonomic string parameters

pub fn with_config(name: String, version: String, config: ServerConfig) -> Self

Create a new MCP server with custom configuration

pub fn with_plugin_manager(self, manager: PluginManager) -> Self

Attach a plugin manager to the server

pub async fn sync_plugin_tools(&self) -> McpResult<()>

Internal method to sync plugin tools with server

pub fn set_capabilities(&mut self, capabilities: ServerCapabilities)

Set server capabilities

pub fn set_protocol_mode(&mut self, mode: ProtocolMode)

Select dual-stack, modern-only, or legacy-only server behavior.

pub fn protocol_mode(&self) -> ProtocolMode

Return the configured protocol support policy.

pub fn set_config(&mut self, config: ServerConfig)

Set server configuration

pub fn set_request_policy(&mut self, policy: RequestPolicy)

Install authorization and rate-limiting controls for all requests.

pub fn with_request_policy(self, policy: RequestPolicy) -> Self

Install authorization and rate-limiting controls using a builder style.

pub fn set_initial_resources(&mut self, resources: HashMap<String, Resource>)

Set initial resources (used by ServerBuilder)

pub fn set_initial_tools(&mut self, tools: HashMap<String, Tool>)

Set initial tools (used by ServerBuilder)

pub fn set_initial_prompts(&mut self, prompts: HashMap<String, Prompt>)

Set initial prompts (used by ServerBuilder)

pub fn set_initial_resource_templates( &mut self, templates: HashMap<String, ResourceTemplate>, )

Set initial resource templates (used by ServerBuilder)

pub fn builder() -> ServerBuilder

Create a builder for constructing servers

pub fn with_capabilities(self, capabilities: ServerCapabilities) -> Self

Configure this server with capabilities using a fluent API

pub fn with_server_config(self, config: ServerConfig) -> Self

Configure this server with a specific configuration (fluent API)

pub async fn add_tool<H>( &self, name: impl Into<String>, description: Option<impl Into<String>>, input_schema: Value, handler: H, ) -> McpResult<()>

where H: ToolHandler + 'static,

Add a tool to the server with a ToolHandler implementation

Examples

// With a ToolHandler implementation
server.add_tool("my_tool", Some("description"), json!({}), MyToolHandler).await?;

pub async fn add_multi_round_tool<H>( &self, name: impl Into<String>, description: Option<impl Into<String>>, input_schema: Value, handler: H, ) -> McpResult<()>

where H: MultiRoundToolHandler + 'static,

Add a tool that may return MCP 2026 input_required results.

pub async fn add_multi_round_tool_detailed<H>( &self, info: ToolInfo, handler: H, ) -> McpResult<()>

where H: MultiRoundToolHandler + 'static,

Add a continuation-aware tool with a fully specified tool definition.

pub async fn add_tool_with_closure<F>( &self, name: impl Into<String>, description: Option<impl Into<String>>, input_schema: Value, handler: F, ) -> McpResult<()>

where F: Fn(&HashMap<String, Value>) -> McpResult<Vec<ContentBlock>> + Send + Sync + 'static,

Add a tool using a closure

Examples

server.add_tool_with_closure("echo", Some("Echo tool"), json!({}), |args| {
    Ok(vec![ContentBlock::text("Echo!")])
}).await?;

pub async fn add_tool_built(&self, tool: Tool) -> McpResult<()>

Add a tool using the ToolBuilder result

pub async fn add_task_tool<H>( &self, info: ToolInfo, handler: H, ) -> McpResult<()>

where H: TaskToolHandler + 'static,

Register a tool whose execution is represented by a durable SEP-2663 task.

pub async fn add_task_tool_with_fallback<H, F>( &self, info: ToolInfo, handler: H, fallback: F, ) -> McpResult<()>

where H: TaskToolHandler + 'static, F: ToolHandler + 'static,

Register a durable task tool plus the synchronous behavior used when a client has not negotiated io.modelcontextprotocol/tasks.

pub async fn add_composed_task_tool<P, H>( &self, info: ToolInfo, preflight: P, handler: H, ) -> McpResult<()>

where P: MultiRoundToolHandler + 'static, H: ComposedTaskToolHandler + 'static,

Register a required-task tool that gathers request-scoped input through MCP multi-round results before creating its durable task.

The preflight handler returns InputRequired for intermediate rounds and Complete when the durable phase may begin. Its completed value is only a readiness signal; the composed handler produces the task result and receives the entire final MultiRoundToolCall.

pub fn info(&self) -> &ServerInfo

Get server information

pub fn name(&self) -> &str

Get server name (for compatibility with tests)

pub fn version(&self) -> &str

Get server version (for compatibility with tests)

pub fn capabilities(&self) -> &ServerCapabilities

Get server capabilities

pub fn config(&self) -> &ServerConfig

Get server configuration

pub async fn add_resource<H>( &self, name: String, uri: String, handler: H, ) -> McpResult<()>

where H: ResourceHandler + 'static,

Add a resource to the server

pub async fn add_resource_detailed<H>( &self, info: ResourceInfo, handler: H, ) -> McpResult<()>

where H: ResourceHandler + 'static,

Add a resource with detailed information

pub async fn remove_resource(&self, uri: &str) -> McpResult<bool>

Remove a resource from the server

pub async fn list_resources(&self) -> McpResult<Vec<ResourceInfo>>

List all registered resources

pub async fn read_resource(&self, uri: &str) -> McpResult<Vec<ResourceContents>>

Read a resource

pub async fn add_tool_detailed<H>( &self, info: ToolInfo, handler: H, ) -> McpResult<()>

where H: ToolHandler + 'static,

Add a tool with detailed information

pub async fn remove_tool(&self, name: &str) -> McpResult<bool>

Remove a tool from the server

pub async fn list_tools(&self) -> McpResult<Vec<ToolInfo>>

List all registered tools

pub async fn call_tool( &self, name: &str, arguments: Option<HashMap<String, Value>>, ) -> McpResult<ToolResult>

Call a tool

pub async fn add_prompt<H>(&self, info: PromptInfo, handler: H) -> McpResult<()>

where H: PromptHandler + 'static,

Add a prompt to the server

pub async fn remove_prompt(&self, name: &str) -> McpResult<bool>

Remove a prompt from the server

pub async fn list_prompts(&self) -> McpResult<Vec<PromptInfo>>

List all registered prompts

pub async fn get_prompt( &self, name: &str, arguments: Option<HashMap<String, Value>>, ) -> McpResult<PromptResult>

Get a prompt

pub async fn add_resource_template( &self, template: ResourceTemplate, ) -> McpResult<()>

Add a resource template to the server

pub async fn list_resource_templates(&self) -> McpResult<Vec<ResourceTemplate>>

List resource templates

pub async fn remove_resource_template(&self, name: &str) -> McpResult<bool>

Remove a resource template

pub async fn add_completion_handler<H>( &self, ref_type: String, handler: H, ) -> McpResult<()>

where H: CompletionHandler + 'static,

Add completion handler for a specific reference type

pub async fn remove_completion_handler(&self, ref_type: &str) -> McpResult<bool>

Remove completion handler for a reference type

pub async fn handle_completion( &self, reference: &CompletionReference, argument: &CompletionArgument, context: Option<&CompletionContext>, ) -> McpResult<Vec<String>>

Handle completion request

pub async fn send_client_request( &self, _request: JsonRpcRequest, ) -> McpResult<JsonRpcResponse>

Send a request to the client (server-initiated)

pub async fn request_sampling( &self, params: CreateMessageParams, ) -> McpResult<CreateMessageResult>

Request LLM sampling from client

pub async fn request_roots(&self) -> McpResult<ListRootsResult>

Request root directories from client

pub async fn request_elicitation( &self, params: ElicitParams, ) -> McpResult<ElicitResult>

Request user input via elicitation

pub async fn request_list_roots(&self) -> McpResult<ListRootsResult>

Request list of roots from the client

Method allows the server to request access to specific directories or files on the client’s file system.

pub async fn notify_roots_list_changed(&self) -> McpResult<()>

Send a notification that the roots list has changed

This notification informs the client that the list of roots the server needs access to has changed.

pub async fn notify_tools_list_changed(&self) -> McpResult<()>

Notify active MCP 2026 subscriptions that the tool catalog changed.

pub async fn notify_prompts_list_changed(&self) -> McpResult<()>

Notify active MCP 2026 subscriptions that the prompt catalog changed.

pub async fn notify_resources_list_changed(&self) -> McpResult<()>

Notify active MCP 2026 subscriptions that the resource catalog changed.

pub async fn start<T>(&mut self, transport: T) -> McpResult<()>

where T: ServerTransport + 'static,

Start the server with the given transport

pub async fn stop(&self) -> McpResult<()>

Stop the server

pub async fn is_running(&self) -> bool

Check if the server is running

pub async fn state(&self) -> ServerState

Get the current server state

pub async fn run_with_transport<T>(self, transport: T) -> McpResult<()>

where T: ServerTransport + 'static,

Start server with custom transport and run until interrupted

This is a convenience method that:

1. Starts the server with the provided transport
2. Waits for Ctrl+C signal
3. smoothly shuts down the server

Arguments

• transport - The transport to use for communication

Example

use prism_mcp_rs::prelude::*;

#[cfg(feature = "stdio")]
use prism_mcp_rs::transport::stdio::StdioServerTransport;

#[tokio::main]
async fn main() -> McpResult<()> {
    let mut server = McpServer::new("my-server".to_string(), "1.0.0".to_string());
    // . add tools, resources, prompts ...

    #[cfg(feature = "stdio")]
    {
        let transport = StdioServerTransport::new();
        server.run_with_transport(transport).await?;
    }
     
    Ok(())
}

pub async fn handle_request( &self, request: JsonRpcRequest, ) -> McpResult<JsonRpcResponse>

Handle an incoming JSON-RPC request

pub async fn handle_request_with_context( &self, request: JsonRpcRequest, context: RequestContext, ) -> McpResult<JsonRpcResponse>

Handle a request with transport-supplied identity and correlation data.

Custom transports and authentication middleware should call this method after validating credentials and constructing a RequestContext.

pub async fn is_initialized(&self) -> bool

Check if the server has been initialized

pub async fn is_stopped(&self) -> bool

Check if the server is stopping or stopped

pub async fn get_state(&self) -> ServerState

Get the current server state (alias for existing state method)

pub async fn has_tools(&self) -> bool

Check if the server has any registered tools

pub async fn has_resources(&self) -> bool

Check if the server has any registered resources

pub async fn has_prompts(&self) -> bool

Check if the server has any registered prompts

pub async fn tool_count(&self) -> usize

Get the number of registered tools

pub async fn resource_count(&self) -> usize

Get the number of registered resources

pub async fn prompt_count(&self) -> usize

Get the number of registered prompts

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

Check if a specific tool is registered

pub async fn has_resource(&self, uri: &str) -> bool

Check if a specific resource is registered

pub async fn has_prompt(&self, name: &str) -> bool

Check if a specific prompt is registered

pub async fn initialize(&self) -> McpResult<()>

Initialize the server (sets state to Running)