Crate mcpkit_server 

Server implementation for the MCP SDK.

This crate provides the server-side implementation for the Model Context Protocol. It includes composable handler traits, a fluent builder API, and request routing.

Overview

Building an MCP server involves:

1. Implementing the ServerHandler trait (required)
2. Implementing optional capability traits (ToolHandler, ResourceHandler, etc.)
3. Using ServerBuilder to create a configured server
4. Running the server with a transport

Example

use mcpkit_server::{ServerBuilder, ServerHandler};
use mcpkit_core::capability::{ServerInfo, ServerCapabilities};

struct MyServer;

impl ServerHandler for MyServer {
    fn server_info(&self) -> ServerInfo {
        ServerInfo::new("my-server", "1.0.0")
    }

    fn capabilities(&self) -> ServerCapabilities {
        ServerCapabilities::new().with_tools()
    }
}

let server = ServerBuilder::new(MyServer).build();
assert!(server.capabilities().has_tools());

Handler Traits

The server uses composable handler traits:

• ServerHandler: Core trait required for all servers
• ToolHandler: Handle tool discovery and execution
• ResourceHandler: Handle resource discovery and reading
• PromptHandler: Handle prompt discovery and rendering
• TaskHandler: Handle long-running task operations

Context

Handlers receive a Context that provides:

• Request metadata (ID, progress token)
• Client and server capabilities
• Cancellation checking
• Progress reporting
• Notification sending

Re-exports

pub use builder::FullServer;

pub use builder::MinimalServer;

pub use builder::NotRegistered;

pub use builder::Registered;

pub use builder::Server;

pub use builder::ServerBuilder;

pub use context::Context;

pub use context::ContextData;

pub use context::NoOpPeer;

pub use context::Peer;

pub use handler::CompletionHandler;

pub use handler::PromptHandler;

pub use handler::ResourceHandler;

pub use handler::ServerHandler;

pub use handler::TaskHandler;

pub use handler::ToolHandler;

pub use health::ComponentHealth;

pub use health::HealthChecker;

pub use health::HealthReport;

pub use health::HealthStatus;

pub use health::LivenessResponse;

pub use health::ReadinessResponse;

pub use metrics::MethodStats;

pub use metrics::MetricsSnapshot;

pub use metrics::ServerMetrics;

pub use router::AugmentedTaskOutcome;

pub use router::begin_augmented_task;

pub use router::call_tool_json;

pub use router::dispatch_notification_hooks;

pub use router::route_completion;

pub use router::route_logging;

pub use router::route_prompts;

pub use router::route_resources;

pub use router::route_tools;

pub use router::run_augmented_tool;

pub use router::tool_task_support;

pub use server::RequestRouter;

pub use server::RuntimeConfig;

pub use server::ServerNotifier;

pub use server::ServerRuntime;

pub use server::ServerState;

pub use server::TransportPeer;

pub use validation::ValidatingToolHandler;

pub use validation::ValidationMode;

pub use validation::validate_json;

Modules

adapter_peer

Server→client request/response peer for the HTTP adapters (#153).

builder

Fluent server builder for MCP servers.

capability

Capability handlers for MCP servers.

context

Request context for MCP handlers.

dispatch

Object-safe dispatch layer.

handler

Composable handler traits for MCP servers.

health

Health check utilities for MCP servers.

metrics

Server-level metrics for MCP servers.

prelude

Prelude module for convenient imports.

router

Request routing for MCP servers.

server

Server runtime for MCP servers.

state

Typestate connection management for MCP servers.

streams

Per-session, per-stream SSE delivery (shared by the HTTP adapters).

validation

Opt-in JSON Schema validation of tool inputs and outputs.

Structs

CancellationToken

A cancellation token for tracking request cancellation.

CancelledFuture

A future that completes when cancellation is requested.

Enums

LogLevel

The MCP logging severity, re-exported from core.