ProxmoxMCP-Plus

Enhanced Proxmox MCP server with advanced virtualization management and full OpenAPI integration

14 stars PythonOthers Updated Aug 9, 2026

homelabinfrastructuremcpmodel-context-protocolopenapiproxmoxproxmox-vepythonvirtualization

Documentation

ProxmoxMCP-Plus

An enhanced Python-based Model Context Protocol (MCP) server for interacting with Proxmox virtualization platforms. This project extends canvrno/ProxmoxMCP with additional features including complete OpenAPI integration and expanded virtualization management capabilities.

Acknowledgments

This project is built upon the open-source project ProxmoxMCP by @canvrno.

New Features and Improvements

Major Enhancements

Feature Category	Description	Tools
VM Lifecycle Management	Complete virtual machine creation, management, and deletion	`create_vm`, `delete_vm`
Power Management	Control VM power states	`start_vm`, `stop_vm`, `shutdown_vm`, `reset_vm`
Container Support	Full LXC container lifecycle management	`get_containers`, `create_container`, `delete_container`, `start_container`, `stop_container`, `restart_container`, `update_container_resources`
Snapshot Management	Create and manage VM/container snapshots	`list_snapshots`, `create_snapshot`, `delete_snapshot`, `rollback_snapshot`
Backup and Restore	Backup and restore VMs and containers	`list_backups`, `create_backup`, `restore_backup`, `delete_backup`
ISO and Template Management	Manage installation media and templates	`list_isos`, `list_templates`, `download_iso`, `delete_iso`
Monitoring	Cluster and resource monitoring	`get_nodes`, `get_node_status`, `get_vms`, `get_storage`, `get_cluster_status`
OpenAPI Integration	REST API endpoints for external integration	20+ API endpoints
Security and Stability	Production-grade error handling and validation	Token-based authentication, comprehensive logging

Built With

Proxmoxer - Python wrapper for Proxmox API
MCP SDK - Model Context Protocol SDK
Pydantic - Data validation using Python type annotations

Features

Full integration with Cline and Open WebUI
Built with the official MCP SDK
Secure token-based authentication with Proxmox
Complete VM lifecycle management (create, start, stop, reset, shutdown, delete)
VM console command execution
LXC container management support
Intelligent storage type detection (LVM/file-based)
Configurable logging system
Type-safe implementation with Pydantic
Rich output formatting with customizable themes
OpenAPI REST endpoints for integration
20+ fully functional API endpoints
Complete snapshot management (create, delete, rollback)
Backup and restore capabilities
ISO and template management

Installation

Prerequisites

UV package manager (recommended)
Python 3.9 or higher
Git
Access to a Proxmox server with API token credentials

Before starting, ensure you have:

[ ] Proxmox server hostname or IP
[ ] Proxmox API token (see API Token Setup)
[ ] UV installed (`pip install uv`)

Option 1: Quick Install (Recommended)

1. Clone and set up environment:

bash

# Clone repository
   git clone https://github.com/RekklesNA/ProxmoxMCP-Plus.git
   cd ProxmoxMCP-Plus

   # Create and activate virtual environment
   uv venv
   source .venv/bin/activate  # Linux/macOS
   # OR
   .\.venv\Scripts\Activate.ps1  # Windows

2. Install dependencies:

bash

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

3. Create configuration:

bash

# Create config directory and copy template
   mkdir -p proxmox-config
   cp proxmox-config/config.example.json proxmox-config/config.json

4. Edit `proxmox-config/config.json`:

json

{
       "proxmox": {
           "host": "PROXMOX_HOST",        # Required: Your Proxmox server address
           "port": 8006,                  # Optional: Default is 8006
           "verify_ssl": false,           # Optional: Set false for self-signed certs
           "service": "PVE"               # Optional: Default is PVE
       },
       "auth": {
           "user": "USER@pve",            # Required: Your Proxmox username
           "token_name": "TOKEN_NAME",    # Required: API token ID
           "token_value": "TOKEN_VALUE"   # Required: API token value
       },
       "logging": {
           "level": "INFO",               # Optional: DEBUG for more detail
           "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
           "file": "proxmox_mcp.log"      # Optional: Log to file
       },
       "mcp": {
           "host": "127.0.0.1",           # Optional: Host for SSE/STREAMABLE transports
           "port": 8000,                  # Optional: Port for SSE/STREAMABLE transports
           "transport": "STDIO"           # Optional: STDIO, SSE, or STREAMABLE
       }
   }

