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., "@claude-ssh-mcp run df -h on production"
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.
MCP addon for Claude Desktop — gives Claude SSH access to your servers.
With pip (auto-installs Node.js if needed):
pip install claude-ssh-mcp
claude-ssh-mcpOr with npm:
npx -y claude-ssh-mcpThat's it. Restart Claude Desktop and you're ready.
Related MCP server: SSH Remote MCP Server
Just talk to Claude naturally:
"Connect to 192.168.1.100 as root with password mypass, call it production"
"Run ls -la /var/www on production"
"Upload C:\Users\me\app.zip to /tmp/app.zip on production"
"Download /var/log/error.log from production"
"Connect to 10.0.0.5 as deploy with key at C:\Users\me.ssh\id_rsa, name it staging"
"Transfer /var/log/app.log from production to /tmp/app.log on staging"
"List my servers"
"Remove staging"
Auto-install — one command adds it to Claude Desktop
Auto-installs Node.js — pip version handles everything
Servers are saved — connect once, reconnect by name
SSH keepalive — connections stay alive during long sessions
Auto-reconnect — recovers from network interruptions
Auto-update — checks for updates every 2 hours
When you tell Claude to connect, the server is saved to ~/.mcp-ssh/servers.json. Next time just say "connect to production".
Edit manually if you prefer:
{
"production": {
"host": "192.168.1.100",
"port": 22,
"username": "root",
"password": "mypass"
},
"staging": {
"host": "10.0.0.5",
"port": 22,
"username": "deploy",
"privateKeyPath": "C:\\Users\\me\\.ssh\\id_rsa"
}
}Tool | What it does |
| Connect to a server (new or saved) |
| Close a connection |
| Show all connections and saved servers |
| Delete a saved server |
| Run a shell command |
| Upload a local file (SFTP) |
| Download a remote file (SFTP) |
| Copy a file between two servers |
| List remote directory contents |
git clone https://github.com/MaraBank/mcp-ssh-server.git
cd mcp-ssh-server
npm install
npm run buildThen in Claude Desktop config (%APPDATA%\Claude\claude_desktop_config.json):
{
"mcpServers": {
"ssh": {
"command": "node",
"args": ["C:\\path\\to\\mcp-ssh-server\\build\\index.js"]
}
}
}MIT — free and open source.
Connect to a remote server via SSH. Provide full details for a new server (it will be saved for next time), or just the sessionName to reconnect to a previously saved server.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Friendly name for this session (e.g. 'production'). If this matches a saved server and no host is given, the saved config is used. | |
| host | No | Hostname or IP address. Omit to connect using a saved server. | |
| port | No | SSH port (default 22) | |
| username | No | SSH username. Omit to use saved server config. | |
| password | No | Password (omit if using key auth) | |
| privateKeyPath | No | Absolute path to a private key file | |
| privateKey | No | Private key contents as a string (not saved to disk) | |
| passphrase | No | Passphrase for the private key, if encrypted |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description bears the full burden of behavioral disclosure. It mentions that a new server is 'saved for next time' but fails to clarify critical traits: whether the connection persists as a session, what the tool returns (e.g., session handle), how authentication methods are prioritized, or error handling. This leaves significant gaps for the agent.
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 extremely concise—two sentences that convey the core functionality without fluff. Every word contributes to understanding the tool's operation, and the structure is front-loaded with the verb 'Connect'.
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 the complexity (8 parameters, no output schema), the description is somewhat complete for the two modes of use. However, it lacks details on connection behavior, session management, and error scenarios, which an agent would need for reliable invocation. It is minimally viable 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 description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema, e.g., no clarification on when to use password vs. privateKey, or precedence among parameters. It is adequate but does not enhance 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 tool's purpose ('Connect to a remote server via SSH') and distinguishes between two modes: providing full details for a new server or using a session name to reconnect to a saved server. It avoids ambiguity with sibling tools by focusing on connection establishment.
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 explains when to provide full details vs. just a sessionName for reconnection, which guides usage. However, it does not explicitly state when not to use this tool (e.g., for file transfer or command execution) or mention sibling tools as alternatives, leaving room for improvement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close an active SSH session.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Name of the session to disconnect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description only states 'Close an active SSH session' without disclosing behavioral details like graceful termination, impact on running processes, or confirmation 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 with no redundant information. Highly concise and front-loaded.
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 a simple tool with one parameter and no output schema, the description is minimally adequate but misses behavioral context such as the requirement that the session must exist and be active.
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 has 100% coverage with description for 'sessionName'. The tool description adds no extra meaning 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 'Close an active SSH session' uses a specific verb (close) and resource (active SSH session), clearly distinguishing it from siblings like ssh_connect (open) and ssh_execute (run command).
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 (e.g., after finishing work, before disconnecting). The description lacks context on prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Download a file from a remote server to the local machine via SFTP.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Session to download from | |
| remotePath | Yes | Absolute path on the remote server | |
| localPath | Yes | Absolute local destination path |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the basic operation. It does not disclose whether the local file is overwritten, if directories are created, authentication requirements, or potential side effects. This is a significant gap.
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 of 10 words, no wasted text. Front-loaded with the core verb and resource, making it immediately scannable.
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?
The tool is simple, but the description lacks details on behavior (e.g., overwrite policy, return value, error handling). Given no output schema, the description should provide more context to ensure safe usage.
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 has 100% coverage for all three required parameters. The description adds no extra meaning beyond the schema descriptions, which are already clear. 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 explicitly states the action (Download), resource (a file), and method (via SFTP). It clearly distinguishes from sibling tools like ssh_upload (opposite direction) and ssh_transfer (potentially bidirectional).
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 is provided on when to use this tool versus alternatives, such as ssh_transfer or when a session must be established first via ssh_connect. The agent is left to infer prerequisites and context.
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 remote server.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Session to run the command on | |
| command | Yes | Shell command to execute |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry behavioral info. Only mentions 'connected remote server', implying a session is needed, but does not disclose behavior such as blocking, output handling, error states, or whether it returns exit codes.
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 and front-loaded. Could be more informative while remaining concise.
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?
No output schema and no annotations. The description lacks details on output format (stdout/stderr), whether it returns any data, or if an active session is required. Incomplete for a command execution tool.
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% (both parameters have descriptions). The description adds no extra meaning beyond the schema; 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?
Description clearly states the verb 'Execute' and the resource 'command on a connected remote server'. It differentiates from sibling tools like ssh_download by specifying execution, but does not explicitly contrast with other 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 like ssh_transfer or ssh_list_files. No mention of prerequisites (e.g., need to establish a session via 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 path via SFTP.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Session to list files on | |
| remotePath | Yes | Absolute directory path 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 cover behavioral traits. It only states the action but omits important details like requiring an active session, output format, error behavior, or permission needs. This is insufficient for an agent to understand side effects or constraints.
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 efficiently conveys the purpose without redundancy. Every word earns its place, making it highly scannable and well-structured.
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 listing tool, the description covers the core action but lacks details about the return format (e.g., file names, metadata). Without an output schema, this omission could cause ambiguity. It is adequate but not fully complete.
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 good descriptions for both parameters. The description adds marginal value beyond the schema, reinforcing the purpose but not providing new semantic details. Baseline score of 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 it lists files and directories via SFTP, distinguishing it from sibling tools like ssh_download, ssh_upload, and ssh_execute which perform different actions. The verb 'List' and resource 'files and directories' are specific.
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 for listing remote directories but does not provide explicit when-to-use or when-not-to-use guidance relative to siblings. No alternatives or exclusions are mentioned.
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 and saved servers.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavior. It states 'list all' indicating a read operation, but lacks details on side effects, authorization, or output specifics. For a simple list tool, this is adequate but not enriching.
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 8-word sentence with no superfluous information. It is front-loaded and every word adds value.
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 tool with no parameters and no output schema, the description covers the basic functionality completely. It could mention what information is returned (e.g., session IDs, hostnames), but is sufficient for a simple list 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?
The input schema has zero parameters and 100% coverage, so baseline is 3. The description adds no parameter-specific semantics beyond the obvious fact that no inputs are 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 specific verb 'list' and defines the resource as 'active SSH sessions and saved servers', clearly distinguishing it from sibling tools like ssh_connect or ssh_disconnect which perform different actions.
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?
While no explicit when-to-use or when-not-to-use guidance is given, the description's simplicity implies it's for viewing current sessions and saved servers without modification. A clear context for its use is present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove a saved server from servers.json and disconnect if currently active.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Name of the server to remove |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully explains the two behaviors: removal from servers.json and disconnection if active. This is explicit about the destructive action. Minor omissions: no mention of undo or error handling.
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, front-loaded with verb and object, no unnecessary words. Highly concise and effective.
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 removal tool with one parameter and no output schema, the description covers core behavior. Missing are error cases, return value, and confirmation, but given low complexity, it is mostly complete.
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 description for sessionName is clear. The tool description adds no extra parameter context beyond the schema, so baseline of 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 the action 'Remove' and the resource 'saved server from servers.json', and adds the disconnection behavior. It easily distinguishes from sibling tools like ssh_connect, ssh_disconnect, and ssh_list_sessions.
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 specify when not to use, prerequisites, or compare with ssh_disconnect or ssh_list_sessions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Transfer a file between two connected remote servers (source → destination) via SFTP.
| Name | Required | Description | Default |
|---|---|---|---|
| sourceSession | Yes | Session name of the source server | |
| sourceRemotePath | Yes | Absolute file path on the source server | |
| destinationSession | Yes | Session name of the destination server | |
| destinationRemotePath | Yes | Absolute file path on the destination server |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations present, and description lacks behavioral details such as whether files are copied or moved, overwrite behavior, error handling, or that transfers happen server-to-server without client involvement.
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 conveys the core action efficiently with no redundancy.
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?
No output schema, annotations missing, and description fails to explain return values, success/failure signals, or that sessions must be active, leaving significant gaps for a transfer 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 descriptions cover all 4 parameters, but the tool description adds no extra meaning beyond the schema, such as explaining 'session name' or linking to ssh_connect.
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?
Description clearly states it transfers a file between two remote servers via SFTP, distinguishing it from siblings like ssh_download and ssh_upload which involve local machine transfers.
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, no mention of prerequisites like needing pre-established sessions, and no exclusions provided.
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 a remote server via SFTP.
| Name | Required | Description | Default |
|---|---|---|---|
| sessionName | Yes | Session to upload to | |
| localPath | Yes | Absolute path to the local file | |
| remotePath | Yes | Absolute destination path on the remote server |
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 the protocol (SFTP) but omits critical details such as overwrite behavior, permission requirements, directory creation, or the need for an active session.
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 8 words. Every word is necessary, and there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although the tool has only 3 parameters and no output schema, the description fails to mention return values, error handling, or prerequisites (e.g., needing an active session via ssh_connect). This leaves an agent uncertain about the tool's full behavior.
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%, so the baseline is 3. The description does not add any additional meaning or examples beyond the schema's parameter descriptions.
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 (Upload), the resource (a local file), the destination (a remote server), and the protocol (via SFTP). It effectively distinguishes from siblings like ssh_download, which does the opposite.
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 when a file needs to be uploaded to a remote server, but it does not explicitly state when to use this tool versus alternatives like ssh_transfer, nor does it mention any prerequisites or restrictions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.1ssh_connectssh_disconnectssh_downloadssh_executessh_list_filesssh_list_sessionsssh_remove_serverssh_transferssh_uploadEach tool targets a distinct operation: connect, disconnect, execute commands, file transfers, listing, and server management. No two tools have overlapping purposes.
All tools follow the consistent pattern 'ssh_verb' or 'ssh_verb_noun' (e.g., ssh_connect, ssh_list_files, ssh_remove_server). No mixing of conventions.
With 9 tools, the set covers essential SSH operations without being bloated. Each tool serves a clear need for remote server management.
The surface provides full lifecycle management: connect/disconnect, command execution, file upload/download/transfer, listing, and session tracking. No obvious gaps for the domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Connect Claude to your Platform7n workspaces — chat, links, and tasks. One-click OAuth.
Scoped, audited SSH exec, sessions, and SFTP on your saved servers without exposing credentials
Connect Claude to Fathom meeting recordings, transcripts, and summaries
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/MaraBank/mcp-ssh-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
