Name: MCP服务器部署平台
Author: mcpize

使用说明

mcpize

Deploy and monetize MCP servers in the cloud.

Installation

npm install -g mcpize

Quick Start

# Login to MCPize
mcpize login

# Create a new MCP server
mcpize init my-server

# Deploy to the cloud
cd my-server
mcpize deploy

# Or analyze an existing project
cd existing-mcp-server
mcpize analyze
mcpize deploy

Authentication

# Browser login (recommended) - opens mcpize.com
mcpize login

# Email/password login
mcpize login --email

Browser login opens mcpize.com, you sign in with Google/GitHub/email, and the CLI receives your session automatically.

Commands

Command	Description
`mcpize login`	Authenticate via browser (recommended)
`mcpize login --email`	Authenticate with email/password
`mcpize logout`	Log out from MCPize
`mcpize init [name]`	Create a new MCP server project
`mcpize analyze`	Generate mcpize.yaml from existing project
`mcpize link`	Link current directory to an existing server
`mcpize deploy`	Deploy to MCPize Cloud
`mcpize status`	Show server status and deployments
`mcpize logs`	View runtime and build logs
`mcpize secrets list`	List environment secrets
`mcpize secrets set <name>`	Set a secret
`mcpize secrets delete <name>`	Delete a secret (alias: `rm`)
`mcpize doctor`	Run pre-deploy diagnostics
`mcpize whoami`	Show current authenticated user
`mcpize publish`	Manage marketplace listing (SEO, pricing, logo)
`mcpize run`	Run MCP server tools via REST API
`mcpize dev`	Run local dev server with hot reload

Local Development

Run your MCP server locally with hot reload:

# Start local dev server
mcpize dev

# With custom entry point
mcpize dev src/server.ts

# Custom port (default 3000, passed to the server as PORT)
mcpize dev --port 8080

# Expose via public tunnel (for testing with Claude/clients)
mcpize dev --tunnel

# Open MCPize Playground for interactive testing
mcpize dev --playground

# Choose tunnel provider (localtunnel, ngrok, cloudflared)
mcpize dev --tunnel --provider ngrok

What mcpize dev runs per runtime:

Runtime	Command
TypeScript	`npm run dev` (or `tsx watch <entry>`)
Python	`uv run fastmcp run -m <module> --reload` for FastMCP projects whose `startCommand` is `.venv/bin/python -m <module>`; otherwise the `startCommand` from `mcpize.yaml`
PHP	`php -S 0.0.0.0:$PORT -t public public/index.php` (the same `public/` front controller FrankenPHP serves in Docker)

The --playground flag automatically creates a tunnel and opens the MCPize Playground where you can test your server's tools interactively.

Templates

Create a new project from a template:

# Interactive: prompts for the template
mcpize init my-server

# TypeScript (typescript/default)
mcpize init my-server --template typescript

# Generate from OpenAPI spec
mcpize init my-api --template openapi --from-url https://api.example.com/openapi.json

# Python
mcpize init my-server --template python

Without --template, mcpize init asks which template to use. A bare language name selects its default template (python → python/default), and openapi selects typescript/openapi.

Template	Description
`typescript/default`	TypeScript MCP server with `@modelcontextprotocol/sdk` (recommended)
`typescript/billing-events`	TypeScript MCP server with event billing
`typescript/openapi`	Generate an MCP server from an OpenAPI spec (`--from-url` / `--from-file`)
`python/default`	Python MCP server with FastMCP
`python/openapi`	Generate a Python FastMCP server from an OpenAPI spec (`--from-url` / `--from-file`, `--api-base-url`)
`php/default`	PHP MCP server with the official `mcp/sdk`

Other options: --dir <path>, --no-install, --no-git. Set MCPIZE_TEMPLATES_DIR to a local checkout of mcpize/templates to scaffold from it instead of GitHub.

Analyze

Generate mcpize.yaml from an existing MCP server project:

# Analyze current directory
mcpize analyze

# Preview without saving
mcpize analyze --dry-run

# Overwrite existing mcpize.yaml
mcpize analyze --force

# Skip confirmation prompt
mcpize analyze --yes

The analyze command:

Detects runtime (TypeScript, Python, Container)
Extracts start command from package.json/Dockerfile
Identifies required credentials from code
Generates a ready-to-deploy manifest

Secrets Management

# Set a secret
mcpize secrets set API_KEY sk-xxx

# Set from file
mcpize secrets set CREDENTIALS --from-file ./credentials.json

# List secrets (names only)
mcpize secrets list

# Export secrets
mcpize secrets export --format env

Logs

# View runtime logs
mcpize logs

# View build logs
mcpize logs --type build

# Follow logs in real-time
mcpize logs --follow

# Filter by severity
mcpize logs --severity ERROR