Verifying Installation

1. Check Python environment:

bash

python -c "import proxmox_mcp; print('Installation OK')"

2. Run the tests:

bash

pytest

3. Verify configuration:

bash

# Linux/macOS
   PROXMOX_MCP_CONFIG="proxmox-config/config.json" python -m proxmox_mcp.server

   # Windows (PowerShell)
   $env:PROXMOX_MCP_CONFIG="proxmox-config\config.json"; python -m proxmox_mcp.server

Configuration

Proxmox API Token Setup

1. Log into your Proxmox web interface

2. Navigate to Datacenter -> Permissions -> API Tokens

3. Create a new API token:

Running the Server

Development Mode

For testing and development:

bash

# Activate virtual environment first
source .venv/bin/activate  # Linux/macOS
# OR
.\.venv\Scripts\Activate.ps1  # Windows

# Run the server
python -m proxmox_mcp.server

MCP Transport Configuration

The MCP server supports multiple transport modes. Configure these in the `mcp` section of

your `proxmox-config/config.json`:

`STDIO`: Default. Run over stdio for MCP clients like Claude Desktop/Cline.
`SSE`: Serve MCP over Server-Sent Events (SSE).
`STREAMABLE`: Serve MCP over streamable HTTP.

OpenAPI Deployment (Production Ready)

Deploy ProxmoxMCP Plus as standard OpenAPI REST endpoints for integration with Open WebUI and other applications.

Quick OpenAPI Start

bash

# Install mcpo (MCP-to-OpenAPI proxy)
pip install mcpo

# Start OpenAPI service on port 8811
./start_openapi.sh

Docker Deployment

bash

# Build and run with Docker
docker build -t proxmox-mcp-api .
docker run -d --name proxmox-mcp-api -p 8811:8811 \
  -v $(pwd)/proxmox-config:/app/proxmox-config proxmox-mcp-api

# Or use Docker Compose
docker-compose up -d

Access OpenAPI Service

Once deployed, access your service at:

API Documentation: http://your-server:8811/docs
OpenAPI Specification: http://your-server:8811/openapi.json
Health Check: http://your-server:8811/health

Claude Desktop Integration

For Claude Desktop users, add this configuration to your MCP settings file:

Configuration file location:

macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
Windows: `%APPDATA%\Claude\claude_desktop_config.json`
Linux: `~/.config/Claude/claude_desktop_config.json`

Quick Setup:

1. Copy the example configuration:

bash

# macOS
   cp proxmox-config/claude_desktop_config.example.json ~/Library/Application\ Support/Claude/claude_desktop_config.json

   # Linux
   cp proxmox-config/claude_desktop_config.example.json ~/.config/Claude/claude_desktop_config.json

   # Windows (PowerShell)
   Copy-Item proxmox-config\claude_desktop_config.example.json $env:APPDATA\Claude\claude_desktop_config.json

2. Edit the file and replace the following values:

Configuration:

json

{
    "mcpServers": {
        "ProxmoxMCP-Plus": {
            "command": "/absolute/path/to/ProxmoxMCP-Plus/.venv/bin/python",
            "args": ["-m", "proxmox_mcp.server"],
            "env": {
                "PYTHONPATH": "/absolute/path/to/ProxmoxMCP-Plus/src",
                "PROXMOX_MCP_CONFIG": "/absolute/path/to/ProxmoxMCP-Plus/proxmox-config/config.json",
                "PROXMOX_HOST": "your-proxmox-host",
                "PROXMOX_USER": "username@pve",
                "PROXMOX_TOKEN_NAME": "token-name",
                "PROXMOX_TOKEN_VALUE": "token-value",
                "PROXMOX_PORT": "8006",
                "PROXMOX_VERIFY_SSL": "false",
                "PROXMOX_SERVICE": "PVE",
                "LOG_LEVEL": "DEBUG"
            }
        }
    }
}

