docker-mcp-server 0.1.0__py3-none-any.whl

docker_mcp/__init__.py

@@ -0,0 +1 @@
+"""Docker MCP Server — Expose Docker operations as MCP tools."""

docker_mcp/client.py

@@ -0,0 +1,13 @@
+"""Docker client singleton."""
+
+import docker
+
+_client: docker.DockerClient | None = None
+
+
+def get_client() -> docker.DockerClient:
+    """Return a shared Docker client instance."""
+    global _client
+    if _client is None:
+        _client = docker.from_env()
+    return _client

docker_mcp/server.py

@@ -0,0 +1,36 @@
+"""Docker MCP Server — main entry point."""
+
+import argparse
+
+from mcp.server.fastmcp import FastMCP
+
+from docker_mcp.tools import register_all_tools
+
+mcp = FastMCP("docker-mcp")
+register_all_tools(mcp)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Docker MCP Server")
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse"],
+        default="stdio",
+        help="Transport mode (default: stdio)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port for SSE transport (default: 8000)",
+    )
+    args = parser.parse_args()
+
+    if args.transport == "sse":
+        mcp.run(transport="sse", port=args.port)
+    else:
+        mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

docker_mcp/tools/__init__.py

@@ -0,0 +1,18 @@
+"""Docker MCP tools."""
+
+from docker_mcp.tools.containers import register as register_containers
+from docker_mcp.tools.images import register as register_images
+from docker_mcp.tools.compose import register as register_compose
+from docker_mcp.tools.volumes import register as register_volumes
+from docker_mcp.tools.networks import register as register_networks
+from docker_mcp.tools.system import register as register_system
+
+
+def register_all_tools(mcp):
+    """Register all tool modules with the MCP server."""
+    register_containers(mcp)
+    register_images(mcp)
+    register_compose(mcp)
+    register_volumes(mcp)
+    register_networks(mcp)
+    register_system(mcp)

docker_mcp/tools/compose.py

@@ -0,0 +1,89 @@
+"""Docker Compose tools (subprocess-based)."""
+
+import subprocess
+
+from docker_mcp.utils import format_error
+
+
+def _run_compose(args: list[str], cwd: str | None = None) -> str:
+    """Run a docker compose command and return output."""
+    cmd = ["docker", "compose"] + args
+    result = subprocess.run(cmd, capture_output=True, text=True, cwd=cwd)
+    output = result.stdout
+    if result.returncode != 0:
+        output += f"\nSTDERR:\n{result.stderr}" if result.stderr else ""
+        return f"Command failed (exit {result.returncode}):\n{output}"
+    return output or "(no output)"
+
+
+def register(mcp):
+    @mcp.tool()
+    def compose_up(project_directory: str, detach: bool = True, build: bool = False) -> str:
+        """Start services from a docker-compose file. project_directory is the folder containing docker-compose.yml."""
+        try:
+            args = ["up"]
+            if detach:
+                args.append("-d")
+            if build:
+                args.append("--build")
+            return _run_compose(args, cwd=project_directory)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def compose_down(project_directory: str, volumes: bool = False) -> str:
+        """Stop and remove compose services."""
+        try:
+            args = ["down"]
+            if volumes:
+                args.append("-v")
+            return _run_compose(args, cwd=project_directory)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def compose_ps(project_directory: str) -> str:
+        """List compose services status."""
+        try:
+            return _run_compose(["ps"], cwd=project_directory)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def compose_logs(project_directory: str, service: str | None = None, tail: int = 100) -> str:
+        """Get logs from compose services. Optionally filter by service name."""
+        try:
+            args = ["logs", "--tail", str(tail)]
+            if service:
+                args.append(service)
+            return _run_compose(args, cwd=project_directory)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def compose_build(
+        project_directory: str,
+        service: str | None = None,
+        no_cache: bool = False,
+    ) -> str:
+        """Build or rebuild compose services. Optionally target a specific service."""
+        try:
+            args = ["build"]
+            if no_cache:
+                args.append("--no-cache")
+            if service:
+                args.append(service)
+            return _run_compose(args, cwd=project_directory)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def compose_restart(project_directory: str, service: str | None = None) -> str:
+        """Restart compose services. Optionally target a specific service."""
+        try:
+            args = ["restart"]
+            if service:
+                args.append(service)
+            return _run_compose(args, cwd=project_directory)
+        except Exception as e:
+            return format_error(e)

