WasmMCP

MCP运维云端

提供方 ddps-lab

运维云端 stdio · 本地进程 会话登录 社区 / 第三方

A framework for building MCP (Model Context Protocol) servers in Rust, compiled to WASM, supporting both local and serverless execution.

一句话选型结论

按资料字段整理

WasmMCP 属于运维云端类 MCP 服务器,stdio · 本地进程,会话登录,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类运维云端 传输方式stdio · 本地进程 鉴权会话登录 部署方式本地部署
GitHub 星标 4 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

运维云端
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

适用场景

Local DeploymentWASMMCP Protocol

安装与配置

stdio · 本地进程 会话登录
客户端在本机拉起子进程,数据不出本机
  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 rust,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
云资源查询

查实例、存储、账单等云上资源状态。

部署与发布

把部署、重启、回滚这类操作接进对话。

监控与告警

拉取监控指标,异常时让模型帮你判断。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 基础信息齐全,可以先按官方文档接入试跑。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在运维云端场景里让模型直接调用外部能力的人。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
WasmMCP当前 未标注 stdio · 本地进程 本地部署 无 2026-06-17
lobehub 未标注 stdio · 本地进程 本地部署 有 2026-04-11
TrendRadar 未标注 stdio · 本地进程 本地部署 有 2026-04-13
Ui Tars Desktop 8a825770 未标注 stdio · 本地进程 本地部署 有 2026-05-17
ruflo 未标注 stdio · 本地进程 本地部署 有 2026-04-13
FastGPT 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

运维云端
字段来自项目仓库与公开索引,中文说明由本站标注
提供方ddps-lab上游标注的维护方 ddps-lab
分类运维云端本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · rust本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-06-17上游最后核验时间

详细介绍

11.4 KB
来自项目仓库与上游目录的原文,未做删改

WasmMCP - Rust MCP Servers in WASM

> Paper: "Orchestrating WASM-based MCP Tool Runtimes for AI Agents across Edge-Cloud Continuum"
> Moohyun Song, Hayoung Kim, Kyoohyun Lee, Jae Gi Son, Kyungyong Lee
> The 26th IEEE/ACM International Symposium on Cluster, Cloud and Internet Computing (CCGrid 2026)

A framework for building MCP (Model Context Protocol) servers in Rust, compiled to WASM.
Supports both Stdio (local) and HTTP (serverless) transports from a single crate.
This repository is a submodule of EdgeAgent, providing WASM-based MCP server implementations used for edge-cloud tool orchestration.

Overview

Write MCP servers once in Rust, compile to WASM, and run anywhere - locally via wasmtime run
or remotely via wasmtime serve / Knative / serverless platforms.

Key Features

  • Pure WASM: No Python/Node.js dependency - just WASM binaries
  • Unified Codebase: Single crate with feature flags for CLI/HTTP builds
  • Lightweight: ~300KB-1.3MB binaries (depends on server complexity)
  • FastMCP-like DX: Declarative tool registration with McpServer::builder()
  • Docker Support: Dockerfiles for both WASM and Python servers
  • Deployment Ready: Scripts for ECR, private registry, and container deployment

Quick Start

Prerequisites```bash

Install Rust WASI target

rustup target add wasm32-wasip2

Install Wasmtime

curl https://wasmtime.dev/install.sh -sSf | bash


### Build All Servers```bash
./scripts/build_all.sh

This builds all 9 servers in both CLI and HTTP variants:
- mcp_server_*_cli.wasm - for wasmtime run (stdio)
- mcp_server_*_http.wasm - for wasmtime serve (HTTP)