Linking

# Link current directory to an existing server
mcpize link

# Link to a specific server
mcpize link --server <server-id>

# Force re-link
mcpize link --force

Publish

Manage your marketplace listing — SEO, pricing, logo, and publish status:

# Full autopilot (generate SEO, logo, mark free, publish)
mcpize publish --auto

# Autopilot with paid pricing
mcpize publish --auto --pricing "Free 100 req/day, Pro $10/mo"

# Granular control
mcpize publish --generate-seo        # AI generates SEO metadata
mcpize publish --free                # Mark as free
mcpize publish --pricing "Free 100 req/day, Pro $10/mo"  # AI generates pricing tiers
mcpize publish --generate-logo       # AI generates logo
mcpize publish --show                # Show current listing status
mcpize publish --unpublish           # Take down from marketplace
mcpize publish --unlist              # Hide from marketplace (API still works)
mcpize publish --list                # Show in marketplace again

# Interactive (walks through each step)
mcpize publish

Run

Call any MCP server's tools directly from the terminal:

# List available tools
mcpize run github-mcp
mcpize run github-mcp --list

# Call a tool with inline JSON
mcpize run github-mcp/search-repos '{"query": "mcp server", "limit": 5}'

# Use --set for simple key=value arguments
mcpize run weather/get-forecast -s city="San Francisco" -s units=metric

# Pipe input from stdin
echo '{"url": "https://example.com"}' | mcpize run scraper/extract-content

# Read arguments from file
mcpize run analytics/run-query --file query.json

# Raw JSON output (pipeable to jq)
mcpize run github-mcp/search-repos '{"query":"mcp"}' --json | jq '.data.items[].name'

# Preview request without executing
mcpize run github-mcp/search-repos '{"query":"test"}' --dry-run

# Use API key instead of session (for CI/CD)
mcpize run github-mcp/search-repos '{"query":"test"}' --api-key sk_live_xxx

Run Options

Option	Short	Description
`--list`	`-l`	List available tools for the server
`--json`	`-j`	Raw JSON output (pipeable)
`--api-key <key>`	`-k`	API key (overrides session)
`--file <path>`	`-f`	Read arguments from JSON file (`-` for stdin)
`--set <k=v>`	`-s`	Set argument key=value (repeatable)
`--dry-run`		Show request without executing
`--verbose`	`-v`	Show request/response headers and timing

Options

# Use specific server
mcpize status --server <server-id>

# Output as JSON
mcpize status --json

# Deploy without waiting
mcpize deploy --no-wait

# Auto-create server if not linked
mcpize deploy --yes

# Skip post-deploy setup wizard
mcpize deploy --skip-wizard

# Force refresh (ignore cache)
mcpize status --refresh

Global Options

Option	Description
`--token <token>`	API token (overrides `MCPIZE_TOKEN` env and saved session)

Environment Variables

Variable	Description
`MCPIZE_TOKEN`	API token (alternative to `mcpize login`)

mcpize.yaml Reference

The mcpize.yaml file configures your MCP server deployment:

version: 1
name: my-server
description: My MCP server
runtime: typescript  # typescript, python, php, container
entry: src/index.ts

build:
  install: npm ci
  command: npm run build
  # dockerfile: Dockerfile  # for container runtime

startCommand:
  type: http  # http, sse, stdio
  command: node dist/index.js
  # args: ["--port", "8080"]

# For STDIO servers (auto-bridged to HTTP)
# bridge:
#   mode: stdio

# Publisher secrets (infrastructure credentials)
secrets:
  - name: OPENAI_API_KEY
    required: true
    description: OpenAI API key

# Subscriber credentials (per-user API keys)
# credentials:
#   - name: USER_TOKEN
#     required: true
#     docs_url: https://example.com/docs
#     mapping:
#       env: API_TOKEN
# credentials_mode: per_user

Fields

Field	Required	Description
`version`	Yes	Schema version (always `1`)
`runtime`	Yes	`typescript`, `python`, `php`, or `container`
`entry`	No	Entry point file
`build.install`	No	Install command (e.g., `npm ci`)
`build.command`	No	Build command (e.g., `npm run build`)
`startCommand.type`	No	Transport: `http`, `sse`, or `stdio`
`startCommand.command`	No	Start command
`bridge.mode`	No	STDIO bridging mode (auto-wraps with mcp-proxy)
`secrets`	No	Publisher infrastructure secrets
`credentials`	No	Subscriber BYOK credentials

IDE Autocomplete

Add this to .vscode/settings.json for mcpize.yaml autocomplete:

{
  "yaml.schemas": {
    "https://raw.githubusercontent.com/mcpize/cli/main/schemas/mcpize.schema.json": "mcpize.yaml"
  }
}

License

MIT