Struct Server 

pub struct Server { /* private fields */ }

An MCP server instance.

Servers are built using ServerBuilder and can run on various transports (stdio, SSE, WebSocket).

Implementations

impl Server

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

Creates a new server builder.

pub fn info(&self) -> &ServerInfo

Returns the server info.

pub fn capabilities(&self) -> &ServerCapabilities

Returns the server capabilities.

pub fn tools(&self) -> Vec<Tool>

Lists all registered tools.

pub fn resources(&self) -> Vec<Resource>

Lists all registered resources.

pub fn resource_templates(&self) -> Vec<ResourceTemplate>

Lists all registered resource templates.

pub fn prompts(&self) -> Vec<Prompt>

Lists all registered prompts.

pub fn task_manager(&self) -> Option<&SharedTaskManager>

Returns the task manager, if configured.

Returns None if background tasks are not enabled.

pub fn into_router(self) -> Router

Consumes the server and returns its router.

This is used for mounting one server’s components into another.

pub fn has_tools(&self) -> bool

Returns the capabilities this server provides.

This is useful when determining what components a server has before mounting.

pub fn has_resources(&self) -> bool

Returns whether this server has resources.

pub fn has_prompts(&self) -> bool

Returns whether this server has prompts.

pub fn stats(&self) -> Option<StatsSnapshot>

Returns a point-in-time snapshot of server statistics.

Returns None if statistics collection is disabled.

pub fn stats_collector(&self) -> Option<&ServerStats>

Returns the raw statistics collector.

Useful for advanced scenarios where you need direct access. Returns None if statistics collection is disabled.

pub fn display_stats(&self)

Renders a stats panel to stderr, if stats are enabled.

pub fn console_config(&self) -> &ConsoleConfig

Returns the console configuration.

pub fn run_stdio(self) -> !

Runs the server on stdio transport.

This is the primary way to run MCP servers as subprocesses. Creates a request-scoped Cx and runs the server loop.

pub fn run_stdio_with_cx(self, cx: &Cx) -> !

Runs the server on stdio with a provided Cx.

This allows integration with a real asupersync runtime.

pub fn run_transport<T>(self, transport: T) -> !

where T: Transport + Send + 'static,

Runs the server on a custom transport with a request-scoped Cx.

This is useful for SSE/WebSocket integrations where the transport is provided by an external server framework.

pub fn run_transport_with_cx<T>(self, cx: &Cx, transport: T) -> !

where T: Transport + Send + 'static,

Runs the server on a custom transport with a provided Cx.

This allows integration with a real asupersync runtime.

pub fn run_transport_returning_with_cx<T>(self, cx: &Cx, transport: T)

where T: Transport + Send + 'static,

Runs the server on a custom transport and returns when the transport closes or the Cx is cancelled.

Unlike run_transport_with_cx, this does not call std::process::exit on shutdown. This is useful for tests and embedding where you need the server loop to be joinable.

pub fn run_transport_returning<T>(self, transport: T)

where T: Transport + Send + 'static,

Runs the server on a custom transport and returns when the transport closes.

This uses a request-scoped Cx, but unlike run_transport it does not exit the process.

pub fn run_sse<W, R>( self, writer: W, request_source: R, endpoint_url: impl Into<String>, ) -> !

where W: Write + Send + 'static, R: Iterator<Item = JsonRpcRequest> + Send + 'static,

Runs the server using SSE transport with a testing Cx.

This is a convenience wrapper around SseServerTransport.

pub fn run_sse_with_cx<W, R>( self, cx: &Cx, writer: W, request_source: R, endpoint_url: impl Into<String>, ) -> !

where W: Write + Send + 'static, R: Iterator<Item = JsonRpcRequest> + Send + 'static,

Runs the server using SSE transport with a provided Cx.

pub fn run_websocket<R, W>(self, reader: R, writer: W) -> !

where R: Read + Send + 'static, W: Write + Send + 'static,

Runs the server using WebSocket transport with a testing Cx.

This is a convenience wrapper around WsTransport.

pub fn run_websocket_with_cx<R, W>(self, cx: &Cx, reader: R, writer: W) -> !

where R: Read + Send + 'static, W: Write + Send + 'static,

Runs the server using WebSocket transport with a provided Cx.