Run Examples```bash

Stdio mode (local development)

wasmtime run ./target/wasm32-wasip2/release/mcp_server_time_cli.wasm

HTTP mode (serverless)

wasmtime serve --addr 127.0.0.1:8000 -S cli=y \
--dir=/tmp/test \
./target/wasm32-wasip2/release/mcp_server_filesystem_http.wasm


## Project Structure```
WasmMCP/
├── wasmmcp/                     # Core framework
│   ├── src/
│   │   ├── lib.rs               # Public API
│   │   ├── server.rs            # McpServer builder
│   │   ├── builder.rs           # Server builder implementation
│   │   ├── registry.rs          # Tool registry
│   │   ├── timing.rs            # Timing utilities
│   │   ├── transport/           # Stdio/HTTP transports
│   │   └── protocol/            # JSON-RPC handling
│
├── wasmmcp-macros/              # export_cli!, export_http! macros
│
├── shared/                      # Shared code across servers
│   └── src/
│       └── lib.rs               # Common utilities
│
├── servers/                     # MCP server implementations
│   ├── wasm_server/             # Rust WASM servers
│   │   ├── time/                # Time tools (timezone conversion)
│   │   ├── filesystem/          # 14 file system tools
│   │   ├── git/                 # Git repository tools
│   │   ├── fetch/               # URL fetching (wasi:http)
│   │   ├── summarize/           # LLM-based summarization
│   │   ├── log-parser/          # Log parsing with regex
│   │   ├── data-aggregate/      # Data aggregation tools
│   │   ├── sequential-thinking/ # Structured thinking tool
│   │   └── image-resize/        # Image processing tools
│   │
│   └── python_server/           # Python server implementations
│       ├── data_aggregate_server.py
│       ├── fetch_server.py
│       ├── image_resize_server.py
│       ├── log_parser_server.py
│       └── summarize_server.py
│
├── docker/                      # Docker configurations
│   ├── wasm-server/             # WASM server Dockerfiles
│   ├── native-server/           # Python server Dockerfiles
│   └── registry/                # Container registry setup
│
├── scripts/
│   ├── build_all.sh             # Build all servers
│   ├── build_server.sh          # Build single server
│   └── run_server.sh            # Run server
│   ├── push-to-ecr.sh           # AWS ECR deployment
│   ├── push-to-registry.sh      # Private registry deployment
│   ├── push-wasm-images.sh      # WASM image deployment
│   └── cleanup-ecr.sh           # ECR cleanup
│
└── tests/
    ├── compare_*.py             # Comparison tests vs Python implementations
    ├── mcp_comparator.py        # Test framework
    ├── test_http_langchain.py   # HTTP transport tests
    └── test_langchain_integration.py  # LangChain integration tests

Writing MCP Servers

Minimal Example```rust

use wasmmcp::schemars::JsonSchema;
use wasmmcp::serde::Deserialize;
use wasmmcp::prelude::*;

[derive(Debug, Deserialize, JsonSchema)]

pub struct GreetParams {
/// Name to greet
pub name: String,
}

pub fn create_server() -> McpServer {
McpServer::builder("my-server")
.version("1.0.0")
.tool::<GreetParams, _>(
"greet",
"Say hello to someone",
|params| Ok(format!("Hello, {}!", params.name))
)
.build()
}

// Export for wasmtime run

[cfg(feature = "cli-export")]

wasmmcp::export_cli!(create_server);

// Export for wasmtime serve

[cfg(feature = "http-export")]

wasmmcp::export_http!(create_server);


### Cargo.toml```toml
[package]
name = &quot;mcp-server-myserver&quot;
version = &quot;0.1.0&quot;
edition = &quot;2021&quot;

[lib]
crate-type = [&quot;cdylib&quot;, &quot;rlib&quot;]

[dependencies]
wasmmcp = { path = &quot;../../../wasmmcp&quot; }
wasi = &quot;0.14&quot;
serde = { version = &quot;1.0&quot;, features = [&quot;derive&quot;] }
serde_json = &quot;1.0&quot;
schemars = &quot;1&quot;

[features]
default = [&quot;cli-export&quot;]
cli-export = []
http-export = []

Building```bash

CLI version

cargo build --target wasm32-wasip2 --release \
-p mcp-server-myserver --features cli-export --no-default-features

HTTP version

cargo build --target wasm32-wasip2 --release \
-p mcp-server-myserver --features http-export --no-default-features


## Available Servers

| Server | Tools | Description |
|--------|-------|-------------|
| time | 2 | Timezone conversion (get_current_time, convert_time) |
| filesystem | 14 | File operations (read/write/edit/search/tree) |
| git | 12 | Git repository read operations |
| fetch | 1 | URL fetching with HTML-to-markdown conversion |
| summarize | 3 | LLM-powered text summarization (OpenAI/Upstage) |
| log-parser | 5 | Log parsing, filtering, statistics |
| data-aggregate | 5 | Data aggregation and deduplication |
| sequential-thinking | 1 | Structured problem-solving |
| image-resize | 6 | Image info, resize, hash, batch operations |

## Architecture

### Unified CLI/HTTP Build```
┌─────────────────────────────────────────────────────────────┐
│                    MCP Server Logic (tools)                  │
├─────────────────────────────────────────────────────────────┤
│                    wasmmcp framework                         │
│                 (McpServer, ToolDef, Protocol)               │
├──────────────────────────┬──────────────────────────────────┤
│   export_cli!            │   export_http!                    │
│   (wasi:cli/run)         │   (wasi:http/incoming-handler)    │
├──────────────────────────┼──────────────────────────────────┤
│   wasmtime run           │   wasmtime serve / Knative        │
└──────────────────────────┴──────────────────────────────────┘

