Struct McpServer 

pub struct McpServer { /* private fields */ }

The main handle for the MCP integration.

McpServer can be attached to a RustApi instance (via its OpenAPI spec) to automatically discover tools. Tool invocations (in later milestones) will be driven through the normal RustAPI handler pipeline.

Implementations

impl McpServer

pub fn new(config: McpConfig) -> Self

Create a new MCP server with the given configuration.

pub fn from_rustapi(app: &RustApi, config: McpConfig) -> Self

Create an MCP server pre-attached to a RustApi instance.

This is the most ergonomic way when you already have a built RustApi. If invocation_mode is InProcess or Auto, a direct in-process dispatcher is captured for zero-overhead tool calls (see RequestInvoker).

pub fn from_spec(config: McpConfig, spec: &OpenApiSpec) -> Self

Create from an explicit OpenAPI spec.

pub fn with_openapi(self, spec: OpenApiSpec) -> Self

Attach (or replace) the OpenAPI spec used for discovery.

Call this after RustApi::auto() / builder if you built the app first.

pub fn with_http_base(self, base: impl Into<String>) -> Self

Configure the base URL of the main RustAPI HTTP server.

When set, tools/call will proxy the call over HTTP to this base (typically “http://127.0.0.1:8080” when using the concurrent runner). This guarantees that tool invocations go through the exact same middleware, auth, validation, and handler code as normal traffic.

pub fn config(&self) -> &McpConfig

Get a reference to the active configuration.

pub fn capabilities(&self) -> Vec<McpCapability>

Return the capabilities this server currently advertises.

pub fn initialize(&self) -> InitializeResult

Perform the initialize handshake.

MCP clients call this first. Returns server info + supported capabilities.

pub async fn list_tools(&self) -> Result<Vec<McpTool>>

Discover and return the list of tools that should be exposed to MCP clients.

Tools are derived from the attached OpenAPI spec (from RustApi), filtered according to McpConfig::allowed_tags and allowed_path_prefixes.

pub async fn call_tool(&self, req: ToolCallRequest) -> Result<ToolCallResponse>

Execute a tool call by proxying it as a real HTTP request to the main RustAPI server (using the configured http_base).

This is the heart of Native MCP: the call goes through your normal layers, interceptors, extractors, validation, error handling, etc.

impl McpServer

pub async fn serve(self, addr: &str) -> Result<()>

Start serving the MCP protocol over HTTP on the given address.

This starts a sidecar HTTP server (separate from your main RustAPI HTTP server) that MCP clients (Claude, etc.) can connect to for tool discovery and invocation.

Supports a minimal JSON-RPC over POST transport for:

• initialize
• tools/list
• tools/call (proxies to the main RustAPI server so full middleware / validation / error handling applies)

pub async fn serve_with_shutdown<F>(self, addr: &str, signal: F) -> Result<()>

where F: Future<Output = ()> + Send + 'static,

Like serve, but with a shutdown signal (e.g. ctrl_c()).

Trait Implementations

impl Clone for McpServer

fn clone(&self) -> McpServer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for McpServer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.