간단한 derive 매크로를 가진 MCP 서버에 Clap CLI를 켭니다.

설치

빠른 시작

다음은 CLI 및 MCP 서버와 같이 작동하는 완전한 계산기 예입니다:

이제 CLI는 두 가지 방법을 사용합니다.

실제 예제: 캐스트

MCP 서버로 캐스트 (Foundry’s CLI) 작업을 만드는 방법은 다음과 같습니다.

그것이 작동하는 방법

#[derive(McpMode)] 매크로:

• CLI에 run_mcp_server() 메소드 추가
• 각 subcommand를 MCP 도구로 변환
• Maps CLI는 적절한 유형과 도구 매개 변수에 대한 인수
• 모든 기존 CLI 기능 보존

라이센스

MIT 또는 아파치 2.0

clap-mcp

Turn any Clap CLI into an MCP server with a simple derive macro.

Installation

[dependencies]
clap-mcp = "0.1"

Quick Start

Here’s a complete calculator example that works as both a CLI and MCP server:

use clap::{Parser, Subcommand};
use clap_mcp::McpMode;

#[derive(Parser, McpMode)]
#[command(name = "calculator")]
#[command(about = "A simple calculator CLI that can also run as an MCP server")]
struct Cli {
    #[command(subcommand)]
    command: Option,
    
    /// Run as MCP server instead of CLI
    #[arg(long)]
    #[mcp(mode_flag)]
    mcp: bool,
    
    /// Port to run MCP HTTP server on (if not specified, uses stdio)
    #[arg(long, value_name = "PORT")]
    mcp_port: Option,
}

#[derive(Subcommand, Clone)]
enum Commands {
    /// Add two numbers
    Add {
        #[arg(short, long)]
        a: f64,
        #[arg(short, long)]
        b: f64,
    },
    
    /// Multiply two numbers
    Multiply {
        #[arg(long)]
        value1: f64,
        #[arg(long)]
        value2: f64,
    },
}

fn execute_command(cmd: Commands) -> Result {
    match cmd {
        Commands::Add { a, b } => {
            Ok(format!("{} + {} = {}", a, b, a + b))
        }
        Commands::Multiply { value1, value2 } => {
            Ok(format!("{} * {} = {}", value1, value2, value1 * value2))
        }
    }
}

fn main() -> Result> {
    let cli = Cli::parse();
    
    if cli.mcp {
        // Run as MCP server - automatically exposes all commands as tools
        if let Some(port) = cli.mcp_port {
            // HTTP server mode on specified port
            let addr = format!("127.0.0.1:{}", port).parse()?;
            cli.run_mcp_server_http_with_handler(addr, execute_command)?;
        } else {
            // stdio mode (default)
            cli.run_mcp_server_with_handler(execute_command)?;
        }
    } else {
        // Run as normal CLI
        match execute_command(cli.command.expect("Subcommand required")) {
            Ok(output) => println!("{}", output),
            Err(e) => eprintln!("Error: {}", e),
        }
    }
    
    Ok(())
}

Now your CLI works both ways:

# Traditional CLI mode
$ calculator add -a 10 -b 32
10 + 32 = 42

$ calculator multiply --value1 7 --value2 6
7 * 6 = 42

# MCP server mode (stdio)
$ calculator --mcp
# Server is now running, ready for MCP clients to connect

# MCP server mode (HTTP on specific port)
$ calculator --mcp --mcp-port 8080
# Server running on http://127.0.0.1:8080, ready for HTTP-based MCP clients

Real Example: Cast

Here’s how you’d make Cast (Foundry’s CLI) work as an MCP server:

#[derive(Parser, McpMode)]
struct Cast {
    #[command(subcommand)]
    cmd: CastCommand,
    
    #[arg(long)]
    #[mcp(mode_flag)]
    mcp: bool,
}