Feature Flags

  • cli-export: Exports wasi:cli/run for stdio communication
  • http-export: Exports wasi:http/incoming-handler for HTTP requests

Both features share the same create_server() function, eliminating code duplication.

LangChain Integration

Stdio Connection```python

from langchain_mcp_adapters.client import MultiServerMCPClient

mcp_config = {
"wasmmcp": {
"transport": "stdio",
"command": "wasmtime",
"args": ["run", "--dir=/tmp", "./target/wasm32-wasip2/release/mcp_server_filesystem_cli.wasm"],
}
}

client = MultiServerMCPClient(mcp_config)
async with client.session("wasmmcp") as session:
tools = await load_mcp_tools(session)


### HTTP Connection```python
mcp_config = {
    &quot;wasmmcp_http&quot;: {
        &quot;transport&quot;: &quot;streamable_http&quot;,
        &quot;url&quot;: &quot;http://localhost:8000&quot;,
    }
}

Container Deployment

Docker Build

Each server has corresponding Dockerfiles in docker/wasm-server/ and docker/native-server/:```bash

Build WASM server image

docker build -f docker/wasm-server/Dockerfile.time -t wasmmcp-time:latest .

Build Python server image

docker build -f docker/native-server/Dockerfile.time -t python-mcp-time:latest .


### Deployment Scripts```bash
# Deploy to AWS ECR
./scripts/push-to-ecr.sh &lt;registry-domain&gt;

# Deploy to private registry
./scripts/push-to-registry.sh &lt;registry-domain&gt;

# Deploy WASM images
./scripts/push-wasm-images.sh &lt;registry-domain&gt;

# Cleanup ECR
./scripts/cleanup-ecr.sh &lt;registry-domain&gt;

Private Container Registry

Setup a local or cloud-based private registry:```bash

Local registry with Docker Compose

cd docker/registry
docker-compose -f docker-compose.registry-local.yml up -d

HTTPS registry with Let's Encrypt

./setup-https-registry.sh <your-domain>

HTTPS registry with DNS validation

./setup-https-dns.sh <your-domain>


### Knative Deployment```yaml
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: wasmmcp-time
spec:
  template:
    spec:
      runtimeClassName: wasmtime-spin
      containers:
        - image: your-registry/wasmmcp-time:latest

Supported Platforms

  • Knative + containerd (runwasi)
  • Docker / Kubernetes
  • Private container registries

Binary Sizes

Server CLI HTTP Difference
sequential-thinking 264KB 276KB +12KB
summarize 292KB 300KB +8KB
data-aggregate 376KB 388KB +12KB
git 388KB 404KB +16KB
filesystem 436KB 448KB +12KB
fetch 528KB 540KB +12KB
time 1.2MB 1.2MB ~0
log-parser 1.3MB 1.3MB ~0
image-resize 1.2MB 1.2MB ~0

Dependencies```toml

[workspace.dependencies]
tokio = { version = "1", default-features = false }
rmcp = { version = "0.10", default-features = false, features = ["server", "macros"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
schemars = "1"
wasi = "0.14"


## License

Apache 2.0. See LICENSE for details.

## Citation

If you use WasmMCP in your research, please cite our paper:```bibtex
@inproceedings{song2026orchestrating,
  title={Orchestrating WASM-based MCP Tool Runtimes for AI Agents across Edge-Cloud Continuum},
  author={Song, Moohyun and Kim, Hayoung and Lee, Kyoohyun and Son, Jae Gi and Lee, Kyungyong},
  booktitle={The 26th IEEE/ACM International Symposium on Cluster, Cloud and Internet Computing (CCGrid)},
  year={2026}
}

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
WasmMCP 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

WasmMCP 怎么在客户端里配置?

它的传输方式未标注,在客户端 MCP 配置里按官方文档填写启动命令和参数,保存后重启客户端生效。

WasmMCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

WasmMCP 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

WasmMCP 能提供哪些能力?

资料显示能力标签包括 Local Deployment、WASM、MCP Protocol、Rust、Edge Computing、AI Agents。具体工具清单以官方文档为准。

WasmMCP 需要什么运行环境?

运行时为 rust;属于本地进程,需要在本机装好运行环境。

WasmMCP 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-06-17。