A
licenseA
qualityB
maintenanceMCP server for managing Proxmox VE clusters — provision VMs and containers, manage snapshots and
backups, execute commands, browse storage, and monitor resources through natural language
34
14
MIT
Proxmox MCP Server
by NightSquawk
Provides tools to manage Proxmox VE and Proxmox Datacenter Manager, enabling operations on nodes, VMs, containers, storage, and more via their API.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Proxmox MCP Serverlist all VMs on node pve1"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Proxmox MCP Server
An MCP (Model Context Protocol) server for Proxmox VE and Proxmox Datacenter Manager, connecting your virtualization infrastructure to AI tools.
Quick start
Claude
bash (macOS/Linux):
PVE_HOST="pve.example.com"
PVE_TOKEN_ID='root@pam!mcp'
PVE_TOKEN_SECRET="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
PVE_TLS_REJECT_UNAUTHORIZED="false"
claude mcp add proxmox \
--env PVE_HOST="$PVE_HOST" \
--env PVE_TOKEN_ID="$PVE_TOKEN_ID" \
--env PVE_TOKEN_SECRET="$PVE_TOKEN_SECRET" \
--env PVE_TLS_REJECT_UNAUTHORIZED="$PVE_TLS_REJECT_UNAUTHORIZED" \
-- npx -y @nightsquawktech/proxmox-mcp-serverPowerShell (Windows):
$PVE_HOST = "pve.example.com"
$PVE_TOKEN_ID = "root@pam!mcp"
$PVE_TOKEN_SECRET = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
$PVE_TLS_REJECT_UNAUTHORIZED = "false"
claude mcp add proxmox `
--env "PVE_HOST=$PVE_HOST" `
--env "PVE_TOKEN_ID=$PVE_TOKEN_ID" `
--env "PVE_TOKEN_SECRET=$PVE_TOKEN_SECRET" `
--env "PVE_TLS_REJECT_UNAUTHORIZED=$PVE_TLS_REJECT_UNAUTHORIZED" `
-- npx -y @nightsquawktech/proxmox-mcp-serverThese examples configure the PVE surface. To also connect a Proxmox Datacenter Manager instance, add the PDM_* equivalents (full variable list in mcp.json).
Cursor
Or put the mcp.json block in .cursor/mcp.json, then verify with:
agent mcp list(The Cursor CLI manages configured servers but has no mcp add; install is via the button or mcp.json.)
VS Code
bash (macOS/Linux):
PVE_HOST="pve.example.com"
PVE_TOKEN_ID='root@pam!mcp'
PVE_TOKEN_SECRET="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
PVE_TLS_REJECT_UNAUTHORIZED="false"
code --add-mcp '{"name":"proxmox","command":"npx","args":["-y","@nightsquawktech/proxmox-mcp-server"],"env":{"PVE_HOST":"'"$PVE_HOST"'","PVE_TOKEN_ID":"'"$PVE_TOKEN_ID"'","PVE_TOKEN_SECRET":"'"$PVE_TOKEN_SECRET"'","PVE_TLS_REJECT_UNAUTHORIZED":"'"$PVE_TLS_REJECT_UNAUTHORIZED"'"}}'PowerShell (Windows):
$PVE_HOST = "pve.example.com"
$PVE_TOKEN_ID = "root@pam!mcp"
$PVE_TOKEN_SECRET = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
$PVE_TLS_REJECT_UNAUTHORIZED = "false"
$config = @{
name = "proxmox"
command = "npx"
args = @("-y", "@nightsquawktech/proxmox-mcp-server")
env = @{
PVE_HOST = $PVE_HOST
PVE_TOKEN_ID = $PVE_TOKEN_ID
PVE_TOKEN_SECRET = $PVE_TOKEN_SECRET
PVE_TLS_REJECT_UNAUTHORIZED = $PVE_TLS_REJECT_UNAUTHORIZED
}
} | ConvertTo-Json -Compress
code --add-mcp $configCodex
bash (macOS/Linux):
PVE_HOST="pve.example.com"
PVE_TOKEN_ID='root@pam!mcp'
PVE_TOKEN_SECRET="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
PVE_TLS_REJECT_UNAUTHORIZED="false"
codex mcp add proxmox \
--env PVE_HOST="$PVE_HOST" \
--env PVE_TOKEN_ID="$PVE_TOKEN_ID" \
--env PVE_TOKEN_SECRET="$PVE_TOKEN_SECRET" \
--env PVE_TLS_REJECT_UNAUTHORIZED="$PVE_TLS_REJECT_UNAUTHORIZED" \
-- npx -y @nightsquawktech/proxmox-mcp-serverPowerShell (Windows):
$PVE_HOST = "pve.example.com"
$PVE_TOKEN_ID = "root@pam!mcp"
$PVE_TOKEN_SECRET = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
$PVE_TLS_REJECT_UNAUTHORIZED = "false"
codex mcp add proxmox `
--env "PVE_HOST=$PVE_HOST" `
--env "PVE_TOKEN_ID=$PVE_TOKEN_ID" `
--env "PVE_TOKEN_SECRET=$PVE_TOKEN_SECRET" `
--env "PVE_TLS_REJECT_UNAUTHORIZED=$PVE_TLS_REJECT_UNAUTHORIZED" `
-- npx -y @nightsquawktech/proxmox-mcp-serverOr add it to ~/.codex/config.toml under [mcp_servers.proxmox].
mcp.json
Every environment variable the server reads, with recommended values. Both surfaces are optional: configure PVE, PDM, or both. Tools for an unconfigured surface error only at call time; the catalog still lists and describes every endpoint regardless.
{
"mcpServers": {
"proxmox": {
"command": "npx",
"args": ["-y", "@nightsquawktech/proxmox-mcp-server"],
"env": {
"PVE_HOST": "pve.example.com",
"PVE_BASE_URL": "https://pve.example.com:8006/api2/json",
"PVE_TOKEN_ID": "root@pam!mcp",
"PVE_TOKEN_SECRET": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"PVE_AUTH_SCHEME": "PVEAPIToken",
"PVE_AUTH_SEP": "=",
"PVE_TLS_REJECT_UNAUTHORIZED": "false",
"PVE_ALLOW_WRITES": "false",
"PDM_HOST": "pdm.example.com",
"PDM_BASE_URL": "https://pdm.example.com:8443/api2/json",
"PDM_TOKEN_ID": "root@pam!mcp",
"PDM_TOKEN_SECRET": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"PDM_AUTH_SCHEME": "PDMAPIToken",
"PDM_AUTH_SEP": "=",
"PDM_TLS_REJECT_UNAUTHORIZED": "false",
"PDM_ALLOW_WRITES": "false",
"PROXMOX_ALLOW_WRITES": "false"
}
}
}
}File locations: .mcp.json in your project root (Claude Code), claude_desktop_config.json (Claude Desktop), .cursor/mcp.json (Cursor).
Related MCP server: proxmox-mcp
Configuration
Variable | Required | Default | Purpose |
| for PVE | Proxmox VE hostname; expands to | |
| no | derived from | Full PVE API base URL; overrides |
| for PVE | PVE API token id, e.g. | |
| for PVE | PVE API token secret (UUID shown once at token creation) | |
| no |
| Auth header scheme override |
| no |
| Separator between token id and secret in the auth header |
| no |
| Set |
| no |
| Enables write operations (POST/PUT/DELETE) on the PVE surface |
| for PDM | Proxmox Datacenter Manager hostname; expands to | |
| no | derived from | Full PDM API base URL; overrides |
| for PDM | PDM API token id | |
| for PDM | PDM API token secret | |
| no |
| Auth header scheme override (PDM is newer; adjust if auth fails) |
| no |
| Separator between token id and secret in the auth header |
| no |
| Set |
| no |
| Enables write operations on the PDM surface |
| no |
| Enables write operations on all surfaces |
Each surface needs its host plus token id and secret; everything else has a working default. The auth header is assembled as <scheme>=<token_id><sep><secret>, e.g. PVEAPIToken=root@pam!mcp=SECRET.
Security & write safety
Proxmox credentials: create a dedicated API token (Datacenter > Permissions > API Tokens) and grant it the least privilege you can. For hard read-only, assign the token the built-in PVEAuditor role.
All write operations (POST/PUT/DELETE) are disabled by default. Set
PROXMOX_ALLOW_WRITES=true(all surfaces) orPVE_ALLOW_WRITES=true/PDM_ALLOW_WRITES=true(per surface) to enable them.Endpoints flagged destructive (delete, stop, reset, reboot, suspend, rollback, destroy, wipe, migrate) additionally require
confirm: trueon the individualcall_endpointcall, even when writes are enabled.Every call validates the operation id and required path parameters against the catalog before any request leaves your machine; requests go directly to your Proxmox host, nothing passes through third parties.
IMPORTANT
The write gate is a guardrail, not a security boundary. The env vars in your MCP config are real credentials, and an AI agent with shell access can bypass the MCP tools and call the Proxmox API directly with them. If you need hard read-only, enforce it at the source: scope the API token itself to read-only permissions (PVEAuditor role).
Tools
Instead of one tool per endpoint, the server exposes each surface through a catalog-backed list/describe/call triple built on mcp-core: list_endpoints discovers operations by category, resource, method, or search term; describe_endpoint returns the full parameter and response spec for one operation; call_endpoint validates the call against the catalog, enforces the write gate, and executes it. Six tools index all 993 endpoints.
pve_list_endpoints Discover Proxmox VE endpoints by category, resource, method, or search
pve_describe_endpoint Full param + response spec for one PVE endpoint
pve_call_endpoint Validate, write-gate, and execute a PVE API call
pdm_list_endpoints Discover Proxmox Datacenter Manager endpoints
pdm_describe_endpoint Full param + response spec for one PDM endpoint
pdm_call_endpoint Validate, write-gate, and execute a PDM API callAPI coverage
993 operations covered: 675 Proxmox VE (PVE) + 318 Proxmox Datacenter Manager (PDM).
Surface | Category | Operations |
PVE | Access & Auth | 45 |
PVE | Cluster | 259 |
PVE | Nodes & Guests | 358 |
PVE | Pools | 7 |
PVE | Storage | 5 |
PVE | System | 1 |
PDM | Access & Auth | 28 |
PDM | Auto Install | 14 |
PDM | Ceph | 12 |
PDM | Configuration | 43 |
PDM | Nodes & Guests | 50 |
PDM | PBS Remotes | 27 |
PDM | PVE Remotes | 93 |
PDM | Ping | 1 |
PDM | Remotes | 19 |
PDM | Resources | 6 |
PDM | Root | 1 |
PDM | SDN | 6 |
PDM | Subscriptions | 17 |
PDM | System | 1 |
Proxmox VE (675 operations)
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
PUT |
|
|
POST |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
DELETE |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
PUT |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
Method | Path | Operation ID |
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
Method | Path | Operation ID |
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
Method | Path | Operation ID |
GET |
|
|
Proxmox Datacenter Manager (318 operations)
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
Method | Path | Operation ID |
GET |
|
|
POST |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
PUT |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
POST |
|
|
PUT |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
PUT |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
PUT |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
DELETE |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
Method | Path | Operation ID |
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
PUT |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
Method | Path | Operation ID |
GET |
|
|
GET |
|
|
GET |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
Method | Path | Operation ID |
GET |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
DELETE |
|
|
GET |
|
|
DELETE |
|
|
POST |
|
|
GET |
|
|
POST |
|
|
POST |
|
|
Method | Path | Operation ID |
GET |
|
|
The catalog is generated deterministically from Proxmox's published API schema (apidoc.js): refresh it with npm run regen after downloading a new schema into _source/, then rebuild this section with node scripts/generate-api-coverage.mjs.
Contributing
Contributions and issues are welcome. Please open an issue first before submitting a PR.
License
AGPL-3.0: free for personal and open-source use. Organizations that cannot comply with the AGPL can purchase a commercial license, and hosted/managed versions are available. See COMMERCIAL.md or contact hello@nightsquawk.tech.
Copyright
For copyright concerns or takedown requests, contact hello@nightsquawk.tech.
Available Tools
6 toolspdm_call_endpointA
Call a Proxmox Datacenter Manager API endpoint and return its JSON response. Validates the operationId and required path params against the catalog, enforces the read-only write gate, then executes. Reads (GET) always run; writes (POST/PUT/DELETE) run only when enabled via PROXMOX_ALLOW_WRITES=true (all surfaces) or PDM_ALLOW_WRITES=true (this surface only). Use pdm_describe_endpoint first to learn the exact params.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
A4.2/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral burden. It discloses the key traits well: read-only gate behavior, write enablement mechanism (with both env var surfaces), the confirmation requirement for destructive ops mentioned in schema, and the explicit validation steps. However, it does not describe the return format shape, error behavior on validation failure, or network/API error handling. The 'Valdestructive confirm required' caveat lives in the schema parameter description rather than being reinforced here.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact (three sentences) and front-loaded with the core purpose in the first sentence. It packs validation behavior, write-gate mechanics, both env var surfaces, and a usage pointer into efficient supporting sentences without padding or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a wrapper tool that delegates to a describe_endpoint companion, the description is fairly complete: it covers when reads/writes run, how writes are enabled, validation steps, and points to describe_endpoint for param details. With no output schema, it doesn't detail the mock JSON response shape, and given the complexity (nested params/path_params/confirm), slightly more coverage of response/error semantics would round it out.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry semantics for the parameters. It explains operation_id as 'The endpoint operationId to call' with an example ('get_nodes') and directs to describe_endpoint for details. It also clarifies params maps to query params for GET/DELETE vs JSON body for POST/PUT, and path_params for {placeholder} values. This adds meaningful meaning beyond the bare schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: 'Call a Proxmox Datacenter Manager API endpoint and return its JSON response.' It uses a specific verb (call) + resource (PDM API endpoint), and distinguishes it from the sibling pve_call_endpoint by naming the Proxmox Datacenter Manager (PDM) specifically. The validation and write-gate enforcement steps add useful process detail.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when this tool runs: 'Reads (GET) always run; writes (POST/PUT/DELETE) run only when enabled via PROXMOX_ALLOW_WRITES=true or PDM_ALLOW_WRITES=true.' It also instructs to 'Use pdm_describe_endpoint first to learn the exact params,' naming a specific sibling alternative. It lacks explicit 'when not to use' guidance relative to pve_call_endpoint, but the PDM vs PVE distinction is evident from the naming and the write-enabling alternatives are clearly enumerated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pdm_describe_endpointA
Get the full spec for one Proxmox Datacenter Manager endpoint: method, path, path params, query/body params (with types, formats, enums, constraints), the response schema, required permissions, and a request sample. Call before pdm_call_endpoint so you send exactly the right params.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
A4.3/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral disclosure burden. It does describe what the tool returns (full endpoint spec, request sample) which adds value, but it doesn't disclose side effects (none expected for a describe operation), latency, or failure modes. There's no contradiction with annotations, and the description adds useful context about the return value, but doesn't go deeper into behavioral characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, information-dense sentence that lists all return components compactly then gives the usage directive. No wasted words, but it's somewhat long and could benefit from slight structural front-loading of the purpose. Still, it earns its length given the tool's role in preparing for PDMS calls.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, no output schema but returns rich endpoint spec data), the description adequately explains the return contents and usage. It doesn't fully compensate for the absence of an output schema, but the enumeration of returned components (types, formats, enums, constraints, permissions, sample) gives a strong picture. Sibling tools exist for listing endpoints and calling them, which is referenced. A return format description isn't strictly needed here since the description tells you what's in the spec.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden for explaining the single parameter. The description mentions operationId usage and its format ('get_nodes' or 'post_nodes_node_qemu'), and references 'list_endpoints' as the source for valid values. It also explains what the operationId represents. With only one parameter and the description covering its semantics well, this is solid.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource structure: 'Get the full spec for one Proxmox Datacenter Manager endpoint' with detailed enumeration of what the spec includes (method, path, path params, query/body params with types/formats/enums, response schema, permissions, request sample). It clearly distinguishes from siblings by naming pdm_call_endpoint as the after-step and referencing pdm_list_endpoints behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use it: 'Call before pdm_call_endpoint so you send exactly the right params.' This provides clear usage context and pairs it with the follow-up action. It doesn't explicitly state when-not-to-use, but the 'call before pdm_call_endpoint' instruction effectively guides correct sequencing among the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pdm_list_endpointsA
List Proxmox Datacenter Manager API endpoints (operationId, method, path, category, description, read/write, destructive). Filter by category, resource, method, reads/writes, or search. Use this to discover an endpoint, then pdm_describe_endpoint for its parameters and pdm_call_endpoint to execute it.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
A4.6/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the disclosure burden. It does list what fields are returned and notes filtering behaviors, plus the limit default of 200 and advice to narrow for big surfaces. However, it doesn't describe pagination behavior, error cases, or whether the output might be truncated. Still, the core behavior (read-only discovery listing) is clearly implied by naming it a discovery tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with zero filler. Front-loads the primary purpose, enumerates returned fields and filter dimensions compactly, and closes with a terse usage chain. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a discovery/listing tool with useful guidance on filters and chaining to describe/call. No output schema exists, but the returned field set is enumerated in the description, partially compensating. Slight gap: it doesn't cover edge behaviors like empty results or combined filter semantics, but for a list tool scaffolded by sibling describe/call tools, it's substantially complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It names each filter dimension (category, resource, method, reads/writes, search) corresponding to the params, adding functional context like case-insensitive substring search and resource-as-first-path-segment. This adds meaningful value beyond the bare schema, though the description doesn't enumerate params verbatim.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('List') plus resource ('Proxmox Datacenter Manager API endpoints') and details what's returned (operationId, method, path, category, description, read/write, destructive). It distinguishes from sibling tools by explicitly referring to pdm_describe_endpoint and pdm_call_endpoint as downstream steps, clearly separating it from pve_* counterparts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance: 'Use this to discover an endpoint, then pdm_describe_endpoint for its parameters and pdm_call_endpoint to execute it.' This chains the tool within a workflow and names alternatives. The filter options (category, resource, method, reads/writes, search) signal when narrowing is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pve_call_endpointA
Call a Proxmox VE API endpoint and return its JSON response. Validates the operationId and required path params against the catalog, enforces the read-only write gate, then executes. Reads (GET) always run; writes (POST/PUT/DELETE) run only when enabled via PROXMOX_ALLOW_WRITES=true (all surfaces) or PVE_ALLOW_WRITES=true (this surface only). Use pve_describe_endpoint first to learn the exact params.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
A4.2/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does a strong job: explains validation of operationId and path params, the read-only write gate, the two env-var mechanisms for enabling writes, and the confirm requirement for destructive operations. This is rich behavioral context for a generic dispatching tool. It could mention what the response looks like or error behavior, but the write-gate and destructive confirm disclosure are substantial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a compact paragraph of ~60 words covering purpose, gating rules, and usage guidance. It's dense but not bloated; every clause earns its place. It could be structured slightly better with separators, but it front-loads the core purpose and adds crucial behavioral details efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a generic API-dispatch tool with 1 required parameter, nested object params, and no output schema, the description is substantially complete. It covers the validating behavior, write-gating across two env surfaces, destructive confirm flow, and directs to the describe tool for param specifics. The main gap is that it doesn't describe the shape of the JSON response or error-handling behavior, but for a low-param generic dispatcher paired with a describe tool, this is a strong, complete description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% in the structured fields provided, but the actual input schema itself has descriptive text for each parameter (operation_id, path_params, confirm, params). The description adds directional value by telling the agent to use describe_endpoint for exact params. For this tool the schema already annotates parameters reasonably; the description complements rather than repeats. Given nested object params for path_params and body fields, the pointer to describe_endpoint is genuinely helpful and raises this above baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: 'Call a Proxmox VE API endpoint and return its JSON response.' It names the specific verb+resource (call a PVE API endpoint), mentions validation against a catalog, the read/write gate, then execution. It distinguishes from siblings by noting pve_ prefix (as opposed to pdm_) and referencing pve_describe_endpoint for param details, though it doesn't explicitly differentiate from pdm_call_endpoint.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Excellent usage guidance. It explicitly states when reads run vs writes and how to enable writes (PROXMOX_ALLOW_WRITES=true vs PVE_ALLOW_WRITES=true). It explicitly directs the user to 'Use pve_describe_endpoint first to learn the exact params,' giving clear instruction on sequencing with a sibling tool. The confirm gate for destructive operations is also disclosed in the schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pve_describe_endpointA
Get the full spec for one Proxmox VE endpoint: method, path, path params, query/body params (with types, formats, enums, constraints), the response schema, required permissions, and a request sample. Call before pve_call_endpoint so you send exactly the right params.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
A4.3/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It discloses what the tool returns (the full spec including response schema and permissions) and clearly frames it as a read/preparatory operation preceding pve_call_endpoint. The read-only nature is implied rather than stated explicitly, and rate limits or other constraints aren't mentioned, but the return content is well-specified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, information-dense sentence followed by a short directive. It front-loads the enumerated contents of the spec and ends with clear usage guidance. Slightly long but every clause earns its place; no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with a single documented parameter, a clear read-only purpose, absence of an output schema, and precise workflow positioning relative to pve_call_endpoint, the description covers what an agent needs. It doesn't explain the return format in detail, but given the tool's purpose is to reveal spec details, the description's enumeration of what's returned is adequate. No output schema exists, so the description partially serves that role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and there is only one parameter, operation_id. The schema provides a description with an example value and a pointer to list_endpoints for discovery. The tool description adds no further param semantics beyond the schema. With a single well-documented param, this is roughly at baseline despite the 0% coverage metric.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the verb ('Get') and resource ('full spec for one Proxmox VE endpoint'), enumerating exactly what the spec contains (method, path, params, response schema, permissions, sample). It distinguishes from siblings by noting 'Call before pve_call_endpoint', positioning it as a companion to pve_call_endpoint and differentiating from pve_list_endpoints.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'Call before pve_call_endpoint so you send exactly the right params.' This gives clear context for invocation and implies the alternative (calling directly without the spec look-up). It effectively communicates the tool's role in the workflow relative to its sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pve_list_endpointsA
List Proxmox VE API endpoints (operationId, method, path, category, description, read/write, destructive). Filter by category, resource, method, reads/writes, or search. Use this to discover an endpoint, then pve_describe_endpoint for its parameters and pve_call_endpoint to execute it.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| params | Yes |
TDQS
A4.1/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The description reveals it's a read-only listing tool (read/write/destructive fields are listed output, not side effects), which is non-destructive by nature. However, it doesn't mention pagination behavior, output size limits beyond the limit param, or whether results are truncated. The description is adequate but lacks depth on behavior edge cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and returned fields. The second sentence is valuable workflow guidance. Minor waste: the filter list partially duplicates the schema parameter names, but the field enumeration adds useful output context. Efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list/discovery tool with no output schema, the description enumerates what will be returned (operationId, method, path, category, description, read/write, destructive), which is valuable. It explains the workflow pipeline and filter options. Lacks explicit statement about it being read-only/safe, but the nature of listing makes that reasonably inferable. The default limit of 200 and filtering guidance partially compensates for the large surface area.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% per context signals, yet all 7 parameters actually have descriptive schema text (filter behavior, defaults). The description adds the limit default (200) and advises narrowing with filters for big surfaces, plus guides users to call with no args to see all categories. This is a 0-param structure (params wraps an object), so the nested param object's individual descriptions carry meaning. The description adds marginal strategic guidance.on top of what schemas already say.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists Proxmox VE API endpoints and enumerates the returned fields (operationId, method, path, category, description, read/write, destructive). It distinguishes itself from siblings by referenceing pve_describe_endpoint and pve_call_endpoint as the next steps, positioning this as the discovery tool in a pipeline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
States explicit filters (category, resource, method, reads/writes, search) and gives clear when-to-use guidance: 'Use this to discover an endpoint, then pve_describe_endpoint for its parameters and pve_call_endpoint to execute it.' This positions the tool within its sibling workflow and differentiates it from pve_describe_endpoint and pve_call_endpoint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.1.0- First observed
pdm_call_endpoint - First observed
pdm_describe_endpoint - First observed
pdm_list_endpoints - First observed
pve_call_endpoint - First observed
pve_describe_endpoint - First observed
pve_list_endpoints
TDQS
A4.3/5.0
Disambiguation4/5
The two endpoint categories (PVE vs PDM) are cleanly separated by the pve_/pdm_ prefixes, and within each the list/describe/call trio has clearly distinct purposes. The only minor ambiguity is that the two list and two describe tools are functionally identical except for their target API, which could cause a misselection if an agent fails to notice the prefix.
Naming Consistency4/5
The naming follows a very consistent pattern: {api}_list_endpoints, {api}_describe_endpoint, {api}_call_endpoint for both PVE and PDM. The pattern is perfectly parallel across both surfaces, though the slightly verbose prefix scheme (pve_/pdm_) could arguably be more concise. This is a strong, predictable convention.
Tool Count5/5
Six tools is an ideal count for a server that proxies two large API surfaces. The two trios each cover the full discover→describe→call workflow for their respective API, making each tool earn its place without any redundancy or bloat.
Completeness5/5
The server's purpose is to proxy arbitrary Proxmox APIs, and it fully covers the necessary surface: discover endpoints, inspect a specific endpoint's spec, and execute the call. The read/write gate and permission metadata are handled by the underlying catalog rather than requiring additional tools. There are no dead-end operations since any Proxmox endpoint can be reached indirectly through this generic pattern.
Maintenance
ActivitySlowing
ResponsivenessNo issues
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
An MCP server that let you interact with Cycloid.io Internal Development Portal and Platform
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
111MCP server for Pentest-Tools.com: run scans, manage findings and reports via your preffered LLM.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server for Proxmox VE that enables read-only cluster inspection, VM/container lifecycle operations, snapshots, migration, and provisioning with safe confirmation gates.MIT
- AlicenseBqualityCmaintenanceA comprehensive MCP server providing 92 tools for managing Proxmox Virtual Environment, including QEMU VMs and LXC containers.921545MIT
- FlicenseBqualityCmaintenanceComprehensive MCP server for Proxmox VE with 68 tools and 4 resources covering VMs, containers, storage, networking, clusters, HA, backups, firewall, and access control.68-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/NightSquawk/proxmox-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server