After configuration:

1. Restart Claude Desktop

2. The ProxmoxMCP-Plus tools will be available in your conversations

3. You can now manage your Proxmox infrastructure through Claude Desktop!

Cline Desktop Integration

For Cline users, add this configuration to your MCP settings file (typically at `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`):

json

{
    "mcpServers": {
        "ProxmoxMCP-Plus": {
            "command": "/absolute/path/to/ProxmoxMCP-Plus/.venv/bin/python",
            "args": ["-m", "proxmox_mcp.server"],
            "cwd": "/absolute/path/to/ProxmoxMCP-Plus",
            "env": {
                "PYTHONPATH": "/absolute/path/to/ProxmoxMCP-Plus/src",
                "PROXMOX_MCP_CONFIG": "/absolute/path/to/ProxmoxMCP-Plus/proxmox-config/config.json",
                "PROXMOX_HOST": "your-proxmox-host",
                "PROXMOX_USER": "username@pve",
                "PROXMOX_TOKEN_NAME": "token-name",
                "PROXMOX_TOKEN_VALUE": "token-value",
                "PROXMOX_PORT": "8006",
                "PROXMOX_VERIFY_SSL": "false",
                "PROXMOX_SERVICE": "PVE",
                "LOG_LEVEL": "DEBUG"
            },
            "disabled": false,
            "autoApprove": []
        }
    }
}

Available Tools & API Endpoints

The server provides comprehensive MCP tools and corresponding REST API endpoints:

VM Management Tools

create_vm

Create a new virtual machine with specified resources.

Parameters:

`node` (string, required): Name of the node
`vmid` (string, required): ID for the new VM
`name` (string, required): Name for the VM
`cpus` (integer, required): Number of CPU cores (1-32)
`memory` (integer, required): Memory in MB (512-131072)
`disk_size` (integer, required): Disk size in GB (5-1000)
`storage` (string, optional): Storage pool name
`ostype` (string, optional): OS type (default: l26)

API Endpoint:

http

POST /create_vm
Content-Type: application/json

{
    "node": "pve",
    "vmid": "200",
    "name": "my-vm",
    "cpus": 1,
    "memory": 2048,
    "disk_size": 10
}

Example Response:

code

VM 200 created successfully.

VM Configuration:
  - Name: my-vm
  - Node: pve
  - VM ID: 200
  - CPU Cores: 1
  - Memory: 2048 MB (2.0 GB)
  - Disk: 10 GB (local-lvm, raw format)
  - Storage Type: lvmthin
  - Network: virtio (bridge=vmbr0)
  - QEMU Agent: Enabled

Task ID: UPID:pve:001AB729:0442E853:682FF380:qmcreate:200:root@pam!mcp

VM Power Management

start_vm: Start a virtual machine

http

POST /start_vm
{"node": "pve", "vmid": "200"}

stop_vm: Force stop a virtual machine

http

POST /stop_vm
{"node": "pve", "vmid": "200"}

shutdown_vm: Gracefully shutdown a virtual machine

http

POST /shutdown_vm
{"node": "pve", "vmid": "200"}

reset_vm: Reset (restart) a virtual machine

http

POST /reset_vm
{"node": "pve", "vmid": "200"}

delete_vm: Completely delete a virtual machine

http

POST /delete_vm
{"node": "pve", "vmid": "200", "force": false}

Snapshot Management Tools

list_snapshots

List all snapshots for a VM or container.

Parameters:

`node` (string, required): Host node name (e.g. 'pve')
`vmid` (string, required): VM or container ID (e.g. '100')
`vm_type` (string, optional): Type - 'qemu' for VMs, 'lxc' for containers (default: 'qemu')

API Endpoint: `POST /list_snapshots`

Example:

http

POST /list_snapshots
{"node": "pve", "vmid": "100", "vm_type": "qemu"}

create_snapshot

Create a snapshot of a VM or container.

Parameters:

