Skip to main content
Glama
Cloady

Cloady

Official
by Cloady

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
API_BASE_URLNoOverrides the target API endpoint if you run Cloady elsewhere.
BEARER_TOKEN_CLOADYYesYour Cloady API token, created in the dashboard under Account → API tokens.

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
getMeA

Get the authenticated user

updateMeA

Update your name, avatar, account card or password (requires full scope).

listRegionsA

List available regions

getHealthA

Check the control plane's database, registry and every ready region. Public: no token needed. Answers 503 when any check fails.

getAiStatusB

Whether Ask AI is set up. Public: no token needed.

askAiA

Public: without credentials a caller gets 7 answers a day per IP address. An API key or a signed-in session gets 60 an hour and answers about its own account, and can build: the AI writes files, uploads them and deploys them, which a read-scope key cannot. A key that isn't valid is refused rather than answered anonymously. Requests with deployment tools can take up to two hours; read-only and anonymous requests have a ten-minute deadline. Set the client timeout accordingly. deploy names a template, repository or image the answer suggests deploying. To carry the conversation on with Cloady support, open a ticket with createTicket: the AI answers it first.

inspectPublicSourceA

Read a public GitHub repository, or a template, and preview what it would deploy. Public: no token needed. Answers 429 when GitHub's rate limit, shared by every caller, runs out. Signed in, use inspectSource.

lookupImageA

Look up a public Docker image and the one-service compose file that runs it. Public: no token needed. Reads Docker Hub, ghcr.io, quay.io, gcr.io, public.ecr.aws, mcr.microsoft.com, registry.gitlab.com and lscr.io only. image is null when the image is not found.

checkDnsA

The addresses a custom domain must point at and, with host, whether it already does and whether another app holds it. Public: no token needed.

checkDomainsA

Checks a name across popular extensions, with what registering each costs on Cloady. q is a name (acme) or a domain (acme.dev): the name searched for comes first, with .com when no extension was typed, then the same name under other extensions, then free variants of it. Availability comes from each registry's RDAP server, or from DNS where an extension has none, so registerDomain's dry run has the final word, on premium names too. With exact, only the name searched for is checked. Public: no token needed.

getWhoisA

What the domain's registry publishes over RDAP: registrar, dates, statuses, nameservers, DNSSEC and the registrant, which is usually redacted. For an extension without RDAP, only whether the domain has nameservers is known. Public: no token needed.

contactSupportA

Send a message to Cloady support without an account. Public: no token needed.

listGithubInstallationsA

List the GitHub App installations your GitHub account can see.

listWorkspacesA

List workspaces for the authenticated user

createWorkspaceB

Create a workspace (requires full scope)

getWorkspaceA

Get a workspace by slug

deleteWorkspaceB

Delete a workspace (requires full scope)

updateWorkspaceC

Update a workspace (requires full scope)

inspectSourceC

Inspect a source and preview its template

listImportableServicesA

Lists the projects and services the provider token can see, each marked importable or not, with the reason. The token is used for this call only and never stored. Import one with importProviderService.

importProviderServiceA

Reads one service from the provider and returns what deployApp needs to recreate it: a source to pass to deployApp as it is, and the service's variables in values, secrets included. A service that runs an image comes back as an upload staged for it, deleted if no app uses it within three hours. The token is used for this call only and never stored, and nothing is deployed until deployApp is called.

createUploadA

Send each file's path and content, or its path and the upload to take it from (fromUpload, as for a picture from generateImage). The response's uploadId goes into deployApp or inspectSource as source { type: "upload", uploadId }. A single .zip file is taken as the whole project. Up to 3000 files and 50 MB; an upload that no app uses within three hours is deleted.

generateImageA

Draws one picture from a prompt and keeps it as a one-file upload. Ship it with a site by putting { path, fromUpload: uploadId } in createUpload; an upload that no app uses within three hours is deleted. At most 40 an hour per account.

deployAppC

Creates the app and starts its first deploy.

deleteAppA

Delete an app and purge its data

updateAppC

Update an app (name / status / version)

redeployAppC

Redeploy an app (refresh code + roll pods)

getSshSessionB

Get the SSH credential for a running container: the GET form of createSshSession.

createSshSessionB

Create a short-lived SSH session credential for a running container.

execCommandC

Run a one-off shell command in a running container (kubernetes exec).

listBackupsB

List an app's backups and its backup settings

updateBackupsB

Turn managed backups on or off and set the daily window

restoreBackupA

Overwrites the app's current volume contents with the snapshot. There is no undo.

listBranchesA

Fetched live from GitHub; empty for apps whose source is not git. current is the branch the app deploys from.

rollbackDeployA

Needs a running, build-backed app whose target image is still in the registry. Restarts every service in the instance, database included.

analyzeDeployA

The AI reads the failed deploy's log, the failing containers' latest output, the names of the source's files, the compose file and the app's variables (never a secret's value), looks further with the read-only API tools when it needs to, and lists what went wrong. A problem's changes would fix it: a variable that isn't secret set to a value, a variable renamed (its value moves with it, secret or not), or new scale factors. Nothing is changed: apply them with createVar, updateVar and updateApp, then deploy again. Counts against the caller's 60 AI answers an hour.

getVolumeKeysA

Get S3 and SFTP credentials for one volume or service filesystem. Derived, not stored, so they are stable and need no rotation step. volume is a name from listVolumes; kind selects a persistent volume (default) or a service filesystem.

getDbCredentialsA

Read from the running pod's resolved environment at call time, so the container is the source of truth rather than the template. component is a compose service running a database.

getDbSchemaA

List a database component's schemas and tables

runDbQueryB

Runs over a real protocol driver, not a shell, and executes whatever is sent — including writes and DDL. Redis and MongoDB take their own command syntax rather than SQL.

getGitOverviewA

Read the working tree of a development app: branch, changes and recent commits. Reads the repository inside the running container by pod exec, so it is ground truth rather than the deploy record. Returns {ok:false, reason} when the app has no repo, no pod, or no git.

discardGitChangesA

Discard every change at the given paths: edited and deleted files go back to the last commit, and new files are deleted, staged or not. Paths are literal, never patterns. Fails before changing anything if a path has no change, and afterwards, naming what is left, if any of those paths still shows one. The discarded work can't be recovered. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

commitGitChangesA

Commit the given paths, staged or not, and nothing else: changes staged at other paths stay staged. Paths are literal, never patterns, and a deleted path commits its deletion. Fails if any of the paths has no change. Without paths, commits every change, untracked files included. While a merge is in progress, git can only commit the whole merge, so the staged index is committed and paths is not used. The commit stays in the app's copy of the repository, which Cloady can't push to the remote. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

checkoutGitBranchA

Switch the working tree to a branch with git switch, so the name is never read as a path. A branch that exists only on the remote is checked out tracking it, and create makes a new branch at the current commit. Refuses when uncommitted changes would be overwritten; other uncommitted changes come along. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

stageGitFilesA

Add the current contents of the given paths to the index, ready for the next commit. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

unstageGitFilesA

Take the given paths out of the index; their changes stay in the working tree. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

mergeGitBranchA

Merge the named branch into the current one, as a merge commit unless it fast-forwards. Refused while another merge, rebase, revert or cherry-pick is in progress. If the merge fails, it is aborted, the call fails, and the error carries git's report. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

rebaseGitBranchA

Replay the current branch's own commits on top of the named branch, rewriting them. Refused while another merge, rebase, revert or cherry-pick is in progress. If the rebase fails, it is aborted, the call fails, and the error carries git's report. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

revertGitCommitA

Add a new commit that undoes the given commit. Refused while another merge, rebase, revert or cherry-pick is in progress. If the revert fails, it is aborted and the call fails. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

cherryPickGitCommitA

Apply the given commit to the current branch as a new commit. Refused while another merge, rebase, revert or cherry-pick is in progress. If the cherry-pick fails, it is aborted and the call fails. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

pullGitChangesA

Fetch the current branch's upstream and fast-forward to it. Fails when the branches have diverged or uncommitted changes would be overwritten. A GitHub remote is read with the workspace's GitHub App installation; any other host is read without credentials. Works only on a development app: any other app answers 403 read_only. Runs git in the app's running container and returns its output.

getGitDiffB

With no sha, diffs the working tree. path narrows it to one file. Large patches come back with truncated: true.

streamAppStatusA

Read an app's live status: per-service state, capacity waits, in-flight deploy. Returns one status frame. Sending Accept: text/event-stream instead follows the status live, a frame every five seconds, which never completes on its own.

streamAppMetricsA

Returns one metrics reading; network and requestsPerSec are null until a second sample exists, so they are null on a one-shot read. Sending Accept: text/event-stream instead follows usage live, a frame every five seconds, which never completes on its own.

streamActiveDeployA

Read the app's in-flight deploy, or its latest when none is running. Returns one {ts, deploy} frame: the active deploy if one is running, otherwise the most recent, and deploy is null when the app has never deployed. Sending Accept: text/event-stream instead follows it live, a frame every two seconds, closing after one terminal frame.

streamDeployLogsA

Returns one {kind:"snapshot", log, status} frame — the whole log so far, not a delta: the stored log for a finished deploy, the live build pod's log for the in-flight one. Sending Accept: text/event-stream instead re-sends a growing snapshot every two seconds; a finished deploy sends one frame and closes, the in-flight one keeps the connection open after it ends, so close it yourself once a frame carries final: true.

listDeploysB

List an app's deploys

listVarsB

List environment variables and credentials for an app

createVarC

Create a new environment variable or credential

importVarsA

Bulk-create environment variables, skipping keys already set

deleteVarA

Delete an environment variable or credential

updateVarA

Change a variable's value, whether it is secret, or its name. A new name keeps the value, so a secret can be renamed without sending it again; a name another variable has is refused.

revealVarB

Reveal the decrypted value of a secret variable

listAppDomainsB

List all domains for an app in a workspace

createDomainC

Create a new domain for an app

deleteDomainC

Delete a domain from an app

updateDomainC

Update a domain configuration

listCertStatusesA

List TLS certificate statuses for app domains

readServiceLogsA

Returns the last 200 log lines of one container as {container, state, logs}; state is no-pod when nothing is running. serviceName is a compose service. Sending Accept: text/event-stream instead follows the log live as server-sent events, one bare data: frame per line, which never completes on its own.

getAppServicesC

List all services in an app instance

createAppDeployB

Trigger a new deployment for an app

listVolumesC

List an app's volumes and service filesystems

transferAppC

Transfer an app to another workspace

getWorkspaceBillingB

Get workspace billing info

listWorkspaceMembersC

List workspace members

listWorkspaceInvitationsB

List pending workspace invitations

createWorkspaceInvitationC

Send workspace invitation

revokeWorkspaceInvitationC

Revoke workspace invitation

transferWorkspaceOwnershipD

Transfer workspace ownership

listWorkspaceDomainsA

Every custom domain the workspace's applications serve, and every domain registered through Cloady, with its renewal details, whether or not an application serves it.

listDnsRecordsA

The DNS records of a domain registered through Cloady in this workspace, or of an application's own address under cloady.io (<app>-<hash>-<workspace>.cloady.io, as its endpoints show it). A registration starts with A and AAAA records for the domain and * pointing at Cloady; an address starts with none, since a wildcard serves it. Records with managed set are Cloady's: they keep the domain or address pointing at your applications and can't be changed or deleted. Answers 409 when a registered domain uses its own nameservers, whose records live there.

createDnsRecordA

Adds a record to a domain registered through Cloady in this workspace, or under an application's cloady.io address. On a registered domain, A, AAAA, ALIAS and CNAME records on the domain itself and on * are Cloady's. Under an address, records go on a name below it, like mail or _verify, and ALIAS, CAA and NS aren't allowed; the first one also gives the address itself a CNAME to Cloady, because a name with records below it no longer matches the wildcard. Records reach the internet within the TTL; a record the registrar refuses, such as a CNAME beside other records on the same name, answers 400 with its reason. Needs the developer role.

updateDnsRecordA

Replaces a record's name, type, content, TTL and priority under the same rules as createDnsRecord. Answers 409 for a record Cloady manages. Needs the developer role.

deleteDnsRecordA

Deletes a record from a domain registered through Cloady in this workspace, or from under an application's cloady.io address. Answers 409 for a record Cloady manages. Needs the developer role.

registerDomainA

Registers a domain for its registry's minimum term, usually a year, charged to the workspace's card: the owner's account card, or the workspace's own when one is pinned. The registrant becomes the domain's legal owner, and the registry may email them to confirm the address. WHOIS privacy and auto-renew are on unless set to false. Without nameservers, Cloady points the domain and every subdomain at Cloady, so attaching any of them to an application with createDomain needs no DNS change. dryRun quotes the price and checks the name can be registered here without charging; premium names, orders over $100 and extensions whose registry needs more than a contact can't be. A card the bank wants to authenticate answers 402 payment_action_required with clientSecret, paymentIntentId and publishableKey in details: confirm it with Stripe.js, then repeat the request with paymentIntentId. If registration fails after the charge, the charge is refunded. Needs the developer role.

listWorkspaceVolumesC

List a workspace's volumes and service filesystems

listWorkspaceIntegrationsB

List workspace integrations and provider status

getWorkspaceSsoC

redirectUri is what to register at the provider; txtValue is the TXT record the domain needs at _cloady.<domain> before it can be saved.

setWorkspaceSsoA

Connect an OpenID Connect identity provider for single sign-on. Refuses a domain whose _cloady.<domain> TXT record doesn't carry the workspace's txtValue yet, so a saved connection is always live. Anyone the provider signs in with an email at the domain joins the workspace as a developer. Omit clientSecret to keep the stored one. Requires admin.

deleteWorkspaceSsoC

Remove single sign-on from the workspace

linkGithubIntegrationC

Link GitHub installation to workspace

disconnectGithubIntegrationC

Disconnect GitHub integration from workspace

listGithubReposC

Search GitHub repositories

listTokensA

List the authenticated user's API tokens

createTokenB

Create a new API token for the current user

revokeTokenC

Revoke an API token

getAccountBillingB

Get account billing information including payment methods and invoices.

startCardSetupA

Create a SetupIntent for saving a card with the inline payment element. Returns a clientSecret that Stripe's payment element exchanges for a saved card in the browser. The secret alone cannot charge anything or read existing cards, and it is scoped to the caller's own Stripe customer.

getUserBillingStateB

Get the account's shared free allowance and payment method status.

getNotificationPreferencesA

Get notification preferences for the current user

updateNotificationPreferencesC

Update notification preferences for the current user

getSecurityStateB

Read the account's sign-in settings

listTicketsA

List support tickets for the current user

createTicketC

The AI answers the ticket first, and each new message from its author, until someone from the Cloady team replies. The team reads every ticket.

getTicketA

Get a single support ticket with all messages

updateTicketB

Update ticket status or mark as read

addTicketMessageC

Add a message to a support ticket

enableTotpA

Takes the key from startTotpSetup and a current code from the app. From then on every sign-in asks for a code from the app.

startTotpSetupA

Returns a new key and its otpauth:// link for a QR code that Google Authenticator or any authenticator app scans. Nothing is saved until enableTotp confirms a code from the app. Answers 409 totp_enabled while an app is already on.

disableTotpB

Turn off sign-in codes from an authenticator app

streamTicketMessagesA

Returns one frame. Sending Accept: text/event-stream instead follows the thread live, every 2.5 seconds, which stops only when the ticket disappears.

checkWorkspaceSlugA

Returns the slug that would actually be used; suffixed is true when the requested one was taken and a numeric suffix was added.

listTemplatesA

Search, filter, sort and page the template catalog. Public: no token needed. total counts every match, and categories counts the matches in each category with every other filter applied. Omit limit for every match.

reviewTemplateA

Rate and review a template (one review per account; sending again replaces it).

deleteTemplateReviewC

Delete your review of a template

getPricingB

Get public resource pricing and the free allowance

getInvitationB

Get invitation details by token

acceptInvitationB

Accept a workspace invitation

declineInvitationB

Decline a workspace invitation

queryAppMetricsA

Runs a PromQL query at one instant against the app's own metrics, kept for 62 days, and returns Prometheus's answer unchanged. Only the app's series are visible, whatever the query selects. Every series carries namespace, the app's (getWorkspace returns each app's), and most carry container, the compose service, and pod. Resources: container_cpu_usage_seconds_total, container_spec_cpu_quota / container_spec_cpu_period (the CPU limit), container_memory_working_set_bytes, container_spec_memory_limit_bytes, container_fs_reads_bytes_total, container_fs_writes_bytes_total, container_oom_events_total, and container_network_receive_bytes_total / container_network_transmit_bytes_total, which carry only pod, so match them as pod=~"<service>-[a-z0-9]+-[a-z0-9]+". Replicas: kube_pod_container_status_ready, kube_pod_container_status_restarts_total, kube_pod_container_status_waiting_reason and kube_pod_container_status_last_terminated_reason (reason), and kube_deployment_spec_replicas / kube_deployment_status_replicas_available, whose deployment is the service. Volumes: kubelet_volume_stats_used_bytes and kubelet_volume_stats_capacity_bytes, whose persistentvolumeclaim is the compose volume (each service's volumes in getWorkspace). Requests to the service the app's address routes to: traefik_service_requests_total (code, method, protocol) and traefik_service_request_duration_seconds_bucket (le). Uptime checks are method="HEAD", so leave them out with method!="HEAD", and a scale-to-zero function reports as container="<service>-fn". Uptime: cloady:probe_success:serving (kind="auto" is the check of the app's address) and cloady:service_up:serving, each service's availability from 0 to 1. Spans, once the app sends OpenTelemetry traces: traces_spanmetrics_calls_total and traces_spanmetrics_latency_bucket (span_name, span_kind, status_code, http_status). RabbitMQ: rabbitmq_detailed_queue_messages_ready. Alert rules: ALERTS (alertname, alertstate, container, cloady_metric), whose alertstate="firing" samples are the app's incident history. queryAppMetricsRange runs a query over a range. A query the store refuses comes back with the store's own status and error. The path is the store's own, so a Grafana data source can point here too.

queryAppMetricsRangeA

Runs a PromQL query at every step of a range against the app's own metrics, kept for 62 days, and returns Prometheus's answer unchanged: one matrix series per label set. Only the app's series are visible. The labels and series are queryAppMetrics'. A query the store refuses comes back with the store's own status and error. The path is the store's own, so a Grafana data source can point here too.

queryAppLogsA

Runs a LogQL query over the app's own logs, kept for seven days, and returns Loki's answer unchanged: lines for a log query, series for a metric query. Streams: {container="<service>"} is each compose service's own output, with pod and a detected_level (error, critical, fatal, warn, info, debug, trace or unknown) to filter on as | detected_level=~"error|critical|fatal"; {container="_events"} holds the Kubernetes events about the app's objects as JSON (kind, name, reason, type, msg, count); {container="_access", service="<service>"} is the ingress access log of the service the app's address routes to, as Traefik's JSON (RequestMethod, RequestPath, DownstreamStatus, Duration in nanoseconds, request_User-Agent), with route, method and status as fields; and {container="_rum", kind="pageview"} with kinds vital, error, net, signal, custom and session holds browser monitoring, with page, session, device, browser, os and country as fields. Session recordings are kept apart: getBrowserSessionReplay reads them, with the developer role. A query the store refuses comes back with the store's own status and error. The path is the store's own, so a Grafana data source can point here too.

queryWorkspaceMetricsA

Runs a PromQL query at one instant across the metrics of every app in the workspace, or only those in env and region, and returns Prometheus's answer unchanged. Group by namespace to tell the apps apart. The labels and series are queryAppMetrics'. A query the store refuses comes back with the store's own status and error. The path is the store's own, so a Grafana data source can point here too.

getBrowserMonitorC

Returns the app's public browser key, the script URL and the hosts allowed to send beacons, from which the snippet is built, when the newest beacon arrived and the settings its snippet carries, the tag Cloady adds at the edge if it adds one, and LCP p75 and active sessions over the range once pages send beacons. Browser monitoring is on while the app's pages carry the snippet, whose own attributes set replay share, masking and the conversion goal, or while Cloady adds it at the edge, whose settings are the one thing stored: the app variable CLOADY_BROWSER_MONITORING.

updateBrowserMonitorA

Makes Cloady add the browser monitoring script tag before </head> of every HTML page the app's address and custom domains serve, with no code change or redeploy, or stop adding it with edge: null. The settings are kept in the app variable CLOADY_BROWSER_MONITORING and apply on the next page load; no service restarts. A page whose head already carries the script keeps its own. Answers 400 when the app has no web address, and 502 when the settings were saved but the app couldn't be reconciled, which repeating a request that sets edge retries. Needs the developer role.

getBrowserSessionReplayA

Returns the session's recording as compressed rrweb segments, masked in the visitor's browser. Recordings are kept for 72 hours, apart from the app's other logs, so queryAppLogs cannot read them. A long session can return several megabytes. Needs the developer role, since recordings show what the app's visitors saw.

getAppTracingB

Returns the app's server monitoring mode, the OpenTelemetry variables each compose service gets while it is on, the agent Cloady loads into each service in auto mode and what it adds at start, and which services have sent spans in the last 7 days. In manual mode spans need an OpenTelemetry SDK or agent in the app's own code.

updateAppTracingA

Turns OpenTelemetry tracing on or off for the app. manual and auto add the app variables OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_PROTOCOL, OTEL_EXPORTER_OTLP_COMPRESSION, OTEL_RESOURCE_ATTRIBUTES, OTEL_METRICS_EXPORTER and OTEL_LOGS_EXPORTER, which point an OpenTelemetry SDK at Cloady's trace store, and each service also gets OTEL_SERVICE_NAME. auto also writes CLOADY_SERVER_MONITORING, the agent for each service (web=node,worker=python), and Cloady loads that OpenTelemetry agent into the service when it starts, with no code change. agents sets the agent of each service it names, null removing it, and the other services keep the agents CLOADY_SERVER_MONITORING already lists (none unless the app is already in auto mode); without agents Cloady detects what each service runs and picks every agent itself. off deletes them all. The app is reconciled: turning it on or off restarts its running services once, and changing agents restarts only the services whose agent changed; a request that changes nothing restarts nothing. Answers 400 for a service the app doesn't have, and 502 when the variables were saved but the app couldn't be reconciled, which repeating a manual or auto request retries. Needs the developer role.

getAppRuntimesA

Returns what each compose service runs, read from its latest build log, its image's configuration and its start command, and the OpenTelemetry agent Cloady recommends loading into it, or why none. Agents exist for Node.js 18.19 and 20.6 or later, Python 3.10 or later, Java 8 or later and .NET 8 or later. Databases, caches, queues, mail servers, proxies, TCP services and functions aren't inspected. Reads public registries, so it can take a few seconds.

searchServiceTracesA

Returns a sample of the requests the service handled in the range, one per trace, with their method, route, status and duration, plus the range's request count and median and 95th-percentile duration. Filter on route, method and status (2xx to 5xx, or a code). Needs tracing on for the app and an OpenTelemetry SDK in the service; traces are kept for 7 days. serviceName is a compose service.

readServiceDependenciesA

Returns the calls observed in the range's traces between the service and other services, databases and hosts, with their rate, failure share and 95th-percentile duration. Without observed calls it falls back to the compose file: depends_on entries and environment values that name another service as a host. serviceName is a compose service.

readTraceA

Returns the spans the workspace's apps sent in a trace, in tree order, with each span's service, timing, status, first exception and attributes. Spans from outside the workspace are left out. Answers 404 when no span of the trace belongs to the workspace, it was sampled out, or it is older than 7 days.

readServiceLogSettingsB

Returns the settings that decide what the service's log holds, read from the running engine (PostgreSQL's log_* settings, MySQL's error log and deadlock settings, Redis's slowlog and memory policy) or, for the service the app's address routes to, from the ingress. Also returns what they mean for each category of the log, as the service's logFormat sorts it, and, for Redis, lines built from its memory and error counters, which Redis never logs. serviceName is a compose service.

streamEngineStatsA

Reads the engine behind a compose service (Postgres, MySQL, MariaDB, ClickHouse, MongoDB, Redis, Valkey or KeyDB) through its own protocol: throughput, latency, connections, cache hit ratio and memory, with the settings and opt-ins that shape them. Returns one frame of cumulative counters with every per-second value null. Sending Accept: text/event-stream instead follows it live, a frame every five seconds with rates over the interval, which never completes on its own.

streamEngineStatementsA

Returns the statements with the most time, the most calls and the slowest means, with their normalized text: pg_stat_statements on Postgres, performance_schema digests on MySQL and MariaDB, system.query_log over range on ClickHouse, per-collection totals on MongoDB. Statement text can carry data, so this needs the developer role. A one-shot read gives cumulative values; sending Accept: text/event-stream instead follows it live, a frame every fifteen seconds with calls and time over the interval.

streamEngineSessionsB

Returns connections grouped by client, each mapped to the compose service it comes from where its address is a pod of the app, and the sessions running or holding a transaction for five seconds or more, waiting on a lock or blocking another, with their query text. Needs the developer role. Sending Accept: text/event-stream instead follows it live, a frame every five seconds.

endEngineSessionA

Cancels the statement a session is running (mode=cancel) or ends its connection (mode=terminate, the default): pg_cancel_backend or pg_terminate_backend, KILL QUERY or KILL, killOp on MongoDB, KILL QUERY on ClickHouse. sessionId comes from streamEngineSessions.

readEngineStorageA

Returns each database's size, the largest 100 tables or collections with rows, table and index bytes, dead tuples and vacuum state on Postgres and reclaimable space elsewhere, and the indexes nothing has used since the counters began. Names the schema, so it needs the developer role.

readEngineKeyspaceB

Samples up to 2,000 keys of database 0 within two seconds, without touching their LRU or LFU clocks where the server allows it, and groups them by the text before the first colon: share of sampled memory, keys, TTLs and the largest keys. Key names can carry data, so this needs the developer role.

readEngineSlowLogA

Returns statements slower than the engine's own threshold across range, newest first: Postgres duration: log lines, MongoDB slow operation log lines, ClickHouse system.query_log, the performance_schema statement history on MySQL and MariaDB, and SLOWLOG (COMMANDLOG on Valkey) on a cache. The last two keep only recent entries. Needs the developer role, because statements and command arguments carry data.

explainEngineStatementC

Plans a statement from streamEngineStatements without running it: EXPLAIN (GENERIC_PLAN) in a read-only transaction on Postgres 16 and later, EXPLAIN FORMAT=JSON on the digest's sample text on MySQL. Flags a sequential scan with a filter on a table of 10,000 rows or more and suggests an index built from the plan's columns.

enableEngineInsightsA

Turns on what streamEngineStats lists as off. Postgres: adds pg_stat_statements to shared_preload_libraries and restarts the service, then creates the extension in the postgres database on a second call, and logs statements slower than 250 ms with lock waits, through ALTER SYSTEM. MySQL and MariaDB: the statement history consumer and deadlock printing at runtime, and on MariaDB user statistics. Never resets any counter.

readServiceJobsA

Finds the job library the service uses and reads it: BullMQ, Sidekiq and Celery state in a Redis service of the same app, RabbitMQ queues, and Sidekiq and Celery job lines in the service's own logs. Returns finished and failed runs per step, each job type with its failure share, run-time p95 and newest outcomes, repeat and cron schedules, and each queue with its waiting jobs, rates, oldest job, consumers and dead letters. searched says where Monitor looked and what it found; nothing is invented when nothing is found. Works on a worker, a Redis or a RabbitMQ service. Failure texts need readServiceJobDetails.

readServiceJobDetailsB

Returns the newest job runs with their state, attempt, run time and error text, the jobs that schedules added within the range, the newest failure of each job type, and up to three failed or dead jobs per queue. Requires the developer role, because error texts can carry job data.

retryServiceJobsA

Moves one failed job, or every failed job of a BullMQ queue, back to the queue's waiting list through the bullmq library, so the app's workers run it again. BullMQ 5 or later only; Sidekiq, Celery and RabbitMQ have no retry here. Requires the developer role.

readServiceMailA

