lattice-mcp
lattice-mcp exposes typed MCP tools that let Claude Code inspect and operate a Lattice container-orchestration fleet through the lattice-api admin surface, with secret masking by default.
Monitor fleet health, API/database health, versions, anomalies, metrics, and audit activity.
Manage workers: inspect, reboot/upgrade, start/stop all containers, register/update/delete, manage tokens, volumes, networks, and port availability.
Manage stacks and containers: create/update/delete, deploy, restart/stop/start, pause/unpause, kill, recreate/remove, inspect logs/lifecycle, import/export/sync compose YAML, and manage deploy tokens.
Manage deployments: list/get, view logs, rollback, and approve pending deployments.
Operate managed databases: provision/update/delete, start/stop/restart/remove, view connections/events/logs/lifecycle, reveal masked/audited credentials, open console authorisation, snapshot/restore/delete, and inspect backup posture/runs/metrics.
Manage backup destinations and container registries, including connectivity/credential tests, repositories, and deployable image tags.
Use discovery/diagnostics: cross-resource search, fleet/container metrics, runner version checks, and anomaly detection.
Manage automations, outbound webhooks, global env vars, templates, users, SSO/SMTP settings, notification preferences, API tokens, worker tokens, and self-update actions.
Protect secrets: mask credentials in responses and refuse writes containing the mask tail unless LATTICE_ALLOW_SECRET_VALUES=1 is set.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@lattice-mcp List all stacks with their status"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
lattice-mcp
Model Context Protocol server for Lattice, the container orchestration platform that runs every appleby.cloud service. Gives Claude Code direct, typed access to workers, stacks, containers, deployments, databases, registries, networks, volumes and instance configuration.
appleby.cloud platform · MCP server · published to npm as
lattice-mcp· consumed vianpx -y lattice-mcp
Overview
lattice-mcp is a single-file Node ESM program (index.js) that speaks MCP over stdio and translates tool calls into HTTP requests against the lattice-api admin surface. It exposes 147 typed tools and holds no business logic, caching or state of its own — every behaviour (pagination, validation, side effects) comes from lattice-api.
Once configured, ask Claude Code things like:
"What's the status of all stacks?"
"Show me logs for the forta-api container"
"Which containers are unhealthy?" (
lattice_get_anomaliesis the best first call)"Deploy stack 5" / "Rollback the last deployment on stack 12"
"What image tags can I deploy from the registry?"
"Create an automation that redeploys monitor-core in both zones from one webhook"
"Why didn't the nightly automation run?" (
lattice_list_automation_runs— skipped firings say why)
Related MCP server: Claude Orchestrator MCP
Role in the appleby.cloud ecosystem
Repo | Relationship |
The API this wraps — its route table is the source of truth for tool coverage. | |
Next.js dashboard over the same API. | |
Agent on each worker VM; WebSocket back to | |
| Sibling MCP servers, same single-file structure. |
Tech stack
Node ≥18 (needs global
fetchandAbortSignal.timeout), ESM ("type": "module").@modelcontextprotocol/sdk^1.29.0 —McpServer+StdioServerTransport.zod^4.4.3 for argument schemas (a declared dependency as of 1.1.1).No build step, no bundler.
node --check index.jsis the only static gate.
Getting started
Prerequisites
Node ≥18.
A Lattice API URL and API token. Generate a token from the Lattice web dashboard under Settings > API Tokens.
Setup
Quickest — interactive setup writes the lattice block into ~/.mcp.json:
npx lattice-mcp --setupOr configure it manually in ~/.mcp.json:
{
"mcpServers": {
"lattice": {
"command": "npx",
"args": ["-y", "lattice-mcp"],
"env": {
"LATTICE_API_URL": "https://lattice-api.appleby.cloud",
"LATTICE_API_TOKEN": "your-api-token"
}
}
}
}Restart Claude Code after setup so the new server and tools are picked up.
Environment variables
Variable | Required | Description |
| Yes | Lattice API base URL |
| Yes | Bearer token for authentication (sent on every request) |
| No | Set to |
Secret values are masked
Every response is passed through a masking step before it reaches the model. Anything that looks
like a credential keeps its first two characters and loses the rest to a fixed-width tail —
supersecret becomes su**********.
That is enough to tell two credentials apart, or to confirm a rotation actually changed something, and not enough to use. The tail is a fixed width so the mask does not reveal the real length.
This covers container and stack env_vars, compose_yaml environment blocks, global env vars
flagged is_secret, database passwords, freshly minted deploy/worker/API tokens, automation
webhook tokens (webhook_token and the webhook_path that embeds it), and automation
http_request steps — header values, the body, and the URL path, where Slack/Discord-style hooks
keep their secret. Variable and header names are left readable — they are the useful half — as
are the URL's host and addresses like TOKEN_URL and AUTH_URL.
Values are checked as well as names, so a secret does not have to be named like one to be
caught. Known provider keys (sk-…, ghp_…, AKIA…, xoxb-…, JWTs) are masked under any
variable name, including unflagged global env vars, and a password inside a connection string
is masked in place: postgres://app:hu**********@db:5432/app.
Interpolation references (${ENCRYPTION_KEY}, $NAME) are names, not values, and are left
readable — only a ${NAME:-default}'s default can be masked. Masked output is also guarded on the
way back in: compose, env-var and container write tools refuse any input containing the mask
tail **********, so editing a compose you read through this server can never write the mask
over a real secret. Edit secrets in lattice-web.
This server authenticates as a Lattice admin, and the API only masks global env vars
server-side for non-admin callers. Without this step, lattice_list_env_vars returns every
secret value in plaintext.
Set LATTICE_ALLOW_SECRET_VALUES=1 to turn masking off if you genuinely need a working value.
Development
Command | What it does |
| Interactive setup — writes the |
| Install dependencies (not vendored) |
| Syntax gate — the only static check that exists |
| Run the server on stdio |
| Confirm the tool count (should be 147) |
|
|
| Publish to npm — this is deployment (requires 2FA passkey from an interactive terminal) |
Tools
All 147 tools, grouped as they appear in index.js. ⚠️ marks destructive tools; their descriptions state the blast radius.
Overview & health
Tool | Description |
| Fleet overview — worker/stack/container counts, failed stacks, CPU/memory |
| API health, database connectivity, telemetry counters and the control-plane host's free disk ( |
| Deployed lattice-api version string — check deploy drift against GitHub tags |
Workers
Tool | Description |
| List workers with status, IP, versions, heartbeat |
| Detailed worker info including metrics |
| CPU, memory, disk, network metrics |
| Reboot a worker machine |
| Upgrade worker runner to latest |
| Stop all containers on a worker |
| Start all containers on a worker |
Stacks
Tool | Description |
| List stacks with status and worker assignment |
| Full stack details including compose YAML |
| Deploy a stack (all or specific containers) |
| Restart all containers in a stack |
| Stop all containers in a stack |
| Start all containers in a stack |
| Update stack configuration (incl. |
Containers
Tool | Description |
| List containers with status, image, ports, health |
| Full container details |
| Recent container logs (stdout/stderr); |
| Lines and bytes stored per container per UTC day, largest first: what fills |
| Lifecycle events (start, stop, health changes) |
| Start a stopped container |
| Stop a running container |
| Restart a container |
| Force kill a container |
| Pause a running container |
| Unpause a paused container |
| Remove a container ⚠️ |
| Remove and recreate a container ⚠️ |
Deployments
Tool | Description |
| List deployments with status and timing |
| Deployment details with container-level status |
| Pull, create, start, swap events with timing |
| Rollback to previous state ⚠️ |
Instance self-update
Tool | Description |
| Trigger the Lattice API container to self-update |
| Trigger the Lattice web container to update |
Audit & API tokens
Tool | Description |
| Audit log entries (who did what, when); filter by |
| List API tokens |
| Create a new API token |
| Delete an API token ⚠️ |
Database instances
Tool | Description |
| List managed databases (filter by worker, engine, status) |
| Full instance config |
| Provision mysql/mariadb/postgres on a worker (omit |
| Update config, limits, snapshot schedule |
| Destroy an instance and its data volume ⚠️ — async; |
| start / stop / restart / remove ⚠️ — |
| Host, port, database and username — no secrets |
| Reveal live credentials (audited; root only on request) |
| Deprecated — root credentials via GET; use the reveal tool |
| Lifecycle history — start here when a database looks wrong |
| 3-2-1 standing — copies, media, off-site, with warnings |
| Scheduled snapshot attempts, including skipped slots and why |
| CPU/memory samples for a database (no containers-table row needed) |
| Container stdout/stderr |
| Worker lifecycle messages, incl. why a create failed |
| Authorise an interactive SQL console session |
| Snapshots for an instance |
| Take a snapshot now |
| Restore from a snapshot ⚠️ |
| Delete a snapshot and its remote file ⚠️ |
Worker port allocation
Tool | Description |
| Claimed host ports on a worker, plus a free suggestion |
Backup destinations
Tool | Description |
| List backup destinations |
| One destination's configuration |
| Create a destination |
| Update a destination |
| Delete a destination ⚠️ |
| Test connectivity without writing a backup (requires a connected |
Registries
Tool | Description |
| Configured container registries |
| Add a registry |
| Update a registry |
| Delete a registry ⚠️ |
| Test a saved registry's stored credentials |
| Test registry credentials before saving |
| What images exist |
| What versions are deployable |
Discovery & diagnostics
Tool | Description |
| Search workers, stacks and containers in one call |
| Restart loops, unhealthy containers, offline workers, low disk on workers and the control plane — best first call |
| Aggregated fleet CPU/memory/disk/network |
| Runner versions and what's outdated |
| Re-poll every worker for its current runner version |
| Per-container metrics over time |
| Which user the token authenticates as |
Stacks — lifecycle, compose & deploy tokens
Tool | Description |
| Create an empty stack |
| Delete a stack and all its containers ⚠️ |
| Containers in a stack |
| Replace a stack's compose YAML |
| Reconcile container records against stored compose YAML |
| Create a stack from compose YAML |
| Export a stack's full definition as portable JSON |
| Recreate a stack from an export document |
| Save a stack as a reusable template |
| CI deploy tokens — |
| Create a CI deploy token |
| Delete a CI deploy token ⚠️ |
| Approve a deployment awaiting approval |
Automations
A trigger (webhook or UTC cron) plus ordered steps. One webhook can redeploy containers in any number of stacks — a deploy token reaches one. Automations created here run as the user who owns this server's API token, authorised each time they run.
Tool | Description |
| Automations with their run-as user and last run — start here when a CI redeploy "didn't happen" |
| One automation's trigger, steps, run-as user and last run |
| Create one — webhook token returned once and masked |
| Rename, or redefine trigger/steps (redefining makes you the run-as user) |
| Switch on — re-validates, makes you the run-as user |
| Switch off — the webhook then answers 200 |
| Fire now and wait for the verdict (up to 50s) — performs real actions |
| New webhook token; the old URL 401s immediately |
| Delete — stops firing, kills the webhook URL ⚠️ |
| Run history incl. skipped firings and why, with every step's result |
Container definitions
Tool | Description |
| Add a container definition to a stack |
| Update a container definition |
| Delete definition and its running container ⚠️ |
Workers — registration, tokens, volumes, networks
Tool | Description |
| Register a worker |
| Update a worker's name, hostname, IP, status, labels |
| Delete a worker ⚠️ |
| Live per-container stats from one worker |
| Worker registration tokens |
| Create a registration token for a worker |
| Delete a worker token ⚠️ |
| Docker volumes on a worker |
| Create a Docker volume on a worker |
| Delete a Docker volume ⚠️ |
| Docker networks on a worker |
| Create a Docker network on a worker |
| Delete a Docker network ⚠️ |
| Every tracked network across the fleet |
| Delete a tracked network by Lattice ID ⚠️ |
| Force-remove a wedged container ⚠️ |
Env vars, templates & webhooks
Tool | Description |
| Global |
| Create a global environment variable |
| Update a global environment variable |
| Delete a global environment variable ⚠️ |
| Saved stack templates |
| Create a stack template |
| Delete a stack template ⚠️ |
| Outbound event webhooks |
| Create an outbound webhook |
| Update a webhook |
| Delete a webhook ⚠️ |
| Send a test payload to a webhook |
Users & instance configuration
Tool | Description |
| List Lattice users with roles and status |
| Create a local Lattice user |
| Update a user's name, role or active flag ⚠️ |
| Delete a Lattice user ⚠️ |
| Get the Forta SSO configuration |
| Update SSO config ⚠️ (can lock out SSO users) |
| Get the SMTP configuration |
| Update the SMTP configuration |
| Send a test email with the saved SMTP config |
| Per-event notification preferences |
| Update notification preferences |
Project structure
Everything lives in one file:
Path | Role |
| The whole server: |
| npm metadata; |
| Contributor/agent guide — conventions, handler contracts, verification. |
| This file. |
Deployment
Published to npm as lattice-mcp (public). Consumers run npx -y lattice-mcp, which resolves the latest published version — so publishing is deployment, and a running MCP server must be restarted to pick up a new version. npm publish requires 2FA via passkey from an interactive terminal.
Contributing & further reading
Read AGENTS.md before changing code — it documents the one-shape tool pattern, the body()/api() helpers, the "read the handler before adding a tool" rule, and the verification steps. Related repos: lattice-api, lattice-web, lattice-runner.
License
MIT
Available Tools
133 toolslattice_approve_deploymentA
Approve a deployment that is waiting on manual approval
Inputs: id (required).
lattice_create_api_tokenB
Create a new API token for AI tools or automation
Inputs: name (required), expires_in.
lattice_create_backup_destinationA
Create a backup destination. config is a free-form object whose shape depends on type (e.g. an S3 destination takes bucket, region, endpoint and credentials)
Inputs: name (required), type (required), config (required).
lattice_create_containerA
Add a container definition to a stack. Creates the record only — deploy the stack to actually start it. JSON-shaped fields are passed as strings, matching the API
Inputs: tag (required), name (required), image (required), stack_id (required), +10 more.
lattice_create_database_instanceB
Provision a database instance on a worker. Creates a real container. Omit port to have a free one allocated automatically — that is the recommended path; a port already in use returns 409 naming the conflict
Inputs: name (required), engine (required), worker_id (required), port, +11 more.
lattice_create_database_snapshotA
Take a snapshot of a database instance now, outside its schedule
Inputs: id (required).
lattice_create_deploy_tokenA
Create a deploy token for a stack. The plaintext is returned once and this server masks it to its first two characters, so the usable value never enters a transcript — read it from the Lattice UI, or set LATTICE_ALLOW_SECRET_VALUES=1. Used as https:///api/deploy/?container=
Inputs: id (required), name (required).
lattice_create_env_varB
Create a global environment variable
Inputs: key (required), value (required), is_secret.
lattice_create_registryB
Add a container registry
Inputs: url (required), name (required), type (required), password, +1 more.
lattice_create_stackA
Create an empty stack. Add containers with lattice_create_container, or use lattice_import_compose to create one from compose YAML
Inputs: name (required), env_vars, worker_id, auto_deploy, +2 more.
lattice_create_templateB
Create a stack template from a config document
Inputs: name (required), config (required), description.
lattice_create_userB
Create a local Lattice user
Inputs: role (required), email (required), password (required), name.
lattice_create_webhookA
Create an outbound webhook. events is a JSON array string, e.g. '["container.status"]' or '["*"]' for everything
Inputs: url (required), name (required), events (required), secret.
lattice_create_workerA
Register a worker. The machine still needs the runner installed and a worker token before it connects
Inputs: name (required), hostname (required), labels, ip_address.
lattice_create_worker_networkB
Create a Docker network on a worker
Inputs: id (required), name (required), driver.
lattice_create_worker_tokenA
Create a registration token for a worker, used by the runner to connect. Plaintext is returned once and this server masks it to its first two characters — read the usable value from the Lattice UI, or set LATTICE_ALLOW_SECRET_VALUES=1
Inputs: id (required), name (required).
lattice_create_worker_volumeC
Create a Docker volume on a worker
Inputs: id (required), name (required), driver.
lattice_database_actionA
Start, stop, restart or remove a database instance's container. 'remove' destroys the container — data survives only if the volume or a snapshot does
Inputs: id (required), action (required).
lattice_delete_api_tokenB
Delete an API token
Inputs: id (required).
lattice_delete_backup_destinationB
Delete a backup destination. Instances pointing at it lose their backup target. Destructive
Inputs: id (required).
lattice_delete_containerA
Delete a container definition and its running container. Destructive — lattice_stop_container only stops it
Inputs: id (required).
lattice_delete_database_instanceA
Delete a database instance record. Destructive — data is lost unless a snapshot exists. Check lattice_list_database_snapshots first
Inputs: id (required).
lattice_delete_database_snapshotA
Delete a database snapshot. Destructive — that restore point is gone
Inputs: snapshot_id (required).
lattice_delete_deploy_tokenA
Delete a deploy token. Any CI pipeline using it stops being able to deploy. Destructive
Inputs: token_id (required).
lattice_delete_env_varA
Delete a global environment variable. Any config referencing ${KEY} fails to interpolate on next deploy. Destructive
Inputs: id (required).
lattice_delete_networkC
Delete a tracked network by its Lattice ID. Destructive
Inputs: id (required).
lattice_delete_registryA
Delete a registry. Containers pulling from it fail on their next deploy. Destructive
Inputs: id (required).
lattice_delete_stackA
Delete a stack and every container in it. Destructive and not recoverable — export it first with lattice_export_stack if you might want it back
Inputs: id (required).
lattice_delete_templateB
Delete a stack template. Destructive
Inputs: id (required).
lattice_delete_userC
Delete a Lattice user. Destructive
Inputs: id (required).
lattice_delete_webhookB
Delete a webhook. Destructive
Inputs: id (required).
lattice_delete_workerA
Delete a worker. Every stack pinned to it becomes undeployable. Destructive
Inputs: id (required).
lattice_delete_worker_networkA
Delete a Docker network on a worker. Containers attached to it lose connectivity. Destructive
Inputs: id (required), name (required).
lattice_delete_worker_tokenA
Delete a worker token. If the runner is using it, it cannot reconnect after a restart. Destructive
Inputs: token_id (required).
lattice_delete_worker_volumeA
Delete a Docker volume on a worker. Any data stored in it is destroyed. Destructive
Inputs: id (required), name (required).
lattice_deploy_stackB
Deploy a stack (all containers or specific ones)
Inputs: id (required), force, container_ids.
lattice_export_stackA
Export a stack's full definition — stack settings plus every container config — as a portable JSON document. Take one before any destructive stack change
Inputs: id (required).
lattice_force_remove_containerA
Force-remove a container on a worker by name, bypassing the normal lifecycle. For clearing a wedged container that ordinary remove will not shift. Destructive
Inputs: id (required), name (required).
lattice_get_anomaliesA
Get detected fleet anomalies — restart loops, unhealthy containers, resource spikes, offline workers. The best first call when asked whether anything is wrong
Inputs: no named parameters.
lattice_get_audit_logA
Get recent audit log entries (who did what, when). Filter by user, action, or resource type to answer 'who deleted X' without scanning.
Inputs: limit, action, offset, user_id, +1 more.
lattice_get_backup_destinationB
Get one backup destination's configuration
Inputs: id (required).
lattice_get_containerA
Get full container details including config, health, env vars, ports
Inputs: id (required).
lattice_get_container_lifecycleA
Get container lifecycle events (start, stop, restart, health changes)
Inputs: id (required), limit.
lattice_get_container_logsC
Get recent container logs (stdout/stderr)
Inputs: id (required), limit, offset, stream, +1 more.
lattice_get_container_metricsB
Get a single container's CPU, memory and network metrics over time
Inputs: id (required), limit, range.
lattice_get_database_connectionA
Get a database instance's host, port, database and username. Contains no secrets — prefer this over the credential tools when you only need to know where a database lives
Inputs: id (required).
lattice_get_database_credentialsA
DEPRECATED — returns root credentials from a plain GET. Use lattice_reveal_database_credentials instead, which is audited and scoped
Inputs: id (required).
lattice_get_database_eventsA
Get a database instance's lifecycle history — every status transition, failure, reconciliation, console open and credential reveal. START HERE when a database is in an unexpected state: this is what explains how it got there
Inputs: id (required), kind, limit.
lattice_get_database_instanceA
Get one database instance: engine, port, limits, snapshot schedule, retention and backup destination
Inputs: id (required).
lattice_get_database_lifecycle_logsB
Get worker-emitted lifecycle messages for a database container, including provisioning progress and the reason a create failed
Inputs: id (required), limit.
lattice_get_database_logsA
Get a database container's stdout/stderr. Use together with lattice_get_database_events when diagnosing a failed or degraded instance — the events say what happened, the logs say why
Inputs: id (required), limit, stream.
lattice_get_deploymentB
Get deployment details including container-level status
Inputs: id (required).
lattice_get_deployment_logsA
Get deployment logs: pull, create, start, swap, rollback events with timing
Inputs: id (required).
lattice_get_fleet_metricsA
Get aggregated fleet-wide CPU, memory, disk and network metrics over a time range
Inputs: range.
lattice_get_notification_prefsB
Get per-event notification preferences
Inputs: no named parameters.
lattice_get_selfA
Get the user this API token authenticates as, including role
Inputs: no named parameters.
lattice_get_smtp_configA
Get the SMTP configuration used for alert emails
Inputs: no named parameters.
lattice_get_sso_configA
Get the Forta SSO configuration
Inputs: no named parameters.
lattice_get_stackA
Get full stack details including compose YAML and env vars
Inputs: id (required).
lattice_get_stack_containersA
List the containers belonging to one stack
Inputs: id (required).
lattice_get_versionA
Get the deployed lattice-api version string. Use to check deploy drift against GitHub tags/commits (e.g. for /howfarbehind).
Inputs: no named parameters.
lattice_get_versionsA
Get runner versions across workers and which are outdated. Use before lattice_upgrade_worker to see what actually needs upgrading
Inputs: no named parameters.
lattice_get_workerB
Get detailed worker info including metrics
Inputs: id (required).
lattice_get_worker_container_statsB
Get live per-container resource stats from one worker
Inputs: id (required).
lattice_get_worker_metricsB
Get recent worker metrics (CPU, memory, disk, network)
Inputs: id (required), range.
lattice_get_worker_port_availabilityA
List host ports already claimed on a worker (by databases and by stack containers) and get a free suggestion. Check this before pinning a database to a specific port
Inputs: id (required), port.
lattice_healthA
Check API health and database connectivity
Inputs: no named parameters.
lattice_import_composeB
Create a new stack from a docker-compose YAML document
Inputs: name (required), compose_yaml (required), worker_id, description, +1 more.
lattice_import_stack_exportA
Recreate a stack from a document produced by lattice_export_stack
Inputs: stack (required), version (required), containers (required).
lattice_kill_containerC
Force kill a container
Inputs: id (required).
lattice_list_all_networksA
List every tracked Docker network across the fleet
Inputs: no named parameters.
lattice_list_api_tokensA
List all API tokens
Inputs: no named parameters.
lattice_list_backup_destinationsA
List configured backup destinations that database snapshots can be shipped to
Inputs: no named parameters.
lattice_list_containersA
List containers with status, image, ports, health. Filter by stack or status
Inputs: name, status, stack_id, worker_id.
lattice_list_database_instancesA
List managed database instances with engine, version, status, worker and health. Filter by worker, engine or status
Inputs: limit, engine, offset, status, +1 more.
lattice_list_database_snapshotsA
List snapshots for a database instance, with size and creation time. Check this before deleting or restoring an instance
Inputs: id (required).
lattice_list_deploymentsB
List deployments with status, strategy, timing. Filter by stack or status
Inputs: limit, status, stack_id.
lattice_list_deploy_tokensA
List a stack's deploy tokens — the credentials CI uses to trigger deployments. Token values are never returned; last_used_at reveals whether CI is actually reaching Lattice
Inputs: id (required).
lattice_list_env_varsA
List global environment variables available for interpolation into stack and container configs as ${NAME}. Values marked is_secret are masked to their first two characters by this server — the API itself only masks them for non-admin callers, and this MCP authenticates as an admin
Inputs: no named parameters.
lattice_list_registriesA
List configured container registries
Inputs: no named parameters.
lattice_list_registry_repositoriesA
List repositories available in a registry — what images exist to deploy
Inputs: id (required).
lattice_list_registry_tagsA
List the tags published for one repository. Use this to answer 'what version can I deploy' or 'is the image my CI just built actually in the registry'
Inputs: id (required), repo (required).
lattice_list_stacksB
List all stacks with status, worker assignment, and deployment strategy
Inputs: status, worker_id.
lattice_list_templatesB
List saved stack templates
Inputs: no named parameters.
lattice_list_usersA
List Lattice users with roles and status
Inputs: no named parameters.
lattice_list_webhooksA
List outbound webhooks that fire on fleet events
Inputs: no named parameters.
lattice_list_worker_networksB
List Docker networks on a worker
Inputs: id (required).
lattice_list_workersA
List all workers with status, IP, Docker version, runner version, last heartbeat
Inputs: status.
lattice_list_worker_tokensA
List a worker's registration tokens. Values are never returned
Inputs: id (required).
lattice_list_worker_volumesA
List Docker volumes on a worker
Inputs: id (required).
lattice_open_database_consoleA
Authorise an interactive console session against a running database and return the worker, container and SQL client command to run. The session itself runs over the admin WebSocket, so this returns the authorisation, not a live shell
Inputs: id (required).
lattice_overviewA
Get fleet overview: worker counts, stack counts, container counts, failed stacks, recent deployments, fleet CPU/memory averages
Inputs: no named parameters.
lattice_pause_containerC
Pause a running container
Inputs: id (required).
lattice_reboot_workerC
Reboot a worker machine
Inputs: id (required).
lattice_recreate_containerB
Recreate a container (remove and create fresh)
Inputs: id (required).
lattice_refresh_versionsA
Re-poll every worker for its current runner version, refreshing what lattice_get_versions reports
Inputs: no named parameters.
lattice_remove_containerC
Remove a container entirely
Inputs: id (required).
lattice_restart_containerC
Restart a container
Inputs: id (required).
lattice_restart_stackC
Restart all containers in a stack
Inputs: id (required).
lattice_restore_database_snapshotA
Restore a database instance from one of its snapshots. Overwrites current data irreversibly — take a fresh snapshot first if the present state matters
Inputs: id (required), snapshot_id (required).
lattice_reveal_database_credentialsA
Reveal a database instance's live credentials. Every call is audited and recorded against the instance. Returns the application user by default; set include_root only when root access is genuinely required. Passwords come back masked to their first two characters — enough to confirm which credential is deployed, not enough to use. Set LATTICE_ALLOW_SECRET_VALUES=1 in the MCP server env to get the real values, or read them from the Lattice UI
Inputs: id (required), include_root.
lattice_rollback_deploymentC
Rollback a deployment to its previous state
Inputs: id (required).
lattice_save_stack_as_templateB
Save an existing stack's configuration as a reusable template
Inputs: id (required), name (required), description.
lattice_searchA
Search across workers, stacks and containers by name in one call. Faster than listing each type and filtering when you only have a partial name
Inputs: q (required), limit.
lattice_start_all_workerC
Start all containers on a worker
Inputs: id (required).
lattice_start_containerB
Start a stopped container
Inputs: id (required).
lattice_start_stackB
Start all containers in a stack
Inputs: id (required).
lattice_stop_all_workerB
Stop all containers on a worker
Inputs: id (required).
lattice_stop_containerC
Stop a running container
Inputs: id (required).
lattice_stop_stackA
Stop all containers in a stack
Inputs: id (required).
lattice_sync_stack_composeB
Reconcile a stack's container records against its stored compose YAML, reporting which containers changed and why
Inputs: id (required).
lattice_test_backup_destinationA
Test connectivity and credentials for a backup destination without writing a real backup. The test is dispatched over the worker's WebSocket, so worker_id is required and that worker must be connected
Inputs: id (required), worker_id (required).
lattice_test_registryB
Test a saved registry's stored credentials
Inputs: id (required).
lattice_test_registry_inlineB
Test registry credentials before saving them
Inputs: url (required), password (required), username (required).
lattice_test_smtpA
Send a test email using the saved SMTP configuration
Inputs: no named parameters.
lattice_test_webhookB
Send a test payload to a webhook to verify the endpoint accepts it
Inputs: id (required).
lattice_unpause_containerC
Unpause a paused container
Inputs: id (required).
lattice_update_apiA
Update the Lattice API container. Pass version to deploy or roll back to a specific tag; omit it to take whatever the compose file resolves to. Returns 'already up to date' without restarting when the resolved image is the one already running
Inputs: force, version.
lattice_update_backup_destinationB
Update a backup destination. Passing config replaces the whole object, it does not merge
Inputs: id (required), name, type, active, +1 more.
lattice_update_containerA
Update a container definition. Changes the stored record — redeploy or recreate the container for them to take effect
Inputs: id (required), tag, name, image, +10 more.
lattice_update_database_instanceA
Update a database instance's configuration. Only the fields you pass are changed
Inputs: id (required), name, port, active, +9 more.
lattice_update_env_varA
Update a global environment variable's value or secret flag. Containers pick it up on their next deploy
Inputs: id (required), value, is_secret.
lattice_update_notification_prefsA
Update notification preferences. Merges into existing prefs; unknown event types are ignored rather than rejected, so verify with lattice_get_notification_prefs afterwards
Inputs: preferences (required).
lattice_update_registryB
Update a registry's URL, type, credentials or active flag
Inputs: id (required), url, name, type, +3 more.
lattice_update_smtp_configC
Update the SMTP configuration
Inputs: host, port, enabled, password, +4 more.
lattice_update_sso_configA
Update the SSO configuration. Misconfiguring this can lock every SSO user out of Lattice — verify local admin access first
Inputs: scopes, enabled, client_id, token_url, +9 more.
lattice_update_stackC
Update stack configuration (name, description, strategy, worker, etc.)
Inputs: id (required), name, active, status, +4 more.
lattice_update_stack_composeA
Replace a stack's compose YAML. This rewrites the stored definition but does not deploy — call lattice_deploy_stack afterwards
Inputs: id (required), compose_yaml (required).
lattice_update_userA
Update a user's name, role or active flag. Setting active=false blocks their access immediately
Inputs: id (required), name, role, active.
lattice_update_webA
Update the Lattice web container. Pass version to deploy or roll back to a specific tag; omit it to take whatever the compose file resolves to
Inputs: force, version.
lattice_update_webhookB
Update a webhook's URL, event list, secret or active flag
Inputs: id (required), url, name, active, +2 more.
lattice_update_workerC
Update a worker's name, hostname, IP, status, labels or active flag
Inputs: id (required), name, active, labels, +3 more.
lattice_upgrade_workerB
Upgrade worker runner to latest version
Inputs: id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 133 tools
Nearly every tool targets a distinct resource and action, and the descriptions carefully disambiguate near-overlaps like container metrics vs worker container stats and database events vs lifecycle logs. A few boundaries remain fuzzy—deprecated get vs reveal credentials, sync vs update compose, and force-remove vs remove—but a careful agent can tell them apart.
The set overwhelmingly follows a lattice_<verb>_<noun> snake_case pattern, making behavior predictable. Minor deviations include noun-only names like lattice_health, lattice_overview, and lattice_search, the parameter-based lattice_database_action, and the confusing singular/plural pair lattice_get_version vs lattice_get_versions.
With 133 tools this is far beyond the extreme-mismatch threshold and creates a massive selection surface for an agent. Even though the platform domain is broad, this many individual endpoints is inappropriate for an MCP server and could be consolidated into parameterized resource actions.
Coverage is unusually thorough: stacks, containers, workers, databases, snapshots, registries, webhooks, users, tokens, and settings all have CRUD plus lifecycle actions. Minor gaps exist—no get-single webhook/registry/template, no template update, no volume/network update—but list endpoints and sensible workarounds cover them.
Maintenance
Related MCP Connectors
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
Hosted Amazon Seller and Vendor MCP server for Claude, ChatGPT, Cursor, Codex, Gemini, Copilot.
Related MCP Servers
- AlicenseAqualityBmaintenanceAn MCP server for managing Modal apps, containers, volumes, and secrets. Also used for deploying & running Modal apps directly from Claude Code and other MCP clients.12396 PyPI4MIT
- AlicenseAqualityFmaintenanceAn MCP server for coordinating multiple Claude Code sessions across related projects.11MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that enables Claude Code to communicate with other Claude Code agents over HTTP, allowing users to ask questions about remote codebases or delegate coding tasks.MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that exposes the Lattice Talent API as tools, enabling AI assistants like Claude to read and manage people data, goals, feedback, reviews, and more.223 npmMIT