A general purpose Model Context Protocol (MCP) server that provides comprehensive developer tools for file editing, shell command execution, and screen capture capabilities. Built using the rmcp crate.

• View files with language detection for markdown formatting
• Write/create files with automatic directory creation
• String replacement with precise matching
• Undo functionality with edit history
• File size protection (400KB limit for text files)

• Cross-platform command execution (PowerShell on Windows, bash/zsh on Unix)
• Combined stdout/stderr output as it appears in terminal
• Output size protection (400KB limit)
• Platform-specific optimizations

• Full display screenshots with monitor selection
• Window-specific capture by title
• Automatic image optimization (768px max width)
• Base64 encoded PNG output

• Image file processing from disk
• Automatic resizing while maintaining aspect ratio
• Format conversion to PNG
• macOS screenshot filename handling

• Multi-step problem solving with sequential progression
• Branching workflows for alternative solution paths
• Step revision capability to update previous steps
• Context preservation across complex reasoning processes

• Gitignore integration - respects .gitignore patterns for file access control
• Path validation - requires absolute paths to prevent directory traversal
• File size limits - prevents memory exhaustion attacks
• Access pattern filtering - blocks access to sensitive files

• Rust 1.70+ (for building from source)
• Claude Desktop or compatible MCP client
• Operating System: macOS, Linux, or Windows

1. Clone the repository:

   git clone git@github.com:VertexStudio/developer.git cd developer

2. Build the project:

   cargo build --release

3. The binary will be available at:

   target/release/developer 

For development/testing purposes:

cargo build # Binary at: target/debug/developer

1. Open Claude Desktop configuration file:

   macOS/Linux:

   code ~/Library/Application\ Support/Claude/claude_desktop_config.json

   Windows:

   code %APPDATA%\Claude\claude_desktop_config.json

2. Add the developer server configuration:

   {"mcpServers":{"developer":{"command": "/path/to/your/developer/target/release/developer", "args": [] } } }

   Example configurations:

   Development build:

   {"mcpServers":{"developer":{"command": "/Users/rozgo/vertex/developer/target/debug/developer", "args": [] } } }

   Production build:

   {"mcpServers":{"developer":{"command": "/Users/rozgo/vertex/developer/target/release/developer", "args": [] } } }

3. Restart Claude Desktop to load the new configuration.

Create a .gitignore file in your working directory to control which files the server can access:

# Sensitive files.env.env.*secrets.*private/ *.key*.pem# Build artifactstarget/ node_modules/ dist/

The server will automatically respect these patterns and block access to matching files.

Once configured, you can use these tools directly in Claude Desktop:

"Can you view the contents of /path/to/my/file.rs?" "Please create a new file at /path/to/hello.py with a simple hello world script" "Replace the line 'old_function()' with 'new_function()' in /path/to/main.rs" "Undo the last edit to /path/to/main.rs" 

"Run 'ls -la' to show me the current directory contents" "Execute 'cargo test' to run the test suite" "Run 'git status' to check the repository status" 

"Take a screenshot of my main display" "Capture a screenshot of the window titled 'VS Code'" "Show me what windows are available for capture" 

"Process the image at /path/to/screenshot.png and show it to me" "Load and display the image from /Users/me/Desktop/diagram.jpg" 

"Start a workflow to implement a new feature with 5 steps" "Create a branch from step 3 to explore an alternative approach" "Revise step 2 to use a different algorithm" 

Developer MCP Server ├── Text Editor → File viewing, editing, string replacement, undo ├── Shell → Cross-platform command execution ├── Screen Capture → Display and window screenshots ├── Image Processor → File-based image processing ├── Workflow → Multi-step problem solving with branching └── Security Layer → Gitignore integration, path validation 

• Commands:view, write, str_replace, undo_edit
• Parameters:path (required), file_text, old_str, new_str
• Limits: 400KB file size, absolute paths only

• Parameters:command (required)
• Features: Platform detection, output redirection, size limits
• Limits: 400KB output size

• Parameters:display (optional), window_title (optional)
• Output: Base64 PNG image, 768px max width

• Parameters: None
• Output: List of capturable window titles

• Parameters:path (required)
• Features: Auto-resize, format conversion, macOS compatibility
• Limits: 10MB file size

• Parameters:step_description, step_number, total_steps, next_step_needed (required), is_step_revision, revises_step, branch_from_step, branch_id, needs_more_steps (optional)
• Features: Sequential progression, branching, step revision
• Output: JSON workflow status

"Tool not found" errors:

• Ensure the binary path in your configuration is correct
• Verify the binary exists and is executable
• Check Claude Desktop logs for detailed error messages

"File access denied" errors:

• Check if the file is blocked by .gitignore patterns
• Ensure you're using absolute paths (not relative paths)
• Verify file permissions

"Command failed" errors:

• Ensure the command exists and is in your system PATH
• Check if the command requires special permissions
• Verify the command syntax for your operating system

Build with debug info for troubleshooting:

cargo build # Use target/debug/developer in your configuration

Use the official MCP inspector to debug and test tools:

npx @modelcontextprotocol/inspector target/debug/developer

This will open a web interface where you can:

• Inspect available tools and their schemas
• Test tool calls interactively
• Debug server responses
• Validate MCP protocol compliance

Export the tools JSON schema for debugging or integration:

# Save tools schema to file cargo run toolbox > tools.json # Pretty print tools schema cargo run toolbox | jq .

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Ensure all tests pass: cargo test
5. Submit a pull request

MIT

• Model Context Protocol - The protocol specification
• Claude Desktop - Official Claude desktop application
• MCP Servers - Official MCP server implementations