llm-tool-mcp

MCP (Model Context Protocol) stdio server for llm-tool registries.

Register your tools in a ToolRegistry, hand it to McpServer, and get a fully compliant MCP server — no boilerplate.

Quick start

use llm_tool::{llm_tool, ToolError, ToolContext, ToolRegistry};
use llm_tool_mcp::McpServer;

/// Adds two numbers.
#[llm_tool]
fn add(
    /// First operand.
    a: i64,
    /// Second operand.
    b: i64,
) -> Result<String, ToolError> {
    Ok(format!("{}", a + b))
}

let registry = ToolRegistry::new().with_tool(Add);

let server = McpServer::new("my-server", "0.1.0", registry)
    .with_context(ToolContext::new(Some("caller-id".into())));

// In production: server.run_stdio().expect("server failed");
// Here we feed a request via an in-memory buffer:
let input = r#"{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"add","arguments":{"a":17,"b":25}}}"#;
let reader = std::io::Cursor::new(format!("{input}\n"));
let mut output = Vec::new();
server.run(reader, &mut output).unwrap();

let resp: serde_json::Value = serde_json::from_slice(&output).unwrap();
assert_eq!(resp["result"]["content"][0]["text"], "42");

Transports: Stdio vs TCP vs Unix Sockets

McpServer is builder-style and supports all common execution models out-of-the-box:

# use llm_tool::ToolRegistry;
# use llm_tool_mcp::McpServer;
# tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
let server = McpServer::new("my-server", "0.1.0", ToolRegistry::new());

// 1. Standard MCP desktop client transport (stdio subprocess):
// server.run_stdio().expect("stdio server failed");

// 2. TCP network server (localhost only):
// server.listen_tcp("127.0.0.1:3000").await.expect("tcp bind failed");

// 3. TCP network server (external / container / docker):
// server.listen_tcp("0.0.0.0:8080").await.expect("tcp bind failed");

// 4. Unix Domain Socket (local IPC):
// server.listen_unix("/tmp/my-agent.sock").await.expect("unix bind failed");
# })

What it handles

Tool errors are returned as MCP content with isError: true (spec-compliant), not as JSON-RPC errors.

Async & custom transports

If running inside an existing Tokio application or network server, use run_async:

# use llm_tool::ToolRegistry;
# use llm_tool_mcp::McpServer;
# tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
let server = McpServer::new("s", "1", ToolRegistry::new());

// Runs over any tokio::io::AsyncBufRead + AsyncWrite streams:
// server.run_async(tokio::io::stdin(), tokio::io::stdout()).await.unwrap();
# })

For custom request/response routing (e.g. Axum HTTP POST or WebSockets), use handle_request directly:

# use llm_tool::ToolRegistry;
# use llm_tool_mcp::McpServer;
# tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
let server = McpServer::new("s", "1", ToolRegistry::new());

let response = server
    .handle_request(r#"{"jsonrpc":"2.0","id":1,"method":"tools/list"}"#)
    .await;
# })

License

Dual-licensed under Apache-2.0 OR MIT.