What is Mcp Chunk Editor

mcp-chunk-editor is an MCP server that provides chunk-oriented text file editing capabilities for Large Language Models (LLMs), allowing for more natural and efficient editing operations by using semantically meaningful chunks instead of traditional line numbers.

Use cases

Use cases include editing source code files in programming projects, modifying documentation in a structured manner, and enhancing collaborative coding environments where LLMs assist in real-time editing.

How to use

To use mcp-chunk-editor, you can utilize various tools such as ‘read_chunks’ to retrieve file chunks, ‘replace_chunks’ to modify content, ‘undo’ to revert changes, ‘create_file’ to generate new files, and ‘delete_file’ to remove existing files. Each tool requires specific parameters like file path and content.

Key features

Key features include semantic chunking for identifying meaningful code structures, immediate application of changes with preview generation, simple undo functionality for recent changes, and efficiency in LLM token usage through incremental updates and lazy chunking.

Where to use

mcp-chunk-editor can be used in software development environments, educational platforms for coding, and any application requiring efficient text editing for LLMs, particularly where semantic understanding of code is beneficial.

MCP Chunk Editor

A Model Context Protocol server that provides chunk-oriented text file editing capabilities for LLMs. This server enables LLMs to edit files using semantically meaningful chunks instead of line numbers, resulting in more natural and efficient editing operations.

Key Features

• Semantic Chunking: Uses Universal CTags to identify meaningful code structures like functions, classes, and methods
• Immediate Application: Changes are applied immediately with preview generation for verification
• Simple Undo: Supports reverting the most recent change for each file
• Efficiency: Optimized for LLM token usage with incremental updates and lazy chunking

Available Tools

• read_chunks - Retrieve chunks of a file, either all chunks or a specific range.

  • file_path (string, required): Path to the file to read
  • chunk_indices (array of integers, optional): List of chunk indices to retrieve
  • include_adjacent (boolean, optional): Include chunks before and after for context
  • encoding (string, optional): File encoding (default: utf-8)

• replace_chunks - Replace the content of one or more chunks and immediately apply the changes.

  • file_path (string, required): Path to the file to modify
  • replacements (array, required): List of {index, new_content} objects
  • encoding (string, optional): File encoding (default: utf-8)

• undo - Revert the last change made by a replace_chunks operation.

  • file_path (string, required): Path to the file to revert changes in

• create_file - Create a new file with given content.

  • file_path (string, required): Path to the file to create
  • content (string, required): Content to write to the file
  • encoding (string, optional): File encoding (default: utf-8)

• delete_file - Delete a file.

  • file_path (string, required): Path to the file to delete

Prerequisites

• Python 3.10 or 3.11 (Python 3.12+ not supported yet due to python-ctags3 compatibility)
• Universal CTags (apt-get install universal-ctags on Debian/Ubuntu)

Installation

Using uv (recommended)

When using uv no specific installation is needed. We will
use uvx to directly run mcp-chunk-editor.

Using PIP

Alternatively you can install mcp-chunk-editor via pip:

pip install mcp-chunk-editor

After installation, you can run it as a script using:

python -m mcp_chunk_editor

Configuration

Configure for Claude.app

Add to your Claude settings:

Customization - Maximum Chunk Size

By default, the server will use a maximum chunk size of 100 lines. This can be customized by adding the argument --max-chunk-size=200 (for example, to set 200 lines) to the args list in the configuration.

Debugging

You can use the MCP inspector to debug the server. For uvx installations:

npx @modelcontextprotocol/inspector uvx mcp-chunk-editor

Or if you’ve installed the package in a specific directory or are developing on it:

cd path/to/servers/src/chunk-editor
npx @modelcontextprotocol/inspector uv run mcp-chunk-editor

How It Works

The chunk editor works by first parsing files with Universal CTags to identify meaningful semantic units like functions, classes, and methods. These semantic units become the chunks that the LLM can operate on.

When editing a file:

1. The LLM requests chunks from a file (read_chunks)
2. The LLM makes changes to specific chunks (replace_chunks)
3. Changes are immediately applied to the file
4. A preview of the changes is returned for verification
5. If needed, the LLM can undo the most recent change (undo)

This workflow is more efficient and natural for LLMs compared to traditional line-based editors, which require precise line numbers and content hashing.

Contributing

We encourage contributions to help expand and improve mcp-chunk-editor. Whether you want to add new tools, enhance existing functionality, or improve documentation, your input is valuable.

For examples of other MCP servers and implementation patterns, see:
https://github.com/modelcontextprotocol/servers

Pull requests are welcome! Feel free to contribute new ideas, bug fixes, or enhancements to make mcp-chunk-editor even more powerful and useful.

License

mcp-chunk-editor is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.