docker_mcp/tools/containers.py

@@ -0,0 +1,179 @@
+"""Container management tools."""
+
+from docker_mcp.client import get_client
+from docker_mcp.utils import format_error
+
+
+def register(mcp):
+    @mcp.tool()
+    def list_containers(all: bool = False) -> str:
+        """List Docker containers. Set all=True to include stopped containers."""
+        try:
+            client = get_client()
+            containers = client.containers.list(all=all)
+            if not containers:
+                return "No containers found."
+            lines = []
+            for c in containers:
+                lines.append(
+                    f"ID: {c.short_id} | Name: {c.name} | Image: {c.image.tags[0] if c.image.tags else 'untagged'} | Status: {c.status}"
+                )
+            return "\n".join(lines)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def create_container(image: str, name: str | None = None, command: str | None = None, ports: dict | None = None, environment: dict | None = None) -> str:
+        """Create a new container from an image without starting it."""
+        try:
+            client = get_client()
+            kwargs = {"image": image}
+            if name:
+                kwargs["name"] = name
+            if command:
+                kwargs["command"] = command
+            if ports:
+                kwargs["ports"] = ports
+            if environment:
+                kwargs["environment"] = environment
+            container = client.containers.create(**kwargs)
+            return f"Container created: {container.short_id} ({container.name})"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def start_container(container_id: str) -> str:
+        """Start a stopped container by ID or name."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            container.start()
+            return f"Container {container.short_id} started."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def stop_container(container_id: str, timeout: int = 10) -> str:
+        """Stop a running container by ID or name."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            container.stop(timeout=timeout)
+            return f"Container {container.short_id} stopped."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def restart_container(container_id: str, timeout: int = 10) -> str:
+        """Restart a container by ID or name."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            container.restart(timeout=timeout)
+            return f"Container {container.short_id} restarted."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def remove_container(container_id: str, force: bool = False) -> str:
+        """Remove a container by ID or name. Use force=True to remove a running container."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            container.remove(force=force)
+            return f"Container {container_id} removed."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def get_container_logs(container_id: str, tail: int = 100) -> str:
+        """Get logs from a container. tail controls how many lines to return."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            logs = container.logs(tail=tail).decode("utf-8", errors="replace")
+            return logs or "(no logs)"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def exec_in_container(container_id: str, command: str) -> str:
+        """Execute a command inside a running container."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            exit_code, output = container.exec_run(command)
+            result = output.decode("utf-8", errors="replace")
+            return f"Exit code: {exit_code}\n{result}"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def inspect_container(container_id: str) -> str:
+        """Get detailed information about a container."""
+        try:
+            import json
+            client = get_client()
+            container = client.containers.get(container_id)
+            return json.dumps(container.attrs, indent=2, default=str)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def run_container(
+        image: str,
+        name: str | None = None,
+        command: str | None = None,
+        ports: dict | None = None,
+        environment: dict | None = None,
+        detach: bool = True,
+    ) -> str:
+        """Create and start a container in one step (equivalent to docker run)."""
+        try:
+            client = get_client()
+            kwargs: dict = {"image": image, "detach": detach}
+            if name:
+                kwargs["name"] = name
+            if command:
+                kwargs["command"] = command
+            if ports:
+                kwargs["ports"] = ports
+            if environment:
+                kwargs["environment"] = environment
+            container = client.containers.run(**kwargs)
+            if detach:
+                return f"Container started: {container.short_id} ({container.name})"
+            output = container.decode("utf-8", errors="replace") if isinstance(container, bytes) else str(container)
+            return output
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def container_stats(container_id: str) -> str:
+        """Get CPU and memory usage stats for a running container."""
+        try:
+            client = get_client()
+            container = client.containers.get(container_id)
+            stats = container.stats(stream=False)
+
+            cpu_delta = stats["cpu_stats"]["cpu_usage"]["total_usage"] - \
+                stats["precpu_stats"]["cpu_usage"]["total_usage"]
+            system_delta = stats["cpu_stats"].get("system_cpu_usage", 0) - \
+                stats["precpu_stats"].get("system_cpu_usage", 0)
+            num_cpus = stats["cpu_stats"].get("online_cpus") or \
+                len(stats["cpu_stats"]["cpu_usage"].get("percpu_usage", [1]))
+            cpu_pct = (cpu_delta / system_delta * num_cpus * 100.0) if system_delta > 0 else 0.0
+
+            mem = stats["memory_stats"]
+            mem_usage = mem.get("usage", 0)
+            mem_limit = mem.get("limit", 1)
+            mem_pct = mem_usage / mem_limit * 100.0
+
+            return (
+                f"Container: {container.name} ({container.short_id})\n"
+                f"CPU: {cpu_pct:.2f}%\n"
+                f"Memory: {mem_usage / (1024**2):.1f} MB / "
+                f"{mem_limit / (1024**2):.1f} MB ({mem_pct:.1f}%)"
+            )
+        except Exception as e:
+            return format_error(e)

