Enables deployment of static websites and files to IPFS via Pinme, with support for checking deployment status, listing deployment history, and generating accessible ENS URLs for hosted content.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Pinme Deploy MCP Server deploy my React app to IPFS"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
一个 Model Context Protocol (MCP) 服务器，集成 Pinme 功能，帮助用户一键将静态网站部署到 IPFS 网络。
GitHub: https://github.com/liaoshengrong/pinme-deploy-mcp
🚀 一键上传: 快速将静态网站、HTML 文件或前端项目上传到 Pinme (IPFS)
📁 灵活支持: 支持单个文件或整个目录上传
🔍 智能检测: 自动检测常见的构建输出目录（build、dist、out、.next 等），无需手动指定路径
🌐 状态检查: 通过 CID 或 ENS URL 检查已部署项目的状态和可访问性
📋 部署列表: 查看所有已上传的项目历史记录，包括 CID、ENS URL 等信息
Related MCP server: Demox MCP Server
无需安装，直接在 Cursor 配置文件中使用：
{
"mcpServers": {
"pinme-deploy": {
"command": "npx",
"args": ["-y", "git+https://github.com/liaoshengrong/pinme-deploy-mcp.git"]
}
}
}如果遇到 npx 缓存错误，运行以下命令清理缓存后重试：
rm -rf ~/.npm/_npxnpm install -g github:liaoshengrong/pinme-deploy-mcp然后在 Cursor 配置文件中添加：
{
"mcpServers": {
"pinme-deploy": {
"command": "pinme-deploy-mcp"
}
}
}curl -fsSL https://raw.githubusercontent.com/liaoshengrong/pinme-deploy-mcp/main/install.sh | bash或下载后执行：
chmod +x install.sh
./install.shgit clone https://github.com/liaoshengrong/pinme-deploy-mcp.git
cd pinme-deploy-mcp
npm install
npm run build然后在 Cursor 配置中使用绝对路径：
{
"mcpServers": {
"pinme-deploy": {
"command": "node",
"args": ["/absolute/path/to/pinme-deploy-mcp/dist/index.js"]
}
}
}可选的环境变量：
PINME_API_KEY: Pinme API 密钥（如果使用 API 部署）
无需全局安装！工具会自动使用 npx 运行 Pinme CLI，无需提前安装。
如果需要手动安装（可选）：
npm install -g pinmenpm start配置 MCP 服务器路径
使用以下工具：
deploy_to_pinme上传文件或目录到 Pinme。
参数：
path (可选): 要上传的文件或目录路径。如果未指定，会自动检测当前目录下的常见构建输出目录（build、dist、out、.next 等）
自动检测的目录：
build - React (Create React App)
dist - Vue, Vite, Webpack
out - Next.js (某些配置)
.next - Next.js
public - 某些静态站点
output - 某些项目
.output - Nuxt.js
site - 某些静态站点生成器
示例：
自动检测（推荐，无需指定路径）：
{}或指定目录：
{
"path": "./build"
}或上传单个文件：
{
"path": "./index.html"
}返回信息：
预览地址（https://pinme.eth.limo/#/preview/...）
IPFS CID
ENS 地址（https://xxxxx.pinit.eth.limo）
check_pinme_status检查已部署项目的状态。
参数：
cid (可选): IPFS CID（内容标识符）
ensUrl (可选): ENS URL（例如：https://xxxxx.pinit.eth.limo）
示例：
{
"cid": "bafkreiekm6o7tb4p53jtw7nwm42qlklqhdn37lj5jqoj4bdvjtfsgnr734"
}或使用 ENS URL：
{
"ensUrl": "https://f34fc1b3.pinit.eth.limo"
}list_deployments列出所有已上传的项目历史记录。
返回信息：
文件名/项目名
本地路径
IPFS CID
ENS URL（可访问的线上地址）
文件大小
文件数量
类型（文件/目录）
上传日期
npm run devnpm run watchPinme CLI: 必须安装 Pinme CLI（npm install -g pinme），否则工具无法工作
文件/目录: 支持上传单个文件（如 HTML）或整个目录（如构建后的静态网站）
ENS URL: 上传成功后，会生成一个 ENS URL（格式：https://xxxxx.pinit.eth.limo），这是可访问的线上地址
预览地址: 上传后会返回一个预览地址（https://pinme.eth.limo/#/preview/...），用于在 Pinme 平台预览
TypeScript
Model Context Protocol SDK
Node.js
MIT
# 在项目根目录下，无需指定路径，自动检测 build 或 dist 目录
# 在 Cursor 中调用 MCP 工具
deploy_to_pinme({})# 在 Cursor 中调用 MCP 工具
deploy_to_pinme({ path: "./build" })
# 或
deploy_to_pinme({ path: "./dist" })# 在 Cursor 中调用 MCP 工具
deploy_to_pinme({ path: "./index.html" })# 在 Cursor 中调用 MCP 工具
list_deployments()# 1. 构建项目
npm run build
# 2. 在 Cursor 中调用（自动检测 build 目录）
deploy_to_pinme({})检查 Pinme 部署状态。可以通过 CID 或 ENS URL 检查。
| Name | Required | Description | Default |
|---|---|---|---|
| cid | No | 要检查的 IPFS CID（内容标识符）。 | |
| ensUrl | No | 要检查的 ENS URL（例如：https://xxxxx.pinit.eth.limo）。 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool checks status but doesn't describe what the check entails (e.g., whether it verifies availability, returns metadata, or performs validation), potential errors, or any side effects. For a status-checking tool with zero annotation coverage, this leaves significant gaps in understanding its behavior and limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, consisting of two clear sentences. The first sentence states the core purpose, and the second adds parameter context without redundancy. It avoids unnecessary words and efficiently conveys essential information, though it could be slightly more structured by explicitly separating purpose from usage notes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (status checking with two parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the status check returns (e.g., success/failure, deployment details), potential error conditions, or how it interacts with sibling tools. For a tool without structured output documentation, the description should provide more behavioral and result context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal value beyond the input schema, which has 100% coverage. It mentions that status can be checked via 'CID 或 ENS URL' (CID or ENS URL), aligning with the schema parameters 'cid' and 'ensUrl'. However, it doesn't provide additional context such as parameter precedence (e.g., if both are provided), format details, or examples beyond what the schema descriptions already cover. With high schema coverage, the baseline is met but not exceeded.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '检查 Pinme 部署状态' (check Pinme deployment status). It specifies the verb '检查' (check) and resource 'Pinme 部署状态' (Pinme deployment status), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'list_deployments', which might also provide status information in a different format or scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context by stating '可以通过 CID 或 ENS URL 检查' (can be checked via CID or ENS URL), which implies this tool is for checking specific deployments identified by these parameters. However, it doesn't explicitly state when to use this tool versus alternatives like 'list_deployments' (which might list all deployments without filtering) or 'deploy_to_pinme' (for deployment actions). The guidance is implied but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
将静态网站、HTML 文件或前端项目上传到 Pinme (IPFS)。支持单个文件或整个目录。如果未指定路径，会自动检测常见的构建输出目录（build、dist、out、.next 等）。
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | 要上传的文件或目录路径。如果未指定，会自动检测当前目录下的常见构建输出目录（build、dist、out、.next 等）。 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It describes the upload behavior and automatic directory detection, but doesn't disclose important behavioral traits like authentication requirements, rate limits, error handling, or what happens to existing deployments. The description adds some context but leaves gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with zero waste. First sentence states purpose and scope, second sentence explains the automatic behavior when parameter is omitted. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a deployment tool with no annotations and no output schema, the description provides adequate basic information about what it does and parameter behavior, but lacks details about what happens after deployment (e.g., returns a URL? CID? success confirmation?), error conditions, or authentication requirements that would be needed for complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents the single parameter. The description adds marginal value by reinforcing the automatic detection behavior mentioned in the schema description, but doesn't provide additional semantic context beyond what's already in the structured data.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('upload to Pinme (IPFS)'), the resource types ('static websites, HTML files, or frontend projects'), and distinguishes from siblings by focusing on deployment rather than status checking or listing deployments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context for when to use this tool (uploading static content to IPFS) and mentions automatic detection of build directories, but doesn't explicitly state when NOT to use it or compare it to sibling tools like check_pinme_status or list_deployments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
列出所有已部署的项目。
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states what the tool does without behavioral details. It doesn't disclose whether this is a read-only operation, if it requires authentication, how results are returned (e.g., pagination, format), or any rate limits, which are critical for a list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no parameters and no output schema, the description is minimally adequate but lacks completeness. Without annotations or output schema, it should ideally mention return format or behavioral traits to help the agent understand what to expect, but it only states the basic purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter information, but that's appropriate here, meeting the baseline for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('列出' - list) and resource ('已部署的项目' - deployed projects), making the purpose evident. However, it doesn't differentiate from sibling tools like 'check_pinme_status' or 'deploy_to_pinme', which appear related to deployment operations but have different functions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context (e.g., after deployment), or exclusions, leaving the agent to infer usage based on the name and siblings alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a clearly distinct purpose: check_pinme_status monitors deployment status, deploy_to_pinme handles uploading content, and list_deployments retrieves deployment history. There is no overlap in functionality, making tool selection straightforward for an agent.
All tools follow a consistent verb_noun naming pattern (check_pinme_status, deploy_to_pinme, list_deployments), using snake_case throughout. This predictability enhances usability and reduces cognitive load for agents.
With 3 tools, the server is well-scoped for deployment management, covering core operations like checking, uploading, and listing. It is slightly lean but reasonable, as additional tools (e.g., for deletion or updates) might be unnecessary for a simple deployment service.
The toolset covers essential deployment workflows: uploading, status checking, and listing. A minor gap exists in lacking a delete or update tool, but agents can work around this by re-deploying or managing deployments externally. The surface is largely complete for the stated purpose.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Deploy HTML or dist/ to a live HTTPS URL. No account. Drop, MCP, or CLI.
Publish files and folders to the web instantly: permanent URLs, immutable versions, claim links.
Publish one HTML file, get a live installable app URL. No account, no review, no queue.
Deploy files, sites, and Dockerfile apps to live URLs + private drives for agent memory.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/liaoshengrong/pinme-deploy-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
