Proxmox MCP Server
Server Quality Checklist
Latest release: v0.1.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/5The 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/5Six 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/5The 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.
Average 4.3/5 across 6 of 6 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 6 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under AGPL 3.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add
glama.jsonto the root of your repository:{ "$schema": "https://glama.ai/mcp/schemas/server.json", "maintainers": [ "your-github-username" ] }Then . Browse examples.
Add related servers to improve discoverability.
How to sync the server with GitHub?
Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.
To manually sync the server, click the "Sync Server" button in the MCP server admin interface.
How is the quality score calculated?
The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).
Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.
Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).
Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.
Tool Scores
- 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/5Is 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/5Given 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/5Does 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/5Does 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/5Does 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.
- 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/5Is 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/5Given 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/5Does 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/5Does 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/5Does 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.
- 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/5Is 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/5Given 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/5Does 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/5Does 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/5Does 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.
- 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/5Is 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/5Given 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/5Does 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/5Does 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/5Does 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.
- 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/5Is 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/5Given 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/5Does 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/5Does 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/5Does 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.
- 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/5Is 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/5Given 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/5Does 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/5Does 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/5Does 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.
GitHub Badge
Glama performs regular codebase and documentation scans to:
- Confirm that the MCP server is working as expected.
- Confirm that there are no obvious security issues.
- Evaluate tool definition quality.
Our badge communicates server capabilities, safety, and installation instructions.
Card Badge
Copy to your README.md:
Score Badge
Copy to your README.md:
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