Module mcp 

MCP (Model Context Protocol) server implementations.

ReasonKit implements MCP servers in Rust (no Node.js) for tool integration.

MCP (Model Context Protocol) Server Registry

Rust-based MCP server implementation for ReasonKit.

Overview

This module provides:

• Server Registry: Dynamic server discovery and registration
• MCP Client: Connect to and interact with external MCP servers
• Health Monitoring: Automatic health checks for registered servers
• Tool Management: Tool capability reporting and execution
• Protocol Compliance: Full MCP specification support

Architecture

┌─────────────────────────────────────────────────────────────┐
│ MCP Registry (Coordinator)                                  │
│   - Server discovery                                        │
│   - Health monitoring                                       │
│   - Capability aggregation                                  │
├─────────────────────────────────────────────────────────────┤
│ MCP Client (Consumer)                                       │
│   - Connect to external MCP servers                         │
│   - Execute tools via RPC                                   │
│   - Access resources                                        │
├─────────────────────────────────────────────────────────────┤
│ MCP Servers (Multiple instances)                            │
│   - ThinkTool servers (GigaThink, LaserLogic, etc.)         │
│   - Custom tool servers                                     │
│   - Resource providers                                      │
├─────────────────────────────────────────────────────────────┤
│ Transport Layer                                             │
│   - JSON-RPC 2.0 over stdio (primary)                       │
│   - HTTP/SSE (optional)                                     │
└─────────────────────────────────────────────────────────────┘

MCP Protocol

Based on MCP specification (2025-11-25):

• JSON-RPC 2.0 messaging
• Lifecycle management (initialize, shutdown)
• Tools, Resources, and Prompts primitives
• Progress notifications
• Cancellation support

Example: MCP Client

use reasonkit::mcp::{McpClient, McpClientConfig, McpClientTrait};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create client configuration
    let config = McpClientConfig {
        name: "sequential-thinking".to_string(),
        command: "npx".to_string(),
        args: vec![
            "-y".to_string(),
            "@modelcontextprotocol/server-sequential-thinking".to_string()
        ],
        env: HashMap::new(),
        timeout_secs: 30,
        auto_reconnect: true,
        max_retries: 3,
    };

    // Connect to the server
    let mut client = McpClient::new(config);
    client.connect().await?;

    // List available tools
    let tools = client.list_tools().await?;
    println!("Available tools: {:?}", tools);

    // Call a tool
    let result = client.call_tool(
        "think",
        serde_json::json!({
            "query": "What is chain-of-thought reasoning?"
        })
    ).await?;

    println!("Result: {:?}", result);

    // Disconnect
    client.disconnect().await?;

    Ok(())
}

Example: Server Registry

use reasonkit::mcp::{McpRegistry, McpServerConfig, TransportType};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create registry
    let mut registry = McpRegistry::new();

    // Register a ThinkTool server
    let config = McpServerConfig {
        name: "gigathink".to_string(),
        command: "rk-thinktool".to_string(),
        args: vec!["--module".to_string(), "gigathink".to_string()],
        transport: TransportType::Stdio,
        env: Default::default(),
    };

    registry.register_server(config).await?;

    // Discover all available tools
    let tools = registry.list_all_tools().await?;
    for tool in tools {
        println!("Tool: {} from server {}", tool.name, tool.server);
    }

    Ok(())
}

Re-exports

pub use types::ErrorCode;

pub use types::Implementation;

pub use types::JsonRpcVersion;

pub use types::McpError;

pub use types::McpMessage;

pub use types::McpNotification;

pub use types::McpRequest;

pub use types::McpResponse;

pub use types::RequestId;

pub use types::ServerCapabilities;

pub use types::ServerInfo;

pub use types::ToolsCapability;

pub use server::McpServer;

pub use server::McpServerTrait;

pub use server::ServerMetrics;

pub use server::ServerStatus;

pub use registry::HealthCheck;

pub use registry::HealthStatus;

pub use registry::McpRegistry;

pub use registry::ServerRegistration;

pub use client::ClientStats;

pub use client::ConnectionState;

pub use client::McpClient;

pub use client::McpClientConfig;

pub use client::McpClientTrait;

pub use tools::Prompt;

pub use tools::PromptArgument;

pub use tools::ResourceTemplate;

pub use tools::Tool;

pub use tools::ToolCapability;

pub use tools::ToolInput;

pub use tools::ToolResult;

pub use transport::StdioTransport;

pub use transport::Transport;

pub use transport::TransportType;

pub use lifecycle::ClientInfo;

pub use lifecycle::InitializeParams;

pub use lifecycle::InitializeResult;

pub use lifecycle::PingRequest;

pub use lifecycle::ShutdownRequest;

pub use delta_tools::DeltaToolHandler;

pub use thinktool_tools::register_thinktools;

pub use thinktool_tools::BedRockHandler;

pub use thinktool_tools::BrutalHonestyHandler;

pub use thinktool_tools::GigaThinkHandler;

pub use thinktool_tools::LaserLogicHandler;

pub use thinktool_tools::ProofGuardHandler;

pub use thinktool_tools::ThinkToolHandler;

pub use ws_auth::ApiKeyInfo;

pub use ws_auth::ApiKeyValidator;

pub use ws_auth::AuthenticatedWsConnection;

pub use ws_auth::ConnectionInfo;

pub use ws_auth::ConnectionTracker;

pub use ws_auth::InMemoryApiKeyValidator;

pub use ws_auth::SubscriptionTier;

pub use ws_auth::WsAuthError;

pub use ws_auth::WsAuthMessage;

pub use ws_auth::WsAuthResult;

pub use ws_auth::WsAuthState;

Modules

client

MCP Client Implementation

delta_tools

Protocol Delta MCP Tools

lifecycle

MCP Lifecycle Management

registry

MCP Server Registry

server

MCP Server Implementation

thinktool_tools

ThinkTool MCP Handlers

tools

MCP Tools

transport

MCP Transport Layer

types

MCP Protocol Types

ws_auth

WebSocket Authentication Middleware for MCP Server

Constants

DEFAULT_HEALTH_CHECK_INTERVAL_SECS

Default health check interval (30 seconds)

MAX_SERVER_STARTUP_TIMEOUT_SECS

Maximum server startup timeout (10 seconds)

MCP_VERSION

MCP protocol version (2025-11-25)