docker_mcp/tools/images.py

@@ -0,0 +1,84 @@
+"""Image management tools."""
+
+from docker_mcp.client import get_client
+from docker_mcp.utils import format_error
+
+
+def register(mcp):
+    @mcp.tool()
+    def list_images() -> str:
+        """List all Docker images."""
+        try:
+            client = get_client()
+            images = client.images.list()
+            if not images:
+                return "No images found."
+            lines = []
+            for img in images:
+                tags = ", ".join(img.tags) if img.tags else "untagged"
+                size_mb = img.attrs.get("Size", 0) / (1024 * 1024)
+                lines.append(f"ID: {img.short_id} | Tags: {tags} | Size: {size_mb:.1f} MB")
+            return "\n".join(lines)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def pull_image(image: str, tag: str = "latest") -> str:
+        """Pull an image from a registry."""
+        try:
+            client = get_client()
+            img = client.images.pull(image, tag=tag)
+            tags = ", ".join(img.tags) if img.tags else "untagged"
+            return f"Pulled: {tags}"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def build_image(path: str, tag: str | None = None, dockerfile: str = "Dockerfile") -> str:
+        """Build an image from a Dockerfile. path is the build context directory."""
+        try:
+            client = get_client()
+            kwargs = {"path": path, "dockerfile": dockerfile}
+            if tag:
+                kwargs["tag"] = tag
+            image, build_logs = client.images.build(**kwargs)
+            log_output = ""
+            for chunk in build_logs:
+                if "stream" in chunk:
+                    log_output += chunk["stream"]
+            tags = ", ".join(image.tags) if image.tags else image.short_id
+            return f"Built: {tags}\n{log_output}"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def remove_image(image: str, force: bool = False) -> str:
+        """Remove an image by name or ID."""
+        try:
+            client = get_client()
+            client.images.remove(image, force=force)
+            return f"Image {image} removed."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def inspect_image(image: str) -> str:
+        """Get detailed information about an image."""
+        try:
+            import json
+            client = get_client()
+            img = client.images.get(image)
+            return json.dumps(img.attrs, indent=2, default=str)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def tag_image(image: str, repository: str, tag: str = "latest") -> str:
+        """Tag an image with a new name. image is the source image name or ID."""
+        try:
+            client = get_client()
+            img = client.images.get(image)
+            img.tag(repository, tag=tag)
+            return f"Tagged {image} as {repository}:{tag}"
+        except Exception as e:
+            return format_error(e)

