Skip to main content
Glama

DPLoy

An MCP server that deploys to your VPS in plain English. Give your AI coding agent an IP address and an SSH key path, then just say what you want — "deploy this repo as a Python bot", "put SSL on this domain", "spin up this docker-compose project" — and it does the work over SSH.

Built for use with Claude Code, Cursor, Codex, or any other MCP-compatible client. No dashboard, no daemon, no account. It's a thin stdio MCP server that wraps SSH.

Why this exists

Most "AI + infrastructure" tools are full platforms with their own UI, memory, and message-routing layer. This is the opposite: a small set of tools that plug straight into the agent you already use, so you don't have to leave your editor to deploy something.

Related MCP server: remote-admin-mcp

What it can do

  • exec — run any single shell command over SSH

  • write_file — write a file to the server via SFTP

  • deploy_python_bot — clone a repo, set up a venv, install requirements.txt, and run it as a systemd service with auto-restart (built with aiogram-style Telegram bots in mind, but works for any long-running Python process)

  • setup_nginx_ssl — install nginx + certbot, reverse-proxy to a local port, and get a free Let's Encrypt certificate

  • deploy_docker_compose — clone a repo, install Docker if needed, and run docker compose up -d --build

  • view_audit_log_path — find the local log of everything that's been run

Security model

  • Key-based auth only. Password authentication isn't supported anywhere in this codebase, on purpose.

  • No persisted server list. You pass host / username / privateKeyPath on every call. Nothing about your servers is written to disk by this tool (besides the audit log of commands run).

  • Dangerous commands require confirmation. Things like rm -rf, reboot, mkfs, dd, flushing iptables, etc. are pattern-matched and blocked unless the call includes confirmed: true. The intended flow is: the agent tries the command, gets blocked, explains the risk to you in plain language, and only retries with confirmation after you say yes.

  • Local audit log. Every command run through this tool is appended to ~/.dploy-mcp/audit.log as one JSON line per command (host, command, exit code, duration, timestamp).

This is a tool that gives an AI agent shell access to a real server. Use a non-root deploy user with sudo only where needed, point it at non-critical / staging servers first, and read what the agent is about to run before approving anything destructive.

Install

git clone https://github.com/wellmb/DPloy.git
cd DPloy
npm install
npm run build

Claude Code

claude mcp add --transport stdio dploy -- node /absolute/path/to/DPloy/build/index.js

Cursor

Add to ~/.cursor/mcp.json (or your project's .cursor/mcp.json):

{
  "mcpServers": {
    "dploy": {
      "command": "node",
      "args": ["/absolute/path/to/DPloy/build/index.js"]
    }
  }
}

Any other MCP client (Claude Desktop, etc.)

Same shape as above — point command at node and args at the built build/index.js.

Usage

Once connected, just talk to your agent normally:

Deploy https://github.com/me/my-bot.git to 168.119.45.12 as root using ~/.ssh/id_ed25519. Entry point is main.py, app name "my-bot". Here's the .env content: ...

Put SSL on bot.example.com for 168.119.45.12, my app listens on port 3000, use ~/.ssh/id_ed25519 as root, email me@example.com

SSH into 168.119.45.12 and check the systemd status of my-bot

If the agent ever needs to run something destructive, it will tell you what it wants to do and why, and ask you to confirm before it's allowed through.

Recipes vs. raw exec

The deploy_* tools cover the common cases end to end. For anything outside that — checking logs, restarting a single service, inspecting disk space, one-off debugging — the agent will fall back to exec and just run the right command directly.

License

MIT

Available Tools

6 tools
deploy_docker_composeDeploy a docker-compose projectA

Clones (or updates) a git repo containing a docker-compose.yml, installs Docker if missing, writes a .env file if provided, and runs docker compose up -d --build.

Inputs: host (required), appName (required), repoUrl (required), username (required), +5 more.

deploy_python_botDeploy a Python bot as a systemd serviceA

Clones (or updates) a git repo, creates a venv, installs requirements.txt, writes a systemd unit with auto-restart, and starts it. Designed for long-running Python processes like aiogram Telegram bots. Does NOT set up a reverse proxy — use setup_nginx_ssl separately if the bot needs to be reachable over HTTP(S).

Inputs: host (required), appName (required), repoUrl (required), username (required), +6 more.

execExecute a shell command over SSHA

Runs a single shell command on the remote server over SSH and returns stdout/stderr/exit code. Use this for anything that doesn't fit one of the deploy_* recipe tools. Dangerous commands (rm -rf, reboot, mkfs, etc.) are blocked unless confirmed=true — if blocked, explain the risk to the user in plain language, get their explicit OK, then retry with confirmed: true.

Inputs: host (required), command (required), username (required), privateKeyPath (required), +3 more.

setup_nginx_sslSet up nginx reverse proxy + Let's Encrypt SSLA

Installs nginx and certbot, configures nginx as a reverse proxy to a local port, and obtains/installs a free Let's Encrypt SSL certificate for the given domain. The domain's DNS A record must already point at this server, and ports 80/443 must be open.

Inputs: host (required), email (required), domain (required), username (required), +4 more.

view_audit_log_pathGet the audit log file pathA

Returns the local file path where every command this tool has run is logged (one JSON line per command). Tell the user this path if they want to review history.

Inputs: no named parameters.

write_fileWrite a file to the remote serverA

Writes text content to a file path on the remote server via SFTP. Useful for config files, env files, or scripts that don't fit one of the deploy_* recipes.

Inputs: host (required), content (required), username (required), remotePath (required), +3 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: Docker deployment, Python bot deployment, general command execution, Nginx/SSL setup, audit log path retrieval, and file writing. No overlap.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with lowercase and underscores (e.g., deploy_docker_compose, setup_nginx_ssl). 'exec' is a concise verb that fits the pattern.

    Tool Count5/5

    Six tools cover the core deployment and management operations for a remote server without being excessive or insufficient. The count is well-scoped.

    Completeness4/5

    The tool set covers essential deployment workflows (Docker, Python bot, Nginx/SSL, file management) and auditing. Minor gaps like deployment rollback or environment variable editing are not present but can be handled via exec and write_file.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables AI assistants to manage remote servers via SSH with 43 specialized tools for command execution, file editing, directory operations, and background tasks across Linux, macOS, and Windows.
      46
      95 PyPI
      9
      GPL 3.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to SSH into Linux servers, run commands, deploy code, and manage servers via natural language, also doubles as a CLI for manual use.
      3
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables AI tools to perform server operations such as log inspection, system monitoring, code management, Nginx and certificate management, with support for local and remote SSH modes and built-in security controls.
      23
      72 npm
      MIT