MCP server

Redu Official

cloud.redu/mcp

Checked 26 Oct 2026, 08:29 UTC · Connected to it and listed its tools

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

At a glance

Type

MCP server

Publisher

redu.cloud (verified by the MCP Registry)

Status

Working at last check

Tools

95

Token cost

About 42,096 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

26 Oct 2026, 08:29 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

claude mcp add --transport http redu https://mcp.redu.cloud/mcp

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.redu]
url = "https://mcp.redu.cloud/mcp"

Gemini CLI

{"mcpServers":{"redu":{"httpUrl":"https://mcp.redu.cloud/mcp"}}}

Cursor

{"mcpServers":{"redu":{"url":"https://mcp.redu.cloud/mcp"}}}

VS Code

{"servers":{"redu":{"type":"http","url":"https://mcp.redu.cloud/mcp"}}}

Antigravity

agy mcp add redu https://mcp.redu.cloud/mcp

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"redu","server_url":"https://mcp.redu.cloud/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"redu","server_url":"https://mcp.redu.cloud/mcp"}

Tools

• architecture_diagram ~376 tokens
  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
• attach_volume ~352 tokens
  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 (
• check_agent_prerequisites ~154 tokens
  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.
• check_deploy_prerequisites ~338 tokens
  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)
• create_api_key Changes accounts · ~462 tokens
  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
• create_backup ~245 tokens
  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.
• create_clickhouse ~1553 tokens
  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,
• create_controller ~254 tokens
  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
• create_database ~1356 tokens
  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
• create_instance ~772 tokens
  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
• create_media_space ~465 tokens
  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
• create_private_vps ~386 tokens
  Approved pilot accounts only. Create one website VM (1 CPU, 2 GiB RAM, 10 GiB total disk) or one database VM (1 CPU, 1 GiB RAM, 2 GiB total disk). Both start with plain Ubuntu. Maximum one of each, including pending and stopped VMs. The pair shares a 5 GB outgoing Internet budget; incoming and priva
• create_qdrant ~540 tokens
  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
• create_redis ~576 tokens
  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
• create_relational_database ~810 tokens
  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
• create_snapshot ~99 tokens
  Creates a snapshot of a running instance.
• create_volume ~95 tokens
  Creates a block storage volume.
• delete_api_key Deletes data · ~276 tokens
  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
• delete_backup Deletes data · ~84 tokens
  Deletes a backup by ID.
• delete_clickhouse Deletes data · ~118 tokens
  Deletes a managed ClickHouse database and its underlying VM. Pass the numeric id from list_clickhouse_databases. This cannot be undone.
• delete_cluster Deletes data · ~329 tokens
  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
• delete_database Deletes data · ~116 tokens
  Deletes a managed Postgres database and its underlying VM. Pass the numeric database id from list_databases. This cannot be undone.
• delete_deployment Deletes data · ~226 tokens
  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
• delete_dns_entry Deletes data · ~409 tokens
  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
• delete_instance Deletes data · ~94 tokens
  Permanently deletes an instance. This cannot be undone.
• delete_keypair Deletes data · ~94 tokens
  Removes an SSH keypair from your account by name.
• delete_private_vps Deletes data · ~238 tokens
  Permanently delete one of your pilot VMs and its boot disk, including all stored data. Requires explicit user authorization. Use the occupied operation id from get_private_vps_pilot, not a paid VM id. After deletion is verified its one-per-account slot becomes available for a new create_private_vps
• delete_qdrant Deletes data · ~117 tokens
  Deletes a managed Qdrant and its underlying VM, with every collection in it. Pass the numeric id from list_qdrant. This cannot be undone.
• delete_redis Deletes data · ~110 tokens
  Deletes a managed Redis instance and its underlying VM. Pass the numeric id from list_redis. This cannot be undone.
• delete_relational_database Deletes data · ~121 tokens
  Deletes a managed MySQL/MariaDB database and its underlying VM. Pass the numeric id from list_relational_databases. This cannot be undone.
• delete_snapshot Deletes data · ~86 tokens
  Deletes a snapshot by ID.
• delete_volume Deletes data · ~186 tokens
  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
• deploy_app ~4187 tokens
  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 ~3832 tokens
  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_overview ~149 tokens
  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
• deploy_vpn ~609 tokens
  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
• detach_volume ~287 tokens
  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
• exec_private_vps ~354 tokens
  Run a user-requested shell script as ubuntu on an active pilot VM (sudo is available). Both pilots start as plain Ubuntu: install only the database or app the user requested. Either size can run commands without the other pilot. The smaller database pilot can clone from GitHub and download packages
• get_agent_status ~204 tokens
  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.
• get_container_logs ~473 tokens
  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_containers ~372 tokens
  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_deployment ~607 tokens
  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_domain_verification ~262 tokens
  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