docker_mcp/tools/networks.py

@@ -0,0 +1,76 @@
+"""Network management tools."""
+
+from docker_mcp.client import get_client
+from docker_mcp.utils import format_error
+
+
+def register(mcp):
+    @mcp.tool()
+    def list_networks() -> str:
+        """List all Docker networks."""
+        try:
+            client = get_client()
+            networks = client.networks.list()
+            if not networks:
+                return "No networks found."
+            lines = []
+            for n in networks:
+                driver = n.attrs.get("Driver", "unknown")
+                lines.append(f"ID: {n.short_id} | Name: {n.name} | Driver: {driver}")
+            return "\n".join(lines)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def create_network(name: str, driver: str = "bridge") -> str:
+        """Create a new network."""
+        try:
+            client = get_client()
+            network = client.networks.create(name=name, driver=driver)
+            return f"Network created: {network.name} ({network.short_id})"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def remove_network(name: str) -> str:
+        """Remove a network by name or ID."""
+        try:
+            client = get_client()
+            network = client.networks.get(name)
+            network.remove()
+            return f"Network {name} removed."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def inspect_network(name: str) -> str:
+        """Get detailed information about a network."""
+        try:
+            import json
+            client = get_client()
+            network = client.networks.get(name)
+            return json.dumps(network.attrs, indent=2, default=str)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def connect_container_to_network(network_name: str, container_id: str) -> str:
+        """Connect a container to a network."""
+        try:
+            client = get_client()
+            network = client.networks.get(network_name)
+            network.connect(container_id)
+            return f"Container {container_id} connected to network {network_name}."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def disconnect_container_from_network(network_name: str, container_id: str) -> str:
+        """Disconnect a container from a network."""
+        try:
+            client = get_client()
+            network = client.networks.get(network_name)
+            network.disconnect(container_id)
+            return f"Container {container_id} disconnected from network {network_name}."
+        except Exception as e:
+            return format_error(e)

docker_mcp/tools/system.py

@@ -0,0 +1,92 @@
+"""System-level Docker tools (info, prune)."""
+
+from docker_mcp.client import get_client
+from docker_mcp.utils import format_error
+
+
+def register(mcp):
+    @mcp.tool()
+    def system_info() -> str:
+        """Get Docker system information: version, disk usage, and server info."""
+        try:
+            client = get_client()
+            version = client.version()
+            info = client.info()
+            df = client.df()
+
+            images_size = sum(img.get("Size", 0) for img in df.get("Images", []))
+            containers_size = sum(c.get("SizeRw", 0) for c in df.get("Containers", []))
+            volumes_size = sum(
+                v.get("UsageData", {}).get("Size", 0) for v in df.get("Volumes", [])
+            )
+
+            return (
+                f"Docker version: {version.get('Version', 'unknown')}\n"
+                f"API version: {version.get('ApiVersion', 'unknown')}\n"
+                f"OS: {info.get('OperatingSystem', 'unknown')}\n"
+                f"Containers: {info.get('Containers', 0)} "
+                f"(running: {info.get('ContainersRunning', 0)}, "
+                f"stopped: {info.get('ContainersStopped', 0)})\n"
+                f"Images: {info.get('Images', 0)}\n"
+                f"Disk usage — images: {images_size / (1024**2):.1f} MB, "
+                f"containers: {containers_size / (1024**2):.1f} MB, "
+                f"volumes: {volumes_size / (1024**2):.1f} MB"
+            )
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def prune_containers(filters: dict | None = None) -> str:
+        """Remove all stopped containers. Optionally pass filters dict."""
+        try:
+            client = get_client()
+            result = client.containers.prune(filters=filters or {})
+            deleted = result.get("ContainersDeleted") or []
+            space = result.get("SpaceReclaimed", 0)
+            return (
+                f"Removed {len(deleted)} container(s). "
+                f"Space reclaimed: {space / (1024**2):.1f} MB"
+            )
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def prune_images(filters: dict | None = None) -> str:
+        """Remove unused (dangling) images. Optionally pass filters dict."""
+        try:
+            client = get_client()
+            result = client.images.prune(filters=filters or {})
+            deleted = result.get("ImagesDeleted") or []
+            space = result.get("SpaceReclaimed", 0)
+            return (
+                f"Removed {len(deleted)} image layer(s). "
+                f"Space reclaimed: {space / (1024**2):.1f} MB"
+            )
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def prune_volumes(filters: dict | None = None) -> str:
+        """Remove unused volumes. Optionally pass filters dict."""
+        try:
+            client = get_client()
+            result = client.volumes.prune(filters=filters or {})
+            deleted = result.get("VolumesDeleted") or []
+            space = result.get("SpaceReclaimed", 0)
+            return (
+                f"Removed {len(deleted)} volume(s). "
+                f"Space reclaimed: {space / (1024**2):.1f} MB"
+            )
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def prune_networks(filters: dict | None = None) -> str:
+        """Remove unused networks. Optionally pass filters dict."""
+        try:
+            client = get_client()
+            result = client.networks.prune(filters=filters or {})
+            deleted = result.get("NetworksDeleted") or []
+            return f"Removed {len(deleted)} network(s): {', '.join(deleted) or 'none'}"
+        except Exception as e:
+            return format_error(e)

