Woow Podman MCP Server

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Every tool has a clearly distinct purpose: listing containers, inspecting, starting, stopping, logs, stats, top, healthcheck, exec, plus separate tools for images, pods, volumes, networks, and host-level info. There is no overlap that would cause an agent to misselect.
Naming Consistency4/5
The tools consistently use the podman_ prefix and snake_case throughout. Most container operations follow a resource_action pattern (podman_container_start), while some are noun-only (podman_ps, podman_images, podman_events) or compound (podman_system_df), mirroring the podman CLI. The minor style variation is acceptable but not perfectly uniform.
Tool Count4/5
With 18 tools, the server is slightly above the typical well-scoped range of 3-15. However, the breadth of Podman features covered (containers, images, pods, volumes, networks, events, exec) justifies the count, and each tool adds value without redundancy.
Completeness2/5
The tool set is largely read-oriented and lacks fundamental lifecycle operations. There is no way to create or delete containers, pods, volumes, networks, or images (except pulling). Starting/stopping/restarting and exec provide some control, but the missing CRUD operations are significant gaps for a general Podman server.
Average 3.4/5 across 18 of 18 tools scored. Lowest: 2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 40 commits 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 already indicate the tool is idempotent and non-destructive, but the description adds no context about behavioral side effects, such as what happens if the container is already running, failure modes, or resource implications. It offers zero additional behavioral transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short but under-specified; it merely restates the tool name and does not earn its place by adding useful information. It is concise in length but lacks necessary structure or elaboration.
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 simple tool this description is bare minimum, but it lacks important context such as preconditions, state changes, or relationship to sibling tools. The presence of an output schema reduces the need to explain return values, yet the description still feels incomplete for an agent to select and invoke correctly.
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?
The schema has a single 'name' parameter with 0% coverage in the description. The description does not explain what the parameter represents (e.g., container name or ID), so it fails to compensate for the lack of schema-level descriptions, though the parameter is somewhat self-evident from the tool name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Start container' is a direct tautology of the tool name, adding no new information about the action's scope or distinguishing it from sibling tools like restart or stop. It communicates a basic action but fails to differentiate the tool from alternatives.
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?
The description provides no guidance on when to use this tool versus alternatives such as podman_container_restart or podman_container_stop, nor does it mention preconditions like the container needing to exist or be in a stopped state.
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?
Annotations indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds no extra behavioral context beyond the fact that it restarts a container, such as what happens to running processes or network settings. Given annotations, the bar is lower, but the description still adds minimal value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief (three Chinese characters plus 'container'), but this brevity reflects under-specification rather than effective conciseness. It lacks any explanation of parameters or usage context, so it does not earn its place.
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 two parameters and an output schema, the description is inadequate. It provides no context on side effects, required permissions, or typical use cases. While the output schema exists, the description does not guide the agent on what to expect or how to handle failures.
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?
Schema description coverage is 0%, and the description provides no information about the 'name' or 'timeout' parameters. Since the description fails to compensate for the schema's lack of descriptions, parameter semantics are entirely missing.
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 '重啟 container' clearly states the action (restart) and the resource (container), making the purpose immediately understandable. It does not explicitly distinguish itself from sibling tools like start or stop, but the verb 'restart' implies a specific operation.
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 does not mention prerequisites, conditions, or exclusions, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as read-only and non-destructive, so the description needs to add extra context. It adds nothing beyond the basic action, such as output behavior, pagination, or permission requirements, providing minimal value over the annotations.
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, direct sentence that efficiently conveys the core purpose without unnecessary words. It is appropriately brief for a simple list operation.
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?
The tool is simple, and the output schema and annotations cover some aspects. However, the description lacks context about when to use it or how the format parameter behaves, leaving a clear gap in usage guidance. It is adequate but not 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?
The schema contains one parameter 'format' with enum values and a default, but no description. The tool description does not explain this parameter, so the 0% schema description coverage is not compensated, leaving the agent to infer its meaning from the schema 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 states 'List networks' which is a clear verb+resource pair. It doesn't explicitly differentiate from sibling list tools like podman_images or podman_volumes, but the resource is unambiguous and the action is specific.
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?
The description provides no guidance on when to use this tool versus alternatives. It does not mention the format parameter, any exclusions, or prerequisites, leaving the agent without context for 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?
Annotations already declare the tool as read-only and non-destructive, so the description does not need to repeat that. The description adds the behavioral trait of returning a snapshot rather than a stream, which is valuable beyond the annotations. However, it does not describe output format or any operational constraints.
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 extremely concise—a single sentence that is easy to parse and front-loads the core purpose. It omits additional useful detail, but it earns its place by being clear and compact.
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 a read-only annotation, a non-destructive hint, and an output schema available, the description is minimally adequate. However, it lacks essential parameter semantics and does not mention prerequisites like running containers, making it incomplete for a tool with two parameters and no schema descriptions.
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?
The description provides no information about the 'all' and 'names' parameters, and schema description coverage is 0%. While the parameter names are somewhat self-explanatory, the description does not clarify semantics such as whether 'all' includes stopped containers or how 'names' filters results, leaving the agent without sufficient guidance.
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 retrieving container resource usage, with a specific qualifier of 'single snapshot, no streaming.' While it lacks an explicit verb like 'get' or 'show', the meaning is unambiguous and differentiates from sibling tools like podman_container_top (process-level) and podman_ps (listing).
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 that this tool is for one-time snapshots rather than continuous monitoring ('single snapshot, no streaming'), but it does not explicitly state when to use it over alternatives or provide exclusions. This is a thin but present usage hint.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds that the tool executes the healthcheck (not just reads a cached status), but it does not explain behaviors like what happens if no healthcheck is configured or whether the result is returned as structured output.
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, direct sentence. It is extremely concise and front-loaded, with no unnecessary words or repetition.
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 parameter, an output schema exists, and annotations are provided), the description is mostly sufficient. However, it could mention edge cases like containers without a healthcheck or how the result is reported, so it is not fully complete.
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 single parameter 'name' is left entirely to the schema, which only provides its type and title. With schema description coverage at 0%, the description needed to clarify that 'name' refers to the container name and any constraints, but it does not. This fails to compensate for the schema's lack of detail.
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 a specific action (execute and report) on a specific resource (container's healthcheck result). It is distinct from sibling tools like podman_container_inspect or podman_container_logs, which serve different purposes.
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?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as the container needing a healthcheck defined, or when one would prefer inspect or logs to get health information.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the detail that containers within pods are included in the listing, which is useful scope context. No behavioral traits beyond that are disclosed, and there is no contradiction.
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, compact sentence in Chinese that gets straight to the point. Every word is necessary, and there is no redundancy or filler.
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?
The tool is a simple listing operation, but the description is too sparse to be fully complete. It does not explain the 'filters' parameter or the 'format' options, which are important for controlling the output. The output schema exists, but the parameter semantics are missing.
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 0% description coverage, and the description provides no information about the 'format' or 'filters' parameters. This leaves the agent without guidance on how to use these parameters, so the description fails to compensate for the schema gap.
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) and identifies the resource as 'pods' with the additional scope of including the containers within them. This distinguishes it from sibling tools like podman_ps or podman_images.
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 clearly states what the tool does but provides no explicit when-to-use or alternative guidance. It is implied that this is the tool for listing pods, but there is no mention of when to prefer it over podman_ps.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the 'local' scope but does not mention return format, pagination, or other behavioral details. With annotations present, this is adequate but not enriched.
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 concise phrase with zero wasted words. It is immediately front-loaded and efficient for a simple list tool.
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?
Given the tool's simplicity, annotations, and output schema, the description is minimally viable. However, it lacks any mention of parameter usage or filtering capabilities, which are relevant for correct invocation. Sibling tools help, but the description itself leaves 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?
Schema description coverage is 0%, and the description provides no information about the parameters (all, format, filters). The description fails to compensate for the complete lack of parameter documentation, leaving the agent to infer meaning solely from names/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 '列出本機 images' clearly states the tool lists local images, with a specific verb (list) and resource (images). It distinguishes from sibling tools like podman_ps (containers) and podman_volumes (volumes).
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 when one needs to view local images, but does not explicitly state when to use this tool versus alternatives like podman_info or podman_image_pull. No exclusions or alternate tool guidance is provided.
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?
Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds minimal extra behavioral context—just 'disk usage statistics'—but does not elaborate on what scopes are covered (e.g., containers, images, volumes) or the nature of the output. It does not contradict the annotations.
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 short sentence with no unnecessary words. It is concise and straight to the point, containing the core meaning without redundancy.
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?
For a read-only, zero-parameter tool, the description is minimally adequate but sparse. It does not specify which disk usage categories are included (e.g., container, images, volumes) or mention that it provides a system-wide summary. However, given the tool's simplicity and available output schema, the description meets the baseline but leaves room for richer context.
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, so the input schema is trivially 100% covered. The 0-parameter baseline applies, and the description need not explain any parameter details.
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 '磁碟用量統計 (podman system df)' clearly identifies that the tool provides disk usage statistics, which is a specific and distinct function among the sibling tools. It goes beyond merely restating the tool name, though it could be more action-oriented (e.g., 'list' or 'show').
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?
The description offers no guidance on when to use this tool versus alternatives such as podman_info or podman_images. There is no mention of context, 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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the valuable behavioral detail that the event stream is bounded and will not hang, which is informative beyond the annotations. It does not disclose other traits such as filtering behavior or output format, so a 3 is appropriate.
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 exceptionally concise—two short sentences that convey the core purpose, the bounded non-blocking behavior, and a primary use case. Every word earns its place without unnecessary detail.
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 an output schema present and straightforward read-only operation, the description is adequate but leaves parameter semantics unexplained. It covers the tool's purpose and key behavior, but for a tool with 4 optional parameters, the lack of parameter guidance makes it only minimally 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 description coverage is 0%, and the description adds no information about the parameters (limit, since, until, filters). The parameter names are somewhat self-explanatory, but the description does not compensate for the lack of schema descriptions, especially for time formats and filter syntax.
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 the tool reads the podman event stream and notes it is bounded and non-blocking. It gives a specific use case (troubleshooting timelines), but does not explicitly differentiate it from sibling tools like podman_container_logs, so it falls short of a 5.
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 a clear context for use ('good for troubleshooting timelines'), implying when to prefer this tool. However, it does not mention exclusions or explicitly name alternative tools, so it lacks the explicit when-not-to-use guidance that would merit a 5.
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?
Annotations already declare destructiveHint=true, so the agent knows this is a potentially destructive operation. The description adds useful output-format context (stderr prefix, tty behavior) but does not mention prerequisites like the container being running or error handling behavior.
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, efficient, and front-loaded with the core purpose followed by detailed output behavior, with no wasted words.
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?
The description covers the core purpose and output format, and an output schema exists, so return-value details are covered. However, it lacks context about prerequisites (e.g., container must be running) and potential destructive side effects beyond the annotation.
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?
With 0% schema description coverage, the description should compensate; it only clarifies the tty parameter's effect on stderr formatting, while leaving user, workdir, and command semantics implicit from their parameter names.
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 executes commands inside an existing container and returns stdout/stderr and exit code, distinguishing it from container lifecycle siblings like start/stop.
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 executing commands in existing containers, but it does not explicitly compare with alternatives or state 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds useful behavioral details beyond annotations: the default 200-line tail limit and the 'E| ' prefix for stderr lines. This helps the agent anticipate output formatting without overselling.
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 short sentences, with the action stated first and key defaults included. Every word earns its place, and there is no redundant content.
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?
Given the output schema exists, return values need not be described. However, with 8 parameters and no parameter guidance or usage scenarios, the description is minimally complete for a log-fetching tool. It provides the essential behavioral facts but misses opportunities to mention filtering options or when to use them.
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?
Schema description coverage is 0%, and the description does not compensate. It fails to explain any of the 8 parameters (grep, since, until, stdout, stderr, timestamps, etc.) beyond what the schema already provides. The only mention of 'tail' default is a value already present in the schema, adding no semantic value.
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 ('取' / fetch) and the resource ('container logs'), which unambiguously distinguishes it from sibling tools like podman_container_inspect or podman_container_top. The name and description together leave no doubt about the tool's function.
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 the tool is used to retrieve container logs, but it provides no explicit guidance on when to use this over other tools (e.g., when to use grep, since, until filters). No exclusions or alternative recommendations are given, so the usage context is only implied.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds minimal behavioral context beyond the basic purpose, such as noting it lists processes but does not disclose any additional nuances like requiring a running container or the effect of ps_args. With annotations covering the safety profile, a 3 is appropriate.
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, concise sentence that is front-loaded with the action and resource. No unnecessary words or repetition exist, making it highly efficient for an agent to parse.
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 an output schema present, return values are covered. However, the description lacks usage context (e.g., when to prefer this over exec), parameter semantics, and any prerequisites like container state. It is adequate for a simple read tool but leaves clear gaps that could cause incorrect invocation in ambiguous situations.
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 by explaining parameters. It does not. The names 'name' and 'ps_args' are somewhat self-evident, but ps_args' purpose (likely formatting/filtering arguments to ps) is not clarified. The description provides no added meaning beyond the schema's type definitions.
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 action: '列出 container 內的 process' (list processes inside a container), and the parenthetical '(podman top)' explicitly references the underlying command. This specific verb+resource pairing distinguishes it from sibling tools like logs or stats.
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?
No explicit guidance is given about when to use this tool versus alternatives. However, the name and description imply it is for process listing, making the usage context inferable but not explicitly contrasted with siblings like podman_container_exec or podman_container_stats.
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?
Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description discloses that the operation is blocking ('會等到拉完' - waits until done) and warns about timeout for large images. This adds valuable behavioral context not captured by annotations, though it does not mention side effects like modifying the local image store.
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 succinct sentences. The first states the core purpose, and the second adds a key behavioral warning. Every word is useful, and the structure is front-loaded with the main action.
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?
While the tool is relatively simple and has an output schema, the description lacks parameter guidance, which is essential given the 0% schema description coverage. The timeout warning is helpful, but without explaining what 'reference' should contain (e.g., image name and tag), the description is incomplete for correct invocation.
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?
Schema description coverage is 0%, so the description must compensate for missing parameter documentation. However, it does not explain any of the three parameters (reference, policy, tls_verify), leaving the agent without crucial information such as how to format the image reference or what policy values mean. This is a critical gap.
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 with a specific verb and resource: '從 registry 拉 image' (pull image from registry). It distinguishes from sibling tools like podman_images (list images) and podman_ps, making it 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 provides clear context on when to use the tool—for pulling images from a registry—and adds an important usage caveat about blocking until completion and timeout for large images. However, it does not explicitly mention alternatives or when-not-to-use scenarios, which would justify a higher score.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds no extra behavioral context beyond the basic listing operation. It does not contradict annotations, but it also does not disclose any additional traits such as output format or scope.
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, concise sentence. It is appropriately sized for a simple list operation and contains no unnecessary words or repetition.
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, the presence of an output schema, and annotations covering safety, the description is mostly complete. It lacks any mention of the format parameter or scope (e.g., 'all volumes'), but these are not critical for a basic listing tool and are largely covered by the schema and name.
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?
The schema description coverage is 0%, and the description does not compensate for the 'format' parameter. Although the schema fully documents the parameter with enum values and a default, the description offers no additional meaning, leaving the agent to rely solely on the schema for a parameter that could benefit from contextual explanation (e.g., 'json output for machine parsing').
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 '列出 volumes。' clearly states a specific verb (list) and resource (volumes), distinguishing it from sibling tools that operate on containers, images, pods, or networks. It fully captures the tool's purpose.
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?
There is no explicit guidance on when to use this tool versus alternatives. However, the resource name and sibling list imply its use for listing volumes. It lacks contextual cues such as 'use this when you need to see available volumes' or exclusions for other resource types.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is clear. The description adds the behavioral trait that output is large and advises querying only the needed container, which is useful context beyond the annotations. No contradictions found.
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 exactly two short sentences, front-loaded with the main purpose, and the extra warning about output size earns its place. There is no redundancy or fluff.
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?
Output schema exists and annotations cover the safety profile, but the 'section' parameter is completely unexplained, and there is no detailed usage guidance. The description is adequate for a simple inspect tool but leaves gaps in parameter semantics and alternative usage.
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 provides no information about the 'name' or 'section' parameters. It does not clarify what 'section' filters or the expected format of 'name', leaving a significant gap in parameter understanding.
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 'Inspect single container's complete configuration/status' with a specific verb and resource, distinguishing it from sibling tools like podman_ps or podman_container_logs. It also emphasizes 'single container', making the scope explicit.
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 inspecting one container, and the warning 'output is large, only query the one you want' gives a hint to be selective. However, there is no explicit mention of when to use this tool versus alternatives 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?
The description discloses the timeout behavior (default 10 seconds then SIGKILL), which goes beyond the annotations' idempotent/destructive hints. It adds context about how the stop process executes but doesn't mention other side effects.
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 concise sentence that front-loads the primary action. It is efficient and without filler, though it omits some contextual details such as usage guidance.
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, the annotations (idempotent, non-destructive), an existing output schema, and the timeout behavior description, the description is mostly complete. It lacks usage guidance but covers the essential behavioral detail.
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?
With 0% schema description coverage, the description fails to compensate for parameter explanations. It indirectly references the timeout default but does not explicitly link it to the timeout parameter or explain the name parameter beyond the 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 clearly states the action 'stop container' with a specific resource (container). The additional detail about SIGKILL after 10 seconds further clarifies the behavior, distinguishing it from start/restart siblings.
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 the tool is used to stop a container but provides no explicit guidance on when to use it versus alternatives like podman_container_start or podman_container_restart. No exclusions or alternative tool references are mentioned.
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?
Annotations already provide readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the specific data fields returned, which is useful context, but it does not disclose any subtle behaviors such as potential daemon requirements or performance implications. It 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 one concise sentence, front-loaded with 'Podman host overview', and lists key aspects without unnecessary verbiage. Every word 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?
For a simple read-only info tool with an output schema available, the description covers the primary purpose and data scope. It omits any mention of the 'format' parameter, but the optional enum is self-explanatory. The presence of annotations and output schema reduces the need for more detail.
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?
The schema has 0% description coverage for the 'format' parameter. The description does not mention this parameter at all, so the agent must infer its meaning solely from the enum values (text/json). Since the schema coverage is low, the description should have compensated, but it does not.
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 a host-level overview tool, listing concrete data points (version, OS, runtime, rootless, resource usage). It distinguishes from sibling tools like podman_container_inspect and podman_images by focusing on the Podman host itself.
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 clear context for when to use this tool: when host-level information is needed. It does not explicitly name alternatives or exclusions, but the host scope inherently separates it from container/image/pod tools. A note distinguishing it from podman_system_df would have earned a 5.
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?
The annotations already declare readOnlyHint=true and destructiveHint=false, establishing the safe read profile. The description adds the crucial behavioral trait that only running containers are listed by default and that all=true broadens the result to include stopped ones, which is beyond what annotations provide.
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 short sentences, front-loaded with the main action '列出 containers' and then elaborating the default and all parameter. Every word earns its place, with no redundant 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?
Given that this is a simple read-only listing tool with an output schema, the description adequately covers the core behavior and the most important parameter (all). It does not explain filters or format, but those are visible in the schema and the read-only nature is annotated, making it complete enough for a basic list operation.
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?
The input schema has 0% description coverage, leaving the meaning of parameters solely to types and names. The description explains only the 'all' parameter ('all=true 含已停止') but does not clarify 'format' or 'filters', particularly the complex anyOf structure for filters, leaving significant semantic gaps.
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 states '列出 containers' (List containers), which clearly identifies the verb and resource. It further specifies the default scope (only running) and the all=true option to include stopped containers, distinguishing it from inspection or management tools like podman_container_inspect and podman_container_start.
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 about the default behavior (listing running containers) and explicitly mentions how to include stopped ones using all=true. While it does not mention alternatives or when-not-to-use, the context is clear enough for basic usage compared to sibling tools.
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:

[![Woow_podman__mcp_server MCP server](https://glama.ai/mcp/servers/WOOWTECH/Woow_podman__mcp_server/badges/card.svg)](https://glama.ai/mcp/servers/WOOWTECH/Woow_podman__mcp_server)

Score Badge

Copy to your README.md:

[![Woow_podman__mcp_server MCP server](https://glama.ai/mcp/servers/WOOWTECH/Woow_podman__mcp_server/badges/score.svg)](https://glama.ai/mcp/servers/WOOWTECH/Woow_podman__mcp_server)

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/WOOWTECH/Woow_podman__mcp_server'

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