Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@SSH MCP Server connect to user@example.com and check the status of nginx"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server that provides SSH access with Warp-like terminal experience. Connect to remote servers, execute commands, transfer files, and manage interactive shell sessions.
npm install -g @kpanuragh/ssh-mcpOr run directly with npx:
npx @kpanuragh/ssh-mcpRelated MCP server: SSH MCP Server
SSH Connection Management - Multiple concurrent connections with session persistence
Command Execution - Run commands with stdout/stderr capture and exit codes
SFTP Operations - Upload, download, and list files on remote servers
Interactive Shell - PTY-based shell sessions for interactive commands
Authentication - Support for both password and SSH key authentication
Tool | Description |
| Establish SSH connection to a remote server |
| Execute a command on connected server |
| Close an SSH session |
| List all active SSH sessions |
| Upload a file to remote server |
| Download a file from remote server |
| List files in remote directory |
| Start interactive shell session |
| Send input to interactive shell |
| Read output from interactive shell |
| Close interactive shell session |
Add to your claude_desktop_config.json:
{
"mcpServers": {
"ssh": {
"command": "npx",
"args": ["@kpanuragh/ssh-mcp"]
}
}
}{
"tool": "ssh_connect",
"arguments": {
"host": "example.com",
"username": "user",
"password": "password"
}
}Or with SSH key:
{
"tool": "ssh_connect",
"arguments": {
"host": "example.com",
"username": "user",
"privateKeyPath": "/home/user/.ssh/id_rsa"
}
}{
"tool": "ssh_exec",
"arguments": {
"sessionId": "uuid-from-connect",
"command": "ls -la"
}
}{
"tool": "sftp_upload",
"arguments": {
"sessionId": "uuid-from-connect",
"localPath": "/local/file.txt",
"remotePath": "/remote/file.txt"
}
}{
"tool": "ssh_shell_start",
"arguments": {
"sessionId": "uuid-from-connect"
}
}{
"tool": "ssh_shell_send",
"arguments": {
"sessionId": "uuid-from-connect",
"shellId": "shell-uuid",
"input": "cd /var/log\n"
}
}{
"tool": "ssh_disconnect",
"arguments": {
"sessionId": "uuid-from-connect"
}
}MIT
Download a file from the remote server via SFTP
| Name | Required | Description | Default |
|---|---|---|---|
| localPath | Yes | Local destination path for the downloaded file | |
| sessionId | Yes | Session ID from ssh_connect | |
| remotePath | Yes | Path to the file on the remote server |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. However, it only states the basic action. It does not mention whether the file is overwritten locally, what happens on error, or any 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence. It is front-loaded with the key action, but lacks additional details. It is appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and limited description, the tool definition is incomplete. It does not specify return values, error behavior, or constraints (e.g., size limits). For a file transfer operation, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema already contains descriptions for all three parameters. The tool description adds no additional information beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Download a file from the remote server via SFTP' clearly states the verb 'download' and the resource 'file from remote server via SFTP'. It distinguishes from sibling tools like sftp_upload and sftp_list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives like sftp_upload or ssh_exec. No prerequisites are mentioned (e.g., need for an active session from ssh_connect).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List files and directories in a remote directory via SFTP
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes | Session ID from ssh_connect | |
| remotePath | Yes | Path to the remote directory to list |
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 only states the operation is a list, but fails to disclose error handling (e.g., invalid path or session), return format, or that it is a read-only operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the action and resource. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool, the description is adequate but incomplete: it does not describe the output format, which would be helpful since no output schema exists. It also omits the need for an active session, though the parameter description implies it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema descriptions for both parameters are clear. The description adds no additional semantic context beyond what the schema already provides, resulting in a baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is specific: it lists files and directories in a remote directory via SFTP. It clearly distinguishes from sibling tools like ssh_exec (execute commands) and sftp_upload/download (file transfer).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It does not mention prerequisites like establishing an SFTP session via ssh_connect, nor does it provide context for when listing is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload a local file to the remote server via SFTP
| Name | Required | Description | Default |
|---|---|---|---|
| localPath | Yes | Path to the local file to upload | |
| sessionId | Yes | Session ID from ssh_connect | |
| remotePath | Yes | Destination path on the remote server |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations; description fails to disclose behavior like overwrite policy, error handling, or session requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, concise, but somewhat under-described.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lacks crucial behavioral and contextual details for a tool with no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters with descriptions; tool description adds no extra semantics beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool uploads a local file remotely via SFTP, distinguishing it from siblings like sftp_download. However, it could mention it requires an active session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use or prerequisites compared to sibling tools. Important context like needing an active session from ssh_connect is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Establish an SSH connection to a remote server. Returns a session ID for subsequent operations.
| Name | Required | Description | Default |
|---|---|---|---|
| host | Yes | Hostname or IP address of the SSH server | |
| port | No | SSH port (default: 22) | |
| password | No | Password for authentication (use this OR privateKey/privateKeyPath) | |
| username | Yes | Username for SSH authentication | |
| passphrase | No | Passphrase for encrypted private key | |
| privateKey | No | Private key content as string (use this OR password OR privateKeyPath) | |
| privateKeyPath | No | Path to private key file (use this OR password OR privateKey) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must fully convey behavior. It states connection establishment and session ID return but omits details like connection timeout, authentication method priority when multiple are provided, or any side effects other than opening a connection.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two focused sentences with no superfluous information. Front-loaded with purpose, immediately followed by key output (session ID). Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has 7 parameters including complex authentication choices (password vs privateKey vs privateKeyPath) and no output schema. Description does not clarify authentication precedence, return value format, or error conditions, leaving significant gaps for agent decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, adequately explaining parameters. Tool description adds no extra meaning beyond what's already in schema definitions. Baseline 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Establish', the resource 'SSH connection to a remote server', and the output 'Returns a session ID'. It distinguishes from sibling tools like ssh_exec, ssh_disconnect, etc., which handle post-connection operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. Does not mention prerequisites (e.g., must have credentials) or when not to use (e.g., if you only need file transfer via SFTP). Sibling tools like sftp_upload are distinct but no comparative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close an SSH session and clean up resources
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | Yes | Session ID to disconnect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It mentions 'clean up resources' but does not detail side effects, error conditions (e.g., invalid sessionId), or required permissions. For a disconnection tool, more context about resource management is expected.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words. It is front-loaded with the verb and object, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description is mostly adequate. It covers the core purpose but could benefit from mentioning that the session must be active or what happens if it's already disconnected.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (one parameter with description). The description does not add meaning beyond the schema's 'Session ID to disconnect'. Baseline score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Close an SSH session') and the scope ('clean up resources'). It differentiates from sibling tools like ssh_connect, ssh_exec, and ssh_list_sessions by focusing on disconnection and cleanup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage after a session is established but does not explicitly state when to use this tool versus alternatives (e.g., ssh_shell_close for shell sessions). No guidance on prerequisites 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.
Execute a command on a connected SSH server. Returns stdout, stderr, and exit code.
| Name | Required | Description | Default |
|---|---|---|---|
| cwd | No | Working directory for the command | |
| env | No | Environment variables as key-value pairs | |
| pty | No | Allocate a PTY for the command (useful for interactive commands) | |
| command | Yes | Command to execute on the remote server | |
| sessionId | Yes | Session ID from ssh_connect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the return values (stdout, stderr, exit code) but does not disclose potential side effects on the remote server, permissions context, timeout behavior, or that the command runs with the SSH user's privileges. This is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It efficiently communicates the core purpose and output. Every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description correctly notes the return format. However, it lacks information about behavioral aspects like destructiveness, timeout limits, or prerequisites (active session). For a command execution tool with many siblings, this is minimally adequate but could be improved.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% documentation coverage, so the baseline is 3. The description does not add any additional meaning to parameters; it only summarizes the overall function. No extra guidance on parameter usage is provided beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the verb 'Execute', the resource 'command on a connected SSH server', and the output 'stdout, stderr, and exit code'. It clearly distinguishes from sibling tools like ssh_connect, ssh_shell_*, and sftp_*, 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit guidance on when to use this tool versus alternatives. It is implied that this is for non-interactive commands, but there is no mention of prerequisites (e.g., needing an active session from ssh_connect) or when to use shell tools instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all active SSH sessions
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior. It only states 'List all active SSH sessions' without detailing what information is returned (e.g., session IDs, users, IPs) or any side effects. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It is front-loaded, but could be slightly more informative without sacrificing brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description should explain the return value (e.g., format of session list). It does not, leaving the agent unsure of what to expect. The tool is simple, but completeness is lacking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so schema coverage is trivially 100%. The description does not add parameter semantics, but baseline is 3 as per guidelines for high schema coverage. No additional value is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'List' and resource 'active SSH sessions', clearly stating the tool's function. It is easily distinguishable from siblings like ssh_connect or ssh_exec, which perform different operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 scenarios such as monitoring sessions before connecting or disconnecting, which would help an agent decide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close an interactive shell session
| Name | Required | Description | Default |
|---|---|---|---|
| shellId | Yes | Shell ID from ssh_shell_start | |
| sessionId | Yes | Session ID from ssh_connect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits (e.g., side effects, prerequisites). Only states 'Close an interactive shell session', omitting whether it requires an active session or what happens afterwards.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single 5-word sentence, front-loaded with verb and object, no wasted words. Highly concise and focused.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Simple tool with two well-documented parameters and no output schema. However, missing return value or error information is a minor gap for such an operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear references to other tools (ssh_shell_start, ssh_connect). The description adds no extra meaning, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Close an interactive shell session' clearly states the action (close) and the resource (interactive shell session), distinguishing it from siblings like ssh_shell_start or ssh_shell_read.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like ssh_disconnect or when closing a shell is appropriate. The description lacks context for selecting this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read output from an interactive shell session
| Name | Required | Description | Default |
|---|---|---|---|
| clear | No | Clear the output buffer after reading (default: true) | |
| shellId | Yes | Shell ID from ssh_shell_start | |
| sessionId | Yes | Session ID from ssh_connect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry the burden. It fails to disclose behavior like buffer clearing (only hinted in schema's clear parameter) or whether reading blocks.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no redundancy. However, it could benefit from slight expansion for context without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Missing lifecycle context: does not explain the interactive shell workflow (start, send, read, close). No output schema, and description alone insufficient for a 3-parameter tool with unclear behavioral expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter descriptions. The description adds no additional meaning beyond what the schema already provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Read output from an interactive shell session,' providing a specific verb and resource. It distinguishes from siblings like ssh_shell_send (input) and ssh_exec (command execution).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 like ssh_exec. Does not mention prerequisites (e.g., need ssh_shell_start) 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.
Send input to an interactive shell session
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Input to send to the shell (include \n for Enter) | |
| shellId | Yes | Shell ID from ssh_shell_start | |
| sessionId | Yes | Session ID from ssh_connect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits but only states the basic action. It does not mention effects on the shell, statefulness, or how input formatting works (the hint is only in the schema).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise (one sentence) with no fluff. However, it could include a brief usage hint without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with full schema coverage and no output schema, the description is minimally adequate. It explains the core action but lacks contextual guidance on usage flow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter descriptions, so baseline is 3. The description adds no extra meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('send input') and resource ('interactive shell session'), clearly distinguishing it from sibling tools like ssh_exec which runs non-interactive commands.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., ssh_exec). Prerequisites like starting a shell with ssh_shell_start are not mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start an interactive shell session. Returns a shell ID for sending commands and reading output.
| Name | Required | Description | Default |
|---|---|---|---|
| cols | No | Terminal width in columns (default: 80) | |
| rows | No | Terminal height in rows (default: 24) | |
| sessionId | Yes | Session ID from ssh_connect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only states the basic action and return value. It omits crucial details like whether the shell is blocking, timeout behavior, resource cleanup, or error handling for invalid sessionId.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with front-loaded purpose. No unnecessary words, but could include a brief note about lifecycle or prerequisites without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters, no output schema, and 10 siblings, the description covers starting a shell but fails to mention lifecycle (e.g., must call ssh_shell_close). It doesn't clarify that cols/rows are optional. Acceptable but not thorough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 no additional meaning beyond the schema's parameter descriptions. Each parameter (sessionId, cols, rows) is adequately documented in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Start', the resource 'interactive shell session', and the output 'shell ID for sending commands and reading output'. This distinguishes it from siblings like ssh_exec (non-interactive) and ssh_connect (establishes connection).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies interactive use via 'shell ID for sending commands and reading output', but lacks explicit guidance on when to use this vs. alternatives like ssh_exec. It does not mention prerequisites (e.g., session from ssh_connect) 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.
Each tool targets a distinct operation: connection management, command execution, file transfer, or interactive shell. No two tools overlap in purpose.
All tool names follow a consistent prefix pattern (ssh_, sftp_, ssh_shell_) with snake_case and verb_noun structure, making them predictable.
11 tools is well-scoped for an SSH server covering connection, execution, file operations, and interactive shell. Each tool serves a clear purpose without bloat.
Covers core SSH workflows (connect, exec, disconnect) and SFTP operations. Lacks SSH-native file listing (only SFTP) and advanced features like port forwarding, but basic coverage is solid.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Scoped, audited SSH exec, sessions, and SFTP on your saved servers without exposing credentials
Run commands and read/write files on your servers over Termalin's keyless tunnels (hosted MCP).
Remote shell and detached long-running jobs on your own machines — no SSH, open ports or VPN.
Let AI operate servers without SSH. Choose actions, approve risky changes, and audit every step.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/kpanuragh/ssh-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