docker_mcp/tools/volumes.py

@@ -0,0 +1,54 @@
+"""Volume management tools."""
+
+from docker_mcp.client import get_client
+from docker_mcp.utils import format_error
+
+
+def register(mcp):
+    @mcp.tool()
+    def list_volumes() -> str:
+        """List all Docker volumes."""
+        try:
+            client = get_client()
+            volumes = client.volumes.list()
+            if not volumes:
+                return "No volumes found."
+            lines = []
+            for v in volumes:
+                driver = v.attrs.get("Driver", "unknown")
+                lines.append(f"Name: {v.name} | Driver: {driver}")
+            return "\n".join(lines)
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def create_volume(name: str, driver: str = "local") -> str:
+        """Create a new volume."""
+        try:
+            client = get_client()
+            volume = client.volumes.create(name=name, driver=driver)
+            return f"Volume created: {volume.name}"
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def remove_volume(name: str, force: bool = False) -> str:
+        """Remove a volume by name."""
+        try:
+            client = get_client()
+            volume = client.volumes.get(name)
+            volume.remove(force=force)
+            return f"Volume {name} removed."
+        except Exception as e:
+            return format_error(e)
+
+    @mcp.tool()
+    def inspect_volume(name: str) -> str:
+        """Get detailed information about a volume."""
+        try:
+            import json
+            client = get_client()
+            volume = client.volumes.get(name)
+            return json.dumps(volume.attrs, indent=2, default=str)
+        except Exception as e:
+            return format_error(e)

docker_mcp/utils.py

@@ -0,0 +1,14 @@
+"""Shared helpers for Docker MCP tools."""
+
+from docker.errors import DockerException, NotFound, APIError
+
+
+def format_error(e: Exception) -> str:
+    """Format a Docker exception into a user-friendly message."""
+    if isinstance(e, NotFound):
+        return f"Not found: {e.explanation}"
+    if isinstance(e, APIError):
+        return f"Docker API error: {e.explanation}"
+    if isinstance(e, DockerException):
+        return f"Docker error: {e}"
+    return f"Error: {e}"

