Webmin MCP Server

An MCP (Model Context Protocol) server that provides Claude with tools to manage Linux systems via Webmin's administration interface.

Features

• Multi-Server Support -- Manage multiple Webmin servers with user-friendly aliases

• System Monitoring -- System info, memory, disk, network, and process status

• Service Management -- Start, stop, restart, enable, and disable services

• User & Group Administration -- Create, modify, and delete system users and groups

• Scheduled Tasks -- View, create, edit, and delete cron jobs

• Package Management -- Package info and available updates

• File Operations -- Read, write, copy, rename, and delete remote files

• Storage -- SMART disk health monitoring and LVM volume management

• Security -- Fail2ban jail status and banned IP management

• Database -- MySQL databases, users, and server status

• Webmin ACL -- Manage Webmin user accounts and module permissions

• Disk Quotas -- Monitor and set disk quota limits for users and groups

• Audit & Backup -- Webmin action logs, SSH config, and configuration backups

• Safety Framework -- Tiered safety system with safe mode to prevent dangerous operations

Related MCP server: Hetzner Cloud MCP Server — Cloud API + SSH management (60 tools)

Quick Start

1. Install (choose one):

   From source:

   git clone https://github.com/gjenkins20/webmin-mcp-server.git
   cd webmin-mcp-server
   pip install -e .

   With Docker:

   docker pull gjenkins20/webmin-mcp-server

2. Configure -- Create a webmin-servers.json (see Configuration):

   {
     "default_server": "my-server",
     "servers": {
       "my-server": {
         "host": "192.168.1.100",
         "port": 10000,
         "username": "admin",
         "password": "your-password",
         "use_https": true,
         "verify_ssl": false,
         "safe_mode": true
       }
     }
   }

3. Add to Claude Desktop (claude_desktop_config.json):

   From source:

   {
     "mcpServers": {
       "webmin": {
         "command": "python",
         "args": ["-m", "src.server"],
         "cwd": "/path/to/webmin-mcp-server",
         "env": {
           "WEBMIN_CONFIG_FILE": "/path/to/webmin-servers.json"
         }
       }
     }
   }

   With Docker:

   {
     "mcpServers": {
       "webmin": {
         "command": "docker",
         "args": [
           "run", "--rm", "-i",
           "-v", "/path/to/webmin-servers.json:/app/webmin-servers.json:ro",
           "gjenkins20/webmin-mcp-server"
         ]
       }
     }
   }

Requirements

• Python 3.11+

• A running Webmin instance (typically on port 10000)

• Webmin credentials with appropriate permissions

Webmin Server Setup

The MCP server uses Webmin's XML-RPC API. Ensure your Webmin server is configured:

1. Provision the service account:

   • Webmin 2.650+ (recommended): Create a dedicated RPC/API-only account in Webmin -> Webmin Users. This account type exists specifically for automation like this MCP server -- it blocks browser/module access entirely and is unaffected by the two-factor caveat below.

   • Older Webmin versions: In Webmin -> Webmin Users -> (your user) -> enable "Can accept RPC calls".

   • Two-factor authentication caveat: Webmin 2.640+ rejects RPC Basic-Auth requests for accounts that have 2FA enabled -- the RPC call fails with a generic 401/403. If you enable 2FA on your Webmin users, use a dedicated RPC/API-only account for this MCP server rather than a 2FA-enrolled one.

2. Install XML::Parser: The Perl XML::Parser module must be installed:

   # Debian/Ubuntu
   sudo apt install libxml-parser-perl
   
   # RHEL/CentOS
   sudo yum install perl-XML-Parser

3. Module Access: Grant the user access to required modules (System Status, Bootup and Shutdown, Users and Groups, Scheduled Cron Jobs, Network Configuration)

4. RPC timeout (optional): For tools that read/write large files, Webmin 2.620+ has a config option to raise the default RPC timeout (Webmin Configuration -> Advanced Options). Increase it if you see timeouts on large file operations.

Configuration

Multi-Server Configuration (Recommended)

Create a webmin-servers.json file to manage multiple Webmin servers. See webmin-servers.example.json for a complete example.

Configuration sources (priority order):

1. WEBMIN_CONFIG_FILE env var -- path to JSON config file

2. WEBMIN_SERVERS_JSON env var -- inline JSON string

3. ./webmin-servers.json -- local file in current directory

4. ~/.config/webmin-mcp/servers.json -- user config directory

5. Legacy WEBMIN_* env vars -- single server (creates "default" alias)

Single Server Configuration (Legacy)

For a single server, set environment variables:

export WEBMIN_HOST="your-webmin-server.com"
export WEBMIN_PORT="10000"
export WEBMIN_USERNAME="admin"
export WEBMIN_PASSWORD="your-password"
export WEBMIN_USE_HTTPS="true"
export WEBMIN_VERIFY_SSL="true"  # Set to false for self-signed certs

Or create a .env file (see .env.example).

Using Multiple Servers

With multi-server configuration, all tools accept an optional server parameter:

"Get system info from pi1"           -> Uses pi1 (default)
"Check disk usage on web-server"     -> Uses web-server
"List services on server: nas"       -> Uses nas

Use list_webmin_servers to see all configured servers and their aliases.

Available Tools

All tools accept an optional server parameter to target a specific Webmin server. See the full API reference for detailed parameters and response formats.

Safety Framework

The server includes a tiered safety system to prevent accidental damage.

Safety Tiers

Safe Mode

Safe mode is enabled by default. When active:

• Dangerous operations are blocked (user creation/deletion, password changes, cron deletion)

• Critical services (ssh, webmin, systemd-*, dbus) cannot be stopped

• File writes/deletes are restricted to /tmp and /var/tmp

• Critical system users and paths are protected

Configure per-server in webmin-servers.json:

{
  "servers": {
    "production": { "safe_mode": true },
    "development": { "safe_mode": false }
  }
}

Or globally via environment: export WEBMIN_SAFE_MODE=false

Docker

Pull from Docker Hub

docker pull gjenkins20/webmin-mcp-server

Build locally

docker build -t webmin-mcp-server .

Run standalone

# With config file
docker run --rm -i \
  -v /path/to/webmin-servers.json:/app/webmin-servers.json:ro \
  gjenkins20/webmin-mcp-server

# With environment variables
docker run --rm -i \
  -e WEBMIN_HOST=192.168.1.100 \
  -e WEBMIN_USERNAME=admin \
  -e WEBMIN_PASSWORD=your-password \
  gjenkins20/webmin-mcp-server

Tagging strategy

Development

# Install with dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Lint and format
ruff check src tests
ruff format src tests

# Type check
mypy src

See CONTRIBUTING.md for guidelines on contributing to the project.

Project Structure

webmin-mcp-server/
├── src/
│   ├── server.py         # MCP server setup
│   ├── webmin_client.py  # Webmin API client
│   ├── config.py         # Configuration management
│   ├── models.py         # Pydantic models
│   └── tools/            # MCP tool implementations
├── tests/                # Test suite
├── docs/
│   ├── api-reference.md  # Full API documentation
│   └── webmin_api_map.md # Webmin API endpoint mapping
├── .github/workflows/    # CI/CD (Docker build & push)
├── Dockerfile
└── webmin-servers.example.json

License

MIT