A streamlined Model Context Protocol server for efficient AI-powered code editing using FastApply. Inspired by opencode-fast-apply's simplicity and partial editing approach.

FastApply MCP Server provides intelligent code editing through partial file editing, achieving 80-98% token savings compared to full-file approaches. The server uses smart matching to locate and replace code sections automatically, making it ideal for editing large files efficiently.

• Partial File Editing: Edit only the sections you need (50-500 lines recommended)
• Smart Matching: Automatic exact and normalized whitespace matching
• XML Safety: Built-in protection against prompt injection
• Token Efficiency: 80-98% token savings vs full-file editing
• Binary Detection: Automatic detection and rejection of binary files
• Atomic Operations: Safe file writes with automatic rollback on failure
• Clear Error Messages: Actionable suggestions for troubleshooting

• Python 3.13 or higher
• FastApply-compatible server (LM Studio, Ollama, or OpenAI-compatible endpoint)

Run directly without installation:

uvx fastapply-mcp

git clone https://github.com/your-org/fastapply-mcp.git
cd fastapply-mcp

# Using uv
uv sync
source .venv/bin/activate
uv pip install -e .

# Or using pip
pip install -e .

Configure the server with just 3 environment variables:

# .env file
FAST_APPLY_URL=http://localhost:1234/v1
FAST_APPLY_MODEL=fastapply-1.5b
FAST_APPLY_API_KEY=optional-api-key

That's it! No complex configuration needed.

Add to your Claude Desktop configuration:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "fastapply": {
      "command": "uvx",
      "args": ["fastapply-mcp"],
      "env": {
        "FAST_APPLY_URL": "http://localhost:1234/v1",
        "FAST_APPLY_MODEL": "fastapply-1.5b"
      }
    }
  }
}

{
  "mcpServers": {
    "fastapply": {
      "command": "python",
      "args": ["/path/to/fastapply-mcp/src/fastapply_mcp/main.py"],
      "env": {
        "FAST_APPLY_URL": "http://localhost:1234/v1",
        "FAST_APPLY_MODEL": "fastapply-1.5b"
      }
    }
  }
}

The server implements the standard MCP protocol and works with any compatible client.

The server provides a single, focused tool for efficient code editing.

• target_filepath (required): Path to the file to edit (relative or absolute)
• original_code (required): The exact section of code to modify (50-500 lines recommended)
• code_edit (required): The changes to apply

1. Read the file to get current content
2. Extract the relevant section (50-500 lines with context)
3. Call FastApply API with partial content
4. Smart match finds the section in the full file
5. Replace the section atomically
6. Generate diff for verification

{
  "target_filepath": "src/utils.py",
  "original_code": "def parse_config(path):\n    with open(path) as f:\n        return json.load(f)",
  "code_edit": "def parse_config(path):\n    try:\n        with open(path) as f:\n            return json.load(f)\n    except FileNotFoundError:\n        raise ConfigError(f'Config not found: {path}')"
}

Use ... existing code ... markers for unchanged sections:

# ... existing code ...
def updated_function():
    return "modified"
# ... existing code ...

This tells the AI to skip regenerating unchanged parts, making edits faster.

Partial editing provides massive token savings:

The tool uses a two-tier matching system:

Finds exact string match in the file.

Handles CRLF/LF differences automatically:

• Normalizes \r\n → \n
• Normalizes \r → \n
• Matches whitespace-normalized content

Ensures the section appears only once in the file to prevent ambiguous replacements.

Built-in protection against prompt injection:

# User code with XML tags
original_code = "<code>malicious</code>"

# Automatically escaped before API call
# "&lt;code&gt;malicious&lt;/code&gt;"

# Safely processed and unescaped after

All XML special characters (&, <, >, ", ') are automatically escaped and unescaped.

1. Install LM Studio from https://lmstudio.ai
2. Download a FastApply-compatible model
3. Start the local server (default: http://localhost:1234)
4. Configure FAST_APPLY_URL=http://localhost:1234/v1

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a FastApply model
ollama pull fastapply-1.5b

# Start the server
ollama serve

Configure FAST_APPLY_URL=http://localhost:11434/v1

Any OpenAI-compatible API works:

FAST_APPLY_URL=https://api.openai.com/v1
FAST_APPLY_MODEL=gpt-4
FAST_APPLY_API_KEY=sk-...

• Workspace Isolation: All operations confined to current working directory
• Path Validation: Prevents directory traversal attacks
• File Size Limits: 10MB default maximum
• Binary Detection: Rejects binary files automatically
• UTF-8 Validation: Ensures proper file encoding
• Atomic Writes: Safe file operations with rollback

Clear, actionable error messages:

❌ Error: Cannot locate original_code in file (whitespace mismatch detected).

💡 Troubleshooting:
  1. Re-read the file to get current content
  2. Ensure original_code matches exactly (including whitespace)
  3. Provide more context to make the section unique

Verify your FastApply server is running:

curl http://localhost:1234/v1/models

Use the tool only for existing files. For new files, use your MCP client's write tool.

• Re-read the file to get current content
• Ensure whitespace matches exactly (tabs vs spaces)
• Provide more context to make the section unique

The tool handles CRLF/LF differences automatically, but tabs vs spaces must match exactly.

fastapply-mcp/
├── src/
│   └── fastapply_mcp/
│       ├── __init__.py
│       └── main.py          # Single-file implementation (~487 lines)
├── .env.example
├── pyproject.toml
└── README.md

# Format code
ruff format .

# Lint code
ruff check .

# Type checking
mypy src/

# Syntax check
python -m py_compile src/fastapply_mcp/main.py

This implementation follows these principles:

1. Do one thing well - Focus on efficient file editing
2. Trust the client - MCP client handles undo, concurrency, etc.
3. Optimize for common case - Partial editing is 10x more efficient
4. Clear errors - Help users fix problems quickly
5. No premature optimization - Remove unused features

• Read: 5000 lines
• Send to API: 125,000 tokens
• Process: ~30 seconds
• Cost: High

• Read: 5000 lines (send only 100)
• Send to API: 2,000 tokens
• Process: ~3 seconds
• Cost: 98% cheaper

Contributions are welcome! Please:

1. Fork the repository and create a feature branch
2. Write tests for new functionality
3. Ensure code meets quality standards
4. Submit a pull request with clear description

MIT License - see LICENSE file for details.

• Inspiration: opencode-fast-apply for the partial editing approach
• MCP Community: For the Model Context Protocol specification
• FastApply: For the efficient code merging models

• GitHub Issues: Report bugs and request features
• Discussions: Ask questions and share ideas
• Documentation: See inline code comments for implementation details