Click on "Deploy 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., "@ftp-mcp sync local dist/ to remote staging with dry run"
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 enterprise-grade Model Context Protocol (MCP) server providing sophisticated FTP and SFTP operations optimized specifically for AI coding assistants. Features smart synchronization, connection pooling, directory caching, unified diff patching, and comprehensive security controls.
Your AI can:
spin up a VPS
install a web server
build your entire app
…and then gets stuck trying to upload files.
So it writes a Python script.
Then forgets it exists.
Then writes it again next session.
This fixes that.
One connection. One call. Done.
Built for AI to install. Designed for AI to use.
Related MCP server: mcp-dev-tools
Connection Pooling & Caching: Sustains underlying connections across tool calls and leverages strict memory caching with smart aggressive invalidation for extreme sub-15ms performance.
AI-Optimized Tooling: Implements chunking (startLine/endLine) for huge files, cursor-paginated limit bounds for vast directories, and diff-based local file morphing native to FTP without pulling heavy files.
Security & Authorization: Native support for SSH Key exchanges (both direct and Agent-forwarding), Pass-phrase authentication, and explicit readOnly: true config profiling to sandbox dangerous modifications.
Smart Directory Syncing: Deep hash-and-size sync algorithms for minimal network payload deployments, complete with --dryRun toggling that logs differences back to the LLM without modifying live directories.
Git & Node Aware: Automatically unpacks .gitignore and .ftpignore environments. Semantically evaluates package.json for smart context summarization.
AI-Guided Initialization: A dedicated "AI-First" configuration track (--init) that provides highly verbose instruction context during setup, ensuring AI assistants absorb server capabilities and operational constraints directly into their working memory.
Interactive Initializer: Simple scaffolding of configurations natively via the CLI for human users.
Audit Logging: Robust instrumentation generating structured .ftp-mcp-audit.log traces on all filesystem mutations.
Comprehensive E2E Testing: Guaranteed operational functionality validated continuously by Node-based MCP IO test orchestration.
Run this in your target project directory to scaffold the configuration securely:
npx ftp-mcp --initThis will run an interactive initialization wizard dropping a .ftpconfig instance natively into your working directory. Then install the package globally so your MCP client can access it universally:
npm install -g ftp-mcpOption A: Project Config File (Recommended)
Your .ftpconfig can hold dozens of isolated environments.
{
"production": {
"host": "ftp.example.com",
"user": "prod-user",
"password": "your-password",
"port": 21,
"secure": false,
"readOnly": true
},
"staging": {
"host": "sftp://staging.example.com",
"user": "staging-user",
"privateKey": "./keys/id_rsa",
"passphrase": "my-secure-key",
"port": 22
},
"default": {
"host": "ftp.mysite.com",
"user": "default-user",
"password": "your-password"
}
}The server automatically identifies .ftpconfig relative to your execution layer and falls back to environment properties.
Option B: Environment Variables
Required:
# Windows
setx FTPMCP_HOST "ftp.example.com"
setx FTPMCP_USER "username"
setx FTPMCP_PASSWORD "password"
# Linux/Mac
export FTPMCP_HOST="ftp.example.com"
export FTPMCP_USER="username"
export FTPMCP_PASSWORD="password"Advanced SFTP Keys:
export FTPMCP_PRIVATE_KEY="/path/to/id_rsa"
export FTPMCP_PASSPHRASE="optional-phrase"
export FTPMCP_AGENT="pageant"Register the MCP server directly to your AI Code Editor (Cursor, Cline, Claude Desktop, Windsurf, etc.).
Example integration:
Command: npx
Arguments: -y ftp-mcp
When navigating large remote codebases, AI assistants conventionally hit token-overflow limits. ftp_get_contents supports startLine and endLine parameters. ftp-mcp intercepts the inbound download stream at the bytecode layer and cleanly drops data outside your strict index bounds, returning only the exact lines requested without destroying context.
Instead of requesting a 5,000-line remote file, making a 2-line edit locally, and pushing the huge file back, ftp-mcp exposes an ftp_patch_file command. Simply provide a standard Unified Diff patch string, and ftp-mcp will read the live destination, map diff logic, and commit the modification directly over SCP.
Calling ftp_analyze_workspace will traverse the remote filesystem natively investigating configurations (package.json, composer.json). It will evaluate structure patterns and package dependencies, instantly reporting exact context of the remote language mapping (e.g. "Node.js Environment operating React mapping to Express").
The server provides built-in prompts that guide AI agents through complex workflows:
audit-project: Instructs the agent on how to perform a deep security and architectural audit of a remote codebase.
deploy-checklist: Provides a standard safety checklist for agents to verify before performing production deployments or massive synchronizations.
Access remote files as standard MCP resources without explicitly calling a tool:
URI Template: mcp://remote-file/{path}
Supports direct UTF-8 reading and respects all PolicyEngine security boundaries and path-traversal guards.
Real-time Logging: Emits protocol-native logging notifications for internal events like connection pooling, cache reuse, and transfer lifecycle steps.
Progress Tracking: Long-running operations (ftp_sync, ftp_batch_upload, etc.) emit granular progress updates (0-100%) so the AI agent and user can monitor large transfers in real-time.
Set "readOnly": true in any .ftpconfig profile. AI interactions over ftp_delete, ftp_patch_file, ftp_put_contents, or ftp_sync(direction: "upload") will immediately halt with a standardized sandbox violation, keeping production environments entirely safe from hallucinated tool executions.
Deploy environments utilizing deep comparison trees via ftp_sync.
Use dryRun: true to have the system safely evaluate the entire sync matrix, printing standard output natively to the context console reporting exactly what logic would have executed.
ftp_sync deeply integrates with standard .gitignore indexing and custom .ftpignore pattern files perfectly out-of-the-box.
ftp_connect: Switch between named FTP profiles.
ftp_get_contents: Read file content directly from the server utilizing paginated line extraction.
ftp_put_contents: Write content directly to a remote file.
ftp_patch_file: Apply unified diff modifications cleanly over the network.
ftp_summarize_file: Generates token-light structural signatures representing the files contents natively.
ftp_stat: Get detailed metadata regarding permissions, bytes, and modification arrays.
ftp_exists: Conditional logic pipeline for execution paths without traversing subdirectories.
ftp_disk_space: System OS level free-byte parsing (SFTP ONLY).
ftp_analyze_workspace: Pull complex semantic environments based on workspace root configuration definitions.
ftp_list: List all files/directories subject to limit and offset token bounding rules.
ftp_tree: Build full recursive maps.
ftp_search: Target files by wildcard properties instantly down the document tree.
ftp_mkdir / ftp_rmdir: Folder creation and complex recursive destruction commands.
ftp_upload / ftp_download: Strict file 1-to-1 transports.
ftp_batch_upload / ftp_batch_download: Multi-mapped array uploads avoiding multi-tool overhead.
ftp_sync: Advanced deep-logic size-tree mappings dropping into deployment synchronization pools.
ftp_delete: Drop target properties.
ftp_copy: OS level SSH file duplications ignoring massive TCP IO transport arrays.
ftp_rename: Target displacement mappings.
ftp_chmod: OS level Permission flags executing bit-mask rules natively on SFTP sockets.
Audit Logging is continuously enabled. Ensure the terminal running the MCP protocol maintains structural write-permissions to the local project deployment folder.
Ensure any currentConfig caching resets are tied exclusively to ftp_connect profile pivoting.
See CHANGELOG.md for a detailed list of changes in each release.
Author: Kynlo Akari
Introspect the remote directory to identify technical environments (e.g., Node.js, PHP, Python) and read dependency manifests. Use this to gain architectural context of a new codebase.
Inputs: path.
Download a selection of remote files to local destinations. HIGHLY RECOMMENDED for bulk downloads to leverage stable socket persistence.
Inputs: files (required).
Upload a collection of local files to remote destinations in a single operation. HIGHLY RECOMMENDED for multiple files to minimize connection handshaking overhead and drastically improve performance.
Inputs: files (required).
Change remote file permissions. CRITICAL: Only supported on SFTP connections.
Inputs: mode (required), path (required).
Establish or switch the active connection to a specific remote server profile defined in your .ftpconfig (e.g., 'production', 'staging'). This is the first step before performing any remote operations.
Inputs: useEnv, profile.
Directly duplicate a file on the remote server without downloading and re-uploading. CRITICAL: Only supported on SFTP connections.
Inputs: destPath (required), sourcePath (required).
Permanently remove a file from the remote server. Use with caution.
Inputs: path (required).
Execute a pre-defined deployment preset from .ftpconfig. This typically maps a specific local folder to a remote target with pre-configured exclusion rules.
Inputs: deployment (required).
Query the remote server for available disk space. CRITICAL: Only available on SFTP connections.
Inputs: path.
Standard single-file transport from the remote server. For bulk downloads, favor ftp_batch_download.
Inputs: localPath (required), remotePath (required).
Check for the existence of a file or folder without performing heavy file operations. Use this for conditional logic workflows.
Inputs: path (required).
Read the source text of a remote file. CRITICAL: For large files, use 'startLine' and 'endLine' to extract specific chunks and prevent hitting the LLM context limit.
Inputs: path (required), endLine, startLine.
List files and directories in a remote path. Use 'limit' and 'offset' for pagination when dealing with directories containing hundreds of files to avoid context overflow.
Inputs: path, limit, offset.
List all available deployment presets from .ftpconfig
Inputs: no named parameters.
Expose all recent mutations currently stored in the system's SnapshotManager. Essential for planning rollbacks.
Inputs: no named parameters.
Create a new directory structure on the remote server. Supports nested creation (mkdir -p).
Inputs: path (required).
Apply a Unified Diff patch to a remote file. RECOMMENDED: Use this instead of ftp_put_contents for updating existing files to minimize bandwidth and ensure atomic-like updates. For new files, use ftp_put_contents.
Inputs: path (required), patch (required), createBackup, expectedHash.
Scan the remote server to determine supported filesystem features (e.g., chmod availability, symlink support, disk space querying). Helpful for troubleshooting capabilities.
Inputs: testPath.
Write raw text directly to a remote destination. Best for creating NEW files. For modifying existing files, prefer ftp_patch_file.
Inputs: path (required), content (required).
Move or rename files and directories on the remote server.
Inputs: newPath (required), oldPath (required).
Delete a directory from the remote server.
Inputs: path (required), recursive.
Undo a previous file mutation by restoring it from a system-generated snapshot. This provides safety during complex refactoring tasks.
Inputs: transactionId (required).
Advanced remote file search. Supports finding files by name (wildcards), extension, or content regex (grep-like). Use this to find specific code patterns across the remote workspace.
Inputs: path, limit, offset, pattern, +3 more.
Retrieve comprehensive metadata for a remote property, including size, modification timestamps, and UNIX permissions.
Inputs: path (required).
Deploy entire project folders using smart synchronization. Analyzes local and remote directory trees and only transfers files that have changed in size or modification date. Automatically respects .gitignore and .ftpignore.
Inputs: localPath (required), remotePath (required), dryRun, direction, +1 more.
Retrieve internal performance metrics, including average latency, connection pool health, and total processed bytes.
Inputs: no named parameters.
Generate a complete recursive directory map. Use this to visualize project structure, but be cautious with 'maxDepth' in very large remote repositories to avoid excessive network payload.
Inputs: path, maxDepth.
Standard single-file transport to the remote server. For bulk transfers, favor ftp_batch_upload.
Inputs: localPath (required), remotePath (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 28 tools
Each tool has a clearly distinct purpose, with descriptions that differentiate similar operations like single vs batch upload/download, and patch vs put for file content updates. No tools appear to overlap in functionality.
All tools follow a consistent ftp_verb_noun or ftp_verb pattern in snake_case, with no deviation in naming convention. This makes the tool set predictable and easy to navigate.
With 28 tools, the set is extensive but each tool serves a specific purpose (connection, file operations, batch processing, deployment, rollback, telemetry). While slightly above typical, the count is justified by the comprehensive feature set.
The tool set covers nearly all FTP operations including connect, list, get, put, patch, delete, rename, mkdir, rmdir, chmod, search, tree, sync, and batch transfers. Advanced features like rollback and workspace analysis add completeness, with no obvious gaps for standard FTP workflows.
Cloud-hosted MCP server for secure AI access to enterprise data sources via CData Connect AI.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
