SSH MCP Server

Server Quality Checklist

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

Latest release: v0.8.1
Disambiguation5/5
Each tool has a distinct purpose: exec variants (single, batch, shell, sudo), SFTP operations (upload, download, list, etc.), session management (shell_*), and server configuration. Even similar-sounding tools like exec and exec_shell are clearly differentiated by interactive vs sudo mode.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern: exec_*, sftp_*, shell_*, list_*, etc. No mixing of styles (all lowercase with underscores). Even standalone verbs like 'connect' and 'disconnect' fit the pattern.
Tool Count5/5
Twenty tools is appropriate for an SSH management server. It covers connection, command execution, file transfer, session control, server configuration, and audit, without excessive redundancy.
Completeness5/5
The tool surface covers the full lifecycle of SSH operations: connect/disconnect, various execution modes, SFTP file management, persistent shell sessions, server config storage, health checks, and logs. Missing features like port forwarding are not core to typical SSH workflows.
Average 3.7/5 across 20 of 20 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- Last stable release on February 5, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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?
The description provides no behavioral details beyond the name. It doesn't disclose side effects, error conditions, or requirements (e.g., must have an active connection). With no annotations, the description carries full burden but fails to add transparency.
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?
Extremely concise (one phrase). Front-loaded but may be too brief; could be expanded to a sentence without losing conciseness.
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?
Adequate for a simple action with no output schema, but lacks details on behavior when 'all' is true or when parameters don't match a connection. More context would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already explains parameters. The description adds no additional meaning beyond the schema; it doesn't mention parameters at all.
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 '断开 SSH 连接' clearly states the action and resource (disconnect SSH connection). It distinguishes from siblings like 'connect' and 'list_active_connections'. However, it could be more specific about targeting individual connections vs all.
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 on when to use this tool vs alternatives (e.g., 'connect', 'list_active_connections'). Missing context about prerequisites or when not to use.
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?
With no annotations provided, the description bears full responsibility for behavioral disclosure. It fails to mention whether the operation is read-only, any permission requirements, rate limits, or pagination. The description is too terse to convey key behavioral traits beyond the basic action.
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 highly concise, consisting of a single relevant sentence. However, it could be slightly more structured by front-loading key information like the read-only nature. The brevity is efficient but leaves room for improvement without adding significant length.
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?
Given that there is no output schema and the tool has four optional parameters, the description should explain the output format, sorting, and any limits or pagination. It fails to mention that logs are typically sorted by time or that the 'limit' parameter controls results count. The description is incomplete for practical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add any additional meaning to the parameters beyond what the schema provides (e.g., default values, enum choices). It neither complements nor contradicts the schema, thus scoring at baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '获取操作审计日志' clearly states the verb 'Get' and the resource 'operation audit logs', which is specific and distinct from sibling tools like health_check or list_servers. However, it does not explicitly differentiate from any potential overlapping functionality, so it loses one point.
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 when to filter by server or operation type. It lacks any context about prerequisites, return behavior, or integration with other tools, making it difficult for an agent to decide when this tool is appropriate.
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?
No annotations are provided, so the description carries full burden. It only states the purpose but does not disclose behavioral traits such as whether it requires an existing connection, what happens on failure, return format, or idempotency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise (one sentence). It is front-loaded, but the brevity sacrifices necessary context. It is not excessively long, but could be more informative without being verbose.
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?
Given simple parameters and no output schema, the description should explain what the output or effect is (e.g., returning a boolean or status). It fails to provide that, making the tool behavior ambiguous.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond the schema parameter descriptions, which already define host, port, and username.
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 checks SSH connection health status, which is a specific verb and resource. It distinguishes from sibling tools like connect (establish connection) and exec (execute commands), as health check is a diagnostic action.
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 usage guidelines are provided. The description does not specify when to use this tool versus alternatives, nor does it mention prerequisites or exclude any scenarios.
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?
With no annotations, the description carries full burden. It discloses deletion but not irreversibility, permissions needed, error handling, or behavior when recursive is false on a directory. The recursive parameter is documented in schema but not highlighted in description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences are efficient and front-load the action. However, the brevity sacrifices important behavioral details for a destructive tool.
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 performs a destructive operation yet lacks output schema, safety warnings, or details on how recursive deletion works. Connection guidance is partial; missing prerequisites like active connection state.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds minor value by elaborating on alias/host omission for single connections, but does not enhance understanding of other parameters like path, recursive, or confirmation token.
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 deletes remote files or directories (specific verb+resource). It is distinct from sibling tools like sftp_ls, sftp_mkdir, etc., and the addition of server specification context further clarifies the action.
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 provides basic guidance on server selection (alias vs host, single connection case) but lacks explicit when-to-use vs alternatives (e.g., exec commands for deletion) and does not mention prerequisites like having an active connection.
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 fully convey behavioral traits. It mentions a two-step confirmation process and a production warning, hinting at destructiveness. However, it lacks explicit statements about side effects, reversibility, or error conditions, which is a gap for a deletion tool.
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 concise with two sentences, front-loading the action. Every sentence provides relevant information 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?
With no output schema or annotations, the description covers the core purpose and key precondition. However, it omits information about return values, error handling, and how the confirmation token is obtained or validated, leaving gaps for a complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds minimal extra semantics beyond the schema (e.g., confirming the token requirement). It does not elaborate on parameter format, defaults, or token acquisition 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 clearly states the action (delete) and the resource (saved server configuration), and includes a critical precondition (requiring a confirmation token). While it does not explicitly differentiate from siblings, the sibling list contains no other deletion tool, so purpose is 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 explicit usage guidance by stating that a confirmation token must first be obtained, and that production servers have special warnings. This clarifies the two-step process but does not detail when not to use the tool or compare to alternatives.
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?
No annotations are present, so the description should disclose behavioral traits. The description only states the upload action and mentions the overwrite parameter indirectly via schema. It does not mention authentication requirements, error handling, whether an active connection is needed, or any side effects beyond file upload. This is insufficient for a tool with no 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 sentence that covers the core purpose and key usage hint. It is concise and front-loaded, with no wasted words.
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?
Given 8 parameters and no output schema, the description lacks details on return values, error outcomes, prerequisites (like active connection), or behavior when overwrite is set. The tool performs a meaningful action, and the description does not adequately prepare an agent for its use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter is described in the schema. The tool description adds context about alias/host priority and connection state, which provides some added value. However, it does not elaborate on other parameters beyond what the schema already provides.
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 ('上传本地文件到远程服务器' - upload local files to remote server) and the resource (local file, remote server). It also distinguishes from sibling tools like sftp_download and sftp_ls by specifying upload direction.
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 guidance on using alias vs host for target server specification, and notes that host can be omitted when there's a single active connection. This helps the agent decide between connection methods, but does not explicitly mention when not to use this tool or provide exclusion criteria.
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?
No annotations are provided, so the description must fully disclose behavioral traits. It mentions persistence but fails to describe side effects (e.g., sending commands, potential risks), auth requirements, or error handling. The description is insufficient for safe usage without 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 concise with two sentences, front-loading the purpose and target rules. Every sentence provides actionable information without redundancy or fluff.
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?
With 10 parameters and no output schema, the description is too minimal. It does not explain return values, how to read responses (despite a sibling shell_read), or the behavior after input is sent. For a multi-turn interaction tool, this leaves significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds minor context about target specification (alias/host) but does not elaborate on other parameters like confirmation tokens, waitForPrompt, or timeout beyond what the schema already provides.
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 sends input to a persistent shell session for multi-turn interactions like bastion host login. It specifies the target requirement (alias or host) and differentiates from siblings by emphasizing persistence and interactivity.
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 explicitly states when to specify target (alias/host) and that target can be omitted when only one connection exists. It implies use for persistent sessions but does not explicitly exclude alternatives like exec or shell_close.
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, the description carries full burden. It discloses target selection rules and dangerous command handling, but does not mention permissions, side effects, or output behavior. Moderately transparent but incomplete.
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?
Efficient 5-sentence paragraph, front-loaded with purpose, no redundant or irrelevant content. Each sentence contributes unique information.
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?
Covers target specification and dangerous command handling, but does not explain output/return, error behavior, or differentiate from similar siblings. With no output schema, additional context on results would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already provides 100% coverage with descriptions. The description adds minor value (e.g., recommending alias) but largely repeats schema info. Baseline 3 is appropriate.
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 'execute command on remote server' (specific verb+resource). However, it does not differentiate from siblings like exec_shell or exec_sudo, which also execute commands, making it less helpful for distinction.
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?
Provides concrete guidance: use alias (preferred) or host, single-connection shortcut, multi-server confirmation requirement, and dangerous command confirmation token. Lacks explicit comparison to alternative tools but gives good operational context.
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?
Discloses the sudo execution behavior, confirmation tokens, and timeout options, but lacks details on success/failure responses, error handling, or rate limits. With no annotations, the description carries the full burden but does not fully cover 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph that is relatively concise but lacks structured formatting (e.g., bullet points) to improve readability. It front-loads the main purpose but could be organized better.
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 complexity (10 parameters, no output schema, no annotations), the description covers execution context and confirmation needs, but does not address return values, error handling, or examples, leaving gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter descriptions. The tool description adds usage context (e.g., when to omit host), but does not significantly enhance meaning beyond the schema. Baseline of 3 is appropriate given high schema coverage.
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 with sudo privileges, distinguishing it from siblings like 'exec' (without sudo) and 'exec_shell'. It specifies requirements for target server and mentions confirmation tokens for dangerous commands.
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?
Provides clear guidance on specifying target via alias or host, when to omit target in single-connection scenarios, and confirmation for dangerous commands and target switching. However, it does not explicitly state when to use alternatives like 'exec' for non-sudo commands.
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, the description bears the full burden of behavioral disclosure. It reveals that batch operations are risky and require confirmation for dangerous commands, but it does not detail error handling, output format, concurrent execution behavior, or what constitutes a 'dangerous command'. This is partially transparent but leaves gaps.
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 short (two sentences) and conveys the essential purpose and risk information without fluff. However, it could be slightly more structured (e.g., bullet points for warnings) to improve scanability.
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 high-risk batch execution tool with no output schema and no annotations, the description lacks details on output format, error handling, partial failure behavior, and the exact warning mechanism for production servers. It sets risk expectations but is not fully complete for an agent to use reliably.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the input schema already describes each parameter. The description adds no additional per-parameter semantics; it only reinforces the risk and token usage. Thus, baseline 3 is appropriate.
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 that the tool executes commands on multiple servers ('在多台服务器批量执行命令'), distinguishing it from sibling tools like exec (single server) or exec_sudo. It also highlights the batch aspect and risk, 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?
The description provides explicit usage guidance: it warns about high risk, mentions special warnings for production servers, and specifies that dangerous commands require a confirmationToken. This informs the agent when caution is needed, though it does not explicitly list when not to use or name alternative tools.
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?
Without annotations, the description must disclose behavioral traits. It mentions interactive shell mode and connection context, but fails to explain critical aspects like the purpose of confirmation tokens, potential destructive actions, error handling, or output behavior. The description is insufficient for safe tool invocation.
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 extremely concise (three short sentences) and front-loaded: first sentence states purpose, second gives key instruction, third covers edge case. No wasted words.
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?
Despite a clear purpose, the description omits crucial context for a complex tool with 9 parameters, no output schema, and no annotations. It does not explain the interactive shell behavior, use for confirmation tokens, timeout behavior, or error handling. This leaves the agent underinformed.
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 100%, so baseline is 3. The description adds value by explaining the relationship between alias/host and the single-connection rule, and recommends alias over host. This context goes beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is for interactive shell mode in scenarios where exec is not supported (e.g., bastion host traversal), distinguishing it from sibling tools like exec, exec_batch, and exec_sudo.
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 specifies when to use (scenarios where exec is not supported) and provides clear guidance on target server specification (alias recommended, host alternative, and omission allowed when only one active connection). However, it does not explicitly state when not to use or compare to other execution tools.
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, the description carries full burden. It states the tool lists saved configurations, implying a read-only operation, but does not disclose any behavioral details such as permissions, side effects, or whether it returns names only or full details.
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 sentence with no unnecessary words. It is appropriately concise and front-loads the purpose.
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, no output schema), the description is mostly complete. It could mention the return type but is adequate for its complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the only parameter 'group', with a description 'filter by group'. The tool description adds no additional meaning beyond the schema, meeting the baseline of 3.
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 lists saved server configurations, which is a specific verb-resource combination. It distinguishes itself from sibling tools like connect, exec, or health_check.
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 for listing saved server configs, but does not explicitly state when to use it versus alternatives such as list_active_connections or health_check. No when-not 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?
No annotations are provided, so the description carries the full burden. It mentions the basic behavior (download) and the overwrite parameter, but does not disclose error handling, authentication requirements, or idempotency. This is adequate but not comprehensive.
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 extremely concise with only two sentences. It front-loads the purpose and provides essential parameter guidance without any fluff. Every sentence earns 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?
Given 8 parameters, no annotations, and no output schema, the description is insufficient. It does not explain what the function returns (e.g., success message, file path), error scenarios, or prerequisites like needing an active connection. The user is left to infer important details from the schema alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters, so baseline is 3. The description adds value by explaining the usage of 'alias' vs 'host' and the optionality when single connection, but does not provide additional semantics beyond what is in the schema for other parameters like 'remotePath' and 'localPath'.
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 ('下载文件从远程服务器到本地' - download files from remote server to local) and distinguishes it from sibling tools like sftp_upload (upload) and sftp_ls (list). The verb 'download' is specific and the resource 'file' is explicit.
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 guidance on when to use 'alias' vs 'host' and notes that parameters can be omitted when there is a single connection. However, it does not explicitly state when to avoid this tool in favor of alternatives like sftp_ls or sftp_mkdir.
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?
With no annotations provided, the description must convey behavioral traits. It fails to mention whether an active connection is required, error handling (e.g., invalid path), recursion, or the meaning of targetConfirmationToken. This lack of detail hinders safe invocation.
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 sentence, making it concise and front-loaded. It efficiently conveys the core usage pattern, though it could be slightly expanded without losing conciseness.
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 and complete schema descriptions, the description covers the key connectivity nuance. However, it omits expected behaviors like output format (file listing structure) and error conditions, which a well-rounded description should include.
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 input schema has 100% coverage, providing baseline clarity. The description adds value by explaining when alias is preferred over host and that host can be omitted for single connections, which is not evident from the schema alone.
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 purpose as '列出远程目录内容' (list remote directory contents), which is a specific verb+resource combination. It distinguishes itself from sibling tools like sftp_download or exec by focusing on directory listing.
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 guidance on using alias vs host, and notes that host can be omitted when there is a single active connection. However, it does not explicitly state when to use this tool over alternatives like exec for listing, 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states the basic action and connection hint, but fails to disclose side effects (e.g., behavior if directory already exists, error handling, or permissions required). No annotation 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?
Description is two sentences with no waste, front-loads the main action, and provides essential guidance succinctly.
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?
Despite schema covering all parameters, the description lacks explanation of return values, error behavior, and the purpose of the recursive and targetConfirmationToken parameters. For a tool with 7 parameters and no output schema, this is insufficient.
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?
Input schema has 100% coverage for all 7 parameters. The description adds useful context about when alias/host are needed, going beyond the schema descriptions. However, it does not elaborate on other parameters like recursive or targetConfirmationToken.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states '在远程服务器创建目录' (create directory on remote server), providing a specific verb and resource. It distinguishes from sibling tools like sftp_ls, sftp_rm, and sftp_upload, which have 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Describes when to use alias (recommended) or host to specify the target server, and notes that these can be omitted when there is a single active connection. This provides clear context for usage, though it does not explicitly mention when not to use the tool or point to alternatives.
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, the description must disclose behavioral traits. It mentions the confirmation token for overwriting and recommends setting the environment field. However, it omits details on first-time vs. update behavior, whether partial updates are allowed, return values, error conditions, or security implications, leaving gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first states the primary purpose, the second adds crucial usage guidance. No extraneous information, front-loaded, and every sentence serves a purpose.
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 complexity (12 parameters, no output schema), the description is minimal. It covers the core function and the unique confirmation workflow, but lacks details on return values, error handling, and what happens on failure or partial updates. The schema descriptions are thorough, but the tool description could be more complete for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value by advising to set the environment field to prevent production mishaps and clarifying that confirmationToken is required for overwriting, enriching the context beyond the schema for those two parameters.
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 saves server configuration and credentials. The confirmation token workflow and environment recommendation distinguish it from siblings like connect, exec, and list_servers, making its purpose 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for saving configurations, but it does not explicitly state when to use it versus alternatives (e.g., for updating vs. creating, or when to use remove_server instead). No exclusions or guidance on tool selection are provided, limiting the agent's decision support.
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?
With no annotations, the description should disclose behavioral traits (e.g., what happens to the session, any cleanup, whether it's destructive). The description only states the action without mentioning side effects or safety considerations. For a session-closing tool, this is insufficient.
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 sentences that convey the core purpose and key usage guidance without any fluff. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple close operation with no output schema, the description is largely complete. It identifies the tool's domain (persistent shell sessions) and specifies constraints on parameter usage. A minor gap is the lack of mention of error handling or what happens if the session does not exist, but given the tool's simplicity, this is acceptable.
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 schema covers 100% of parameters with descriptions. The tool description adds value by explaining the recommendation for 'alias' over 'host' and the condition for omitting parameters (single connection). This goes beyond what the schema provides.
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 purpose: closing a persistent shell session. It uses specific terms ('关闭持久化 shell 会话') and distinguishes itself from sibling tools like 'connect' (open), 'disconnect' (likely close all), and 'exec' (execute commands). The verb-resource pair is precise.
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 practical guidance: use 'alias' (recommended) or 'host' to specify the target server, and omitting parameters when there is a single active connection. While it does not explicitly state when not to use the tool or list alternatives, the parameter usage advice is clear and helpful.
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 the full burden of behavioral disclosure. It states that the tool reads the output buffer from a persistent session, implying a non-destructive operation. However, it does not describe what happens if the buffer is empty, whether reading affects the session state beyond the optional clear parameter, or if there are any prerequisites (e.g., an active connection). The description is adequate but not comprehensive.
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 long, front-loaded with the core action. Every phrase serves a purpose: the action, target specification, and a note on omission. There is no wasted text.
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 has 5 parameters, no output schema, and several sibling tools, the description is reasonably complete but lacks details on return format or buffer behavior. It does not explain how the output is presented (e.g., plain text, structured data) or what happens if multiple commands were sent. Still, it covers the essential usage for an agent to select and invoke the tool.
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 input schema covers all parameters (100% coverage), so the baseline is 3. The description adds value by recommending alias over host, and clarifying that host can be omitted when only one connection exists. This provides practical guidance beyond the schema's parameter descriptions. The clear parameter is not mentioned in the description, but the schema already defines it.
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: reading the output buffer of a persistent shell session. It specifies the method to select a target (alias or host) and distinguishes from siblings like shell_send (which sends commands) and exec (which runs new commands). The verb 'read' and resource 'output buffer' are 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 provides guidance on when to use the tool (to read output) and how to specify the target (alias recommended, host as alternative, can omit for single connection). It lacks explicit exclusion scenarios or alternatives to other tools, but the context is clear enough for an agent to determine appropriate use.
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, the description bears full burden. It discloses connection methods and credential override but omits side effects, authentication requirements, or connection lifecycle details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no fluff, front-loaded with purpose. Every sentence contributes meaning.
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?
Covers the two main use cases and parameter relationships well. Lacks details on return values, error handling, or post-connection behavior, but is reasonable for a connection tool.
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 100%, but the description adds value by explaining mutual exclusivity between alias and host+username, and the at-least-one requirement for password/privateKey, as well as override behavior.
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 verb '建立 SSH 连接' and the resource, and distinguishes two connection methods, making it distinct from sibling tools like disconnect or exec.
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 explicitly says '两种方式二选一' and explains when to use alias vs direct connection, including credential override. It provides clear context but does not mention alternatives explicitly.
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 clarifies it is a read-only listing with server tags and aliases. No annotations exist, so the description carries the full burden. It does not explicitly state non-destructive behavior, but it is implied by 'list'.
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?
Single concise sentence, front-loaded with action and scope. No unnecessary words.
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?
For a simple tool with no parameters and no output schema, the description fully covers what the tool does and what information it provides. No gaps.
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?
No parameters exist (0 parameters), so baseline 4 is appropriate. Description adds no parameter-level detail, but none is needed.
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?
Clearly states it lists active SSH connections with server environment tags and alias information. Distinct from sibling tools like 'connect' (establishes connections) and 'list_servers' (shows available servers).
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?
Description implicitly indicates use for identifying connected servers, but does not provide explicit when-to-use or when-not-to-use guidance relative to siblings. A small addition could improve.
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:

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

Score Badge

Copy to your README.md:

[![ssh-mcp-server MCP server](https://glama.ai/mcp/servers/jiahuidegit/ssh-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/jiahuidegit/ssh-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/jiahuidegit/ssh-mcp-server'

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