What can you do with this server?

This server lets AI coding agents deploy and manage files on their own FTP/FTPS/SFTP servers. * List configured servers (ftp_list_servers) — see name, protocol, host, port, root, read-only state, and auth kind without ever exposing credentials. * Test connectivity (ftp_test) — connect, list the root directory, and confirm the server is reachable. * List remote directories (ftp_list) — browse folder contents, with directories shown first. * Read remote text files (ftp_read) — fetch file contents directly into the conversation (binary files are refused). * Upload files (ftp_upload) — push a local file, auto-creating parent directories. * Deploy whole directories (ftp_deploy) — recursively upload a local folder over a single connection, with gitignore-like include/exclude globs and a read-only dry-run mode. * Download files (ftp_download) — pull remote files locally, protecting against accidental overwrites. * Create directories (ftp_mkdir) — make one or more nested remote folders. * Rename or move entries (ftp_rename) — relocate files or folders on the server. * Delete files or directories (ftp_delete) — remove a file, or recursively remove a directory (never the server root). It enforces security by design: a path jail confines all operations under each server's root, a read-only mode blocks all writes on protected servers, and credentials never enter the model's context or tool output.

Which integrations are available for this server?

Allows AI agents to deploy and manage files on Hostinger FTP/FTPS/SFTP hosting, including uploads, downloads, directory listings, and deletions. Allows AI agents to deploy and manage files on Ionos FTP/FTPS/SFTP hosting, including uploads, downloads, directory listings, and deletions. Allows AI agents to deploy and manage files on OVH FTP/FTPS/SFTP hosting, including uploads, downloads, directory listings, and deletions.

How do I use ftp-deploy-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ftp-deploy-mcp deploy ./build to staging" 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.

de en es ja ko ru zh

ftp-deploy-mcp

by alebgl77

Overview Schema Related Servers Score Discussions

JavaScript

Remote

ftp-deploy-mcp

The deploy button for AI coding agents.

Give Claude Code, Claude Desktop, Cursor, Windsurf, Trae, Antigravity, or any MCP client a focused way to list, read, upload, download, and deploy files on your own FTP, FTPS, and SFTP servers.

Version française → README.fr.md

License: MIT Node >=18 MCP compatible

Purpose-built deployment controls keep credentials out of tool responses, support read-only servers and dry runs, and limit local file access with localRoot. The repository is covered by an extensive end-to-end suite that runs against local FTP and SFTP servers. There is no telemetry.

Availability: install from source today. The npm package and MCP registry entry have not been published yet, so npx -y ftp-deploy-mcp and registry-based installation will not work until the first release is announced. Existing Glama and MCP Index pages are discovery listings, not proof that an installable package is available. Package and server metadata are aligned at release candidate 0.2.0, pending publication.

First source install

Install Node.js 18 or newer.
Run git clone https://github.com/alebgl77/ftp-deploy-mcp.git, then cd ftp-deploy-mcp.
Run npm install.
Run npm run setup, then edit the generated server config: set an absolute localRoot, replace credentials, and configure the SFTP host-key pin or the FTP/FTPS safety acknowledgments described below.
Restart the MCP client and try a dry run:

Call ftp_deploy with:
{"server":"prod","local_dir":"dist","remote_dir":"/","dry_run":true}

Windows users can run install.cmd and macOS/Linux users can run ./install.sh instead of steps 3–4. Review every generated server entry before the first connection.

Related MCP server: mcp-remote-ssh

Protocol and security matrix

Protocol	Transport identity	Remote-root behavior	Recommended use
SFTP	Encrypted. `hostKeySha256` is required unless `allowUnknownHostKey: true` explicitly accepts impersonation risk.	`realpath`/`lstat` checks refuse symlink components and keep operations below `root`. A malicious or changing server can still create a race between validation and use.	Preferred. Pin a fingerprint verified out of band.
FTPS	Encrypted when certificate verification succeeds. `insecureTLS: true` also requires `allowInsecure: true` and disables MITM protection.	A client-side sub-root cannot be a reliable anti-symlink jail. `root` other than `/` is refused unless `allowUnsafeRemoteRoot: true`.	Use a dedicated, server-side chrooted account whose visible root is `/`.
FTP	Plaintext. Refused unless `allowInsecure: true` accepts interception and credential exposure.	Same limitation as FTPS: the real boundary is the server account/chroot, not lexical client path checks.	Legacy-only, on a trusted network, with a dedicated chrooted account.