`node` (string, required): Host node name
`vmid` (string, required): VM or container ID
`snapname` (string, required): Snapshot name (no spaces, e.g. 'before-update')
`description` (string, optional): Description for the snapshot
`vmstate` (boolean, optional): Include memory state (VMs only, default: false)
`vm_type` (string, optional): Type - 'qemu' or 'lxc' (default: 'qemu')

API Endpoint:

http

POST /create_snapshot
Content-Type: application/json

{
    "node": "pve",
    "vmid": "100",
    "snapname": "pre-upgrade",
    "description": "Before system upgrade",
    "vmstate": true
}

delete_snapshot

Delete a snapshot.

Parameters:

`node` (string, required): Host node name
`vmid` (string, required): VM or container ID
`snapname` (string, required): Snapshot name to delete
`vm_type` (string, optional): Type - 'qemu' or 'lxc' (default: 'qemu')

API Endpoint:

http

POST /delete_snapshot
{"node": "pve", "vmid": "100", "snapname": "old-snapshot"}

rollback_snapshot

Rollback VM/container to a previous snapshot.

WARNING: This will stop the VM/container and restore to the snapshot state!

Parameters:

`node` (string, required): Host node name
`vmid` (string, required): VM or container ID
`snapname` (string, required): Snapshot name to restore
`vm_type` (string, optional): Type - 'qemu' or 'lxc' (default: 'qemu')

API Endpoint:

http

POST /rollback_snapshot
{"node": "pve", "vmid": "100", "snapname": "before-update"}

Container Management Tools

get_containers

List all LXC containers across the cluster.

API Endpoint: `POST /get_containers`

Example Response:

code

Containers

nginx-server (ID: 200)
  - Status: RUNNING
  - Node: pve
  - CPU Cores: 2
  - Memory: 1.5 GB / 2.0 GB (75.0%)

create_container

Create a new LXC container with specified configuration.

Parameters:

`node` (string, required): Host node name (e.g. 'pve')
`vmid` (string, required): Container ID number (e.g. '200')
`ostemplate` (string, required): OS template path (e.g. 'local:vztmpl/alpine-3.19-default_20240207_amd64.tar.xz')
`hostname` (string, optional): Container hostname (defaults to 'ct-{vmid}')
`cores` (integer, optional): Number of CPU cores (default: 1)
`memory` (integer, optional): Memory size in MiB (default: 512)
`swap` (integer, optional): Swap size in MiB (default: 512)
`disk_size` (integer, optional): Root disk size in GB (default: 8)
`storage` (string, optional): Storage pool for rootfs (auto-detects if not specified)
`password` (string, optional): Root password
`ssh_public_keys` (string, optional): SSH public keys for root user
`network_bridge` (string, optional): Network bridge name (default: 'vmbr0')
`start_after_create` (boolean, optional): Start container after creation (default: false)
`unprivileged` (boolean, optional): Create unprivileged container (default: true)

API Endpoint:

http

POST /create_container
Content-Type: application/json

{
    "node": "pve",
    "vmid": "200",
    "ostemplate": "local:vztmpl/alpine-3.19-default_20240207_amd64.tar.xz",
    "hostname": "my-container",
    "cores": 2,
    "memory": 1024,
    "disk_size": 10
}

delete_container

Delete/remove an LXC container completely.

WARNING: This operation permanently deletes the container and all its data!

Parameters:

`selector` (string, required): Container selector - '123' | 'pve1:123' | 'pve1/name' | 'name'
`force` (boolean, optional): Force deletion even if container is running (default: false)

API Endpoint:

http

POST /delete_container
Content-Type: application/json

{
    "selector": "200",
    "force": false
}

Backup and Restore Tools

list_backups

List available backups across the cluster.

Parameters:

`node` (string, optional): Filter by node
`storage` (string, optional): Filter by storage pool
`vmid` (string, optional): Filter by VM/container ID

API Endpoint: `POST /list_backups`

Example:

http

POST /list_backups
{"node": "pve", "storage": "backup-storage"}

create_backup

Create a backup of a VM or container.

Parameters:

`node` (string, required): Node where VM/container runs
`vmid` (string, required): VM or container ID to backup
`storage` (string, required): Target backup storage
`compress` (string, optional): Compression - '0', 'gzip', 'lz4', 'zstd' (default: 'zstd')
`mode` (string, optional): Backup mode - 'snapshot', 'suspend', 'stop' (default: 'snapshot')
`notes` (string, optional): Notes/description for the backup

API Endpoint:

http

POST /create_backup
Content-Type: application/json

{
    "node": "pve",
    "vmid": "100",
    "storage": "backup-storage",
    "compress": "zstd",
    "mode": "snapshot",
    "notes": "Weekly backup"
}

restore_backup

Restore a VM or container from a backup.

Parameters:

`node` (string, required): Target node for restore
`archive` (string, required): Backup volume ID (from list_backups output)
`vmid` (string, required): New VM/container ID for the restored machine
`storage` (string, optional): Target storage for disks (uses original if not specified)
`unique` (boolean, optional): Generate unique MAC addresses (default: true)

API Endpoint:

http

POST /restore_backup
Content-Type: application/json

{
    "node": "pve",
    "archive": "backup:backup/vzdump-qemu-100-2024_01_15.vma.zst",
    "vmid": "200",
    "unique": true
}

delete_backup

Delete a backup file from storage.

WARNING: This permanently deletes the backup!

Parameters:

`node` (string, required): Node name
`storage` (string, required): Storage pool name
`volid` (string, required): Backup volume ID to delete

API Endpoint:

http

POST /delete_backup
{
    "node": "pve",
    "storage": "backup-storage",
    "volid": "backup:backup/vzdump-qemu-100-2024_01_15.vma.zst"
}

ISO and Template Management Tools

list_isos

List available ISO images across the cluster.

Parameters:

`node` (string, optional): Filter by node
`storage` (string, optional): Filter by storage pool

API Endpoint: `POST /list_isos`

Returns: List of ISOs with filename, size, and storage location.

list_templates

List available OS templates for container creation.

Parameters:

`node` (string, optional): Filter by node
`storage` (string, optional): Filter by storage pool

API Endpoint: `POST /list_templates`

Returns: List of templates (vztmpl) with name, size, and storage. Use the returned Volume ID with create_container's ostemplate parameter.

download_iso

Download an ISO image from a URL to Proxmox storage.

Parameters:

`node` (string, required): Target node name
`storage` (string, required): Target storage pool (must support ISO content)
`url` (string, required): URL to download from
`filename` (string, required): Target filename (e.g. 'ubuntu-22.04-live-server-amd64.iso')
`checksum` (string, optional): Checksum for verification
`checksum_algorithm` (string, optional): Algorithm - 'sha256', 'sha512', 'md5' (default: 'sha256')

API Endpoint:

http

POST /download_iso
Content-Type: application/json

{
    "node": "pve",
    "storage": "local",
    "url": "https://releases.ubuntu.com/22.04/ubuntu-22.04-live-server-amd64.iso",
    "filename": "ubuntu-22.04-live-server-amd64.iso",
    "checksum": "a1b2c3..."
}

delete_iso

Delete an ISO or template from storage.

Parameters:

`node` (string, required): Node name
`storage` (string, required): Storage pool name
`filename` (string, required): ISO/template filename to delete

API Endpoint:

http

POST /delete_iso
{
    "node": "pve",
    "storage": "local",
    "filename": "old-distro.iso"
}

Monitoring Tools

get_nodes

Lists all nodes in the Proxmox cluster.

API Endpoint: `POST /get_nodes`

Example Response:

code

Proxmox Nodes

pve-compute-01
  - Status: ONLINE
  - Uptime: 156d 12h
  - CPU Cores: 64
  - Memory: 186.5 GB / 512.0 GB (36.4%)

get_node_status

Get detailed status of a specific node.

Parameters:

`node` (string, required): Name of the node

API Endpoint: `POST /get_node_status`

get_vms

List all VMs across the cluster.

API Endpoint: `POST /get_vms`

get_storage

List available storage pools.

API Endpoint: `POST /get_storage`

get_cluster_status

Get overall cluster status and health.

API Endpoint: `POST /get_cluster_status`

execute_vm_command

