Allows deploying Docker Compose projects to a VPS, including cloning the repository, installing Docker if needed, and running docker compose up -d --build.
Allows obtaining free SSL certificates using certbot for domains secured by nginx.
Allows setting up nginx as a reverse proxy to a local port for a domain.
Allows deploying Python bots or applications as systemd services with auto-restart, including cloning repo, setting up venv, and installing dependencies.
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., "@DPLoy Deploy https://github.com/me/my-bot.git to 168.119.45.12 as root using ~/.ssh/id_ed25519."
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.
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.
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
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
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.
git clone https://github.com/wellmb/DPloy.git
cd DPloy
npm install
npm run buildclaude mcp add --transport stdio dploy -- node /absolute/path/to/DPloy/build/index.jsAdd to ~/.cursor/mcp.json (or your project's .cursor/mcp.json):
{
"mcpServers": {
"dploy": {
"command": "node",
"args": ["/absolute/path/to/DPloy/build/index.js"]
}
}
}Same shape as above — point command at node and args at the built
build/index.js.
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.
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.
MIT
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.
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Server IP address or hostname, e.g. 168.119.45.12 | |
| port | No | SSH port, defaults to 22 | |
| branch | No | Git branch to checkout | |
| appName | Yes | Short name for this app, used as the directory name | |
| repoUrl | Yes | Git repo URL containing docker-compose.yml at its root | |
| username | Yes | SSH username, e.g. root or deploy | |
| passphrase | No | Passphrase for the private key, if it has one | |
| envFileContent | No | Contents to write as .env next to docker-compose.yml | |
| privateKeyPath | Yes | Path to the private key on THIS machine, e.g. "~/.ssh/id_ed25519" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It clearly states the tool clones/updates a git repo, installs Docker if missing, writes a .env file if provided, and runs docker compose up -d --build. This covers major side effects (Docker installation, file creation). However, it does not mention prerequisites like git existing, potential overwriting of existing files, or what happens on failure. Still, it is fairly transparent.
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 concise sentence that front-loads the main action and lists key steps. Every phrase is necessary, and there is no fluff. It is appropriately sized for the tool's complexity.
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?
With 9 parameters, no output schema, and no annotations, the description covers the main workflow but misses important details like parameter relationships, success criteria, or what happens when Docker is already installed. The sibling tools are diverse, and more context on when to use this over exec or write_file would improve completeness. It is adequate but has gaps.
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 input schema already documents all 9 parameters with individual descriptions. The tool description adds minimal extra meaning beyond providing a high-level workflow (e.g., 'writes a .env file if provided' maps to envFileContent). With full schema coverage, a baseline of 3 is appropriate, and the description does not significantly enhance parameter understanding.
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 title and description clearly state it deploys a docker-compose project. The description enumerates specific steps (clone/update git repo, install Docker, write .env file, run docker compose up -d --build), making the purpose very specific. It distinguishes from sibling tools like deploy_python_bot, exec, and write_file.
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 implies usage for docker-compose projects but provides no explicit guidelines on when to use or avoid this tool. No alternatives are mentioned, and there is no discussion of prerequisites or scenarios where exec or write_file might be preferred. The context from sibling tools offers some implicit differentiation, but the description itself lacks guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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).
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Server IP address or hostname, e.g. 168.119.45.12 | |
| port | No | SSH port, defaults to 22 | |
| branch | No | Git branch to checkout, defaults to the repo's default branch | |
| appName | Yes | Short name for this app, used as the directory and service name, e.g. 'solpath-bot' | |
| repoUrl | Yes | Git repo URL to clone, e.g. https://github.com/you/your-bot.git | |
| username | Yes | SSH username, e.g. root or deploy | |
| entryPoint | Yes | Path to the entry script relative to the repo root, e.g. 'main.py' | |
| passphrase | No | Passphrase for the private key, if it has one | |
| envFileContent | No | Contents to write as .env in the app directory (API keys, etc.) | |
| privateKeyPath | Yes | Path to the private key on THIS machine, e.g. "~/.ssh/id_ed25519" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description outlines key behaviors (clones/updates repo, creates venv, installs requirements, writes systemd unit, starts service). However, it lacks details on idempotency, error handling, SSH key management, and what happens if the service or directory already exists.
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: first covers the core actions, second provides purpose and exclusion. No redundant information; every sentence adds value.
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 10 parameters, no output schema, and no annotations, the description covers main behaviors but misses important details like idempotency, SSH key handling, and handling of existing deployments. Adequate but has gaps that could confuse an AI agent.
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 coverage is 100%, so the description adds minimal meaning beyond attribute names. It references entryPoint and appName in context but does not elaborate on parameter formats, constraints, or relationships.
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 explicitly states the tool clones/updates a git repo, creates a venv, installs requirements, writes a systemd unit with auto-restart, and starts it. It specifies it is for long-running Python processes like aiogram Telegram bots and distinguishes from sibling tool setup_nginx_ssl by stating what it does NOT do.
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?
Provides clear guidance: designed for long-running Python processes (e.g., Telegram bots) and explicitly states when not to use (when a reverse proxy is needed) with a direct alternative: 'use setup_nginx_ssl separately'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Server IP address or hostname, e.g. 168.119.45.12 | |
| port | No | SSH port, defaults to 22 | |
| command | Yes | The shell command to run, e.g. 'systemctl status nginx' | |
| username | Yes | SSH username, e.g. root or deploy | |
| confirmed | No | Set to true only after the user has explicitly approved a flagged dangerous command | |
| passphrase | No | Passphrase for the private key, if it has one | |
| privateKeyPath | Yes | Path to the private key on THIS machine, e.g. "~/.ssh/id_ed25519" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: it runs a command remotely, returns stdout/stderr/exit code, and blocks dangerous commands unless confirmed=true. It also instructs how to handle blocked commands by explaining risks and getting explicit user approval.
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?
Three efficient sentences with no wasted words. The description is front-loaded with the core action and return format, then usage guidance, then safety protocol.
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?
Despite no output schema, the description explicitly mentions the return values (stdout/stderr/exit code). It covers when to use, dangerous command handling, and basic parameters. For a complex tool with 7 parameters, it provides sufficient context without being overly verbose.
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 coverage is 100%, so baseline is 3. The description adds value by explaining the confirmed parameter in context of dangerous commands and implying the use of host and username. It gives additional semantic meaning beyond the schema descriptions.
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 runs a single shell command over SSH and returns stdout/stderr/exit code. It distinguishes itself from sibling deploy_* recipe tools by explicitly stating to use it for anything that doesn't fit those recipes.
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?
Explicitly states when to use this tool: 'Use this for anything that doesn't fit one of the deploy_* recipe tools.' It also provides guidance on dangerous commands, explaining the blocking mechanism and how to handle it with user confirmation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Server IP address or hostname, e.g. 168.119.45.12 | |
| port | No | SSH port, defaults to 22 | |
| Yes | Email for Let's Encrypt registration and expiry notices | ||
| domain | Yes | Domain name pointing at this server, e.g. bot.example.com | |
| username | Yes | SSH username, e.g. root or deploy | |
| passphrase | No | Passphrase for the private key, if it has one | |
| upstreamPort | Yes | Local port the app listens on, e.g. 3000 | |
| privateKeyPath | Yes | Path to the private key on THIS machine, e.g. "~/.ssh/id_ed25519" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool installs software and modifies configuration, which implies system-level changes. However, it does not explicitly state that existing nginx configurations may be overwritten or that the tool requires root privileges.
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 two sentences long, front-loaded with the core purpose, and every word adds value. No redundant or verbose phrasing.
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 setup tool with 8 parameters and no output schema, the description covers the essential workflow and prerequisites. It is sufficient for an agent to determine when to invoke this tool and what it accomplishes, though details on post-execution state are omitted.
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 input schema has 100% description coverage, so the schema already explains each parameter well. The description adds minimal extra context beyond the prerequisites. The baseline of 3 is appropriate.
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 installs nginx and certbot, configures a reverse proxy, and obtains a Let's Encrypt SSL certificate. These specific actions distinguish it from sibling tools like deploy_docker_compose or exec, which have different purposes.
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 explicitly specifies prerequisites: DNS A record must point at the server and ports 80/443 must be open. This tells the agent when the tool can be used, though it does not directly mention when not to use it or suggest alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool is read-only and returns a file path with each command logged as one JSON line. No side effects or hidden traits are needed for this simple 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?
Two sentences, front-loaded with the core function, and no wasted words. The first sentence states the action and result, the second gives usage advice. Perfectly concise.
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 has no parameters, no output schema, and a straightforward purpose, the description covers everything needed: what it returns and what to do with it. No gaps.
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 zero parameters, so schema coverage is 100% (vacuous). As per guidelines, a baseline of 4 is appropriate since the description does not need to add parameter meaning.
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 returns a local file path for audit logs, specifying the exact resource (audit log file) and the action (returns path). It distinguishes from sibling tools which are all about deployment and file writing, none providing audit log paths.
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 explicitly advises to tell the user this path if they want to review history, providing clear context for when to use. It does not discuss alternatives or when not to use, but given the tool's simplicity, this is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Server IP address or hostname, e.g. 168.119.45.12 | |
| port | No | SSH port, defaults to 22 | |
| content | Yes | File content to write | |
| username | Yes | SSH username, e.g. root or deploy | |
| passphrase | No | Passphrase for the private key, if it has one | |
| remotePath | Yes | Absolute or ~-relative path on the remote server | |
| privateKeyPath | Yes | Path to the private key on THIS machine, e.g. "~/.ssh/id_ed25519" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations so description must carry full burden. States it writes via SFTP, but lacks details on overwrite behavior, error handling, or permission requirements. Adequate for basic understanding but not comprehensive.
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, front-loaded with the core action, no redundant information. Every word adds value.
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?
With 7 parameters, 5 required, and no output schema or annotations, the description could include more about return behavior, overwrite safety, or prerequisites. Still, it covers the primary 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?
Schema coverage is 100% with all parameters described. Description adds no extra parameter information beyond the schema, so baseline score is appropriate.
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?
Clearly states the action (writes text content via SFTP), the resource (file path on remote server), and distinguishes from sibling deploy_* tools by specifying use cases like config files and scripts.
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?
Provides explicit context when to use (config files, env files, scripts) and hints at alternatives (deploy_* recipes). Missing guidance on when not to use relative to exec or other tools, but sufficient for most agents.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0deploy_docker_composedeploy_python_botexecsetup_nginx_sslview_audit_log_pathwrite_fileEach 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.
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.
Six tools cover the core deployment and management operations for a remote server without being excessive or insufficient. The count is well-scoped.
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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Deploy and manage your apps, databases, storage, and scheduled jobs from your AI agent
Let AI operate servers without SSH. Choose actions, approve risky changes, and audit every step.
Build and deploy websites, Telegram and Discord bots from chat via the DreamAgent platform.
Zero-Ops deploy of a private AI workspace to your own VPS — from your AI chat. Free and open-source.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/wellmb/DPloy'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
