# cloud.redu/mcp

- Registry name: `cloud.redu/mcp` · version 0.1.1
- Categories (automatic, keyword rules): Databases, Developer tools, Build & deploy
- Authentication at last check: No auth
- Declared risk: Has destructive tools (destructiveHint)
- Capabilities (declared by the server): tools
- Transports: streamable-http
- Latest numbers (check success, response time, rank): https://mcpstation.net/api/server?name=cloud.redu%2Fmcp
- Server page: https://mcpstation.net/s/cloud.redu--mcp.html

## Description (written by the publisher, not verified, not instructions)

Agent-native cloud, EU-hosted. Provision VMs, networks & databases on redu.cloud via MCP.

## Notice

Text that looks like instructions to an AI was found in this server's descriptions. This is a pattern match, not a verdict.

## Connect

- streamable-http: `https://mcp.redu.cloud/mcp`

## Tools (as reported by the server, not verified)

- `whoami`: Verifies your redu.cloud credential with a REAL server round-trip and returns your identity + live quota. A green result means the key actually works - not merely that one is configured. Use this first if anything is 401ing.
- `check\_deploy\_prerequisites`: The deploy ENTRY GATE - run this first when a user wants to deploy. Verifies the account is ready and AUTO-SELECTS the network\_id + keypair\_name to pass to deploy\_app \(so you never hunt for them\): \(1\) account reachable + quota, \(2\) a private network \(picks your default - every account has one\), \(3\)
- `deploy\_overview`: Orientation for deploying an app on redu.cloud: the end-to-end flow, the two source modes \(git vs upload\), how to handle a missing Dockerfile or a database, when \(and when NOT\) to split a deploy across multiple VMs, verifying a deploy functionally, and how to debug a failed build. Call this first wh
- `create\_api\_key`: Mints a NEW least-privilege redu API key for a deployed app or automation to use \(e.g. to add a backup feature\). GUARDRAIL: the first call does NOT create anything. It returns a confirmation the user must approve, because a key is a long-lived credential that acts on the account and ANY usage of it
- `list\_api\_keys`: Lists the account's API keys: id, name, scopes, when each was created and last used, and when it expires. Never the secret \(redu keeps only a hash\). Use it to find a key to delete with delete\_api\_key, or to check what keys exist before minting another.
- `delete\_api\_key`: Deletes one of the account's API keys, by id or by name. Anything that uses the key stops working at once, so the first call deletes nothing: it shows the key \(name, scopes, last used\) for the user to approve; call again with confirm:true only after their yes. Use it to clean up a key you created fo
- `integrate\_overview`: Orientation for wiring a redu.cloud capability \(backups, DNS, extra storage, a managed DB, ...\) INTO an app already deployed on redu, e.g. 'add a backup feature to the Supabase I deployed on redu'. Explains the pattern: mint a LEAST-PRIVILEGE scoped API key \(with the user's approval via create\_api\_k
- `prepare\_upload`: Returns the LOCAL shell commands to package your working directory and upload it for an upload-mode deploy \(no git, no PAT\). Run them in the user's terminal, capture \`source\_token\` from the upload's JSON response, then call deploy\_app with that source\_token \(omit repo\). The upload authenticates AUTO
- `scaffold\_local`: OPTIONAL preflight: returns a podman-compose.yml + .env so the user can run the app \(and a throwaway local Postgres\) on THEIR machine before deploying to redu - to see it run / sanity-check the container. Requires local podman/podman-compose. It's a suggestion, not a gate - skip it and go straight t
- `plan\_instance`: Aggregates images/flavors/keypairs/networks/security groups into human-friendly choices. Does not create anything. Happy path: import\_keypair → plan\_instance → create\_instance → get\_ssh\_command. Call this second \(after import\_keypair, if you have no keypairs\).
- `plan\_managed\_datastore`: Plans a direct managed datastore create without provisioning anything. Use this before create\_database, create\_relational\_database, create\_redis, create\_clickhouse or create\_qdrant \(engine 'qdrant', the vector database\). For app deployments you need none of these: datastores are managed by default,
- `select\_surface`: For a repo with SEVERAL runnable parts, call this BEFORE plan\_deploy. You enumerate the candidate surfaces \(find every Dockerfile/Containerfile, OPEN each, classify by its EXPOSE + CMD - never by directory name\) and pass them in; redu RANKS them with fixed rules \(a standalone browser desktop/noVNC \>
- `plan\_deploy`: Turns YOUR repo classification \(you scan the repo and pass what you found\) into a complete, approvable deploy plan WITHOUT creating anything. ⚡ REDU NEEDS THREE FILES IF THEY EXIST - redu.md, the compose file, the Dockerfile - and there are two ways to give them. ⭐ BEST, for an upload-mode deploy: r
- `list\_instances`: Lists your compute instances.
- `list\_flavors`: Lists available instance sizes.
- `list\_images`: Lists available OS images.
- `list\_keypairs`: Lists your SSH keypairs. If empty, call import\_keypair first before creating instances.
- `list\_security\_groups`: Lists your security groups.
- `list\_private\_networks`: Lists your private networks.
- `list\_volumes`: Lists your block storage volumes.
- `list\_snapshots`: Lists your instance snapshots.
- `list\_backups`: Lists your volume backups.
- `list\_clusters`: Lists your autoscaling clusters.
- `list\_dns\_entries`: Lists the public names \(DNS entries\) on this account: each entry's id, the names it serves \(domain\_names\) and the address it forwards to. delete\_dns\_entry removes one by its id.
- `list\_domains`: Lists the custom domains on this account with their status: verified \(it can be bound with dname on deploy\_app/deploy\_compose, dns\_entries on create\_instance, or set\_cluster\_domain\) or pending \(its TXT check has not passed: get\_domain\_verification gives the record, verify\_domain checks it\). The publ
- `list\_regions`: Lists available regions.
- `list\_databases`: Lists your managed PostgreSQL databases. Once a row's status is 'ready', it carries the private-network connection details \(private\_ip, port 5432, db\_name, db\_user\).
- `list\_relational\_databases`: Lists your managed MySQL/MariaDB databases \(the relational-database resource\). Each row carries its engine \('mysql'\|'mariadb'\); once status is 'ready' it has the private-network connection details \(private\_ip, port 3306, db\_name, db\_user\).
- `list\_media\_spaces`: Lists Redu media spaces: private NFS media VMs backed by persistent volumes. For WordPress/WooCommerce clusters, reuse one on the app's private network for wp-content/uploads, or pass create\_media\_space:true to deploy\_app/deploy\_compose/upgrade\_to\_cluster so Redu creates one.
- `list\_clickhouse\_databases`: Lists your managed ClickHouse databases \(OLAP / analytics - its own resource, not a relational DB\). Once a row's status is 'ready' it carries the private-network connection details \(private\_ip, ClickHouse HTTP port 8123, db\_name, db\_user\).
- `list\_redis`: Lists your managed Redis instances. Once a row's status is 'ready' it carries the private-network connection details \(private\_ip, port 6379\) - connect from another instance on the same private network with redis-cli -h \<private\_ip\> -p 6379 -a \<password\>.
- `list\_qdrant`: Lists your managed Qdrant vector databases \(create\_qdrant, or started for a deploy\). Once a row's status is 'ready' it carries private\_ip \(REST port 6333, gRPC 6334\); the API key is never listed.
- `create\_media\_space`: Creates a private Redu media space: a small NFS VM backed by a persistent volume, intended for WordPress/WooCommerce wp-content/uploads in autoscaling clusters. Prefer letting deploy\_app/deploy\_compose create this by passing create\_media\_space:true after plan\_deploy approval; use this tool when manu
- `upgrade\_to\_cluster`: THE WAY TO MAKE AN EXISTING APP HIGHLY AVAILABLE. If the user asks for high availability, redundancy, no single point of failure, surviving a host or VM failure, or 'stay up if a machine dies', this is the tool: point it at their running VM and pass high\_availability:true. It needs no rebuild and no
- `update\_cluster`: Updates a running autoscaling cluster to a new app version IN PLACE, with NO URL change: snapshots the 'hero' VM \(the source/master VM you SSH into and change - it is also the always-on baseline member that serves traffic\), then redu rolling-updates the autoscaled extra members to that snapshot ONE
- `set\_cluster\_domain`: Changes the PUBLIC HOSTNAME a cluster serves on, so the user can put THEIR OWN production domain \(shop.acme.com, app.theircompany.com\) in front of it instead of the auto-generated redu.cloud URL. That is what this tool is for: a real product on a real brand. The cluster itself is untouched - same me
- `delete\_cluster`: Deletes an autoscaling cluster - tears down the WHOLE cluster: every autoscaled EXTRA member VM, the load balancer, the pool, the cluster security group, and the cluster's \*.redu.cloud proxy host. Your SOURCE \(hero\) VM is NOT part of the stack and is NOT deleted - it was the always-on baseline membe
- `import\_keypair`: Registers an existing SSH public key on your account. Use this to import your own public key so you can SSH into instances. The private key never leaves your machine.
- `delete\_keypair`: Removes an SSH keypair from your account by name.
- `get\_ssh\_command`: Returns the SSH command to connect to an instance via the redu.cloud TCP proxy. ACCEPTS an instance id, a deployment's id / name / instance\_id, OR a MANAGED DATASTORE's id / name / instance\_id \(Postgres, MySQL/MariaDB, ClickHouse, Redis\) - it resolves all of them, so you do not have to work out whic
- `get\_instance\_logs`: The VM's SERIAL CONSOLE: kernel messages and early-boot/cloud-init output. ⛔ THIS IS NOT YOUR APPLICATION'S LOGS. For a deployed app - a crash loop, a 500, a failed DB connection - use get\_container\_logs, which returns what the containers actually printed. Reach for this one only for boot-level ques
- `instance\_action`: Start, stop, or reboot an instance. action must be START, STOP, REBOOT\_SOFT, or REBOOT\_HARD.
- `create\_instance`: Creates a raw compute instance for custom OS/cloud-init workflows. For app/source deployments, prefer check\_deploy\_prerequisites -\> plan\_deploy -\> deploy\_app/deploy\_compose; do not use create\_instance as a shortcut around the deployment plan. Requires a recent plan\_instance. For reduOS, set cloud\_in
- `delete\_instance`: Permanently deletes an instance. This cannot be undone.
- `create\_database`: Provisions a managed PostgreSQL database on a dedicated VM on your private network. Requires a recent plan\_managed\_datastore. For app deployments, prefer deploy\_app database:'managed' so plan\_deploy includes and wires the DB automatically. It is PRIVATE - reachable only from another instance on the
- `delete\_database`: Deletes a managed Postgres database and its underlying VM. Pass the numeric database id from list\_databases. This cannot be undone.
- `create\_relational\_database`: Provisions a managed MySQL \(or MariaDB\) database on a dedicated VM on your private network - the relational-database resource \(use this instead of create\_database when the app needs MySQL/MariaDB, e.g. WordPress, NextCloud, Matomo, many PHP/LAMP apps\). Requires a recent plan\_managed\_datastore. For a
- `delete\_relational\_database`: Deletes a managed MySQL/MariaDB database and its underlying VM. Pass the numeric id from list\_relational\_databases. This cannot be undone.
- `create\_clickhouse`: Provisions a managed ClickHouse database \(OLAP / columnar analytics engine, Apache-2.0\) on a dedicated VM on your private network - its OWN resource, NOT a relational database. Requires a recent plan\_managed\_datastore. Use it for analytics / observability workloads that need a column store \(PostHog,
- `delete\_clickhouse`: Deletes a managed ClickHouse database and its underlying VM. Pass the numeric id from list\_clickhouse\_databases. This cannot be undone.
- `upgrade\_to\_ha`: Turns an EXISTING, running single-machine managed Postgres or ClickHouse into a THREE-machine highly available cluster, in place, keeping the data and the same username, password and database name. Use this when the user has a live database and wants it to survive a machine or host failure: they do
- `create\_redis`: Provisions a managed Redis instance on a dedicated VM on your private network. Requires a recent plan\_managed\_datastore. It is PRIVATE - reachable only from another instance on the same private network, via its internal/private IP on port 6379 \(not a public address\). AUTH \(requirepass\) is always ena
- `delete\_redis`: Deletes a managed Redis instance and its underlying VM. Pass the numeric id from list\_redis. This cannot be undone.
- `create\_qdrant`: Provisions a managed Qdrant vector database on a dedicated VM. Requires a recent plan\_managed\_datastore \(engine 'qdrant'\). Reachable from your private network at \<private\_ip\>:6333 \(REST\) and :6334 \(gRPC\), and at a public https URL; every request must carry the api-key header \(always required\). Backu
- `delete\_qdrant`: Deletes a managed Qdrant and its underlying VM, with every collection in it. Pass the numeric id from list\_qdrant. This cannot be undone.
- `deploy\_app`: Deploys an app to a VM and exposes it at a public https://\<name\>-\<id\>.redu.cloud URL. The container is built ON the VM. PREREQS - run check\_deploy\_prerequisites first for network\_id + keypair\_name, then plan\_deploy for cost approval. Source can be git repo or prepare\_upload source\_token. PORT must b
- `deploy\_compose`: Deploys a MULTI-CONTAINER app - a repo that ships docker-compose.yml / compose.yaml - onto ONE VM via podman-compose, and exposes one or more services at redu.cloud URLs. Use this instead of deploy\_app when the repo is a compose stack. Same prereqs + source modes as deploy\_app; always run plan\_deplo
- `deploy\_vpn`: Stands up a redu VPN gateway \(WireGuard tunnelled over wstunnel on WSS/443\) on your PRIVATE network, so you \(or your team\) can reach the private IPs of the VMs you deployed on redu, over a single https endpoint - no UDP, no extra ports. This is the TENANT VPN for reaching your OWN deployed resources
- `list\_deployments`: Lists your app deployments. Each row carries status \(provisioning/ready/build\_failed/error\), the current build phase while provisioning \(installing/source/building/built/starting\), the public access\_point URL, port, repo, and build\_log on failure.
- `verify\_deployment`: Asks redu to re-probe a deployment's public URL and update its status from what it actually observes. USE THIS AFTER YOU HAVE FIXED A FAILED DEPLOY - a deployment that ended 'error' or 'build\_failed' but is now serving becomes 'ready' again, and you do NOT need to redeploy it to get a green status.
- `delete\_deployment`: Deletes a deployment and its underlying app VM, with the data kept on that machine \(its named volumes\): the only way kept data is deleted, so ask the user first. Pass the numeric id from list\_deployments. IMPORTANT: its managed datastores are NOT deleted \(data safety\): its database, Redis and Qdrant
- `wait\_for\_deployment`: ⭐ CALL THIS INSTEAD OF POLLING. Waits up to 50 seconds per call \(an MCP client cuts a call at about 60 s\) for the deployment to reach a TERMINAL state \(ready, build\_failed, error or vm\_missing\) and returns, in ONE response, everything you would otherwise fetch afterwards: the HTTP status of the PUBL
- `get\_deployment`: Fetches ONE deployment by its numeric id \(from list\_deployments\). Returns its current status, the public access\_point URL, the underlying VM id, AND the build\_log - IN FULL when status is 'build\_failed' or 'error', which is when it is the diagnosis and you should read it; otherwise the LAST 40 LINES
- `get\_containers`: WHAT IS ACTUALLY RUNNING on a deployment's VM: every container's name, image, state, health, restart count, exit code and published ports - including the ones that have CRASHED, which are the ones you need. Use this the moment a deployment says 'ready' but the URL misbehaves, and before you reach fo
- `get\_container\_logs`: THE APPLICATION'S OWN LOGS - what \`docker logs\`/\`podman logs\` would show for each container in a deployment. This is the tool for 'it deployed fine but it does not work': a 500, a crash loop, a failed DB connection, a missing env var all announce themselves here and NOWHERE else. ⛔ DO NOT use get\_in
- `get\_resource\_usage`: HOW MUCH ROOM IS LEFT on a deployment's VM: total/used/available memory, swap, disk free, load average, CPU count, and OOM kills in the last 24h - plus per-container memory and CPU. Use it to answer 'is this flavor big enough', to size the NEXT deploy of the same app honestly instead of guessing, an
- `get\_env\_keys`: WHICH ENVIRONMENT VARIABLES the deployment was actually given, BY NAME - the keys in the env files on the VM \(/opt/app-src/.env and friends\), never the values. Most of the time the real question is 'did DATABASE\_URL get wired, or is the app reading a name I did not set', and the name answers it: you
- `architecture\_diagram`: Read-only. Fetches EVERY resource on your redu.cloud account \(VMs, volumes, private networks, managed databases: Postgres/MySQL/MariaDB/ClickHouse/Redis/Qdrant, load balancers, and DNS access points\) and renders ONE Mermaid diagram of the whole account, grouped into per-private-network subgraphs wit
- `create\_snapshot`: Creates a snapshot of a running instance.
- `delete\_snapshot`: Deletes a snapshot by ID.
- `create\_backup`: Creates a backup, by volumeId or by instanceId \(the instance's volume is resolved for you\). The backup is held independently of the instance, so it survives the VM. Poll list\_backups until the new backup is available.
- `restore\_backup`: Restores a backup into an existing volume \(volumeId\), an instance's volume \(instanceId\), or a new one \(volumeName\). Poll list\_volumes for the restored volume. DISASTER RECOVERY \(the original VM is gone, so its volume died with it\): restore with volumeName to rebuild the data as a NEW volume. To brin
- `delete\_backup`: Deletes a backup by ID.
- `set\_managed\_backups`: Turns nightly AUTOMATED \(scheduled\) backups ON or OFF for a MANAGED data service - the toggle that create\_backup \(a one-off volume snapshot\) is NOT. Once enabled, redu's nightly job backs the service up on its own and prunes to the retention window; see them with list\_backups and recover with the se
- `create\_volume`: Creates a block storage volume.
- `attach\_volume`: Attaches an EXISTING block volume to a running instance as an extra disk. This is how you finish a RESTORE after a VM is gone: restore\_backup \(volumeName\) rebuilds the data into a new volume, then attach\_volume puts that volume on a replacement instance - then SSH in \(get\_ssh\_command\) and mount it \(
- `detach\_volume`: Detaches a block volume from an instance, leaving the volume \(and its data\) intact and 'available' to attach elsewhere. Unmount it INSIDE the guest first \(\`umount /mnt/...\`\) or you risk a dirty filesystem. You cannot detach an instance's ROOT/boot disk while it runs. Use this to move a data volume t
- `delete\_volume`: Permanently deletes a block storage volume and the data on it. This cannot be undone. The volume must be 'available' \(detached\) - detach\_volume it first, and note you cannot detach a running instance's boot disk. A volume left behind after a restore keeps billing, so delete the ones you no longer ne
- `get\_domain\_verification`: Starts \(or resumes\) a claim on a custom domain and returns the DNS TXT record that proves it is the user's: they add it at the domain's DNS provider, then you call verify\_domain. Until it verifies, list\_domains shows the domain as pending. A pending claim's TXT value can change \(values are specific
- `verify\_domain`: Checks the DNS TXT ownership record of a custom domain and, when it matches, marks the domain verified for this account. Call get\_domain\_verification first for the record, have the user add it at their DNS provider, then call this until it reports verified \(a new record can take minutes, sometimes h
- `release\_domain`: Removes a custom domain from this account: a verified domain is no longer verified for it \(using it again needs a new TXT check\), and a pending claim is cancelled. The first call releases nothing: it shows the domain for the user to approve; call again with confirm:true only after their yes. The sec
- `delete\_dns\_entry`: Removes one public name \(a DNS entry\), by its id from list\_dns\_entries or by the name itself. The name stops serving at once, and anything reached through it \(a site, an API, an OAuth callback\) stops working with it. When the name belongs to one of your instances or deployments, that instance's own
- `check\_agent\_prerequisites`: Checks if your account has everything needed to run autonomous coding agents. Returns a checklist: API key validity, private network, SSH keypair, and billing. Safe to call anytime - read-only. Call this first before create\_controller.
- `create\_controller`: Creates a self-configuring controller VM on redu.cloud. Auto-discovers your network, Ubuntu image, and flavor. Generates and uploads an SSH keypair if you don't have one. The VM bootstraps itself - no SSH or VPN needed. After \~7 minutes, authorize the fleet \(run the authorize.sh one-liner it returns
- `trigger\_agent\_batch`: Starts the autonomous agent batch on your controller VM. Agents read agent-ready tasks from your ROADMAP.md, implement them in parallel, and open PRs. No VPN needed - runs over HTTPS; the controller stays running after you disconnect. Each ROADMAP task MUST be a single checkbox line \`- \[ \] \*\*Title\*\*
- `get\_agent\_status`: Returns the current status of your controller VM. On a freshly set-up VM also returns the trigger token needed to authorize the fleet and to call trigger\_agent\_batch. Call this after setup\_agent\_fleet to confirm the VM is ready.
- `setup\_agent\_session`: One-shot tool that guides you through the complete agent setup: checks prerequisites, creates the controller VM, and returns next steps. Ideal for first-time setup. Call this when a user says 'set up autocoding agents for my repo'.
- `setup\_agent\_fleet`: Complete one-shot setup: validates prerequisites, creates a controller VM + worker VMs, auto-creates a public HTTPS URL on port 7070, seeds a starter ROADMAP.md into the repo if absent, and returns the trigger token. Call this when a user says 'set up autocoding agents for my repo' or 'I want agents

Measured by MCP Station. Methods: https://mcpstation.net/methods.html · Terms: https://mcpstation.net/terms.html