Execute a command in a VM's console using QEMU Guest Agent.

Parameters:

`node` (string, required): Name of the node where VM is running
`vmid` (string, required): ID of the VM
`command` (string, required): Command to execute

API Endpoint: `POST /execute_vm_command`

Requirements:

VM must be running
QEMU Guest Agent must be installed and running in the VM

Open WebUI Integration

Configure Open WebUI

1. Access your Open WebUI instance

2. Navigate to Settings → Connections → OpenAPI

3. Add new API configuration:

json

{
  "name": "Proxmox MCP API Plus",
  "base_url": "http://your-server:8811",
  "api_key": "",
  "description": "Enhanced Proxmox Virtualization Management API"
}

Natural Language VM Creation

The system supports natural language VM creation requests through AI assistants. Example requests:

"Can you create a VM with 1 cpu core and 2 GB ram with 10GB of storage disk"
"Create a new VM for testing with minimal resources"
"I need a development server with 4 cores and 8GB RAM"

The AI assistant will automatically call the appropriate APIs and provide detailed feedback.

Storage Type Support

Intelligent Storage Detection

ProxmoxMCP Plus automatically detects storage types and selects appropriate disk formats:

LVM Storage (local-lvm, vm-storage)

Format: `raw`
High performance
Note: No cloud-init image support

File-based Storage (local, NFS, CIFS)

Format: `qcow2`
Cloud-init support
Flexible snapshot capabilities

Project Structure

code

ProxmoxMCP-Plus/
├── src/                          # Source code
│   └── proxmox_mcp/
│       ├── server.py             # Main MCP server implementation
│       ├── config/               # Configuration handling
│       ├── core/                 # Core functionality
│       ├── formatting/           # Output formatting and themes
│       ├── tools/                # Tool implementations
│       │   ├── vm.py             # VM management
│       │   ├── container.py      # Container management
│       │   └── console/          # VM console operations
│       └── utils/                # Utilities (auth, logging)
│
├── tests/                        # Unit test suite
├── test_scripts/                 # Integration tests & demos
│   ├── README.md                 # Test documentation
│   ├── test_vm_power.py          # VM power management tests
│   ├── test_vm_start.py          # VM startup tests
│   ├── test_create_vm.py         # VM creation tests
│   └── test_openapi.py           # OpenAPI service tests
│
├── proxmox-config/               # Configuration files
│   └── config.json               # Server configuration
│
├── Configuration Files
│   ├── pyproject.toml            # Project metadata
│   ├── docker-compose.yml        # Docker orchestration
│   ├── Dockerfile                # Docker image definition
│   └── requirements.in           # Dependencies
│
├── Scripts
│   ├── start_server.sh           # MCP server launcher
│   └── start_openapi.sh          # OpenAPI service launcher
│
└── Documentation
    ├── README.md                 # This file
    ├── VM_CREATION_GUIDE.md      # VM creation guide
    ├── OPENAPI_DEPLOYMENT.md     # OpenAPI deployment
    └── LICENSE                   # MIT License

Testing

Run Unit Tests

bash

pytest

Run Integration Tests

bash

cd test_scripts

# Test VM power management
python test_vm_power.py

# Test VM creation
python test_create_vm.py

# Test OpenAPI service
python test_openapi.py

API Testing with curl

bash

# Test node listing
curl -X POST "http://your-server:8811/get_nodes" \
  -H "Content-Type: application/json" \
  -d "{}"

# Test VM creation
curl -X POST "http://your-server:8811/create_vm" \
  -H "Content-Type: application/json" \
  -d '{
    "node": "pve",
    "vmid": "300",
    "name": "test-vm",
    "cpus": 1,
    "memory": 2048,
    "disk_size": 10
  }'

Production Security

API Key Authentication

Set up secure API access:

bash

export PROXMOX_API_KEY="your-secure-api-key"
export PROXMOX_MCP_CONFIG="/app/proxmox-config/config.json"

Nginx Reverse Proxy

Example nginx configuration:

nginx