All three protocols also enforce localRoot for ftp_upload, ftp_deploy, and ftp_download. This limits which local files the MCP server can access.

What you get

Ten focused MCP tools for server discovery, testing, listing, reading, uploading, recursive deploys, downloading, creating directories, renaming, and deleting.
Multiple named servers in one local configuration.
Gitignore-like deploy exclusions, dry-run, and per-server readOnly mode.
FileZilla import, an interactive setup wizard, and a read-only doctor command.
Credentials loaded locally from the config, environment variables, or SSH keys and never intentionally returned to the model.

Server configuration

The first configuration found wins:

--config <path>
FTP_MCP_CONFIG
./ftp-servers.json
~/.ftp-mcp/servers.json

The teaching example below is JSON with comments. Real configuration files must be strict JSON; start from ftp-servers.example.json.

{
  "defaultServer": "prod",
  "servers": {
    "prod": {
      "protocol": "sftp",
      "host": "ssh.example.com",
      "port": 22,
      "user": "deploy",
      "password": "${ENV:PROD_PASSWORD}",
      "privateKeyPath": "~/.ssh/id_ed25519",
      "passphrase": "${ENV:PROD_KEY_PASSPHRASE}",
      "localRoot": "/home/alice/projects/site",
      "root": "/var/www/site",
      "hostKeySha256": "SHA256:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
      "readOnly": false
    }
  }
}

Replace the all-A fingerprint; it is deliberately non-functional for a real host. Use hostKeySha256 as an array during a controlled key rotation:

"hostKeySha256": [
  "SHA256:old_verified_43_character_base64_value_here",
  "SHA256:new_verified_43_character_base64_value_here"
]

The illustrative labels above show the shape but are not valid pins. Each real entry is exactly SHA256: plus 43 characters of unpadded base64.

Field reference

Field	Applies to	Meaning
`protocol`	all	Required: `ftp`, `ftps`, or `sftp`.
`host` / `port` / `user`	all	Connection endpoint and account. Default ports are 21, 990 for implicit FTPS, and 22 for SFTP.
`password`	all	Password or `${ENV:NAME}` placeholder.
`privateKeyPath` / `passphrase`	SFTP	SSH private key path and optional passphrase. A leading `~` is expanded. These authenticate the user; they do not verify the server.
`localRoot`	all	Required for upload, deploy, and download. Must resolve to an existing absolute local directory; a leading `~` is supported. Relative and symlink/junction escapes are refused. Relative tool paths resolve inside it, and absolute tool paths must still remain inside it.
`root`	all	Remote root, default `/`. Tool paths are resolved below it. SFTP performs server-side realpath/lstat checks. FTP/FTPS need a server-side chroot for a trustworthy boundary.
`hostKeySha256`	SFTP	Required fingerprint string or non-empty array of pins. Format: `SHA256:<43-character unpadded base64>`. Cannot be combined with `allowUnknownHostKey`.
`allowUnknownHostKey`	SFTP	Emergency compatibility override. `true` accepts an unverified server identity and visibly warns on results.
`readOnly`	all	Blocks upload, deploy, mkdir, rename, and delete. A deploy dry run remains available.
`implicitTLS`	FTPS	Uses implicit TLS, normally on port 990.
`insecureTLS`	FTPS	Disables certificate verification. Requires `allowInsecure: true`.
`allowInsecure`	FTP/FTPS	Explicitly accepts plaintext FTP or unverified FTPS. It does not make the connection secure.
`allowUnsafeRemoteRoot`	FTP/FTPS	Allows a `root` other than `/` despite the unresolved symlink-escape risk. Use only when the server-side account boundary is understood.

Any string can contain ${ENV:VARIABLE_NAME}. Missing variables produce a named configuration error.

Verify an SFTP fingerprint out of band

Do not trust a fingerprint obtained only through the connection you are about to verify.

Obtain the SHA-256 host-key fingerprint from the hosting provider's authenticated control panel or support channel, or from an administrator through a separately authenticated channel.
If you administer the host, use its trusted console to run a command such as ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub -E sha256.
Compare the complete SHA256:... value before putting it in hostKeySha256. ssh-keyscan may collect a candidate key, but by itself it does not authenticate that key.

For rotation, verify the new fingerprint out of band, temporarily configure both old and new pins, rotate the server key, confirm connections use the expected key, then remove the old pin. Do not use allowUnknownHostKey as a rotation shortcut.

Tool reference