docker_mcp_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: docker-mcp-server
+Version: 0.1.0
+Summary: Docker MCP server exposing Docker operations as MCP tools
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: docker (>=7.0,<8.0)
+Requires-Dist: mcp (>=1.12,<2.0)
+Description-Content-Type: text/markdown
+
+# Docker MCP Server
+
+A Model Context Protocol (MCP) server that exposes Docker operations as tools — manage containers, images, compose services, volumes, and networks directly from Claude.
+
+## Installation
+
+```bash
+pip install docker-mcp
+```
+
+Or with `uvx` (no install needed):
+
+```bash
+uvx docker-mcp
+```
+
+## MCP Configuration
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "docker": {
+      "command": "uvx",
+      "args": ["docker-mcp"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add docker -- uvx docker-mcp
+```
+
+Or add manually to your project's `.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "docker": {
+      "command": "uvx",
+      "args": ["docker-mcp"]
+    }
+  }
+}
+```
+
+### Docker (SSE mode)
+
+Run the server as a container and connect over HTTP:
+
+```bash
+docker run -d \
+  -p 8000:8000 \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  ghcr.io/firasmosbahi/docker-mcp:latest
+```
+
+Then configure your MCP client to connect to `http://localhost:8000/sse`.
+
+## Available Tools
+
+### Containers
+
+| Tool | Description |
+|------|-------------|
+| `list_containers` | List containers (`all=true` includes stopped) |
+| `create_container` | Create a container without starting it |
+| `run_container` | Create and start a container in one step |
+| `start_container` | Start a stopped container |
+| `stop_container` | Stop a running container |
+| `restart_container` | Restart a container |
+| `remove_container` | Remove a container (`force=true` for running) |
+| `get_container_logs` | Get container logs (configurable tail lines) |
+| `exec_in_container` | Execute a command inside a running container |
+| `inspect_container` | Get full container details as JSON |
+| `container_stats` | Get CPU and memory usage for a container |
+
+**Examples:**
+
+```
+List all containers including stopped ones
+→ list_containers(all=true)
+
+Run an nginx container on port 8080
+→ run_container(image="nginx", name="my-nginx", ports={"80/tcp": 8080}, detach=true)
+
+Get the last 50 lines of logs from my-app
+→ get_container_logs(container_id="my-app", tail=50)
+
+Execute a command inside a container
+→ exec_in_container(container_id="my-app", command="env")
+```
+
+### Images
+
+| Tool | Description |
+|------|-------------|
+| `list_images` | List all local images with size |
+| `pull_image` | Pull an image from a registry |
+| `build_image` | Build an image from a Dockerfile |
+| `tag_image` | Tag an image with a new name |
+| `remove_image` | Remove an image |
+| `inspect_image` | Get full image details as JSON |
+
+**Examples:**
+
+```
+Pull the latest Alpine image
+→ pull_image(image="alpine", tag="latest")
+
+Build an image from the current directory
+→ build_image(path="/my/project", tag="my-app:v1")
+
+Tag an image for pushing to a registry
+→ tag_image(image="my-app:v1", repository="myrepo/my-app", tag="v1.0.0")
+```
+
+### Compose
+
+| Tool | Description |
+|------|-------------|
+| `compose_up` | Start services (detached by default) |
+| `compose_down` | Stop and remove services |
+| `compose_build` | Build or rebuild services |
+| `compose_restart` | Restart services |
+| `compose_ps` | List service status |
+| `compose_logs` | Get service logs |
+
+**Examples:**
+
+```
+Start all services in a project
+→ compose_up(project_directory="/my/project")
+
+Rebuild a specific service without cache
+→ compose_build(project_directory="/my/project", service="api", no_cache=true)
+
+Get logs for the web service
+→ compose_logs(project_directory="/my/project", service="web", tail=100)
+```
+
+### Volumes
+
+| Tool | Description |
+|------|-------------|
+| `list_volumes` | List all volumes |
+| `create_volume` | Create a named volume |
+| `remove_volume` | Remove a volume |
+| `inspect_volume` | Get volume details |
+
+### Networks
+
+| Tool | Description |
+|------|-------------|
+| `list_networks` | List all networks |
+| `create_network` | Create a network |
+| `remove_network` | Remove a network |
+| `inspect_network` | Get network details |
+| `connect_container_to_network` | Connect a container to a network |
+| `disconnect_container_from_network` | Disconnect a container from a network |
+
+### System
+
+| Tool | Description |
+|------|-------------|
+| `system_info` | Docker version, OS, container/image counts, disk usage |
+| `prune_containers` | Remove all stopped containers |
+| `prune_images` | Remove unused (dangling) images |
+| `prune_volumes` | Remove unused volumes |
+| `prune_networks` | Remove unused networks |
+
+**Examples:**
+
+```
+Check Docker system status and disk usage
+→ system_info()
+
+Free up space by removing unused resources
+→ prune_containers()
+→ prune_images()
+→ prune_volumes()
+```
+
+## Transport Modes
+
+```bash
+# stdio (default) — for MCP clients that manage the process
+docker-mcp
+
+# SSE — for HTTP-based MCP clients
+docker-mcp --transport sse --port 8000
+```
+
+## Requirements
+
+- Python 3.11+
+- Docker daemon running and accessible (Docker Desktop or Docker Engine)
+
+## Development
+
+```bash
+git clone https://github.com/firasmosbahi/docker-mcp
+cd docker-mcp
+poetry install
+poetry run pytest
+```
+