server {
    listen 80;
    server_name your-domain.com;
    
    location / {
        proxy_pass http://localhost:8811;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Troubleshooting

Common Issues

1. Port already in use

bash

netstat -tlnp | grep 8811
   # Change port if needed
   mcpo --port 8812 -- ./start_server.sh

2. Configuration errors

bash

# Verify config file
   cat proxmox-config/config.json

3. Connection issues

bash

# Test Proxmox connectivity
   curl -k https://your-proxmox:8006/api2/json/version

View Logs

bash

# View service logs
tail -f proxmox_mcp.log

# Docker logs
docker logs proxmox-mcp-api -f

Deployment Status

Feature Completion Status

[x] VM Creation (user requirement: 1 CPU + 2GB RAM + 10GB storage)
[x] VM Power Management (start VPN-Server ID:101)
[x] VM Deletion Feature
[x] Container Management (LXC)
[x] Container Creation and Deletion
[x] Snapshot Management (create, delete, rollback)
[x] Backup and Restore
[x] ISO and Template Management
[x] Storage Compatibility (LVM/file-based)
[x] OpenAPI Integration (port 8811)
[x] Open WebUI Integration
[x] Error Handling & Validation
[x] Complete Documentation & Testing

Production Readiness

ProxmoxMCP Plus is ready for production deployment. The system supports natural language VM creation requests through AI assistants. When a user requests VM creation (e.g., "create a VM with 1 cpu core and 2 GB ram with 10GB of storage disk"), the system will:

1. Call the `create_vm` API endpoint

2. Automatically select appropriate storage and format

3. Create VMs matching the specified requirements

4. Return detailed configuration information

5. Provide next-step recommendations

Development

After activating your virtual environment:

Run tests: `pytest`
Format code: `black .`
Type checking: `mypy .`
Lint: `ruff .`

License

MIT License

Special Thanks

@canvrno for the foundational project ProxmoxMCP
Thanks to the Proxmox community for providing the powerful virtualization platform
Thanks to all contributors and users for their support

ProxmoxMCP Plus with OpenAPI integration is ready for production deployment.

Frequently asked questions

What is ProxmoxMCP-Plus?

ProxmoxMCP-Plus is Enhanced Proxmox MCP server with advanced virtualization management and full OpenAPI integration

How do I install ProxmoxMCP-Plus?

Open the GitHub repository and follow its README. Most MCP servers are added to your client's MCP config, then called by your agent.

Is ProxmoxMCP-Plus open source?

Yes — it is hosted on GitHub at https://github.com/rodaddy/ProxmoxMCP-Plus and has 14 stars.

Related MCP tools

mcp-context-forge

An AI Gateway, registry, and proxy that sits in front of any MCP, A2A, or REST/gRPC APIs, exposing a unified endpoint with centralized discovery, guardrails and management. Optimizes Agent & Tool calling, and supports plugins.

4,422 Python

agentsaiapi-gateway+17

OpenOSINT

AI-powered OSINT agent with interactive REPL, MCP server, and CLI. 19 tools. Works with Claude, GPT-4, or local models. For authorized security research only.

1,523 Python

ai-agentanthropicclaude+16

cve-mcp-server

Production-grade MCP server giving Claude 27 security intelligence tools across 21 APIs — CVE lookup, EPSS scoring, CISA KEV, MITRE ATT&CK, Shodan, VirusTotal, and more.

1,383 Python

cisa-kevclaude-aicve+15

projectmem

Open-source coding agent memory. Records issues, attempts, fixes and decisions, then warns your agent before it repeats an approach that already failed. Native MCP server for Claude Code, Cursor, Antigravity and Codex. 100% local, no cloud, no telemetry. MIT.

796 Python

ai-agentsai-memoryai-tools+17

fastmcp

🚀 The fast, Pythonic way to build MCP servers and clients Trusted by 19900+ developers. Trusted by 19900+ developers. Trusted by 19900+ developers.

19,927 Python

agentsfastmcpllms+6

mcp-agent

Build effective agents using Model Context Protocol and simple workflow patterns Python-based implementation. Trusted by 7600+ developers.

7,669 Python

agentsaiai-agents+5

Run your own MCP server? See who uses it and what to fix.

Measure it with TrackMCP