• get_env_keys ~325 tokens
  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
• get_instance_logs ~258 tokens
  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
• get_private_vps_action ~128 tokens
  Read the status, bounded output and exit code of your pilot command, or the SSH access instructions. An unknown result must be inspected before submitting a new request. Does not repeat commands.
• get_private_vps_pilot ~77 tokens
  Read your private VPS pilot approval and occupied website/database slots. This does not create a VM or change billing.
• get_private_vps_ssh ~326 tokens
  Install the user's SSH PUBLIC key on either pilot and return its SSH connection instructions through the restricted relay. The smaller database pilot works on its own; no website pilot is needed. Application ports stay private. Reuse or generate an Ed25519 key locally; send only its public key, neve
• get_resource_usage ~299 tokens
  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_ssh_command ~515 tokens
  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
• import_keypair ~187 tokens
  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.
• instance_action ~121 tokens
  Start, stop, or reboot an instance. action must be START, STOP, REBOOT_SOFT, or REBOOT_HARD.
• integrate_overview ~178 tokens
  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
• list_api_keys ~113 tokens
  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.
• list_backups ~48 tokens
  Lists your volume backups.
• list_clickhouse_databases ~113 tokens
  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_clusters ~50 tokens
  Lists your autoscaling clusters.
• list_databases ~88 tokens
  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_deployments ~112 tokens
  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.
• list_dns_entries ~92 tokens
  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 ~155 tokens
  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_flavors ~50 tokens
  Lists available instance sizes.
• list_images ~48 tokens
  Lists available OS images.
• list_instances ~50 tokens
  Lists your compute instances.
• list_keypairs ~66 tokens
  Lists your SSH keypairs. If empty, call import_keypair first before creating instances.
• list_media_spaces ~121 tokens
  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_private_networks ~51 tokens
  Lists your private networks.
• list_qdrant ~96 tokens
  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.
• list_redis ~113 tokens
  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_regions ~48 tokens
  Lists available regions.
• list_relational_databases ~113 tokens
  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_security_groups ~51 tokens
  Lists your security groups.
• list_snapshots ~50 tokens
  Lists your instance snapshots.
• list_volumes ~50 tokens
  Lists your block storage volumes.
• plan_deploy ~3747 tokens
  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
• plan_instance ~153 tokens
  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 ~463 tokens
  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,
• prepare_upload ~337 tokens
  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
• publish_private_vps Sends messages · ~335 tokens
  Publish a user-requested HTTP application from either pilot, including the smaller pilot on its own, at a generated public HTTPS URL. First install and start the application, enable its production authentication and verify its local HTTP port. This publishes the app only; it does not assign a public
• release_domain ~329 tokens
  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
• restore_backup ~405 tokens
  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
• scaffold_local ~339 tokens
  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
• select_surface ~794 tokens
  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 >
• set_cluster_domain ~768 tokens
  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
• set_managed_backups ~470 tokens
  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
• setup_agent_fleet ~693 tokens
  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
• setup_agent_session ~184 tokens
  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'.
• trigger_agent_batch ~282 tokens
  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**
• update_cluster ~620 tokens
  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
• upgrade_to_cluster ~2989 tokens
  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
• upgrade_to_ha ~1180 tokens
  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
• verify_deployment ~304 tokens
  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.
• verify_domain ~302 tokens
  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
• wait_for_deployment ~434 tokens
  ⭐ 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
• whoami ~103 tokens
  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.

Browse

• MariaDB tools
• PostHog tools
• Domains and DNS
• Online shops
• Web analytics
• Databases

Related MCP servers

• VibeKit
  Build, deploy, and operate hosted web apps on VibeKit (vibekit.bot) from any MCP client.
• Entity Enricher
  Multi-LLM entity enrichment: schemas, single/batch enrichment, fusion, model benchmarks.
• Gluecron
  AI-native git hosting — repos, PRs, issues, CI gates, and AI code review over MCP (60 tools).
• Kleap
  Build, edit, publish, and manage websites and web apps with Kleap hosting, domains, and analytics.
• Hetzner Cloud MCP by usefulapi
  Servers, volumes, networks, firewalls, load balancers, pricing and safe power operations.
• Noxgild
  Secure AI access to Windows, macOS, Linux computers and a hosted Cloud Browser.
• OSIR Domain Registrar
  Register, renew, transfer, and manage domains, DNS, VPS, and email with 106 tools. By OSIR.
• Shiply
  Publish any app in one call: SQL database, functions, email, and a custom domain. Flat price.

Badge for your README

[![AptLynx](https://aptlynx.net/badge/cloud.redu/mcp.svg)](https://aptlynx.net/servers/cloud.redu/mcp)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents