MCP tool list

This page is produced from the answer of the MCP server’s own tools/list call each time the docs are built. To connect an assistant, see Connect an AI tool with MCP.

91 tools, server version 2.13.3.

add_appspace_container

Add a new container definition to an App Space.

Inputs: appspace_id (string, required), name (string, required), image (string, required), tag (string), role (string)

add_service_to_appspace

Add a standard, curated database/service to an App Space — durable and wired in one call. Works with ANY codebase in the App Space (an AI-built app, a market app, the user's own image): creates the service container from an official image with a generated password and a persistent volume, and (if bind_to is given) injects the connection env into the app container AND records the dependency so it starts first. Then start/restart the App Space.

Inputs: appspace_id (string, required), service (string, required), bind_to (string), name (string), version (string)

append_agent_note

Append a timestamped note to the project's running notes file (default notes/agent-notes.md). Use this to durably record decisions, TODOs, and context the agent should remember about a project across conversations. Pass the active `project` id.

Inputs: note (string, required), project (string), path (string)

call_connection

Call one of the acting user's connections with its stored credential.

Inputs: name (string, required), method (string, required), path (string, required), params (object), json_body (any), body (string), headers (object)

check_vm_connectivity

Test whether a VM's public IP is reachable FROM INSIDE specific countries, using check-host.net probe nodes located there — a real-world censorship/reachability check no server-side test can give you. Essential for anti-censorship / VPN use: it answers "can someone in Iran actually reach this box?". Ping (ICMP) by default; pass a `port` to TCP-test a specific service (e.g. 443 for a VPN protocol). Returns per-country reachable / blocked / partial + latency; if a country is blocking the IP, rotate or reprovision to a fresh IP. Note: check-host has ~8 Iran nodes but NO mainland-China nodes — pass 'hk' only as a weak proxy for China (it sits outside the Great Firewall).

Inputs: vm_code (string, required), port (integer), countries (string)

create_appspace_volume

Create a new volume for an App Space (required for stateful containers).

Inputs: appspace_id (string, required), name (string, required), size_gb (integer, required), mount_path (string, required)

create_secret

Store a new encrypted secret.

Inputs: name (string, required), value (string, required), description (string)

create_service

Provision a new service (VM or App Space) from a catalogue product version.

Inputs: product_version_id (string, required), idempotency_key (string), name (string), description (string), selections (object), metadata (object)

create_ssh_key

Upload a new SSH public key to the user's account.

Inputs: name (string, required), public_key (string, required)

create_vm_snapshot

Create a snapshot of a VM. A one-time charge may apply.

Inputs: service_id (string, required), description (string, required)

delete_container_env

LEGACY MyCP container — NOT for App Spaces (use set_appspace_container_env with merge=False).

Inputs: app_code (string, required), container_code (string, required), env_id (integer, required)

delete_secret

Delete a secret from the user's account.

Inputs: secret_code (string, required)

delete_ssh_key

Delete an SSH key from the user's account.

Inputs: ssh_key_code (string, required)

delete_workspace_file

Delete a file from the workspace. `path` is relative to the project root; pass the active `project` id. This is irreversible.

Inputs: path (string, required), project (string)

deploy_blueprint

Assemble an App Space from a blueprint in one call: create the app container (a pre-built image OR build-from-source) with its exposure + release command, then add and wire each required curated service. This is how a complex app (app + its databases/services) is composed from curated pieces rather than a black-box compose.

Inputs: appspace_id (string, required), blueprint (object, required)

deploy_project

Deploy your workspace code into an App Space and VERIFY it — in ONE call. THE reliable way to ship a web app. Reuse ONE App Space (create it once with quick_create_service, then pass its id here every time). In one move it snapshots your code, builds the app container from your Dockerfile, wires any database it needs, starts it, waits for it to become healthy, and returns the public URL — so you never hand-run deploy -> poll get_deployment_status -> verify.

Inputs: appspace_id (string, required), project (string), subpath (string), dockerfile (string)

deploy_repo

Deploy a GitHub repo into an App Space in one move: read its manifests, detect its stack (framework, port, release command, needed services), then build the app from source and provision + wire the curated services it needs. After it returns, start the App Space and (if a release command was detected) run_appspace_release. Requires a Dockerfile in the repo; if the repo ships a docker-compose, use import_appspace_compose instead.

Inputs: appspace_id (string, required), github_url (string, required), branch (string)

deploy_workspace

Snapshot the workspace and start a deploy, returning a `deploy_operation_id` to poll.

Inputs: appspace_id (string, required), project (string), subpath (string), dockerfile (string), deploy (boolean)

describe_workspace

Describe the agent's workspace: whether object storage is configured, the S3 endpoint, and the path prefix files live under. Pass the active `project` id to scope to that project (user_<id>/proj_<project>/); omit it for the user root. Use this before reading/writing.

Inputs: project (string)

detect_app_stack

Read a GitHub repo's manifests and propose how to deploy it: the framework, whether it has a Dockerfile, the app port, the release/migrate command, and the curated services it likely needs (from its dependencies). Use this before deploy_repo, or to plan a deployment.

Inputs: github_url (string, required), branch (string)

diagnose_appspace

Diagnose WHY an App Space's workloads are failing — one call, whole App Space. Returns a `headline` (the problem in one line), every container's runtime state + failure **verdict** (`healthy` / `crash_loop` / `exited` / `oom` / `not_deployed` / `starting`) with `exit_code`, real `restart_count`, `lifetime_seconds`, `oom_killed`, and a plain-English `likely_cause`, plus the deployment's recent orchestration logs. ALWAYS call this when a container is not running, when a deploy/start didn't come up, or before telling the user an app is healthy — it turns "it won't start" into an actionable cause (wrong image / no foreground server / app error / out of memory). Read-only.

Inputs: appspace_id (string, required)

diff_deployment

Show what changed between the snapshot currently RUNNING and the latest one you deployed — a real file-level diff (via the workspace git history). Use it so the user sees exactly what a deploy will change / did change. Renders as a Diff card.

Inputs: appspace_id (string, required), ctx (any)

disable_vm_rescue_mode

Return a VM from rescue mode to normal boot.

Inputs: vm_code (string, required)

enable_vm_rescue_mode

Boot a VM into rescue mode for emergency recovery.

Inputs: vm_code (string, required)

export_appspace_compose

Export the full compose YAML for an App Space (snapshot of current state).

Inputs: appspace_id (string, required)

generate_app_project

Generate a deployable app (a Docker Compose project) from a description.

Inputs: intent (string, required)

get_appspace_logs

Fetch an App Space container's runtime STATE and recent LOGS. Use this to debug why an app isn't working: each container now reports a **verdict** with `exit_code`, real `restart_count`, `lifetime_seconds`, `oom_killed`, and a plain-English `likely_cause` — so a restart loop is explained ("exits in 0.17s with code 0 → the image has no long-running server / wrong start command"), not just flagged. The service can read "running" while a container crash-loops; this shows the truth. NOTE: the `logs` here are buildcp **orchestration** events, not the app's own stdout — rely on the per-container verdict/exit_code for the cause, and run_appspace_command on a live container to inspect further. Prefer `diagnose_appspace` for a whole-App-Space summary. Read-only.

Inputs: appspace_id (string, required), container_id (string), tail (integer)

get_appspace_resource_profile

Get CPU/RAM/disk allocation for an App Space.

Inputs: appspace_id (string, required)

get_container_logs

LEGACY MyCP container — NOT for App Spaces (use diagnose_appspace / get_appspace_logs).

Inputs: app_code (string, required), container_code (string, required), tail (integer)

get_container_metrics

LEGACY MyCP container — NOT for App Spaces (use diagnose_appspace).

Inputs: app_code (string, required), container_code (string, required)

get_container_realtime_status

LEGACY MyCP container — NOT for App Spaces (use diagnose_appspace / get_deployment_status).

Inputs: app_code (string, required), container_code (string, required)

get_deployment_status

Show exactly what is deployed for an App Space: the live snapshot ref actually running, each container's health, the public URL, whether it's serving, and whether the workspace has changes not yet deployed. Use this instead of guessing from separate list/diagnose calls, and after any deploy to confirm what shipped. Renders as a Deployment card.

Inputs: appspace_id (string, required), ctx (any)

get_finance_balance

Get the user's current available balance and accrued charges.

Inputs: action (string)

get_finance_ledger

Get the ledger of individual charge and payment events.

Inputs: page (integer), size (integer)

get_finance_summary

Get a billing summary: balance, burn rate, runway days, and projection.

get_market_app

Get one App Market app's details and the inputs an install needs.

Inputs: slug (string, required)

get_market_installation

Check the status and access outputs of an App Market installation.

Inputs: installation_code (string, required)

get_operation

Poll the status of an asynchronous service operation.

Inputs: operation_id (string, required)

get_secret

Retrieve a secret. If reveal=True, the decrypted value is returned. Every reveal is recorded in the account's audit log.

Inputs: secret_code (string, required), reveal (boolean)

get_service

Get full detail of a service instance including specs, selections, pricing, linked VM or App Space, and access information.

Inputs: service_id (string, required)

get_services_summary

Get a dashboard overview: count of running VMs and App Spaces.

get_vm_access

Retrieve access credentials (username, password, IPs) for a VM.

Inputs: vm_code (string, required)

get_vm_file

Read a text file from a VM over SFTP.

Inputs: vm_code (string, required), remote_path (string, required), max_bytes (integer)

get_vm_metrics

Read live in-guest metrics from a VM over SSH — CPU cores, load, memory, disk, uptime. Read-only; complements get_vm_realtime_status (provider power state).

Inputs: vm_code (string, required)

get_vm_realtime_status

Query the provider API directly for live VM status (not the cached DB value).

Inputs: vm_code (string, required)

get_vm_traffic

Get bandwidth/traffic usage for a VM (egress is a billable meter).

Inputs: vm_code (string, required)

get_workspace_file

Read a text file from the workspace. `path` is relative to the project root (e.g. "code/main.py"); pass the active `project` id. Errors on non-UTF-8 binaries — the workspace holds source, config, notes, and text artifacts.

Inputs: path (string, required), project (string)

import_appspace_compose

Deploy from a compose YAML. This is the fastest way to make multi-container changes.

Inputs: appspace_id (string, required), yaml_content (string, required), override (boolean)

install_market_app

Install a published App Market app onto one of the user's VMs.

Inputs: vm_code (string, required), slug (string), version_code (string), inputs (object)

install_market_app_to_appspace

Install a compose-based App Market app into an App Space (the container platform), NOT a VM. The app's recipe is rendered — generated secrets filled, host bind-mounts adapted to persistent volumes — and its containers are added to the App Space; start/restart to deploy. This runs a market app on the general compute substrate alongside your own app. (For a plain database prefer add_service_to_appspace, which wires the connection URL for you.)

Inputs: appspace_id (string, required), slug (string, required), inputs (object)

list_appspace_containers

List container definitions inside an App Space, with their public URLs.

Inputs: appspace_id (string, required)

list_appspace_networks

List network items and container attachments for an App Space.

Inputs: appspace_id (string, required)

list_appspace_volumes

List volumes attached to an App Space.

Inputs: appspace_id (string, required)

list_catalogue

List available plans to provision, one compact row each.

Inputs: service_type (string), provider (string)

list_connections

List the acting user's ENABLED connections the agent may call.

list_container_deployments

LEGACY MyCP container — NOT for App Spaces (use get_deployment_status).

Inputs: app_code (string, required), container_code (string, required)

list_container_env

LEGACY MyCP container — NOT for App Spaces (use list_appspace_containers, which shows env keys).

Inputs: app_code (string, required), container_code (string, required)

list_curated_services

List the curated standard services (databases, caches, search, vector DBs, queues, object storage, analytics, time-series, graph) that add_service_to_appspace can deploy and wire into ANY app in one call — official images, sane defaults, durable, connection injected. Use this to choose the right backing service for a codebase. Optionally filter by category.

Inputs: category (string)

list_secrets

List secret names and codes stored in the user's account.

list_service_alerts

Retrieve billing and lifecycle alerts for services.

Inputs: service_id (string)

list_service_operations

List recent operations for a service.

Inputs: service_id (string, required), status (string), limit (integer)

list_services

List the user's service instances (VMs and App Spaces).

Inputs: service_type (string), status (string), provider (string), search (string), page (integer), size (integer), sort_by (string), sort_dir (string)

list_ssh_keys

List SSH keys stored in the user's account.

list_vm_snapshots

List snapshots for a VM-backed service instance.

Inputs: service_id (string, required)

list_workspace_files

List files in the workspace, optionally under a sub-path `prefix` (e.g. "code/"). Pass the active `project` id to scope to that project. Returns each file's path (relative to the project root), size, and last-modified; those paths are what get/write/delete take.

Inputs: prefix (string), project (string)

manage_vm_service

Manage a systemd service on a VM (systemctl). A first-class service primitive instead of raw shell.

Inputs: vm_code (string, required), service (string, required), action (string, required)

perform_service_operation

Trigger a lifecycle action on an existing service.

Inputs: service_id (string, required), action (string), operation (string), idempotency_key (string), ip_version (integer), container_code (string), container_codes (array), new_product_version_id (string), new_plan (string)

promote_appspace

Promote (clone) an App Space's PRODUCTION containers into a new dedicated App Space for a target environment. The model: one App Space per app-creation holds both the app's production containers AND our build/test (sandbox) containers; promote graduates just the production ones — leaving the sandbox behind — into a fresh, owned App Space for the user's staging or production environment. Each environment is its own App Space.

Inputs: source_appspace_id (string, required), environment (string), name (string), tier (string), teardown_source (boolean)

push_workspace_to_git

Snapshot the project's workspace into a git repository and return a pinned build context (repo_url#commit) the container platform can build a reproducible image from. This is the studio build bridge: the platform builds only from git URLs, so to turn generated/local code into an immutable artifact for staging/production, push it here, then deploy with a compose `build.context` set to the returned `build_context`.

Inputs: project (string), dockerfile (string), subpath (string)

put_vm_file

Write a text file onto a VM over SFTP (creating parent dirs). Use this to drop a script, config, or small asset onto the box instead of heredoc-ing it through a shell command.

Inputs: vm_code (string, required), remote_path (string, required), content (string, required), mode (string)

query_app_logs

Search an App Space's DURABLE historical logs (the central log store, Loki via logate). Unlike get_appspace_logs/diagnose_appspace (live `docker logs`, which vanish when a container is removed or redeployed), this survives restarts and teardown — use it for a post-mortem after a container is gone, to search across time, or to grep for an error. Scoped to YOUR App Space only. Read-only.

Inputs: appspace_id (string, required), contains (string), since (string), limit (integer), container_id (string)

quick_create_service

Create a VM or App Space from FRIENDLY inputs — no UUIDs. Prefer this over create_service.

Inputs: service_type (string, required), plan (string), provider (string), ram_gb (integer), location (string), os (string), name (string), idempotency_key (string)

read_vm_logs

Read logs from a VM — a systemd unit's journal (default: whole system journal), or tail a log file. Read-only.

Inputs: vm_code (string, required), unit (string), path (string), lines (integer)

rebuild_vm

Reinstall the OS on an existing VM. The VM keeps its IP but all data is wiped.

Inputs: vm_code (string, required), os_slug (string, required)

remove_appspace_container

Remove a container definition from an App Space.

Inputs: appspace_id (string, required), container_id (string, required)

restart_container

LEGACY MyCP container — NOT for App Spaces (use deploy_project, or perform_service_operation reboot).

Inputs: app_code (string, required), container_code (string, required)

restore_vm_snapshot

Restore a VM from a snapshot.

Inputs: service_id (string, required), snapshot_code (string, required)

rollback_container

LEGACY MyCP container — NOT for App Spaces (use deploy_project with the previous code).

Inputs: app_code (string, required), container_code (string, required), target_deployment_id (string, required)

run_appspace_command

Run a shell command INSIDE a running App Space container and return its stdout, stderr, and exit code. This is the sandbox's hands for INSTALL / RUN / TEST / INSPECT — e.g. "pip install -r requirements.txt", "pytest -q", "curl -s localhost:8000", "ls -la /app". The App Space must be started (its container attached to a running deployment).

Inputs: appspace_id (string, required), container_id (string, required), command (string, required), timeout_seconds (integer)

run_appspace_release

Run an app's release/init command ONCE, after its dependencies are up — e.g. database migrations. Waits until the container is running (its data services must be reachable first), then executes the command and returns its output. Use after starting an App Space that has a database: e.g. command="python manage.py migrate" for a Django app, or a schema/seed step. This is what makes a real app (with a DB) come up correctly instead of erroring on a missing schema.

Inputs: appspace_id (string, required), container_id (string, required), command (string, required), wait_seconds (integer), timeout_seconds (integer)

run_vm_command

Run a shell command on a VM over SSH and return stdout, stderr, and the exit code. This is the agent's hands inside a customer VM — install packages, inspect the box, run a script, deploy. Uses the VM's platform-managed keypair. WRITE action (it can change the machine).

Inputs: vm_code (string, required), command (string, required), timeout_seconds (integer)

search_app_market

Search the Doprax App Market for installable, published apps.

Inputs: query (string), limit (integer)

set_appspace_container_env

Set environment variables on an App Space container. Takes effect on the next start/restart. Use this to wire configuration (e.g. a connection string) into a container.

Inputs: appspace_id (string, required), container_id (string, required), env (object, required), merge (boolean)

set_container_env

LEGACY MyCP container — NOT for App Spaces (use set_appspace_container_env).

Inputs: app_code (string, required), container_code (string, required), key (string, required), value (string, required), is_secret (boolean), description (string)

start_container

LEGACY MyCP container — NOT for App Spaces (use deploy_project, or perform_service_operation start).

Inputs: app_code (string, required), container_code (string, required)

stop_container

LEGACY MyCP container — NOT for App Spaces (use perform_service_operation(service_id, action='stop')).

Inputs: app_code (string, required), container_code (string, required)

sync_workspace_to_appspace

Copy the project's workspace files into a RUNNING App Space container so generated code can build and run there. Reads every file under the project workspace (optionally just a sub-path `prefix`) and writes it into `dest_dir` (default /app) inside the container, keeping the directory layout.

Inputs: appspace_id (string, required), container_id (string, required), dest_dir (string), prefix (string), project (string), timeout_seconds (integer)

sync_workspace_to_vm

Copy the code YOU generated (the per-project agent workspace) onto a VM over SFTP, preserving the directory tree under `dest_dir`. This is how you ship a project onto a raw VM.

Inputs: vm_code (string, required), dest_dir (string, required), project (string), subpath (string)

validate_docker_image

Check whether a Docker Hub image tag exists and is publicly accessible.

Inputs: image (string, required)

write_workspace_file

Create or overwrite ONE text file in the workspace. Writing a whole project? Use `write_workspace_files` instead — one call for the whole set, not one round trip per file. `path` is relative to the project root (e.g. "code/main.py", "code/requirements.txt", "uploads/data.csv"); pass the active `project` id. Persist generated code, configs, and uploads here so they survive across conversations and can be built/run later. Convention: code under code/, uploads under uploads/, agent notes under notes/.

Inputs: path (string, required), content (string, required), project (string)

write_workspace_files

Write MANY workspace files in ONE call. Strongly preferred over calling `write_workspace_file` repeatedly — you almost always know the whole file set before you start writing, and one call per file costs a full model round trip each.

Inputs: files (array, required), project (string)