{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"docker-mcp-server","slug":"docker-mcp-server","name":"Docker MCP Server","type":"mcp","url":"https://github.com/ckreiling/mcp-server-docker","page_url":"https://unfragile.ai/docker-mcp-server","categories":["mcp-servers"],"tags":["docker","containers","devops","community"],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"docker-mcp-server__cap_0","uri":"capability://tool.use.integration.mcp.protocol.based.docker.tool.invocation.with.pydantic.validation","name":"mcp protocol-based docker tool invocation with pydantic validation","description":"Exposes 20+ discrete Docker operations (container lifecycle, image management, network/volume operations) as MCP tools with standardized request/response handling. Each tool is registered via @app.call_tool() decorator, validates inputs using Pydantic schemas from input_schemas.py, executes operations through the Docker Python SDK (v7.1.0+), and serializes responses using output_schemas.py. Supports both local Unix socket and remote SSH connections via DOCKER_HOST environment variable.","intents":["I want to list, start, stop, and inspect containers from an LLM client without writing Docker CLI commands","I need to pull, build, and manage container images programmatically through natural language","I want to execute commands inside running containers and capture output through an MCP interface","I need to manage Docker networks and volumes as part of infrastructure-as-code workflows"],"best_for":["Developers building LLM agents that need Docker automation capabilities","DevOps teams integrating Docker management into Claude Desktop workflows","AI researchers exploring LLM-driven infrastructure automation"],"limitations":["Requires Python 3.12+ runtime; no support for Python 3.11 or earlier","All Docker operations execute synchronously over stdio; no built-in queuing or async batching for high-throughput scenarios","Remote SSH connections require DOCKER_HOST environment variable configuration; no built-in credential management or SSH key rotation","Tool responses are serialized to JSON; binary outputs (container tarballs, image exports) are not supported"],"requires":["Python 3.12+","Docker daemon (any recent version) accessible via Unix socket or SSH","mcp framework 1.9.0+","docker SDK 7.1.0+","Claude Desktop or other MCP-compatible client"],"input_types":["structured JSON (tool parameters validated against Pydantic schemas)","container/image identifiers (names, IDs, tags)","command strings for container execution"],"output_types":["structured JSON (container/image metadata, operation results)","text (command output from container execution, logs)","boolean (success/failure indicators)"],"categories":["tool-use-integration","devops-automation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_1","uri":"capability://planning.reasoning.plan.apply.workflow.for.safe.container.composition.via.docker.compose.prompt","name":"plan+apply workflow for safe container composition via docker_compose prompt","description":"Implements a two-phase infrastructure change pattern where the LLM first queries current Docker state using tools like list_containers(), generates a human-readable plan describing desired changes, presents the plan to the user for review, and only executes approved operations. This is registered as an MCP prompt (docker_compose) that guides the LLM through state inspection, planning, and conditional execution. The workflow prevents accidental destructive operations by requiring explicit user approval before applying changes.","intents":["I want to describe desired container configurations in natural language and review the execution plan before Docker makes changes","I need a safe way to compose multi-container setups without risking unintended deletions or overwrites","I want the LLM to inspect current state, propose changes, and wait for approval before applying infrastructure changes"],"best_for":["Teams managing production Docker environments who require change approval workflows","Non-technical users who want to compose containers safely without Docker CLI knowledge","Infrastructure teams building LLM-driven deployment pipelines with human-in-the-loop safeguards"],"limitations":["Plan+Apply loop is synchronous; the LLM must wait for user approval before proceeding, adding latency to multi-step workflows","No built-in rollback mechanism if execution fails partway through; failed operations require manual cleanup","User approval is text-based (LLM-generated plan); no structured approval format or audit logging of decisions","Cannot handle complex conditional logic (e.g., 'create network only if it doesn't exist'); requires explicit tool calls for state inspection"],"requires":["MCP client capable of handling multi-turn prompt interactions (Claude Desktop)","Access to list_containers, list_images, and other state-inspection tools","User interaction capability (approval step requires human input)"],"input_types":["natural language description of desired container configuration","user approval/rejection of generated plan"],"output_types":["natural language plan describing proposed changes","execution results (success/failure of applied operations)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_10","uri":"capability://tool.use.integration.python.3.12.runtime.with.stdio.based.mcp.protocol.communication","name":"python 3.12+ runtime with stdio-based mcp protocol communication","description":"The server is a Python 3.12+ application that communicates with MCP clients over stdin/stdout using JSON-RPC protocol. The server runs as a long-lived process that reads MCP requests from stdin, processes them (validating inputs, executing Docker operations, serializing outputs), and writes responses to stdout. This stdio-based communication model enables the server to be launched by MCP clients (e.g., Claude Desktop) without requiring separate network infrastructure — the client spawns the server as a subprocess and pipes requests/responses through standard streams.","intents":["I want to run the MCP server as a subprocess launched by Claude Desktop without network configuration","I need the server to communicate with MCP clients using standard input/output streams","I want to deploy the server in containerized environments where network ports may be restricted"],"best_for":["Claude Desktop users integrating the MCP server locally","Teams deploying MCP servers in containerized or sandboxed environments","Developers building MCP clients that spawn servers as subprocesses"],"limitations":["stdio-based communication is single-threaded — cannot handle concurrent requests from multiple clients","No built-in request/response multiplexing — requests are processed sequentially","Debugging stdio-based communication is difficult — requires capturing stdin/stdout logs","Server crashes or hangs will block the entire client-server connection","No built-in keep-alive or heartbeat — connection may timeout if idle"],"requires":["Python 3.12+","MCP-compatible client that can spawn subprocesses and pipe stdin/stdout"],"input_types":["JSON-RPC requests on stdin"],"output_types":["JSON-RPC responses on stdout"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_11","uri":"capability://tool.use.integration.docker.sdk.integration.for.daemon.api.abstraction","name":"docker sdk integration for daemon api abstraction","description":"The server uses the Docker Python SDK (7.1.0+) to abstract Docker daemon API interactions. Rather than constructing raw HTTP requests to the Docker daemon, the server calls SDK methods like docker.containers.run(), docker.images.pull(), docker.networks.create(), etc. The SDK handles connection pooling, request serialization, response parsing, and error handling. This abstraction layer insulates the MCP server from Docker API versioning and protocol details, allowing it to work with different Docker daemon versions without code changes.","intents":["I want to interact with Docker daemon without constructing raw HTTP requests","I need the server to work with different Docker daemon versions without code changes","I want to leverage Docker SDK's connection pooling and error handling"],"best_for":["Teams building Docker management tools in Python","Projects requiring compatibility with multiple Docker daemon versions","Developers who want to avoid low-level Docker API details"],"limitations":["Docker SDK version must match daemon version — incompatibilities can cause silent failures","SDK abstractions add ~5-10ms overhead per operation compared to raw HTTP","Some advanced Docker features may not be exposed by the SDK — requires fallback to raw API","SDK error messages are sometimes opaque — debugging requires Docker daemon logs"],"requires":["docker SDK 7.1.0+","Docker daemon running and accessible"],"input_types":["Python objects (container configs, image names, etc.)"],"output_types":["Python objects (Container, Image, Network, Volume classes)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_2","uri":"capability://memory.knowledge.real.time.container.log.and.performance.statistics.streaming.via.mcp.resources","name":"real-time container log and performance statistics streaming via mcp resources","description":"Exposes container logs and performance metrics (CPU, memory, network I/O) as MCP resources that stream data in real-time. Implemented via @app.read_resource() handlers that connect to the Docker daemon's log and stats APIs, format output as text or structured data, and push updates to the MCP client. Resources are identified by container ID and can be subscribed to for continuous monitoring without polling.","intents":["I want to tail container logs in real-time through an LLM interface without opening a terminal","I need to monitor container resource usage (CPU, memory) and get alerts when thresholds are exceeded","I want to stream logs from multiple containers simultaneously and correlate events across them"],"best_for":["Developers debugging containerized applications through Claude Desktop","DevOps teams building LLM-driven monitoring dashboards","Infrastructure teams integrating Docker observability into AI-powered incident response workflows"],"limitations":["Streaming is limited by MCP protocol's stdio transport; high-volume log streams may cause buffer overflow or latency","No built-in log filtering, parsing, or aggregation; raw logs are streamed as-is from Docker daemon","Stats API provides point-in-time snapshots; no historical data retention or time-series analysis","Resource subscriptions are stateless; client must re-subscribe after disconnection, losing historical context"],"requires":["Docker daemon with logs and stats APIs enabled (standard in all Docker installations)","MCP client supporting resource streaming (Claude Desktop 1.0+)","Container must be running to stream logs and stats"],"input_types":["container ID or name (to identify which resource to stream)","optional parameters (log tail count, stats update interval)"],"output_types":["text (raw container logs, newline-delimited)","structured JSON (performance metrics: CPU %, memory usage, network I/O)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_3","uri":"capability://tool.use.integration.container.lifecycle.management.run.start.stop.restart.remove.with.configuration.options","name":"container lifecycle management (run, start, stop, restart, remove) with configuration options","description":"Provides granular control over container lifecycle through discrete MCP tools (run_container, start_container, stop_container, restart_container, remove_container). Each operation accepts configuration parameters (image, ports, environment variables, volumes, resource limits) as Pydantic-validated inputs, executes through the Docker Python SDK, and returns container ID or status. Supports both simple operations (stop a running container) and complex configurations (run with custom networks, mounts, and resource constraints).","intents":["I want to start a new container with specific image, ports, and environment variables without writing a Dockerfile","I need to stop, restart, or remove containers as part of deployment or cleanup workflows","I want to run containers with resource limits (CPU, memory) and custom network configurations"],"best_for":["Developers prototyping containerized applications through natural language","DevOps teams automating container deployment workflows via LLM agents","Infrastructure teams building self-healing systems that restart failed containers"],"limitations":["No built-in health checks or readiness probes; containers are considered 'running' immediately after start, even if the application inside is still initializing","Configuration options are passed as flat parameters; complex multi-container orchestration (depends_on, service discovery) requires multiple tool calls","No support for container restart policies or automatic recovery; manual intervention required for persistent failures","Resource limits are set at creation time; cannot be modified on running containers without stop/restart cycle"],"requires":["Docker daemon with container execution capability","Image must be available locally or pullable from a registry","Sufficient system resources (CPU, memory, disk) for requested container configuration"],"input_types":["image name/tag (e.g., 'nginx:latest')","configuration object: ports (dict), environment (dict), volumes (list), resource limits (CPU, memory)","container name or ID (for stop/restart/remove operations)"],"output_types":["container ID (on successful run/start)","status string (on stop/restart/remove)","error message (if operation fails)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_4","uri":"capability://tool.use.integration.image.management.pull.build.list.inspect.remove.with.registry.and.build.context.support","name":"image management (pull, build, list, inspect, remove) with registry and build context support","description":"Exposes Docker image operations as MCP tools: pull_image (fetch from registry), build_image (build from Dockerfile), list_images (enumerate local images), inspect_image (get metadata), remove_image (delete). Each tool validates inputs via Pydantic, executes through Docker SDK, and returns structured metadata (image ID, tags, size, creation date). Build operations accept Dockerfile content or path and build context; pull operations support authentication via registry credentials.","intents":["I want to pull container images from Docker Hub or private registries without using CLI commands","I need to build custom images from Dockerfiles and tag them for deployment","I want to list and inspect local images to understand what's available before running containers"],"best_for":["Developers building and testing containerized applications through LLM interfaces","CI/CD pipelines integrating Docker image building into LLM-driven workflows","Teams managing private registries and needing programmatic image management"],"limitations":["Build operations are synchronous and block the MCP server; large builds can cause timeout or unresponsiveness","No built-in support for multi-stage builds or build caching optimization; Dockerfile must be provided as-is","Registry authentication requires credentials in environment variables; no secure credential management or token refresh","Image size and layer information are retrieved from local metadata; no remote registry inspection without pulling"],"requires":["Docker daemon with image build capability","For pull: network access to registry (Docker Hub, private registry, etc.)","For build: Dockerfile content or path accessible to the server","For private registries: credentials configured via Docker config or environment variables"],"input_types":["image name/tag (for pull, inspect, remove)","Dockerfile content or path (for build)","build context directory (for build operations)","registry credentials (optional, for private registries)"],"output_types":["image ID, tags, size, creation date (for list, inspect)","build output/logs (for build operations)","success/failure status (for pull, remove)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_5","uri":"capability://tool.use.integration.network.and.volume.infrastructure.management.create.list.inspect.remove.connect.disconnect","name":"network and volume infrastructure management (create, list, inspect, remove, connect/disconnect)","description":"Provides MCP tools for Docker network and volume operations: create_network (define custom networks), list_networks/list_volumes (enumerate infrastructure), inspect_network/inspect_volume (get metadata), remove_network/remove_volume (delete), connect_container_to_network (attach running containers). Each operation validates inputs via Pydantic, executes through Docker SDK, and returns structured metadata. Supports network drivers (bridge, overlay, host) and volume drivers (local, named).","intents":["I want to create custom Docker networks so containers can communicate by service name","I need to create persistent volumes for stateful applications without managing host paths","I want to connect running containers to networks or disconnect them for traffic isolation"],"best_for":["Teams building multi-container applications that require service discovery and isolation","DevOps engineers managing persistent data storage for containerized workloads","Infrastructure teams implementing network segmentation and traffic control via LLM agents"],"limitations":["Network operations are limited to single-host networks; no support for multi-host overlay networks in Swarm mode","Volume operations create empty volumes; no built-in data migration or backup/restore functionality","Cannot modify network or volume properties after creation; requires delete and recreate for configuration changes","No built-in network policies or firewall rules; Docker's default bridge networking applies"],"requires":["Docker daemon with network and volume driver support","For overlay networks: Docker Swarm mode enabled (optional, for multi-host scenarios)","Sufficient disk space for volume creation"],"input_types":["network name, driver type (bridge, overlay, host), subnet/gateway (optional)","volume name, driver type (local, named), mount options (optional)","container ID and network name (for connect/disconnect operations)"],"output_types":["network/volume ID, driver, creation date, metadata (for list, inspect, create)","success/failure status (for remove, connect, disconnect)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_6","uri":"capability://tool.use.integration.remote.docker.daemon.management.via.ssh.and.docker.host.environment.variable","name":"remote docker daemon management via ssh and docker_host environment variable","description":"Supports connecting to Docker daemons running on remote machines via SSH by reading the DOCKER_HOST environment variable. The server uses the Docker Python SDK's from_env() method, which automatically parses DOCKER_HOST (e.g., 'ssh://user@host:22/run/docker.sock') and establishes SSH tunnels. This enables managing production Docker engines on remote servers without exposing the daemon socket directly or requiring VPN access.","intents":["I want to manage Docker containers on a production server from my local machine via SSH","I need to deploy containers to a remote Docker daemon without exposing the socket over the network","I want to automate infrastructure changes on remote servers through an LLM agent"],"best_for":["DevOps teams managing production Docker engines on remote servers","Infrastructure teams building LLM-driven deployment pipelines to remote hosts","Solo developers deploying containerized applications to cloud VMs"],"limitations":["SSH connection requires pre-configured SSH keys or password authentication; no built-in credential management or key rotation","DOCKER_HOST must be set as an environment variable; no runtime configuration or connection switching without server restart","SSH tunneling adds latency to all Docker operations; high-frequency operations may experience degraded performance","No connection pooling or multiplexing; each tool call establishes a new SSH connection, increasing overhead"],"requires":["SSH access to remote host with Docker daemon running","SSH key configured (or password authentication enabled) for the target user","DOCKER_HOST environment variable set to SSH URL (e.g., 'ssh://user@host/run/docker.sock')","Docker daemon listening on the remote host"],"input_types":["DOCKER_HOST environment variable (SSH URL format)"],"output_types":["same as local Docker operations (container IDs, logs, stats, etc.)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_7","uri":"capability://tool.use.integration.command.execution.inside.running.containers.with.output.capture.and.streaming","name":"command execution inside running containers with output capture and streaming","description":"Provides an MCP tool (exec_container) that executes arbitrary commands inside running containers and captures stdout/stderr output. Implemented via Docker SDK's exec_run() method, which creates an exec instance, runs the command, and streams output back to the MCP client. Supports both interactive (TTY) and non-interactive execution modes, environment variable injection, and working directory specification.","intents":["I want to run diagnostic commands inside a container (e.g., 'ps aux', 'df -h') without SSH access","I need to execute application-specific commands (database migrations, cache warming) from an LLM agent","I want to capture command output and parse it for monitoring or decision-making"],"best_for":["Developers debugging containerized applications through LLM interfaces","DevOps teams automating operational tasks (migrations, backups) via LLM agents","Infrastructure teams building self-healing systems that execute remediation commands"],"limitations":["Commands execute synchronously; long-running operations block the MCP server and may timeout","No built-in timeout or resource limits; runaway commands can consume container resources indefinitely","Output is captured in memory; large outputs (>1MB) may cause memory issues or truncation","Interactive commands (requiring user input) are not supported; only non-interactive execution is reliable"],"requires":["Container must be running","Command must be available in the container's filesystem and PATH","Container must have a shell (sh, bash) for command execution"],"input_types":["container ID or name","command string (e.g., 'ls -la /app')","optional: environment variables (dict), working directory (string), TTY mode (boolean)"],"output_types":["stdout text (command output)","stderr text (error output)","exit code (integer)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_8","uri":"capability://safety.moderation.pydantic.based.input.validation.and.schema.documentation.for.all.operations","name":"pydantic-based input validation and schema documentation for all operations","description":"All MCP tools use Pydantic models (defined in input_schemas.py) to validate incoming requests before execution. Each tool's parameters are documented as a Pydantic schema that Claude can introspect, providing type hints, required/optional fields, and validation rules. Invalid inputs are rejected with detailed error messages before reaching the Docker SDK, preventing malformed requests from causing daemon errors. Output schemas (output_schemas.py) similarly document response formats.","intents":["I want Claude to understand what parameters each Docker tool accepts and validate inputs before execution","I need clear error messages when I provide invalid parameters (e.g., invalid port numbers, missing required fields)","I want the LLM to introspect tool schemas and compose valid requests without trial-and-error"],"best_for":["LLM developers building agents that call Docker tools and need reliable input validation","Teams requiring strict validation of infrastructure changes before execution","Developers extending the server with custom tools and needing schema documentation"],"limitations":["Pydantic validation adds ~10-50ms overhead per tool call; high-frequency operations may experience latency","Custom validation logic (e.g., 'port must be between 1-65535') must be implemented in Pydantic validators; no declarative validation rules","Schema introspection is limited to Pydantic's JSON schema output; no custom documentation or examples in schemas"],"requires":["Pydantic 2.0+ (specified in pyproject.toml)","MCP client capable of introspecting tool schemas (Claude Desktop)"],"input_types":["JSON objects matching Pydantic schema definitions"],"output_types":["validation errors (if input is invalid)","validated input (if validation passes)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__cap_9","uri":"capability://tool.use.integration.stateless.mcp.server.over.stdio.with.long.lived.process.model","name":"stateless mcp server over stdio with long-lived process model","description":"Implements the MCP server as a long-lived Python process that communicates with clients (Claude Desktop) over stdio using the MCP protocol. The server registers handlers via decorators (@app.list_tools(), @app.call_tool(), @app.get_prompt(), @app.read_resource()) and responds to incoming requests without maintaining session state. Configuration is read from environment variables (DOCKER_HOST, etc.) at startup. The server runs continuously, handling multiple requests from the same client without restart.","intents":["I want a Docker management tool that integrates seamlessly with Claude Desktop without additional infrastructure","I need a server that can handle multiple Docker operations in sequence without losing context","I want to run Docker management locally without exposing APIs or managing credentials in a web service"],"best_for":["Individual developers using Claude Desktop who want local Docker automation","Teams running the server on developer machines or CI/CD runners","Researchers exploring LLM-driven infrastructure automation without complex deployment"],"limitations":["Stateless design means no built-in request queuing or rate limiting; concurrent requests may overwhelm the server","Stdio transport is synchronous; large responses or streaming operations may block the client","No built-in logging or observability; debugging requires stderr inspection or external monitoring","Process must be restarted to pick up configuration changes (DOCKER_HOST, etc.)"],"requires":["Python 3.12+ runtime","MCP framework 1.9.0+","Claude Desktop or other MCP-compatible client","Ability to run long-lived processes (not suitable for serverless/FaaS environments)"],"input_types":["MCP protocol requests over stdio (JSON-RPC format)"],"output_types":["MCP protocol responses over stdio (JSON-RPC format)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"docker-mcp-server__headline","uri":"capability://tool.use.integration.mcp.server.for.docker.management","name":"mcp server for docker management","description":"An MCP server that enables natural language management of Docker containers, images, networks, and volumes, allowing users to interact with their Docker environment through intuitive commands.","intents":["best MCP server for Docker","MCP server for container management","Docker management tool for developers","how to manage Docker containers with natural language","community MCP server for Docker"],"best_for":["developers","server administrators","AI researchers"],"limitations":[],"requires":["Python 3.12+","Docker"],"input_types":["natural language commands"],"output_types":["container management actions","logs","performance statistics"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":75,"verified":false,"data_access_risk":"high","permissions":["Python 3.12+","Docker daemon (any recent version) accessible via Unix socket or SSH","mcp framework 1.9.0+","docker SDK 7.1.0+","Claude Desktop or other MCP-compatible client","MCP client capable of handling multi-turn prompt interactions (Claude Desktop)","Access to list_containers, list_images, and other state-inspection tools","User interaction capability (approval step requires human input)","MCP-compatible client that can spawn subprocesses and pipe stdin/stdout","Docker daemon running and accessible"],"failure_modes":["Requires Python 3.12+ runtime; no support for Python 3.11 or earlier","All Docker operations execute synchronously over stdio; no built-in queuing or async batching for high-throughput scenarios","Remote SSH connections require DOCKER_HOST environment variable configuration; no built-in credential management or SSH key rotation","Tool responses are serialized to JSON; binary outputs (container tarballs, image exports) are not supported","Plan+Apply loop is synchronous; the LLM must wait for user approval before proceeding, adding latency to multi-step workflows","No built-in rollback mechanism if execution fails partway through; failed operations require manual cleanup","User approval is text-based (LLM-generated plan); no structured approval format or audit logging of decisions","Cannot handle complex conditional logic (e.g., 'create network only if it doesn't exist'); requires explicit tool calls for state inspection","stdio-based communication is single-threaded — cannot handle concurrent requests from multiple clients","No built-in request/response multiplexing — requests are processed sequentially","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.52,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:04.691Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=docker-mcp-server","compare_url":"https://unfragile.ai/compare?artifact=docker-mcp-server"}},"signature":"dhKQlWfSTl90RLK/XNUDk53m/DaZoZIcjsoN3babD46XAsRW/vDUXjHEI+zxZP63joTG0ZXw9SYoLhAVX4UVAg==","signedAt":"2026-06-20T18:33:54.683Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/docker-mcp-server","artifact":"https://unfragile.ai/docker-mcp-server","verify":"https://unfragile.ai/api/v1/verify?slug=docker-mcp-server","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}