infra-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct infrastructure operation: container status, logs, disk usage, URL probing, deployment history, service restart, Caddy reload, and disk pruning. There is no functional overlap, and the descriptions clearly differentiate their purposes.
Naming Consistency3/5
Most tools follow an `infra_*_tool` pattern, but `service_url_tool` and `caddy_reload_tool` break the prefix convention. Additionally, the middle portion mixes nouns (logs, disk, deploys) and verbs (restart, prune, reload), making the naming pattern less predictable.
Tool Count5/5
With 8 tools, the set is well-scoped for an infrastructure management server. Each tool covers a meaningful aspect (monitoring, logs, disk, service control, deploys, Caddy config, cleanup) without redundancy or bloat.
Completeness4/5
The toolset provides solid coverage for common infrastructure tasks: status, logs, disk, restart, pruning, URL checks, deploy visibility, and Caddy reload. Minor gaps like explicit start/stop or triggering deploys are noticeable but not critical since restart and deploy history cover most needs.
Average 3.9/5 across 8 of 8 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
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.json to 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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries the full burden of behavioral disclosure. It does not explain what 'recent' means, whether results are ordered, or if the tool has any side effects. No behavioral traits are disclosed beyond the basic premise.
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, readable sentence with no wasted words. However, it is under-specified rather than concise-and-informative, carrying only the minimal core message.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and minimal parameter info, the description is too brief. It does not clarify key context such as recency thresholds, limits, or the nature of results, relying entirely on the output schema to fill gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter (limit_per_repo) with 0% description coverage. The description does not mention this parameter or how it affects results, leaving the agent to infer everything from the parameter name alone.
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 identifies the resource (GitHub Actions runs) and scope (configured deploy repos), which distinguishes it from sibling infra tools focused on status, logs, disk, and restart. However, it lacks an explicit verb like 'list' or 'get', making the action implied rather than stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description only states what it returns, with no mention of use cases, prerequisites, or exclusions.
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 transparency burden. It discloses that `since` uses duration formats, `grep` is plain text, and `stack` selects a compose project. However, it doesn't specify behavior like continuous tailing, what `tail` means, or error handling, leaving gaps for a log 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?
The description is highly concise and front-loaded with the main purpose, followed by clear, scannable parameter notes. Every sentence adds value, and the line break separates general behavior from specific stack guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With five parameters and no annotations, the description is moderately complete: it covers core purpose and three parameters, but misses `tail` semantics. Since an output schema exists, return values don't need prose, but the parameter gap makes the description not fully self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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. It explains `since`, `grep`, and `stack` meanings, but leaves `tail` and `service` unexplained. `tail` is ambiguous (likely number of lines) despite having a default in schema, and `service` is only self-evident from the tool name. This partial coverage is insufficient given zero schema descriptions.
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 'Tail logs from one compose service,' with a specific verb and resource. It distinguishes this from sibling infra tools by focusing on logs and clarifying multi-stack project selection. However, it doesn't explicitly name alternative tools, so it falls just short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for viewing logs, but provides no explicit when-to-use or when-not-to-use guidance relative to sibling tools. It does include useful parameter-level guidance (e.g., 'since accepts 10m / 1h / 2d', 'grep is plain text') which helps contextual use, but not as alternative selection.
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?
With no annotations provided, the description carries full burden. It discloses the core behavior (resolve DNS and probe HTTP status) but lacks details on response codes, timeouts, error handling, or redirects. For a simple read-only liveness check, this is adequate but not rich.
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 a single, front-loaded sentence with an additional short tagline. Every word earns its place, no redundancy or fluff. Concise and well-structured.
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?
The tool is simple with two parameters and an output schema (not shown). The description captures the core purpose and usage context. However, the lack of parameter descriptions and explicit usage boundaries leaves a small gap, but given the output schema existence, it is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description adds minimal parameter meaning. It references <service> in the URL template but does not explain the 'scheme' parameter or its default behavior. The description slightly clarifies the service param's role but leaves scheme ambiguous.
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 the tool's function: resolve a service URL within INFRA_PUBLIC_DOMAIN and probe its HTTP status, framed as a quick liveness check. This distinguishes it from sibling infrastructure tools that focus on status, logs, disk, deploys, restart, reload, or prune. The verb 'probe' and resource specification are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies usage for a quick liveness check, but provides no explicit guidance on when to use this tool versus alternatives like infra_status_tool. No exclusions or alternative tool names are mentioned. The context is clear but not differentiated.
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 convey safety and behavior. The word 'summary' implies a read-only, non-destructive operation, and the usage hint reinforces it as a pre-check. However, it doesn't explicitly state that no modifications are made or describe potential side effects, leaving some ambiguity.
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 two sentences, tightly packed. The first sentence states what it is, the second states when to use it. No wasted words.
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 simple zero-parameter summary tool, the description covers the core purpose and timing. An output schema exists to document return values, so the description doesn't need to explain them. It is complete enough for an agent to decide when to call it.
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?
The tool has zero parameters and an empty schema, so there is nothing for the description to explain. The description correctly doesn't invent any parameters, and the baseline for zero params is a 4.
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 identifies the tool as a summary of VPS disk and Docker storage. It distinguishes from sibling tools by focusing on storage rather than status, logs, or deploy operations. However, it lacks an explicit verb like 'get' or 'show', making it slightly less action-oriented.
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 phrase 'Use before heavy rebuilds' provides explicit timing guidance for when to invoke this tool. It doesn't mention alternatives or exclusions, but it gives clear context that this is a pre-rebuild check.
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?
Without any annotations, the description carries the full burden for behavioral disclosure. It does reveal an important guard: 'Requires confirm=true,' which informs the agent that confirmation is a prerequisite for the reload. However, it does not explain what happens if confirm is false (e.g., no-op vs. error), nor does it mention any side effects like brief downtime. This is adequate but not rich.
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 a single, well-constructed sentence. It front-loads the core purpose and then adds the confirmation requirement. Every word earns its place, with no filler 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?
Given the tool's simplicity (one optional parameter, output schema present), the description covers the essential usage context: what it does, when to do it, and a safety guard. It does not over-explain return values (output schema can handle that) or error cases. Minor gaps include lack of explicit alternative differentiation and behavior when confirm is false, but for a simple reload tool, it is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameter descriptions (0% coverage), so the description must compensate. It does so effectively by directly stating 'Requires confirm=true,' giving the boolean parameter clear semantic meaning: it guards the actual reload. This adds value beyond the raw schema and clarifies the intended usage of the confirm flag.
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 the action: 'Reload Caddy after a Caddyfile change.' It specifies the exact resource (Caddy) and the trigger condition, distinguishing it from sibling tools like infra_restart_tool, which likely handles broader service restarts. The purpose is specific and unambiguous.
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 gives explicit context for when to use: 'after a Caddyfile change.' This clearly implies the appropriate scenario. It does not explicitly mention alternatives or exclusions, but the context is clear enough for an agent to differentiate from other infra tools. No misleading guidance is present.
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. It discloses that the operation is destructive, requires confirm=true, and explains the risk of all_images (removes any image not used by a running container). It stops short of describing all side effects, but covers the key behavioral traits.
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 two sentences plus a compact list. It is front-loaded with the purpose, contains no filler, and every phrase adds value.
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 simple tool (2 params, no required, no enums) and presence of an output schema, the description provides a complete picture: purpose, target options with risk, and confirmation requirement. It doesn't discuss output, but that is covered by the output schema.
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 coverage is 0%, and the description compensates by enumerating valid target values and their meaning, plus the confirm requirement. It doesn't fully explain what happens when confirm=false, but the requirement is clear.
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 the specific verb 'Reclaim' with resource 'docker disk space' and enumerates concrete target types, making the tool's function unmistakable. This clearly distinguishes it from sibling tools like infra_status_tool or infra_disk_tool.
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 states the core scenario ('Reclaim docker disk space') and provides guidance on target selection with risk levels (e.g., 'build_cache (safest)' vs 'all_images (riskier)'). It also mentions the required confirmation flag. However, it does not explicitly call out alternative tools or when not to use it.
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 burden. It discloses the read-only nature by using 'List' and explains the stack parameter's effect, default behavior, and naming source (INFRA_STACKS keys). It does not cover errors or permissions, but for a list operation this is reasonably sufficient.
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 four short sentences, front-loaded with the core purpose. Every sentence provides unique value: output details, parameter behavior, default behavior, and naming source. No redundant or extraneous content appears.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one optional parameter and the presence of an output schema, the description is complete. It explains what the tool lists, how 'stack' is interpreted, and the default behavior. It appropriately avoids repeating return-value details that are presumably in the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It thoroughly explains the 'stack' parameter: it selects the compose project, is optional, defaults to the operator's configured default, and names come from INFRA_STACKS keys. This adds substantial semantic meaning beyond the raw schema.
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 ('List') with a specific resource ('every container in the compose stack') and clarifies the output ('state + status string'). This clearly distinguishes the tool from sibling tools that handle logs, disk, deploy, restart, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for checking container status but does not explicitly state when to prefer this tool over sibling alternatives like infra_logs_tool or service_url_tool. No exclusions or alternative tool mentions are provided, though the stack selection guidance is clear.
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. It discloses important behavioral constraints: `confirm=true` is mandatory and the service must be allowed. This goes beyond the schema, which only shows defaults. While it does not detail downtime or error behavior, it effectively communicates the guardrails for this mutation 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?
The description is compact and front-loaded, with no wasted words. Two short paragraphs convey purpose, requirements, and param semantics. The inline code formatting for `confirm=true`, `INFRA_ALLOWED_SERVICES`, and `stack` enhances readability without bloat.
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 no annotations, a 0% schema description coverage, and an output schema present, this description is quite complete. It covers the core usage, required conditions, and stack handling. It could add edge cases (e.g., what if service not found) or caution about downtime, but it is sufficiently complete for effective invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/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. It explains all three parameters: service (the target), confirm (must be true), and stack (selects compose project, omit for default). This gives full semantic meaning beyond the raw schema.
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 begins with a specific verb and resource: 'Restart a compose service.' This clearly distinguishes it from sibling tools like infra_status_tool (status), infra_logs_tool (logs), and infra_disk_tool (disk), making the purpose unambiguous.
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?
It provides clear context for use by stating prerequisites: 'Requires confirm=true AND service in INFRA_ALLOWED_SERVICES.' It also explains when to use the `stack` parameter ('picks which compose project; omit for default'). However, it does not explicitly mention alternatives or when not to use this tool.
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:

[![infra-mcp MCP server](https://glama.ai/mcp/servers/odanree/infra-mcp/badges/card.svg)](https://glama.ai/mcp/servers/odanree/infra-mcp)

Score Badge

Copy to your README.md:

[![infra-mcp MCP server](https://glama.ai/mcp/servers/odanree/infra-mcp/badges/score.svg)](https://glama.ai/mcp/servers/odanree/infra-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/odanree/infra-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server