Skip to main content
Nerdit’s Model Context Protocol server lets an agent use the same Engine operations as the CLI and HTTP API. Tool results follow the caller’s real role, ownership and service scope. This page lists the 49 tools in the 0.6.0 source interface; an installed server’s tools/list response is authoritative for its version.

Connect over stdio

Use a Nerdit installation that includes the MCP extra. For a Python source installation, install the optional dependency in that same environment using the development setup. If using a binary installation, verify that nerdit mcp is available; installing a Python extra separately does not modify a frozen binary. Add this server entry to your MCP client’s configuration, adapting the surrounding configuration format to that client:
Use an absolute executable path if your client does not inherit your terminal’s PATH. The subprocess reads the same CLI configuration as nerdit, including the remote connection and selected credential. The subprocess and Engine do not need to be on the same machine, but any path given to the deploy tool is local to the MCP server process, not the chat client. Choose a dedicated scoped token before connecting an agent. See Security. Do not store tokens in a shared MCP configuration or paste credentials into the conversation.

Connect over HTTP

The Engine can expose the same tools as Streamable HTTP at /api/mcp (with or without a trailing slash). It is off by default. Enable it in the Engine config after setting a real Engine authentication token through the normal secure setup:
Restart the Engine using your installation’s normal management method. It refuses startup when HTTP MCP is enabled without [daemon].auth_token or without the MCP dependency. A successful node-link setup can enable this transport when both prerequisites are met. Configure an HTTP-capable MCP client with the Engine’s URL and Authorization: Bearer … header. For a same-machine client the default URL is http://127.0.0.1:9321/api/mcp. Remote clients need a protected connection and the configured reachable endpoint; enabling the transport does not widen the Engine’s loopback bind. The transport validates Host/Origin and request size. Requests require Content-Length; the default body cap is 1 MiB ([mcp].max_body_bytes). A readonly token can discover tools and call permitted reads; write calls remain forbidden. For the account-linked remote gateway, follow the App connection guide and use the connection details shown by the App. Do not substitute a local filesystem path for a remote workspace upload.

Deploy from an agent

  1. Call capabilities and doctor to learn the node’s current abilities and the caller’s permissions.
  2. Choose the source: deploy for a folder accessible to the MCP process, deploy_git for a permitted Git repository, or write_app_files followed by deploy_app for agent-authored source.
  3. Use dry_run=true where supported, inspect the plan, then submit the real deployment.
  4. Call wait_for_service with its name and returned deployment version. Inspect diagnose_service on failure and service_logs for selected output.
  5. Verify the returned endpoint is reachable from the intended client. A LAN URL is not an internet URL. Hosted sharing and direct domains have separate prerequisites in Networking and HTTPS.
A workspace remains available after deployment. Update only the changed text files, then call deploy_app again. Files must be UTF-8 text without NUL bytes, bounded to 256 KiB per file, 500 files and 10 MiB total. Use multiple small writes for a larger app; binary assets need a Git or folder source. Workspaces are owner-scoped and survive service deletion unless workspace purge is explicitly requested.

Safe operation

Tool results can contain an error object with a stable code, message and recovery hint. Check for it before proceeding. Deployment acceptance is asynchronous; only a successful wait confirms the deployment outcome. Most write tools accept an idempotency_key and generate one if omitted. Retain an explicit key when retrying the same uncertain operation. Read the HTTP retry contract before reusing one. restart_daemon can close its own HTTP connection during a successful restart: check health before treating that as failure.
Tools can delete services, publish applications, run commands and change configuration within the supplied credential’s permissions. Grant only the access the agent needs. Secret-setting tools keep values out of responses, but values supplied through chat may still enter the client’s conversation history; set sensitive values outside chat.
Token creation/rotation, secrets-key rotation, control-plane backups and restores, and database restores are deliberately absent from MCP. Database dumps return metadata for a server-side archive, not its contents. Use the CLI or HTTP API and the recovery guide for those operator actions.

Tool reference

Serve a deployed app at a domain YOU own, from this node’s own proxy.
Declaratively apply a multi-section daemon config document (all-or-nothing).
Describe this daemon: version, caller role/quotas, URL grammar, backends.No parameters.
Get aggregate cluster metrics (GPUs in use/total, services up).No parameters.
Provision a managed database (kind=database workload).
Use when: the source is a local folder. Asynchronous — follow with wait_for_service.
Use when: you used write_app_files. Asynchronous — follow with wait_for_service.
Use when: the app lives in a Git repo. Asynchronous — follow with wait_for_service.
Use when: you want a starter app. Asynchronous — follow with wait_for_service.
Use when: a service is failing and you need the reason, not the logs.
Run the daemon’s bounded environment health checks (docker/gpu/proxy/db/…).No parameters.
Capture a logical, application-consistent dump of a managed database.
Read a deployed app’s daemon-persisted config (deploy fields + ai bindings).
Read the audit log (admin-scoped), bounded to limit entries per page.
Read daemon config: one section view, or all sections when omitted.
Use when: you need the daemon’s own account of what it just did.
Get one service. name accepts the service name or the job id.
List an app’s workspace: paths, sizes, sha256 and totals.
List the app template store — deployable starter apps (id/name/coordinates).No parameters.
List the dump tars this daemon holds for one managed database.
List managed databases (kind=database workloads), bounded to limit per page.
List GPUs known to the daemon, with live utilization metrics.No parameters.
List served AI models (kind=model workloads), bounded to limit per page.
List the DB-authoritative route inventory, annotated with live Caddy state.
List a service’s secret key names (values are never returned).
List services, optionally filtered by status, bounded to limit per page.
Get the embedded proxy’s typed state (TLS, apex, respawn, live routes).No parameters.
Read one file back from an app’s workspace as text.
Use when: a git app needs a new commit. Asynchronous — follow with wait_for_service.
Remove a custom domain; its route disappears on the next reconcile tick. Idempotent.
Delete one secret key, or all of a service’s secrets when key is omitted.
Delete a service (teardown + remove).
Restart the daemon to apply restart-required config (admin-scoped, audited).
Restart a service (clears backoff).
Run a one-off command in a deployed service’s image (migrations, seeds).
Register a service from a prebuilt image. Idempotency key auto-generated if omitted.
Serve a local AI model as an OpenAI-compatible endpoint.
Use when: you need the raw output a service or its build printed.
Get live CPU, memory, network and PID usage for a running service.
Write an app’s deploy or ai config section (admin/owner-scoped).
Write a daemon config section (admin-scoped, validated, audited).
Set/merge write-only secrets for a service; returns key names only.
Use when: you need a URL you can open (public_url is LAN-only).
Stop a service (desired_state → stopped).
Report disk usage: docker totals + named-volume/model/archive/backup trees.No parameters.
Garbage-collect orphan app images (admin-scoped, audited).
Use when: an app should stop being reachable at its hosted URL.
Use when: a deploy is in flight and you need its real outcome.
Write files into an app’s server-side workspace, then deploy it.