Go Development MCP Server

The Go Development MCP Server is a comprehensive solution for integrating Go development workflows with AI assistants like Claude Desktop or other MCP-compatible tools. It enables AI assistants to compile, test, run, and analyze Go code directly through the Model Context Protocol (MCP).

Features

Go Build: Compile Go code and receive detailed feedback
Go Test: Run tests on Go code with support for coverage analysis
Go Run: Compile and execute Go programs with command-line arguments
Go Mod: Manage Go module dependencies (init, tidy, download, etc.)
Go Format: Format Go code according to standard conventions
Go Analyze: Analyze Go code for issues using static analysis tools
Go Workspace: Manage Go workspaces for multi-module development (NEW!)

New in This Release

MCP v0.29.0 Compatibility: Updated to use the latest Model Context Protocol v0.29.0
Go Workspace Support: Complete workspace management for multi-module Go projects
Project Path Support: All tools now support working with existing Go project directories
Workspace-Aware Execution: All tools can operate within Go workspace context
Strategy Pattern: Flexible execution strategies for code snippets vs. project directories vs. workspaces
Enhanced Response Formatting: Better structured responses with natural language metadata
Improved Error Handling: More detailed and helpful error messages
End-to-End Testing: Comprehensive behavioral testing scripts to verify functionality
Modern Testing Framework: New Go-based testing framework with parallel test execution

Go Workspace Support

The server now includes comprehensive support for Go workspaces, enabling multi-module development workflows. This feature allows you to:

Initialize Workspaces: Create new Go workspaces with go work init
Manage Modules: Add, remove, and organize modules within workspaces
Unified Operations: Run Go commands across all modules in a workspace
Dependency Synchronization: Keep dependencies consistent across modules
Workspace-Aware Tools: All existing tools (build, test, run, etc.) work seamlessly with workspaces

Workspace Commands

The go_workspace tool provides the following subcommands:

init: Initialize a new Go workspace
use: Add modules to an existing workspace
sync: Synchronize workspace dependencies
edit: View and modify workspace configuration
vendor: Vendor all workspace dependencies
info: Get detailed workspace information

Workspace Integration

All existing tools support workspace contexts through the workspace_path parameter:

{ "tool": "go_build", "arguments": { "workspace_path": "/path/to/workspace", "module": "specific-module", "code": "package main..." } }

Testing

The server includes comprehensive testing capabilities to verify that it works correctly with real Go projects. Testing is provided through two frameworks:

Go Testing Framework: Modern, parallel test framework using Go's native testing facilities and testify
PowerShell Testing: Legacy end-to-end behavioral tests (for backward compatibility)

The tests verify all input modes (code-only, project path, and hybrid) and ensure that the execution strategies work as expected.

Running the Tests

Go Tests (Recommended)

# Run all Go tests cd go-dev-mcp .\scripts\testing\run_tests.ps1 -TestType go -UseGoTests -WithCoverage # Run with race detection .\scripts\testing\run_tests.ps1 -TestType go -UseGoTests -WithRaceDetection # Run directly with Go go test -v ./internal/tools/...

PowerShell Tests (Legacy)

# Quick tests cd go-dev-mcp\scripts\testing .\basic\simple_test.ps1 # Comprehensive tests cd go-dev-mcp\scripts\testing .\core\all_tools_test.ps1 -Verbose # Strategy-specific tests cd go-dev-mcp\scripts\testing .\strategies\hybrid_strategy_test.ps1 -Verbose

For detailed information about the testing framework, see the Testing Documentation.

The testing scripts are organized into categories:

Basic tests: Simple, quick-running tests for sanity checks
Core tests: Comprehensive tests covering all tools and input modes
Strategy tests: Tests focused on specific execution strategies like hybrid execution

See the testing README for more details.

Installation

Prerequisites

Go 1.21 or higher
Git

Windows

Manual Installation

Clone the repository:
git clone https://github.com/MrFixit96/go-dev-mcp.git cd go-dev-mcp
Build the executable:
go build -o go-dev-mcp.exe ./cmd/server
Move the executable to a location in your PATH or reference it directly in your Claude Desktop configuration.

Using WinGet (Coming Soon)

winget install go-dev-mcp

macOS

Using Homebrew (Coming Soon)

brew install go-dev-mcp

Manual Installation (macOS)

Clone the repository:
git clone https://github.com/MrFixit96/go-dev-mcp.git cd go-dev-mcp
Build the executable:
go build -o go-dev-mcp ./cmd/server
Move the executable to a location in your PATH:
sudo mv go-dev-mcp /usr/local/bin/

Linux

Clone the repository:
git clone https://github.com/MrFixit96/go-dev-mcp.git cd go-dev-mcp
Build the executable:
go build -o go-dev-mcp ./cmd/server
Move the executable to a location in your PATH:
sudo mv go-dev-mcp /usr/local/bin/

Claude Desktop Integration

To integrate with Claude Desktop, update your claude_desktop_config.json file:

Windows Configuration