All remote path arguments are relative to the configured remote root. The server parameter is optional when defaultServer is set or only one server exists.

Tool	Main parameters	Purpose
`ftp_list_servers`	none	Show server metadata and active safety warnings, never passwords.
`ftp_test`	`server?`	Connect and list the visible root.
`ftp_list`	`server?`, `path?`, `limit?`, `offset?`	List a remote directory. `limit` defaults to 50 (1–200); `offset` defaults to 0.
`ftp_read`	`server?`, `path`, `max_bytes?`	Read a bounded text file; binary data is refused.
`ftp_upload`	`server?`, `local_path`, `remote_path?`	Upload one file from `localRoot`.
`ftp_deploy`	`server?`, `local_dir`, `remote_dir?`, `include?`, `exclude?`, `dry_run?`	Recursively deploy a directory from `localRoot`.
`ftp_download`	`server?`, `remote_path`, `local_path`, `overwrite?`	Download into `localRoot`.
`ftp_mkdir`	`server?`, `path`	Create a remote directory recursively.
`ftp_rename`	`server?`, `from_path`, `to_path`	Rename or move.
`ftp_delete`	`server?`, `path`, `recursive?`	Delete a file or, with explicit recursion, a directory.

Response compatibility, pagination, and annotations

ftp_list returns one page instead of an unbounded directory listing. Its successful response includes total, count, offset, limit, has_more, and next_offset pagination fields. For example, a request with {"server":"prod","path":"/assets","limit":2,"offset":2} may include the following intentionally non-exhaustive excerpt. It omits the required top-level server, path, and security_warning fields and the required per-entry size_bytes and modified_at fields:

{
  "structuredContent": {
    "entries": [
      { "name": "app.css", "type": "file" },
      { "name": "app.js", "type": "file" }
    ],
    "total": 6,
    "count": 2,
    "offset": 2,
    "limit": 2,
    "has_more": true,
    "next_offset": 4
  }
}

The existing human-readable content text is retained for compatibility. On success, every tool except ftp_read also advertises an MCP outputSchema and returns matching structuredContent; ftp_read remains a bounded text-only tool. Tool errors remain isError responses with text content and no structuredContent.

All tools publish MCP annotations describing read-only, destructive, idempotent, and open-world behavior. These annotations are client hints, not a security boundary; enforce access with server credentials, readOnly, localRoot, and the protocol controls described above. ftp_deploy structured results contain a summary and bounded samples, not exhaustive file lists.

ftp_deploy is not a transaction. If one or more transfers fail, the tool returns an MCP error with a partial-deployment summary; files transferred before the failure are not rolled back.

Default deploy exclusions include node_modules, .git, environment files, logs, OS metadata, ftp-servers.json, and .ftp-mcp content at any depth.

Client setup

npm run setup detects supported clients, creates timestamped backups before changing existing client configuration, and prints a block for UI-only clients. To wire a client manually, replace the path below with the absolute path to this checkout:

{
  "mcpServers": {
    "ftp": {
      "command": "node",
      "args": ["/absolute/path/to/ftp-deploy-mcp/src/index.js"]
    }
  }
}

Common locations include .mcp.json for Claude Code, ~/.cursor/mcp.json for Cursor, and ~/.codeium/windsurf/mcp_config.json for Windsurf. Claude Desktop and other clients accept the same command/arguments structure through their MCP settings.

After the first npm release is verified, this source command can be replaced with npx -y ftp-deploy-mcp. It is intentionally not presented as a working installation method today.

FileZilla import and diagnostics

node src/index.js import-filezilla --file /path/sitemanager.xml --out ./ftp-servers.json
npm run doctor

Imported passwords may be decoded into plaintext. Keep the output outside version control, restrict its permissions, add localRoot, and review every insecure-transport or FTP/FTPS remote-root warning before connecting. doctor is read-only and reports configuration and client wiring without printing passwords.

Migrating from v0.1 to the unreleased v0.2

The source checkout contains v0.2 work, but no v0.2 package or registry release exists yet.

Add an absolute localRoot to every server used by upload, deploy, or download.
For every SFTP server, add an out-of-band-verified hostKeySha256. Use allowUnknownHostKey: true only as a temporary, explicit risk acceptance; do not configure both fields.
For FTP/FTPS, prefer a dedicated server-side chroot whose visible root is / and set root to /. A non-root client path now requires allowUnsafeRemoteRoot: true and remains unsafe against server-side symlinks.
Treat a failed ftp_deploy as a partial deployment: inspect its summary and reconcile the remote tree before retrying.
Re-run npm run setup or update the MCP client command to this checkout, then run npm run doctor and a dry run.

Atomic replacement for newly written sensitive configuration is a v0.2 release gate, not a guarantee of the 0.2.0 release-candidate metadata in this checkout. See docs/RELEASE.md before cutting a release.

Security and limitations

The strongest FTP/FTPS boundary is the server's own account isolation or chroot. Client-side normalization rejects obvious traversal, but FTP lacks portable REALPATH/LSTAT primitives and cannot prove that a server-side symlink stays inside a configured sub-root.
SFTP verifies the host pin and rejects symlink components using realpath/lstat. A server controlled by an attacker can still change filesystem state between checks and operations.
readOnly reduces accidental writes through this MCP server; it is not a substitute for read-only credentials enforced by the remote server.
FTP, insecureTLS, allowUnknownHostKey, and allowUnsafeRemoteRoot are explicit risk acceptances, not security features.

Read the full security model and private disclosure policy.

Development

npm test
node src/index.js --version
node src/index.js --help

The test suite uses local FTP and SFTP servers and does not require an external network. Contributions are welcome; see CONTRIBUTING.md. Maintainers should use the release guide. A reproducible, externally hosted read-only agent evaluation is documented in evaluations/README.md.

License

MIT — see LICENSE.

Available Tools

8 tools

ftp_deleteDelete a remote file or directoryA

Delete a remote file, or a directory when recursive:true. Never deletes the server root.

ParametersJSON Schema

Name	Required	Description
`path`	Yes	Remote path to delete, relative to the server root.
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.
`recursive`	No	Required to delete a directory and its contents.

TDQS

A3.9/5.0

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 the recursive behavior for directories and a safety guarantee about not deleting server root. However, it does not mention error handling, confirmation requirements, or return values, leaving gaps for a destructive operation.

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, front-loaded with the primary function, and a second sentence for an important safety constraint. No extraneous 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 the essential behavior and a key constraint, but lacks details on return values, error conditions, or what happens when path does not exist. For a destructive operation without output schema, more completeness would be beneficial.

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% with good parameter descriptions. The tool description adds value by explicitly linking the 'recursive' parameter to directory deletion and adding the safety constraint about server root, which is not in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the action (delete) and the resource (remote file or directory), with a condition for directories (recursive:true). Distinguishes from sibling tools which perform different operations like list, upload, download.

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?

Provides implicit usage via the description of functionality, but no explicit when-to-use or when-to-avoid compared to siblings. The safety note 'Never deletes the server root' offers a constraint but not usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_deployDeploy a local directoryA

Recursively upload a local directory to the server over a single connection, applying default and custom exclude globs (and optional include globs). Supports dry_run.

ParametersJSON Schema

Name	Required	Description
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.
`dry_run`	No	If true, list what would be uploaded without connecting.
`exclude`	No	Extra glob patterns to exclude, added to the built-in defaults.
`include`	No	Glob patterns; when given, a file must match at least one to be uploaded.
`local_dir`	Yes	Local directory to deploy (relative paths resolve against the process cwd).
`remote_dir`	No	Destination remote directory, relative to the server root. Defaults to the root.

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description reveals some behaviors (recursive upload, single connection, glob application, dry_run) but omits details like default excludes, error handling, permission requirements, and return values. The mention of default excludes is helpful 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?

Two concise sentences front-load the main action and critical features (recursive upload, connection, globs, dry_run). No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the main functionality for a moderately complex tool (6 params, no output schema), but lacks details on default excludes, error behavior, and return values. It does not fully compensate for missing annotations.

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 clear parameter descriptions. The description adds context about recursion and glob behavior, but adds little beyond the schema's own descriptions. Baseline of 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 the verb 'upload' and the resource 'local directory', and highlights key features: recursive, single connection, exclude/include globs, dry_run. It distinguishes from sibling tools like ftp_upload (single file) and ftp_download.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for bulk deployment via 'recursively upload a local directory' and 'over a single connection', but does not explicitly state when to use versus alternatives. No when-not or exclusion guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_downloadDownload a remote fileA

Download a remote file to a local path, auto-creating local parent directories. Refuses to overwrite unless overwrite:true.

ParametersJSON Schema

Name	Required	Description
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.
`overwrite`	No	Allow overwriting an existing local file.
`local_path`	Yes	Local destination path (relative paths resolve against the process cwd).
`remote_path`	Yes	Remote file path, relative to the server root.

TDQS

A3.9/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses two important non-obvious behaviors: auto-creating parent directories and refusing overwrite unless overwrite:true. It does not mention error handling or return value, but the core behaviors are well-covered.

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 concise sentences with no fluff. It is front-loaded with the main action and immediately provides key constraints.

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 no output schema, the description could mention the return value or success status. However, it adequately describes the side effects (auto-create directories, overwrite behavior). It does not cover what happens on error or missing remote file, which 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 baseline is 3. The description adds context about auto-creating directories and overwrite behavior, but does not add parameter-specific details 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 it downloads a remote file to a local path, and adds key behaviors (auto-creating parent directories, overwrite guard). This distinguishes it from siblings like ftp_upload, ftp_list, ftp_delete, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage (download vs upload), but does not explicitly mention when to use this tool versus alternatives like ftp_deploy or ftp_list. No exclusion or alternative tool names are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_listList a remote directoryB

List the contents of a remote directory (relative to the server root). Directories are listed first.

ParametersJSON Schema

Name	Required	Description	Default
`path`	No	Remote directory, relative to the server root. Defaults to the root.
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.

TDQS

B3.3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions that 'Directories are listed first', but does not disclose whether the operation is read-only, authentication requirements, error handling, 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise, consisting of two short sentences. Every sentence adds value: the first defines the purpose, the second adds a behavioral detail. It is front-loaded and free of unnecessary 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?

For a simple list tool with no output schema, the description is minimally adequate. It does not specify the format of returned data (e.g., full paths, file sizes, dates) or behavior for invalid paths, leaving some ambiguity for the agent.

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 provides complete descriptions for both parameters (path and server), achieving 100% coverage. The description adds no further meaning beyond what the schema already states, earning a baseline score 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 identifies the tool's action: 'List the contents of a remote directory'. It specifies that paths are relative to the server root and that directories are listed first, which distinguishes it from sibling tools like ftp_list_servers.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use ftp_list versus its siblings. The description lacks explicit context about when to choose this tool over ftp_list_servers, ftp_download, or other file operations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_list_serversList configured serversA

List all configured FTP/FTPS/SFTP servers (name, protocol, host, port, root, read-only, auth kind) and which is default. Never reveals passwords or keys.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.2/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that passwords/keys are never revealed and lists output fields, but omits details like speed, authentication requirements, or whether it caches results. For a list tool, 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no superfluous words. It front-loads the action and resource, then provides specifics. Every sentence serves a 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 no output schema and low complexity (zero parameters), the description sufficiently covers what the tool returns (list of server details) and a critical behavioral note (no secrets leaked). It could describe the output format (e.g., array of objects) but the listed fields compensate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so schema coverage is effectively 100%. The description adds value by enumerating the output fields and adding a security guarantee, which based on the guidelines yields a baseline of 4 with no penalty.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'List' and identifies the resource as 'all configured FTP/FTPS/SFTP servers'. It explicitly enumerates the fields returned (name, protocol, etc.), distinguishing it from sibling tools that perform file operations.

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?

While no explicit when-to-use or alternatives are stated, the context of sibling tools (all action-oriented) implies this tool is for pre-operation configuration review. A note on when to use (e.g., before downloading) would improve clarity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_mkdirCreate a remote directoryB

Recursively create a remote directory (relative to the server root).

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes	Remote directory to create, relative to the server root.
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden. It discloses recursion and relativity, but fails to mention authorization needs, side effects, error handling (e.g., if directory exists), or success criteria.

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?

One sentence, front-loaded, and free of verbose or redundant content. 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 directory creation tool, the description is fairly complete. It covers recursion and path relativity. Lacks error behavior and return value info, but output schema is absent and tool is straightforward.

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 both parameters. The description adds no additional meaning beyond the schema; it simply restates the path property. 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 the action (create) and resource (remote directory), with additional specificity: 'recursively' and 'relative to the server root'. It distinguishes the tool from siblings like ftp_list, ftp_download, etc.

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., ftp_upload, ftp_deploy). The description only states what the tool does, not under what circumstances it should be chosen.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_testTest a server connectionA

Connect to a server, list its root directory, and report success.

ParametersJSON Schema

Name	Required	Description	Default
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses three actions (connect, list, report success) but does not clarify what 'report success' entails (e.g., return value, success indicator) or whether there are side effects. 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?

A single sentence that is concise, front-loaded, and contains no superfluous information. Every word adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity of the tool (one optional parameter, no output schema), the description is sufficiently complete. It could mention what the tool returns, but the key actions are covered.

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 sole parameter 'server' is described in the input schema with default behavior. The tool description adds no further meaning beyond the schema, so it meets the baseline for full 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 it connects to a server, lists root directory, and reports success. It distinguishes itself from sibling tools like ftp_list (which likely lists a specific path) and ftp_list_servers (which lists configured servers).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for testing connectivity, but does not explicitly state when to use this tool versus alternatives like ftp_list (for listing files) or ftp_list_servers (for viewing server configurations). No when-not-to-use guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ftp_uploadUpload a local fileA

Upload one local file to the server, auto-creating parent directories. Remote path defaults to the file basename at the root.

ParametersJSON Schema

Name	Required	Description
`server`	No	Name of the configured server. Defaults to the configured default, or the sole server.
`local_path`	Yes	Local file path (relative paths resolve against the process cwd).
`remote_path`	No	Destination remote path, relative to the server root. Defaults to the local basename at the root.

TDQS

A4.2/5.0

Behavior4/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 discloses that the tool auto-creates parent directories and sets a default remote path. However, it does not mention overwrite behavior, error handling, or authentication requirements, leaving some gaps.

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 clear sentence, front-loaded with the core action and key behavioral traits. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters, no output schema, and no annotations, the description covers the main purpose and two behavioral details. Missing information on success/failure response, overwrite policy, and prerequisites, but sufficient for basic 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%, and the description reinforces the default behavior for remote_path. It adds value with auto-creation context but does not significantly extend beyond 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 the verb 'upload' and the resource 'local file' to the server, with specifics about auto-creating parent directories and default remote path. It effectively distinguishes from sibling tools like ftp_download, ftp_list, etc.

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 implies usage for uploading a single file to the server, with details on auto-creation and default path. It does not explicitly state when not to use it or mention alternatives, but the context is clear enough.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

8 tool updatesv0.1.0Jul 22, 2026
- First observedftp_delete
- First observedftp_deploy
- First observedftp_download
- First observedftp_list
- First observedftp_list_servers
- First observedftp_mkdir
- First observedftp_test
- First observedftp_upload

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: server listing, download, directory creation, deletion, connectivity test, directory listing, file upload, and directory deployment. No ambiguity between tools.

Naming Consistency5/5

All tools follow a consistent 'ftp_' prefix with snake_case verbs (e.g., ftp_list_servers, ftp_download). Naming is predictable and uniform.

Tool Count5/5

8 tools cover the essential operations for an FTP deployment server without being excessive or insufficient. The count is well-scoped.

Completeness4/5

Core CRUD operations are covered (list, download, upload, delete, mkdir) plus deployment and connection testing. Minor gaps like rename or file info are not critical for the deployment focus.

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

microservices.sh
sh.microservices
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Cloud Platforms Agent Orchestration Developer Tools
21
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2
secureflows-mcp A
io.github.michal-lefler
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
Code Analysis Developer Tools Security
181
ClawLinkOAuth
dev.claw-link
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
App Automation Workplace & Productivity
24

Related MCP Servers

ftp-mcp
File Systems Command Line
Kynlos
A
license
A
quality
D
maintenance
An enterprise-grade MCP server for FTP and SFTP operations optimized for AI coding assistants, featuring smart synchronization, connection pooling, and unified diff patching.
Updated 5 months ago (2026-04-10 23:17 UTC)
28
42
2
MIT
mcp-remote-ssh
Command Line Shell Access
faizbawa
A
license
A
quality
A
maintenance
MCP server giving AI agents full SSH access with persistent sessions, structured command output, SFTP file transfer, and port forwarding.
Updated 20 days ago (2026-08-17 06:29 UTC)
18
10
MIT
SSH MCP Server
Shell Access Command Line
avranju
A
license
Not graded
quality
D
maintenance
An MCP server that gives AI agents SSH capabilities to execute commands, transfer files, and inspect remote systems through a preconfigured host list.
Updated 6 months ago (2026-03-08 17:03 UTC)
84
MIT
sshcode-mcp
Shell Access Command Line
guanhxuan
A
license
Not graded
quality
C
maintenance
An MCP server that enables AI assistants to perform development operations on remote servers via SSH, including executing commands, managing files, and browsing directories.
Updated 2 months ago (2026-07-21 08:39 UTC)
1
MIT

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/alebgl77/ftp-deploy-mcp'

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