Enables AI agents to manage Docker containers, Compose stacks, logs, and databases locally or over SSH using structured data.
Also known as hypnosis/docker-mcp-server, docker-mcp-server, @hypnosis/docker-mcp-server
- Stars
- 1
- Tools
- 10
- Downloads, 30 days
- 1,235
- Latest version
- 2.0.1
- Last commit
- Aug 24, 2026
- License
- MIT
What is Docker MCP?
Docker enables AI agents to manage Docker containers, Compose stacks, logs, and databases locally or over SSH using structured data. It exposes 10 tools, such as docker_container, docker_logs, docker_compose.
Summary generated from the project's README
About Docker MCP server
Managing Docker containers and Compose stacks through structured data is what this server enables for AI agents. It provides a way for developers to let their coding assistants inspect containers, read logs, check service health, and query databases without relying on brittle shell commands or parsing messy ASCII tables. By returning named fields like service, project, and state, it allows agents to make more reliable decisions based on explicit results.
Users can run this locally using the local Docker socket or manage remote hosts by defining profiles for SSH connections. It works with various MCP clients including Claude Code, Cursor, and Gemini CLI. Setting up a local environment is simple via npx, while remote management is handled through a profiles configuration file that includes host details and private key paths. This makes it a versatile tool for platform engineers and DevOps professionals who need to maintain environments across development, staging, and production hosts.
What you can do with it
- 1Diagnose Compose stack healthAsk an AI agent to determine if a multi-container application is running correctly and identify failing services.
- 2Reduce AI token consumptionProvide agents with precise, structured data instead of large, unformatted terminal outputs.
- 3Inspect database statesHave an AI agent query a database running within a container to troubleshoot application issues.
Written from the project's README. Every use case is checked against a quote from it.
How to install Docker MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Docker MCP in Claude Code
$ claude mcp add docker-mcp-server -- npx -y @hypnosis/docker-mcp-serverInstall Docker MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"docker-mcp-server": {
"command": "npx",
"args": [
"-y",
"@hypnosis/docker-mcp-server"
]
}
}
}Install Docker MCP in VS Code
.vscode/mcp.json
{
"servers": {
"docker-mcp-server": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@hypnosis/docker-mcp-server"
]
}
}
}Install Docker MCP in VS Code CLI
$ code --add-mcp '{"name":"docker-mcp-server","type":"stdio","command":"npx","args":["-y","@hypnosis/docker-mcp-server"]}'Install Docker MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"docker-mcp-server": {
"command": "npx",
"args": [
"-y",
"@hypnosis/docker-mcp-server"
]
}
}
}Install Docker MCP in Codex
$ codex mcp add docker-mcp-server -- npx -y @hypnosis/docker-mcp-serverInstall Docker MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.docker-mcp-server] command = "npx" args = ["-y", "@hypnosis/docker-mcp-server"]
Install Docker MCP in Gemini CLI
$ gemini mcp add -s user docker-mcp-server npx -- -y @hypnosis/docker-mcp-serverInstall Docker MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"docker-mcp-server": {
"command": "npx",
"args": [
"-y",
"@hypnosis/docker-mcp-server"
]
}
}
}Docker MCP tools 10
Detected from the READMEdocker_containerdocker_logsdocker_composedocker_healthdocker_resourcedocker_container_controldocker_compose_controldocker_dbdocker_db_admindocker_exec
| docker_container | — | |
| docker_logs | — | |
| docker_compose | — | |
| docker_health | — | |
| docker_resource | — | |
| docker_container_control | — | |
| docker_compose_control | — | |
| docker_db | — | |
| docker_db_admin | — | |
| docker_exec | — |
Configuration
DOCKER_MCP_ALLOW_SSH_FALLBACKKeep going when a profile's SSH key is missing, instead of refusing the profile. Defaults to false.
DOCKER_MCP_PROFILES_FILEAbsolute path to the JSON file describing the Docker hosts this agent may reach. Without it the server answers about the Docker on this machine.
DOCKER_PROFILESThe same profiles JSON inline, used when no profiles file is set.
LOG_LEVELLog verbosity: error, warn, info or debug. Defaults to info.
| Name | Description | |
|---|---|---|
| DOCKER_MCP_ALLOW_SSH_FALLBACK | Keep going when a profile's SSH key is missing, instead of refusing the profile. Defaults to false. | |
| DOCKER_MCP_PROFILES_FILE | Absolute path to the JSON file describing the Docker hosts this agent may reach. Without it the server answers about the Docker on this machine. | |
| DOCKER_PROFILES | The same profiles JSON inline, used when no profiles file is set. | |
| LOG_LEVEL | Log verbosity: error, warn, info or debug. Defaults to info. |
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablehypnosis/docker-mcp-server is public and reachablegithub.com/hypnosis/docker-mcp-server ↗Pass
- Package names this repository as its source@hypnosis/docker-mcp-server names hypnosis/docker-mcp-server as sourcenpmjs.com/package/@hypnosis/docker-mcp-server ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for @hypnosis/docker-mcp-servernpmjs.com/package/@hypnosis/docker-mcp-server/v/2.0.1#proven ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-08-24github.com/hypnosis/docker-mcp-server ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @hypnosis/docker-mcp-serverPass
- No critical advisory in the package or its dependencies162 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model10 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubDocker MCP Server — Docker tools for AI agents
A Docker MCP server that lets AI agents operate Compose stacks with structured, Docker-native tools — instead of brittle shell commands and terminal-shaped output.
Inspect containers, read logs, check health, query databases, take dumps, and bring stacks up or down — on your laptop or on a server across the world by naming its profile.
It speaks Docker the way you do: your compose files, project names, and service names. Answers come back as named fields with enough context for an agent to act on them, rather than parse an ASCII table and guess.
Works with Claude Code, Codex CLI, Cursor, opencode, Gemini CLI, Qwen Code and other MCP clients.
Install · Tools · Setup · Security · Docs · Changelog
Install in 30 seconds
No global installation required. npx downloads the package on first use:
npx -y @hypnosis/docker-mcp-server
Add it to your MCP client — Claude Code, for example — for every project:
claude mcp add docker -s user -- npx -y @hypnosis/docker-mcp-server
That is the whole setup for the Docker on this machine. No profiles file, no environment variables: the server uses the local Docker socket, and the compose project of your working directory is the project it answers about.
For a Docker host on another machine, add one file with the servers you reach over SSH:
claude mcp add docker -s user \
-e DOCKER_MCP_PROFILES_FILE="$HOME/.claude/docker-profiles.json" \
-- npx -y @hypnosis/docker-mcp-server
{
"default": "local",
"profiles": {
"local": { "mode": "local" },
"production": {
"host": "prod.example.com",
"username": "deployer",
"privateKeyPath": "~/.ssh/id_ed25519"
}
}
}
Now every tool takes a profile, and docker_health({ action: "profiles" }) lists what the
server was given.
Codex, Cursor, opencode and other clients are covered in Set up the Docker MCP server.
Install as a plugin
Some clients — Claude Code, for example — can take the whole thing as a plugin instead:
/plugin marketplace add hypnosis/docker-mcp-server
/plugin install docker-mcp-server@docker-mcp-server
The plugin brings the server up against the Docker on this machine, with no configuration at
all. Point it at other hosts the same way as above, with DOCKER_MCP_PROFILES_FILE.
Requirements
Node.js 18+ and a Docker daemon you can already reach — the local socket, or a remote host over SSH with a key.
The server starts whether or not Docker is up. A call made while the daemon is down answers "start Docker" and works on the next try, without restarting your MCP client.
Prefer a pinned version, offline work, or one less registry check per launch:
npm install -g @hypnosis/docker-mcp-server, then use docker-mcp-server as the command
instead of npx.
Who this Docker MCP server is for
- AI-assisted developers who build, run, and debug applications with Docker Compose.
- Backend and full-stack developers who need their coding agent to inspect containers, logs, health checks, databases, and Compose services while solving a problem.
- Independent developers and small product teams who deploy Docker applications to their own servers and want one agent workflow for local development and production.
- Platform engineers who maintain Docker environments across development, staging, and production hosts.
- DevOps engineers and SREs using AI coding agents for incident checks, routine container work, and faster investigation of Compose-based services.
- Agencies and technical teams maintaining client applications, where an agent needs to understand an unfamiliar Compose stack before making a change.
- QA and release engineers who need repeatable visibility into test stacks, service health, logs, and databases before a release.
Why use a Docker MCP server instead of raw Docker CLI?
Docker CLI is excellent for a person at a terminal. An AI agent needs something different: Docker and Compose concepts it can query directly, results it can reason about, and clear boundaries between what happened, what was not found, and what could not be checked.
Less context, lower AI cost
docker ps, docker stats, and docker logs are designed to be read on a screen. Their output
mixes labels, values, units, and formatting into text an agent must parse before it can use it.
A Docker MCP tool returns the fields the task needs: service, project, state, health, ports, timestamps, byte counts, exit codes, and log streams. The agent receives less terminal noise, spends fewer tokens interpreting it, and keeps more context for the problem it is solving.
Debug Docker Compose as a system
A Docker application is more than a list of containers. It is a Compose project with services, dependencies, health checks, logs, databases, and resources that affect one another.
The server lets an agent ask about that system in the names you use every day: the project, service, and Compose file. One call can show the state and health of a stack; another can inspect a bounded log window, measure a service, or query the database already running beside it. The agent spends its turns finding the cause, not assembling and decoding shell commands.
Make decisions from explicit results
A shell command can return an empty table, clipped output, or an error printed alongside ordinary text. For an agent, those are different situations — and treating them as the same leads to guesses.
Docker MCP results say what was found, what was not found, what was cut short, and why an action did not run. A missing healthcheck is not a failed healthcheck; an empty list is not a failed read; a command with no exit code never started. That gives the agent a reliable basis for its next step, and gives you fewer confident-looking but wrong fixes.
Manage local and remote Docker hosts over SSH
Use the same Docker MCP tools on the Docker daemon beside you and on a remote server. A remote Docker host is a profile: a stable name, its SSH connection, and the authentication it needs. The agent names that profile in a tool call:
docker_container({ "action": "list", "profile": "production" })
Leave profile out and the default Docker host answers, so local development stays frictionless.
Name a profile the server does not know and the response lists the profiles it does know instead
of quietly sending a request to another machine.
Remote Docker Compose projects are resolved by the labels their containers already carry. Ask for
a project by name wherever it lives on that host — no remote working directory or fixed Compose
path to maintain. For a project that has not run there yet, pass its file explicitly with
compose_path.
Built for the Model Context Protocol
A native Docker MCP server built on the official MCP SDK, with structured tools designed for AI agents rather than terminal automation.
Its behaviour is covered by unit tests and end-to-end tests that run against real Docker containers, not only mocks.
Docker MCP vs Docker CLI: practical examples
The Docker CLI is the right interface when a person is driving the terminal. These examples show what changes when an AI agent needs to inspect a Docker Compose application, understand the result, and choose the next safe step.
Each comparison uses the same real-world task: first the commands and output an agent would have to work through, then the structured Docker MCP result it can use directly.
Diagnose the health of a Docker Compose stack
Situation: A deploy just went out. The site is slow, and you do not know whether a container is down, a healthcheck is failing, or something is eating the memory.
Question: "Is this stack healthy?"
Raw docker CLI
$ docker compose ps
NAME IMAGE STATUS PORTS
shop-api-1 shop-api:latest Up 4 minutes (healthy) 0.0.0.0:8080->8080/tcp
shop-postgres-1 postgres:16 Up 4 minutes (unhealthy) 5432/tcp
shop-worker-1 shop-worker:latest Exited (1) 2 minutes ago
$ docker stats --no-stream
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O
1f2c4d5e6a7b shop-api-1 3.10% 214.8MiB / 7.66GiB 2.74% 12.4MB / 8.9MB 0B / 4.1MB
9a8b7c6d5e4f shop-postgres-1 0.42% 1.204GiB / 7.66GiB 15.7% 3.2MB / 44MB 112MB / 890MB
$ docker inspect --format '{{.State.Health.Status}}' shop-postgres-1
unhealthy
$ docker inspect --format '{{.State.Health.Status}}' shop-worker-1
Template parsing error: executing "" at <.State.Health.Status>: nil pointer evaluating *types.Health.Status
Three commands, three formats, and the last one fails because the worker image declares no healthcheck at all. Nothing is broken — there is simply nothing to read — but the agent now has to tell "no healthcheck" apart from "failing", and a table gives it no help.
Structured MCP result
docker_container({ "action": "list", "project": "shop" })
{
"action": "list",
"project": "shop",
"containers": [
{ "name": "shop-api-1", "service": "api", "project": "shop", "state": "running",
"health": "healthy", "image": "shop-api:latest",
"ports": ["0.0.0.0:8080->8080/tcp"], "created": "2026-08-24T09:14:02Z" },
{ "name": "shop-postgres-1", "service": "postgres", "project": "shop", "state": "running",
"health": "unhealthy", "image": "postgres:16",
"ports": ["5432/tcp"], "created": "2026-08-24T09:14:01Z" },
{ "name": "shop-worker-1", "service": "worker", "project": "shop", "state": "exited",
"health": null, "image": "shop-worker:latest",
"ports": [], "created": "2026-08-24T09:14:01Z" }
],
"reason": null,
"legend": {
"containers[].state=running": "Running now.",
"containers[].state=exited": "Stopped. Its logs survive, its processes do not.",
"containers[].health=healthy": "Its own healthcheck passed last run.",
"containers[].health=unhealthy": "Its own healthcheck failed enough times in a row to give up on it.",
"containers[].health=null": "The image declares no healthcheck, so nothing is measured. Not the same as failing."
}
}
What changes for the agent
| Raw docker CLI | Structured MCP | Your gain |
|---|---|---|
| Three commands and three output formats | One call with state, health and ports per service | Fewer round trips |
| A missing healthcheck errors out or reads as failure | health: null is explained in the answer itself |
No container blamed for a check nobody wrote |
| Container names must be mapped back to services | Every row carries service, project and name |
The agent speaks compose, not container ids |
The legend explains only the words this answer used, right next to the fields that used them —
so the meaning of unhealthy is not sitting hundreds of messages back in a tool description.
Need numbers rather than states? docker_container({ action: "stats", service: "postgres" })
returns CPU, memory against its limit, network and disk as numbers, with the answer saying
plainly that it is one instant reading and not an average.
Need the healthchecks themselves? docker_health({ action: "services" }) reports each
service's own verdict, counts its checks and failures, and calls a service with no healthcheck
none rather than counting it as sick.
Investigate container logs without losing context
Situation: The API started returning 502 about ten minutes ago. The container has been running for a week and has written hundreds of thousands of lines.
Question: "What did it print when it broke?"
Raw docker CLI
$ docker compose logs api --tail 200
api-1 | 2026-08-24T10:31:07.104Z INFO request GET /health 200 3ms
api-1 | 2026-08-24T10:31:07.882Z INFO request GET /health 200 2ms
... 196 more lines of the same ...
api-1 | 2026-08-24T10:39:14.522Z ERROR database connection timed out after 30000ms
$ docker compose logs api --since 10m | grep -i error
api-1 | 2026-08-24T10:39:14.522Z ERROR database connection timed out after 30000ms
The first call spent two hundred lines of context on health-check noise. The second found the error but threw away the lines around it, and nothing in either output says whether the stream was stdout or stderr, or whether anything was dropped on the way.
Structured MCP result
docker_logs({ "service": "api", "project": "shop", "since": "10m", "lines": 50 })
{
"service": "api",
"project": "shop",
"date": "2026-08-24",
"lines": [
{ "stream": "stdout", "time": "10:39:14.518",
"text": "INFO pool exhausted, waiting for a free connection" },
{ "stream": "stderr", "time": "10:39:14.522",
"text": "ERROR database connection timed out after 30000ms" },
{ "stream": "stderr", "time": "10:39:14.530",
"text": "ERROR upstream 502 while proxying GET /api/orders" }
],
"returned_lines": 3,
"since": "10m",
"until": null,
"truncated": false,
"truncated_reason": null,
"clipped_lines": 0,
"follow": false,
"reason": null,
"legend": {
"lines[].stream=stderr": "the stream the container wrote to; many programs write their ordinary progress there, so a line is not an error for being here"
}
}
What changes for the agent
| Raw docker CLI | Structured MCP | Your gain |
|---|---|---|
| A tail is a guess: too few lines miss it, too many bury it | since and until cut the window by time, then lines counts |
Fewer tokens on noise |
| One text blob; stream and timestamp are glued into it | Every line carries its own stream, time and text |
Errors are found by field, not by grep |
| A dropped middle looks exactly like a quiet log | truncated, truncated_reason and clipped_lines name every cut |
No "the logs are clean" from a partial read |
The day the lines fall on is said once, at the top, and each line then carries only its time — the same stamp repeated on every line is text you would be paying for. Lines spread across more than one day keep their full stamps, and the answer says why.
since also takes a date or a UNIX timestamp, and follow: true waits for lines still to come,
returning what arrived within its own time and size ceiling instead of hanging on an open stream.
Query a database running in Docker
Situation: Orders stopped appearing on the dashboard. You want to look in the database — which is a container, with a client inside it and no port published to your machine.
Question: "What does the table actually hold?"
Raw docker CLI
$ docker compose exec -T postgres psql -U app -d shop -c "select status, count(*) from orders group by status"
status | count
-----------+-------
paid | 1284
pending | 17
(2 rows)
$ docker compose exec -T redis redis-cli info keyspace
db0:keys=41822,expires=41822,avg_ttl=3600000
Every engine needs its own client, its own flags and its own way of naming the user and the database. Get one flag wrong and the shell prints an error the agent has to read as text — the call itself "succeeded".
Structured MCP result
docker_db({ "action": "query", "service": "postgres", "project": "shop",
"query": "select status, count(*) from orders group by status" })
{
"action": "query",
"service": "postgres",
"project": "shop",
"engine": "postgresql",
"query": "select status, count(*) from orders group by status",
"output": " status | count\n-----------+-------\n paid | 1284\n pending | 17\n(2 rows)",
"stderr": "",
"exit_code": 0,
"clipped_bytes": 0,
"warnings": [],
"reason": null,
"legend": {}
}
What changes for the agent
| Raw docker CLI | Structured MCP | Your gain |
|---|---|---|
| A different client, flag set and user for every engine | One tool for PostgreSQL, MySQL/MariaDB, Redis, MongoDB and SQLite | One thing to learn, five databases |
| A refused statement still looks like a successful command | exit_code and stderr stay apart from output |
A failure reads as a failure |
| Credentials get retyped into the command line | The container's own user and database are the default | Fewer secrets in the transcript |
status asks the database about itself instead — version, size, uptime, connections — and
format: "csv" lays PostgreSQL rows out for parsing. A statement that would destroy a database
or a whole keyspace does not run until it carries the confirmation marker; see
Destructive command protection for AI agents.
Back up a database before a risky migration
Situation: A migration is about to rewrite a table. You want a dump first — and you want to know the dump is real before the migration touches anything.
Question: "Do I actually have a backup?"
Raw docker CLI
$ docker compose exec -T postgres pg_dump -U app shop | gzip > backup.sql.gz
$ echo $?
0
$ ls -lh backup.sql.gz
-rw-r--r-- 1 you staff 20B 24 Aug 11:02 backup.sql.gz
Exit code zero came from gzip, the last command in the pipe — not from pg_dump. Twenty
bytes is an empty archive: the dump failed on a wrong user, the error went to the terminal, and
the shell reported success. A migration now runs on the strength of a backup that does not exist.
Structured MCP result
docker_db_admin({ "action": "backup", "service": "postgres", "project": "shop" })
{
"action": "backup",
"service": "postgres",
"project": "shop",
"engine": "postgresql",
"file": "/backups/shop-2026-08-24T11-02-17.dump.gz",
"bytes": 48219553,
"verified": true,
"message": null,
"confirmed": false,
"restarted": false,
"reason": null,
"legend": {
"verified": "The file was read back around the call, and bytes is its size on disk. This is the difference between a dump that exists and a command that did not fail."
}
}
What changes for the agent
| Raw docker CLI | Structured MCP | Your gain |
|---|---|---|
| A pipe reports the exit code of its last command | The dump is read back and its size named | An empty backup cannot pass for a good one |
| Each engine needs its own dump command and flags | One call for PostgreSQL, MySQL, MongoDB, SQLite and Redis | Same workflow whatever the stack runs |
| "Done" is a word | verified is a field, and bytes: null says why it is unknown |
The agent knows what it does not know |
When the file cannot be read back, the answer says so instead of claiming a size: verified
stays false, bytes is null, and message names what stopped it — an unknown size is never
reported as an empty file.
Filling the database back is the same tool: action: "restore". It overwrites what is there,
so it is refused until the call carries the confirmation marker in its confirm field — and the
refusal tells you to take a backup here first.
Understand Docker disk usage before cleaning up
Situation: The server is at 90% disk. Docker is the obvious suspect, but you do not know whether it is images, volumes, stopped containers or build cache — and pruning the wrong one destroys a database.
Question: "What is safe to reclaim?"
Raw docker CLI
$ docker system df
TYPE TOTAL ACTIVE SIZE RECLAIMABLE
Images 48 9 31.2GB 22.4GB (71%)
Containers 21 7 1.8GB 412MB (22%)
Local Volumes 19 6 64.9GB 38.1GB (58%)
Build Cache 264 0 9.7GB 9.7GB
$ docker system df -v | head -40
... several screens of per-image, per-container and per-volume tables ...
The summary is readable by a person and expensive for an agent: percentages in parentheses,
sizes as text with mixed units, and the detail view is several screens long. To compare
"reclaimable volumes" against "reclaimable images" the agent has to parse 64.9GB and
38.1GB (58%) back into numbers.
Structured MCP result
docker_resource({ "action": "disk" })
{
"action": "disk",
"count": 4,
"total_bytes": 115534368358,
"disk": [
{ "group": "images", "count": 48, "active": 9,
"size_bytes": 33500985344, "unused_bytes": 24051816448 },
{ "group": "containers", "count": 21, "active": 7,
"size_bytes": 1932735283, "unused_bytes": 431994470 },
{ "group": "volumes", "count": 19, "active": 6,
"size_bytes": 69686362112, "unused_bytes": 40908324864 },
{ "group": "build_cache", "count": 264, "active": 0,
"size_bytes": 10414285619, "unused_bytes": 10414285619 }
],
"reason": null,
"legend": {
"disk[].active": "How many of them something uses right now: a running container, or an image behind one.",
"disk[].unused_bytes": "Size of what nothing uses at the moment. Removing it frees less than this: what is shared stays until its last holder is gone.",
"disk[].group=images": "Images are counted by their layers on disk, so this is what they really take; the sizes of separate images add up to more, because a shared layer belongs to each of them.",
"disk[].group=containers": "Only what a container wrote on top of its image. What the image itself takes is counted with the images."
}
}
Docker MCP questions
How do I add Docker MCP to Claude Code?
Run claude mcp add docker-mcp-server -- npx -y @hypnosis/docker-mcp-server in your terminal. Add --scope user to make it available in every project.
How do I add Docker MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Docker MCP provide?
It exposes 10 tools, including docker_container, docker_logs, docker_compose, docker_health, docker_resource.
Can I manage remote Docker hosts?
Yes, you can manage remote hosts over SSH by creating a profiles file that includes the host, username, and private key path.
Does the server require Docker to be running?
The server will start even if the Docker daemon is down; it will simply inform the agent to start Docker.
What are the system requirements?
You need Node.js 18+ and a reachable Docker daemon, either via a local socket or a remote host over SSH.