{ "mcpServers": { "go-dev": { "command": "C:\\path\\to\\go-dev-mcp.exe", "args": [], "env": { "GOCACHE": "%LOCALAPPDATA%\\go-build", "LOCALAPPDATA": "%LOCALAPPDATA%", "GOPATH": "%USERPROFILE%\\go", "GOROOT": "%GOROOT%", "PATH": "%PATH%", "DEBUG": "*" }, "disabled": false, "autoApprove": [] } } }

Environment Variables Used:

%LOCALAPPDATA%: Resolves to C:\Users\{username}\AppData\Local
%USERPROFILE%: Resolves to C:\Users\{username}
%GOROOT%: Go installation directory (automatically set by Go installer)
%PATH%: System PATH for Go binary access

Alternative using Go Environment Variables:

{ "mcpServers": { "go-dev": { "command": "C:\\path\\to\\go-dev-mcp.exe", "args": [], "env": { "DEBUG": "*" }, "disabled": false, "autoApprove": [] } } }

Note: The alternative configuration relies on Go's default environment detection. Go automatically uses %LOCALAPPDATA%\go-build for GOCACHE and %USERPROFILE%\go for GOPATH when not explicitly set.

macOS and Linux

{ "mcpServers": { "go-dev": { "command": "/path/to/go-dev-mcp", "args": [], "env": {}, "disabled": false, "autoApprove": [] } } }

Usage

Working with Code Snippets

All tools accept Go code directly through the code parameter:

// Use go_build to compile code go_build(code: "package main\n\nfunc main() {\n\tfmt.Println(\"Hello World\")\n}") // Run tests with go_test go_test(code: "package main", testCode: "package main\n\nimport \"testing\"\n\nfunc TestHello(t *testing.T) {...}")

Working with Project Directories

All tools now support working with existing Go project directories through the new project_path parameter:

// Compile a project go_build(project_path: "/path/to/your/go/project") // Run tests in a project go_test(project_path: "/path/to/your/go/project", verbose: true, coverage: true) // Format all files in a project go_fmt(project_path: "/path/to/your/go/project") // Analyze a project for issues go_analyze(project_path: "/path/to/your/go/project", vet: true)

Configuration

The server uses a configuration file located at:

Windows: %APPDATA%\go-dev-mcp\config.json
macOS: ~/Library/Application Support/go-dev-mcp/config.json
Linux: ~/.config/go-dev-mcp/config.json

A default configuration file will be created on first run, which you can customize:

{ "version": "1.0.0", "logLevel": "info", "sandboxType": "process", "resourceLimits": { "cpuLimit": 2, "memoryLimit": 512, "timeoutSecs": 30 } }

Security

The Go Development MCP Server runs commands in a sandboxed environment with:

Process isolation
Resource limits (CPU, memory, execution time)
Temporary directory containment
No network access by default

License

MIT

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Roadmap

Add support for Go workspaces
Implement Docker-based sandbox for stronger isolation
Add debugging capabilities
Support for Go race detector
Improved error reporting with suggestions

Workspace Usage Examples

Basic Workspace Operations

Creating a New Workspace

{ "tool": "go_workspace", "arguments": { "command": "init", "workspace_path": "/path/to/my-workspace", "modules": ["./module1", "./module2"] } }

Adding Modules to Existing Workspace

{ "tool": "go_workspace", "arguments": { "command": "use", "workspace_path": "/path/to/my-workspace", "modules": ["./new-module", "../external-module"] } }

Getting Workspace Information

{ "tool": "go_workspace", "arguments": { "command": "info", "workspace_path": "/path/to/my-workspace" } }

Multi-Module Development Workflow

1. Initialize Workspace Structure

# Create workspace directory mkdir my-project-workspace cd my-project-workspace # Initialize with MCP { "tool": "go_workspace", "arguments": { "command": "init", "workspace_path": ".", "modules": ["./api", "./client", "./shared"] } }

2. Build Across All Modules

{ "tool": "go_build", "arguments": { "workspace_path": "/path/to/my-workspace" } }

3. Test Specific Module

{ "tool": "go_test", "arguments": { "workspace_path": "/path/to/my-workspace", "module": "api", "coverage": true } }

4. Synchronize Dependencies

{ "tool": "go_workspace", "arguments": { "command": "sync", "workspace_path": "/path/to/my-workspace" } }

Advanced Workspace Features

Workspace with Custom Code

{ "tool": "go_run", "arguments": { "workspace_path": "/path/to/my-workspace", "module": "api", "code": "package main\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(\"Running in workspace context\")\n}" } }

Vendor All Dependencies

{ "tool": "go_workspace", "arguments": { "command": "vendor", "workspace_path": "/path/to/my-workspace" } }

Format All Modules

{ "tool": "go_fmt", "arguments": { "workspace_path": "/path/to/my-workspace" } }

Error Handling and Troubleshooting

Common Workspace Issues

Missing go.work file: Use init command to create workspace
Module not found: Use use command to add modules
Dependency conflicts: Use sync command to resolve
Build failures: Check module-specific issues with targeted commands

Workspace Validation