Reads a Postfix service's delivery log and queue: outbound attempts by outcome per step, time to delivery, inbound rejections and authentication failures, outcomes by recipient domain, bounce reasons with addresses masked, the queue's size by state and the retry settings. Postfix must log to standard output (maillog_file = /dev/stdout). Stalwart is read from its own Prometheus exporter and JMAP API once its admin turns the exporter on and the app holds an API key as the variable STALWART_API_KEY (and the exporter's login, if it has one, as STALWART_METRICS_AUTH, written user:secret); Mailpit and MailHog report what they caught. Nothing is invented for a server Monitor cannot read.

readServiceMailQueueA

Lists up to 100 messages in a Postfix queue, or in Stalwart's through its API, with their sender, recipients, the remote server's last reply, when the server tries again and how many attempts it has made. Requires the developer role, because it shows addresses.

flushServiceMailQueueA

Asks Postfix to attempt delivery now, for one queued message (postqueue -i) or the whole queue (postqueue -f), instead of waiting for its retry time. Requires the developer role.

checkMailDomainsB

Finds the domains the service sends from (Postfix's log and myorigin, or Stalwart's own domain list) and checks each in public DNS: SPF evaluated against the address the mail leaves from, DKIM keys for the selectors seen signing, DMARC policy and MX. Also reverse DNS of that address, the certificate offered after STARTTLS, and the address on Spamhaus, Barracuda, SpamCop and UCEPROTECT, and for Stalwart the DMARC aggregate reports it received. The address belongs to the node and is shared by every app on it. Runs the checks on every call.

listAlertsA

Returns the app's alert rules with their state, the services they are firing on and when each last fired. Rules live in the app's own alerting tenant, evaluated once a minute. A production app gets two default rules the first time its alerts are read: down for 2 minutes, and more than 3 restarts within 15 minutes, both emailing members. With service, only rules that watch that compose service, and state for it alone.

createAlertC

p95 and errors exist only for the service the app's address routes to. A rule that fires emails members who keep incident emails on (when email) and posts to its channels. Answers 400 bad_rule when the rule does not fit the metric.

deleteAlertC

Past incidents stay in the history.

updateAlertB

Changes the threshold, durations, notifications or the on/off switch. Turning a rule off silences it, so it stops notifying.

listChannelsA

Slack, webhook and PagerDuty destinations the app's alert rules can post to. Their URLs and keys are never returned.

createChannelC

Slack and webhook channels take url, PagerDuty takes routingKey. Needs the admin role.

deleteChannelC

Also removes it from every alert rule of the app that posts to it.

updateChannelC

Change a notification channel

testChannelA

Hands a test alert to the app's Alertmanager, which posts it to the channel within a minute and a resolve five minutes later. On PagerDuty this opens an incident, which pages whoever is on call.

getStatusPageB

Returns the address of the app's public status page and what it shows: one component per compose service with its state, its uptime and 60 daily bars, and the incidents of the last 14 days. Availability is measured once a minute from replica readiness and, for the service the app's address routes to, the uptime check. Every app has the page, and anyone with the address can read it.

getPublicStatusA

The data behind https://cloady.com/status/{workspaceSlug}/{appSlug}. Public: no token needed. env reads a preview or development app; production by default. Answers 404 when there is no such app.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

C2.9/5.0

Scored across 160 tools

Disambiguation3/5

The 160-tool surface covers many subdomains, and most tools have distinct scopes documented in detail, but several families are easy to confuse: getStatusPage vs getPublicStatus, queryAppMetrics vs streamAppMetrics vs queryAppMetricsRange vs queryWorkspaceMetrics, listWorkspaceDomains vs listAppDomains vs listDnsRecords, and createSshSession vs getSshSession. Descriptions usually resolve the ambiguity, so boundaries are mostly clear but not effortless.

Naming Consistency5/5

Almost all names are camelCase verb-first (list..., get..., create..., update..., delete..., stream..., read..., query...). The convention is consistent across 160 tools, with only natural verb variety rather than style mixing.

Tool Count1/5

160 tools is far beyond the 3-15 well-scoped range and even beyond the 25+ 'too many' threshold; the platform is broad, but this is an extreme surface for one MCP server. Each subdomain could be split into separate servers.

Completeness4/5

Coverage is unusually broad: workspace/app lifecycle, deploys, domains/DNS, variables, volumes/backups, billing, support, observability, git, database, mail, alerts, and integrations. Minor gaps remain, such as no obvious standalone getApp/listApps tool, but getWorkspace appears to expose app details and most workflows have a path.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues