MCP Text Editor: Token-Efficient File Editing for LLM Workflows

Stop loading entire files into your LLM context when you only need to edit a few lines. This MCP server gives you surgical file editing with intelligent partial loading that can slash your token usage by 90% while keeping your edits safe from conflicts.

Why Your Current File Editing Workflow is Burning Tokens

When you're working with LLMs on code or text files, you're probably doing this:

1. Load entire file → 2000 tokens
2. Make small edit → another 2000 tokens
3. Save changes → hope nothing else modified the file

That's 4000+ tokens for what should be a 200-token operation. Plus zero protection against concurrent edits that could overwrite your changes.

Token-Smart Partial File Access

Instead of dumping whole files into context, specify exactly what you need:

{
  "file_path": "large_config.py",
  "line_start": 45,
  "line_end": 60,
  "encoding": "utf-8"
}

Get back just those 15 lines with metadata you need for safe editing. For a 500-line file, that's ~300 tokens instead of 3000.

Multi-file, multi-range requests let you grab specific sections from multiple files in one operation:

{
  "files": [
    {
      "file_path": "app.py",
      "ranges": [
        {"start": 1, "end": 20},    // imports
        {"start": 100, "end": 150}  // specific function
      ]
    },
    {
      "file_path": "config.py", 
      "ranges": [{"start": 45, "end": 60}]
    }
  ]
}

Perfect for LLM workflows where you need context from related functions across multiple files without loading everything.

Conflict-Safe Editing That Actually Works

Every file operation uses SHA-256 hashes to detect conflicts before they corrupt your work:

1. Get content with hash: Load the lines you need plus a hash of the current state
2. Make your edits: LLM processes just those lines
3. Apply with verification: Server checks the hash before writing - if someone else modified the file, you get an error instead of data loss

{
  "files": [{
    "file_path": "app.py",
    "hash": "sha256-current-file-hash",
    "patches": [{
      "start": 45,
      "end": 50,
      "range_hash": "sha256-hash-of-lines-being-replaced", 
      "contents": "new code here\n"
    }]
  }]
}

Patches apply bottom-to-top automatically, so line numbers stay correct even with multiple edits.

Real-World Use Cases

Code Reviews: Load just the changed functions from a PR instead of entire files

uvx mcp-text-editor
# Then pull specific line ranges from modified files

Log Analysis: Extract specific time ranges from massive log files without reading everything

{"file_path": "app.log", "line_start": 1500, "line_end": 1600}

Configuration Updates: Edit specific sections of config files while preserving comments and structure

{
  "start": 25, "end": 30,
  "contents": "# Updated config\nDEBUG=False\nPORT=8080\n"
}

Collaborative Editing: Multiple developers/LLMs can work on different parts of the same file safely

Drop-In Claude Integration

Add to your Claude desktop config and start using immediately:

{
  "mcpServers": {
    "text-editor": {
      "command": "uvx",
      "args": ["mcp-text-editor"]
    }
  }
}

Or install via Smithery: npx -y @smithery/cli install mcp-text-editor --client claude

Beyond Basic File Operations

• Multi-encoding support: Handle UTF-8, Shift_JIS, Latin1 files correctly
• Atomic operations: Multiple file edits succeed or fail together
• Memory efficient: Process large files without loading them entirely
• Docker ready: docker run -i --rm --mount "type=bind,src=/path,dst=/path" mcp/text-editor

The line-oriented approach means you can precisely target specific functions, classes, or configuration blocks instead of working with entire files. Your LLM gets exactly the context it needs, nothing more.

This isn't just another file editor - it's designed specifically for the token economics and safety requirements of LLM-assisted development workflows.