docker_mcp_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+docker_mcp/__init__.py,sha256=UC9qWtcWABjjeYSMrlqbsUcpuInIpMBPptSBmC3waEw,67
+docker_mcp/client.py,sha256=ZmdVAUm6LGqPaWpowXeeaAraCRRcsFWdhsjJ5cNPUkQ,281
+docker_mcp/server.py,sha256=Zrl4mpjnWMXP0M_BshRFUzTTrhD3U_N3ZUP2_p-Tl_8,792
+docker_mcp/tools/__init__.py,sha256=eLzcpDQbBYHZstkk2QY2MKIfdDOCbQVesX2OMBqHxuk,671
+docker_mcp/tools/compose.py,sha256=Yu9nrvJqjx-znRfpOQzCdzmmdmb3BjJZHSqHq620r14,3135
+docker_mcp/tools/containers.py,sha256=NV_iPnsQftRZUVQlQiPzNbpQCUaJ4fh-6EkllHPP-es,7078
+docker_mcp/tools/images.py,sha256=gQFSusM-ZO766VaIzQIuKdbHrq1ptXLuMZHL2sK6SbM,3047
+docker_mcp/tools/networks.py,sha256=2EeXx8xSPac7aJYt5vuvSorBp6ostaH1QhTsS2fCxGY,2683
+docker_mcp/tools/system.py,sha256=M-AMTd9CQHD58b_vHVGTZDjIq5u-UhdCeNKKEnyHZpw,3747
+docker_mcp/tools/volumes.py,sha256=J7rHMHJ88xRO75_-JmTefU0KNqWZL2oA7lP4MxVy3KE,1739
+docker_mcp/utils.py,sha256=_7lCCkP02lV5jNhGQhP_h0RwOrA4PWIw2niuDk30bSw,474
+docker_mcp_server-0.1.0.dist-info/METADATA,sha256=ObmnB8aH7rQjxuRD7ikN6WbvO6b1tRLH7nm2TCm_LuY,5695
+docker_mcp_server-0.1.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+docker_mcp_server-0.1.0.dist-info/entry_points.txt,sha256=PPn1r_ZVhzThkGy3OGBdwL2sWf7Y7DyNZ2bg99yK7SE,53
+docker_mcp_server-0.1.0.dist-info/RECORD,,

docker_mcp_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.1
+Root-Is-Purelib: true
+Tag: py3-none-any

docker_mcp_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+docker-mcp=docker_mcp.server:main
+