Prerequisites:

• Claude Desktop installed
• mcp-go binary installed (see Installation Methods)

Steps:

1. Find your config file location:

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

2. Open or create the config file

3. Add the MCP server configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true"
      }
    }
  }
}

4. Update the command path:

   • Replace /usr/local/bin/mcp-go with your actual mcp-go path
   • Find it with: which mcp-go (macOS/Linux) or where mcp-go (Windows)

5. Restart Claude Desktop

✅ Verify:

• Open Claude Desktop
• Check that MCP tools are available
• Try asking Claude to run a Go command

⚠️ Troubleshooting:

• If tools don't appear, check the config file JSON is valid
• Verify the binary path is correct
• Check Claude Desktop logs for errors

Prerequisites:

• Cursor installed
• mcp-go binary installed

Steps:

1. Open Cursor Settings:

   • Press Cmd+, (macOS) or Ctrl+, (Windows/Linux)
   • Or: Cursor → Settings → Settings

2. Navigate to MCP Servers:

   • Search for "MCP" in settings
   • Or go to: Settings → Features → MCP Servers

3. Add server configuration:

   • Click "Add Server" or edit settings JSON
   • Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true"
      }
    }
  }
}

4. Update the command path to match your installation

5. Reload Cursor (restart or reload window)

✅ Verify:

• Open a Go file
• Check that MCP tools are available in the command palette
• Try using Go-related AI features

Prerequisites:

• VS Code with MCP extension installed
• mcp-go binary installed

Steps:

1. Choose configuration location:

   • Workspace: .vscode/settings.json (project-specific)
   • User: User Settings JSON (global)

2. Open settings JSON:

   • Press Cmd+Shift+P (macOS) or Ctrl+Shift+P (Windows/Linux)
   • Type "Preferences: Open Settings (JSON)"
   • Or edit .vscode/settings.json in your workspace

3. Add MCP server configuration:

{
  "mcp.servers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true"
      }
    }
  }
}

4. Update the command path

5. Reload VS Code window

✅ Verify:

• Check Output panel for MCP server messages
• Verify Go environment: go version in integrated terminal
• Test tools: Try calling go_fmt or go_test

💡 Tip: For workspace settings, create .vscode/settings.json in your project root

Prerequisites:

• VS Code with Cline extension installed
• mcp-go binary installed

Steps:

1. Install Cline extension from VS Code marketplace

2. Open Cline settings:

   • Go to: Settings → Extensions → Cline
   • Or edit settings JSON

3. Add MCP server:

{
  "cline.mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

4. Update command path and reload

✅ Verify: Cline should recognize MCP Go tools

Prerequisites:

• Windsurf installed
• mcp-go binary installed

Steps:

1. Open Windsurf Settings:

   • Go to Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true"
      }
    }
  }
}

3. Update path and restart Windsurf

✅ Verify: MCP tools available in Windsurf

Prerequisites:

• Zed installed
• mcp-go binary installed

Steps:

1. Open Zed Settings:

   • Cmd+, (macOS) or Ctrl+, (Windows/Linux)

2. Navigate to MCP configuration:

   • Settings → Features → MCP

3. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

4. Update path and restart Zed

✅ Verify: MCP integration working

Prerequisites:

• JetBrains IDE with AI Assistant enabled
• mcp-go binary installed

Steps:

1. Open IDE Settings:

   • Go to: Settings/Preferences → Tools → AI Assistant → MCP Servers

2. Add MCP server:

   • Click "Add" or edit configuration
   • Add:

{
  "mcp-go": {
    "command": "/usr/local/bin/mcp-go",
    "args": [],
    "env": {
      "DISABLE_NOTIFICATIONS": "true"
    }
  }
}

3. Update path and restart IDE

✅ Verify: AI Assistant can use Go tools

💡 Tip: Works with IntelliJ IDEA, GoLand, WebStorm, PyCharm, etc.

Prerequisites:

• Perplexity Desktop installed
• mcp-go binary installed

Steps:

1. Open Perplexity Settings:

   • Settings → Integrations → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Perplexity can access Go tools

Prerequisites:

• Amazon Q Developer CLI installed
• mcp-go binary installed

Steps:

1. Create or edit config file:

   • Location: ~/.aws-q/config.json or %USERPROFILE%\.aws-q\config.json

2. Add MCP server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Run aws-q commands with Go support

Prerequisites:

• Smithery installed
• mcp-go binary installed

Steps:

1. Open Smithery configuration:

   • Edit ~/.smithery/config.json or use Smithery UI

2. Add server:

{
  "servers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart Smithery

✅ Verify: Server appears in Smithery

Prerequisites:

• Claude Code CLI installed
• mcp-go binary installed

Steps:

1. Edit config file:

   • Location: ~/.claude-code/config.json

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: CLI can use Go tools

Prerequisites:

• Amp installed
• mcp-go binary installed

Steps:

1. Open Amp Settings:

   • Settings → MCP Servers

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Amp integration working

Prerequisites:

• Warp Terminal installed
• mcp-go binary installed

Steps:

1. Open Warp Settings:

   • Cmd+, (macOS) or Ctrl+, (Windows/Linux)

2. Navigate to AI → MCP Servers

3. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

4. Update path and restart Warp

✅ Verify: AI features in Warp can use Go tools

Prerequisites:

• Copilot Coding Agent installed
• mcp-go binary installed

Steps:

1. Edit config:

   • Location: ~/.copilot/config.json

2. Add MCP server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Copilot agent can use Go tools

Prerequisites:

• GitHub Copilot CLI installed
• mcp-go binary installed

Steps:

1. Configure Copilot CLI:

   • Edit ~/.github/copilot/config.json

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: CLI commands work with Go

Prerequisites:

• LM Studio installed
• mcp-go binary installed

Steps:

1. Open LM Studio Settings:

   • Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: LM Studio can use Go tools

Prerequisites:

• Visual Studio 2022 with MCP extension
• mcp-go binary installed

Steps:

1. Install MCP extension for Visual Studio 2022

2. Open Tools → Options → MCP Servers

3. Add server:

   • Name: mcp-go
   • Command: Path to mcp-go.exe
   • Args: (empty)

4. Save and restart Visual Studio

✅ Verify: MCP tools available in Visual Studio

Prerequisites:

• Roo Code installed
• mcp-go binary installed

Steps:

1. Open Roo Code Settings:

   • Settings → MCP Configuration

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Roo Code integration working

Prerequisites:

• Gemini CLI installed
• mcp-go binary installed

Steps:

1. Edit config:

   • Location: ~/.gemini/config.json

2. Add MCP server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Gemini CLI can use Go tools

Prerequisites:

• Qwen Coder installed
• mcp-go binary installed

Steps:

1. Open Settings:

   • Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Qwen Coder integration working

Prerequisites:

• Opencode installed
• mcp-go binary installed

Steps:

1. Edit config:

   • Location: ~/.opencode/config.json

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Opencode can use Go tools

Prerequisites:

• OpenAI Codex access
• mcp-go binary installed

Steps:

1. Configure Codex:

   • Edit ~/.openai/codex/config.json

2. Add MCP server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Codex integration working

Prerequisites:

• Kiro installed
• mcp-go binary installed

Steps:

1. Open Kiro Settings:

   • Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Kiro can use Go tools

Prerequisites:

• Trae installed
• mcp-go binary installed

Steps:

1. Edit config:

   • Location: ~/.trae/config.json

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Trae integration working

Prerequisites:

• Bun installed
• mcp-go binary installed

Steps:

1. Create MCP config:

   • Location: ~/.bun/mcp/config.json

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Bun can use MCP Go server

Prerequisites:

• Deno installed
• mcp-go binary installed

Steps:

1. Configure Deno MCP:

   • Edit ~/.deno/mcp/config.json

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Deno MCP integration working

Prerequisites:

• Docker installed
• Docker Compose (optional, for easier management)

Steps:

1. Pull the image:

docker pull ghcr.io/inja-online/golang-mcp:latest

2. Run the container:

docker run -it --rm \
  -v $(pwd):/workspace \
  -w /workspace \
  ghcr.io/inja-online/golang-mcp:latest

3. Or use docker-compose:
   • Create docker-compose.yml:

version: '3.8'
services:
  mcp-go:
    image: ghcr.io/inja-online/golang-mcp:latest
    volumes:
      - .:/workspace
    working_dir: /workspace
    stdin_open: true
    tty: true

4. Start with docker-compose:

docker-compose up

✅ Verify:

docker run --rm ghcr.io/inja-online/golang-mcp:latest mcp-go --version

💡 Tip: Use volumes to mount your Go projects into the container

Prerequisites:

• MCP-compatible client that supports .mcpb files

Steps:

1. Download the .mcpb file from releases

2. Install the bundle:

   • Double-click the .mcpb file, or
   • Use your MCP client's "Install Bundle" feature

3. Follow client-specific installation prompts

✅ Verify: Bundle appears in your MCP client's server list

💡 Tip: .mcpb files are self-contained bundles with all dependencies

Prerequisites:

• Windows 10/11
• Go 1.24+ installed (optional, for building from source)

Steps:

1. Download Windows binary:

   • Go to releases page
   • Download golang-mcp_Windows_x86_64.zip

2. Extract the archive:

   • Right-click → Extract All
   • Or use: Expand-Archive golang-mcp_Windows_x86_64.zip

3. Move to a permanent location:

   • Create folder: C:\Program Files\mcp-go\
   • Move mcp-go.exe there

4. Add to PATH:

   • Open System Properties → Environment Variables
   • Edit "Path" variable
   • Add: C:\Program Files\mcp-go
   • Click OK on all dialogs

5. Verify installation:

   • Open PowerShell or Command Prompt
   • Run: mcp-go --version

✅ Success: You should see the version number

⚠️ Troubleshooting:

• If command not found, restart your terminal after adding to PATH
• Check PATH with: $env:PATH (PowerShell) or echo %PATH% (CMD)
• Verify file exists: Test-Path "C:\Program Files\mcp-go\mcp-go.exe"

Prerequisites:

• BoltAI installed
• mcp-go binary installed

Steps:

1. Open BoltAI Settings:

   • Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: BoltAI integration working

Prerequisites:

• Rovo Dev CLI installed
• mcp-go binary installed

Steps:

1. Edit config:

   • Location: ~/.rovo/config.json

2. Add MCP server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Rovo CLI can use Go tools

Prerequisites:

• Zencoder installed
• mcp-go binary installed

Steps:

1. Open Zencoder Settings:

   • Settings → MCP Configuration

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Zencoder can use Go tools

Prerequisites:

• Qodo Gen installed
• mcp-go binary installed

Steps:

1. Edit configuration:

   • Location: ~/.qodo/config.json

2. Add MCP server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Qodo Gen integration working

Prerequisites:

• Factory installed
• mcp-go binary installed

Steps:

1. Open Factory Settings:

   • Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Factory can use Go tools

Prerequisites:

• Crush installed
• mcp-go binary installed

Steps:

1. Edit config:

   • Location: ~/.crush/config.json

2. Add server:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path

✅ Verify: Crush integration working

Prerequisites:

• Augment Code installed
• mcp-go binary installed

Steps:

1. Open Augment Code Settings:

   • Settings → MCP Servers

2. Add configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

3. Update path and restart

✅ Verify: Augment Code can use Go tools

Common issues and their solutions. Use the symptoms to find your problem quickly.

Installation Issues

❌ "Command not found: mcp-go"

Symptoms:

• Terminal says mcp-go: command not found
• Binary exists but can't be run

Solutions:

1. Check if binary is installed:

   which mcp-go  # macOS/Linux
   where mcp-go   # Windows
   

2. Add to PATH:

   • macOS/Linux: Add $HOME/go/bin to PATH

     export PATH=$PATH:$HOME/go/bin
     

   • Windows: Add %USERPROFILE%\go\bin to PATH in Environment Variables

3. Verify PATH:

   echo $PATH  # macOS/Linux
   echo %PATH% # Windows
   

✅ Success: mcp-go --version should work

❌ "Permission denied"

Symptoms:

• Permission denied error when running mcp-go

Solutions:

1. Make binary executable:

   chmod +x /path/to/mcp-go
   

2. Check file permissions:

   ls -l /path/to/mcp-go
   

3. On Windows: Run as Administrator if needed

❌ "Go version too old"

Symptoms:

• Error about Go version
• Requires Go 1.24+

Solutions:

1. Check Go version:

   go version
   

2. Update Go:

   • Visit golang.org
   • Download latest version
   • Install and restart terminal

Configuration Issues

❌ "Config file not found"

Symptoms:

• Platform can't find config file
• Server doesn't start

Solutions:

1. Create config file if it doesn't exist
2. Check file location (see platform-specific guides)
3. Verify JSON syntax is valid
4. Check file permissions (readable)

❌ "Invalid JSON in config"

Symptoms:

• Config file has syntax errors
• Server fails to start

Solutions:

1. Validate JSON:

   • Use online JSON validator
   • Or: python -m json.tool config.json

2. Common mistakes:

   • Missing commas
   • Trailing commas
   • Unclosed brackets

3. Fix and restart your MCP client

❌ "Binary path incorrect"

Symptoms:

• Server can't find mcp-go binary
• Path errors in logs

Solutions:

1. Find correct path:

   which mcp-go  # macOS/Linux
   where mcp-go  # Windows
   

2. Use absolute path in config (not relative)

3. On Windows: Use forward slashes or double backslashes:

   "command": "C:/Program Files/mcp-go/mcp-go.exe"
   // or
   "command": "C:\\Program Files\\mcp-go\\mcp-go.exe"
   

Platform-Specific Issues

❌ Claude Desktop: Tools don't appear

Symptoms:

• Config file looks correct
• Tools not available in Claude

Solutions:

1. Restart Claude Desktop completely
2. Check config file location:
   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows: %APPDATA%\Claude\claude_desktop_config.json
3. Validate JSON syntax
4. Check Claude Desktop logs for errors
5. Verify binary path is correct and executable

❌ VS Code: MCP extension not working

Symptoms:

• MCP extension installed but not working
• No tools available

Solutions:

1. Check extension is enabled
2. Reload VS Code window: Cmd+Shift+P → "Reload Window"
3. Check Output panel for MCP messages
4. Verify settings JSON syntax
5. Try workspace settings instead of user settings

❌ Docker: Container won't start

Symptoms:

• Docker container exits immediately
• Permission errors

Solutions:

1. Check Docker is running:

   docker ps
   

2. Check image exists:

   docker images | grep golang-mcp
   

3. Check volume mounts:

   • Verify paths are correct
   • Check permissions on mounted directories

4. View logs:

   docker logs <container-id>
   

Runtime Issues

❌ "Go command not found"

Symptoms:

• MCP server can't find go command
• Go tools fail

Solutions:

1. Verify Go is installed:

   go version
   

2. Check PATH includes Go:

   echo $PATH  # Should include Go bin directory
   

3. Set GOROOT if needed:

   export GOROOT=/usr/local/go
   

❌ "LSP tools not available"

Symptoms:

• LSP tools don't appear
• ENABLE_LSP=true but no tools

Solutions:

1. Check gopls is installed:

   which gopls
   go install golang.org/x/tools/gopls@latest
   

2. Verify ENABLE_LSP is set:

   echo $ENABLE_LSP  # Should be "true"
   

3. Restart MCP server after setting environment variable

❌ "Permission prompts keep appearing"

Symptoms:

• Permission prompts for every command
• Want to disable them

Solutions:

1. Set DISABLE_NOTIFICATIONS:

   export DISABLE_NOTIFICATIONS=true
   

2. Add to config file env section:

   "env": {
     "DISABLE_NOTIFICATIONS": "true"
   }
   

3. Restart MCP client

Performance Issues

❌ "Server is slow"

Symptoms:

• Commands take too long
• Timeouts

Solutions:

1. Enable debug logging:

   export DEBUG_MCP=true
   

2. Check system resources (CPU, memory)

3. Check Go proxy:

   go env GOPROXY
   

4. Try different GOPROXY:

   export GOPROXY=https://proxy.golang.org
   

Getting More Help

Still having issues?

1. Check logs:

   • Enable DEBUG_MCP=true
   • Check platform-specific log locations

2. Verify installation:

   mcp-go --version
   go version
   

3. Test standalone:

   echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | mcp-go
   

4. Check GitHub Issues:

   • Search existing issues
   • Create new issue with:
     • Error messages
     • Platform information
     • Config file (sanitized)
     • Debug logs

Code Execution Tools

✅ go_run

Execute a Go file directly using go run.

Parameters:

• file (string, required): Path to the Go file to run
• args ([]string, optional): Command line arguments to pass to the program
• working_dir (string, optional): Working directory for the command
• env_vars (map[string]string, optional): Additional environment variables

Examples:

Run a simple Go file:

{
  "name": "go_run",
  "arguments": {
    "file": "main.go"
  }
}

Run with command line arguments:

{
  "name": "go_run",
  "arguments": {
    "file": "server.go",
    "args": ["--port", "8080", "--host", "localhost"]
  }
}

Run with environment variables:

{
  "name": "go_run",
  "arguments": {
    "file": "app.go",
    "env_vars": {
      "DEBUG": "true",
      "LOG_LEVEL": "info"
    }
  }
}

Go Tools

🔧 7 tools for building, testing, formatting, and managing Go code.

✅ go_build

Build Go packages and dependencies with various build flags.

Parameters:

• package (string, optional): Package path to build (default: current directory)
• output (string, optional): Output file name
• race (bool, optional): Enable race detector
• tags ([]string, optional): Build tags
• ldflags (string, optional): Linker flags
• trimpath (bool, optional): Remove file system paths from executable
• working_dir (string, optional): Working directory

Examples:

Basic build:

{
  "name": "go_build",
  "arguments": {
    "output": "myapp"
  }
}

Build with race detector:

{
  "name": "go_build",
  "arguments": {
    "output": "myapp",
    "race": true
  }
}

Build with build tags and version info:

{
  "name": "go_build",
  "arguments": {
    "output": "myapp",
    "tags": ["production", "linux"],
    "ldflags": "-X main.version=1.0.0 -X main.buildTime=$(date +%s)",
    "trimpath": true
  }
}

go_test

Run Go tests with coverage, benchmarks, and race detection.

Parameters:

• package (string, optional): Package path to test
• cover (bool, optional): Enable coverage analysis
• cover_pkg (string, optional): Packages to cover
• bench (bool, optional): Run benchmarks
• race (bool, optional): Enable race detector
• verbose (bool, optional): Verbose output
• timeout (string, optional): Test timeout

Examples:

Run all tests:

{
  "name": "go_test",
  "arguments": {
    "verbose": true
  }
}

Run tests with coverage:

{
  "name": "go_test",
  "arguments": {
    "cover": true,
    "cover_pkg": "./..."
  }
}

Run tests with benchmarks and race detection:

{
  "name": "go_test",
  "arguments": {
    "bench": true,
    "race": true,
    "timeout": "30s"
  }
}

go_fmt

Format Go code using go fmt.

Parameters:

• paths ([]string, optional): Paths to format (default: current directory)
• working_dir (string, optional): Working directory

Examples:

Format current directory:

{
  "name": "go_fmt",
  "arguments": {}
}

Format specific files:

{
  "name": "go_fmt",
  "arguments": {
    "paths": ["./cmd", "./internal"]
  }
}

go_mod

Manage Go modules (init, tidy, download, vendor, get).

Parameters:

• operation (string, required): Module operation: init, tidy, download, vendor, get
• module_path (string, optional): Module path (for init or get)
• packages ([]string, optional): Package paths (for get)
• working_dir (string, optional): Working directory

Examples:

Initialize a new module:

{
  "name": "go_mod",
  "arguments": {
    "operation": "init",
    "module_path": "github.com/user/project"
  }
}

Tidy dependencies:

{
  "name": "go_mod",
  "arguments": {
    "operation": "tidy"
  }
}

Add a dependency:

{
  "name": "go_mod",
  "arguments": {
    "operation": "get",
    "packages": ["github.com/gin-gonic/gin@latest"]
  }
}

Vendor dependencies:

{
  "name": "go_mod",
  "arguments": {
    "operation": "vendor"
  }
}

go_doc

Generate documentation for Go packages.

Parameters:

• package (string, required): Package path
• all (bool, optional): Show all documentation
• working_dir (string, optional): Working directory

Examples:

View package documentation:

{
  "name": "go_doc",
  "arguments": {
    "package": "net/http"
  }
}

View all documentation including unexported symbols:

{
  "name": "go_doc",
  "arguments": {
    "package": "./internal/utils",
    "all": true
  }
}

go_lint

Lint Go code using golangci-lint or go vet.

Parameters:

• package (string, optional): Package path to lint
• linter (string, optional): Linter to use: golangci-lint or vet (default: vet)
• working_dir (string, optional): Working directory

Examples:

Lint with go vet:

{
  "name": "go_lint",
  "arguments": {
    "package": "./..."
  }
}

Lint with golangci-lint:

{
  "name": "go_lint",
  "arguments": {
    "linter": "golangci-lint",
    "package": "./cmd"
  }
}

go_cross_compile

Cross-compile Go code for different platforms.

Parameters:

• package (string, optional): Package path to build
• output (string, required): Output file name
• goos (string, required): Target OS (e.g., linux, darwin, windows)
• goarch (string, required): Target architecture (e.g., amd64, arm64)
• working_dir (string, optional): Working directory

Examples:

Build for Linux:

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "myapp-linux",
    "goos": "linux",
    "goarch": "amd64"
  }
}

Build for Windows:

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "myapp.exe",
    "goos": "windows",
    "goarch": "amd64"
  }
}

Build for macOS ARM:

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "myapp-darwin-arm64",
    "goos": "darwin",
    "goarch": "arm64"
  }
}

Optimization Tools

⚡ 6 tools for profiling, benchmarking, and optimizing Go code performance.

✅ go_profile

Generate performance profile using pprof.

Parameters:

• type (string, required): Profile type: cpu or mem
• output (string, required): Output profile file path
• duration (string, optional): Profile duration
• package (string, optional): Package to profile
• working_dir (string, optional): Working directory

Examples:

Generate CPU profile:

{
  "name": "go_profile",
  "arguments": {
    "type": "cpu",
    "output": "cpu.prof"
  }
}

Generate memory profile:

{
  "name": "go_profile",
  "arguments": {
    "type": "mem",
    "output": "mem.prof",
    "package": "./internal/handlers"
  }
}

go_trace

Generate execution trace for Go programs.

Parameters:

• output (string, required): Output trace file path
• package (string, optional): Package to trace
• working_dir (string, optional): Working directory

Example:

{
  "name": "go_trace",
  "arguments": {
    "output": "trace.out",
    "package": "./..."
  }
}

go_benchmark

Run benchmarks and analyze results.

Parameters:

• pattern (string, optional): Benchmark pattern to match
• count (int, optional): Number of iterations
• timeout (string, optional): Benchmark timeout
• package (string, optional): Package to benchmark
• working_dir (string, optional): Working directory

Examples:

Run all benchmarks:

{
  "name": "go_benchmark",
  "arguments": {}
}

Run specific benchmark pattern:

{
  "name": "go_benchmark",
  "arguments": {
    "pattern": "BenchmarkSort",
    "count": 5
  }
}

Run benchmarks with timeout:

{
  "name": "go_benchmark",
  "arguments": {
    "timeout": "10m",
    "package": "./internal/cache"
  }
}

go_race_detect

Detect race conditions in Go code.

Parameters:

• package (string, optional): Package to test
• working_dir (string, optional): Working directory

Example:

{
  "name": "go_race_detect",
  "arguments": {
    "package": "./..."
  }
}

go_memory_profile

Generate memory profile for analysis.

Parameters:

• output (string, required): Output profile file path
• package (string, optional): Package to profile
• working_dir (string, optional): Working directory

Example:

{
  "name": "go_memory_profile",
  "arguments": {
    "output": "mem.prof",
    "package": "./internal/processor"
  }
}

go_optimize_suggest

Analyze code and provide optimization suggestions based on profiling and benchmarking.

Parameters:

• package (string, optional): Package to analyze
• working_dir (string, optional): Working directory

Examples:

Analyze current package:

{
  "name": "go_optimize_suggest",
  "arguments": {}
}

Analyze specific package:

{
  "name": "go_optimize_suggest",
  "arguments": {
    "package": "./internal/processor"
  }
}

This tool runs benchmarks and static analysis to provide optimization suggestions including:

• Benchmark results for performance baseline
• Static analysis issues from go vet
• General optimization recommendations
• Suggestions for race detection, profiling, and concurrency improvements

Server Management Tools

🚀 5 tools for managing long-running Go servers in the background.

✅ go_server_start

Start a long-running Go server in the background.

Parameters:

• id (string, required): Unique server ID
• name (string, required): Server name
• command (string, required): Command to run (usually 'go' or binary path)
• args ([]string, required): Command arguments
• working_dir (string, optional): Working directory
• env_vars (map[string]string, optional): Environment variables
• log_size (int, optional): Maximum log lines to keep (default: 1000)

go_server_stop

Stop a running server.

Parameters:

• id (string, required): Server ID
• force (bool, optional): Force kill the server (SIGKILL)

go_server_list

List all running servers.

go_server_logs

Get logs from a running server.

Parameters:

• id (string, required): Server ID
• count (int, optional): Number of recent log lines (0 for all)

go_server_status

Get detailed status of a server.

Parameters:

• id (string, required): Server ID

Package Documentation Tools

📚 3 tools for discovering and exploring Go package documentation.

✅ go_pkg_docs

Fetch package documentation from go.dev (pkg.go.dev). Returns package overview, functions, types, and examples.

Parameters:

• package (string, required): Package path (e.g., github.com/gin-gonic/gin, net/http)
• version (string, optional): Package version

Examples:

Fetch standard library documentation:

{
  "name": "go_pkg_docs",
  "arguments": {
    "package": "net/http"
  }
}

Fetch third-party package documentation:

{
  "name": "go_pkg_docs",
  "arguments": {
    "package": "github.com/gin-gonic/gin",
    "version": "v1.9.1"
  }
}

The tool returns:

• Package overview and description
• List of functions with signatures and descriptions
• List of types with their kinds and descriptions
• Code examples (if available)

go_pkg_search

Search for packages on go.dev. Returns a list of matching package paths.

Parameters:

• query (string, required): Search query

Examples:

Search for HTTP routers:

{
  "name": "go_pkg_search",
  "arguments": {
    "query": "http router"
  }
}

Search for database drivers:

{
  "name": "go_pkg_search",
  "arguments": {
    "query": "database driver postgres"
  }
}

The tool returns a list of package paths matching your query, which you can then use with go_pkg_docs to review documentation.

go_pkg_examples

Extract examples from package documentation.

Parameters:

• package (string, required): Package path
• version (string, optional): Package version

Examples:

Extract examples from standard library:

{
  "name": "go_pkg_examples",
  "arguments": {
    "package": "net/http"
  }
}

Extract examples from third-party package:

{
  "name": "go_pkg_examples",
  "arguments": {
    "package": "github.com/gin-gonic/gin",
    "version": "v1.9.1"
  }
}

LSP Tools

🔌 5 tools for Language Server Protocol integration (optional).

⚠️ Note: LSP tools are optional and require ENABLE_LSP=true environment variable to be set. These tools provide Language Server Protocol integration for advanced IDE features.

✅ lsp_start_session

Start an LSP session for a workspace root URI.

Parameters:

• root_uri (string, required): Workspace root URI (file:// path)
• gopls_path (string, optional): Path to gopls binary (default: searches PATH)
• args ([]string, optional): Additional arguments for gopls
• env (map[string]string, optional): Environment variables for gopls

Examples:

Start session with default gopls:

{
  "name": "lsp_start_session",
  "arguments": {
    "root_uri": "file:///path/to/workspace"
  }
}

Start session with custom gopls path:

{
  "name": "lsp_start_session",
  "arguments": {
    "root_uri": "file:///path/to/workspace",
    "gopls_path": "/usr/local/bin/gopls",
    "args": ["-rpc.trace"],
    "env": {
      "GOPATH": "/custom/gopath"
    }
  }
}

lsp_shutdown_session

Shutdown an LSP session for a workspace root URI.

Parameters:

• root_uri (string, required): Workspace root URI

Example:

{
  "name": "lsp_shutdown_session",
  "arguments": {
    "root_uri": "file:///path/to/workspace"
  }
}

lsp_request

Send a request to an LSP session and wait for a result.

Parameters:

• root_uri (string, required): Workspace root URI
• method (string, required): LSP method name (e.g., "textDocument/hover", "textDocument/completion")
• params (object, optional): Request parameters

Examples:

Get hover information:

{
  "name": "lsp_request",
  "arguments": {
    "root_uri": "file:///path/to/workspace",
    "method": "textDocument/hover",
    "params": {
      "textDocument": {
        "uri": "file:///path/to/workspace/main.go"
      },
      "position": {
        "line": 10,
        "character": 5
      }
    }
  }
}

Get code completion:

{
  "name": "lsp_request",
  "arguments": {
    "root_uri": "file:///path/to/workspace",
    "method": "textDocument/completion",
    "params": {
      "textDocument": {
        "uri": "file:///path/to/workspace/main.go"
      },
      "position": {
        "line": 15,
        "character": 20
      }
    }
  }
}

lsp_notify

Send a notification to an LSP session (does not wait for response).

Parameters:

• root_uri (string, required): Workspace root URI
• method (string, required): LSP method name (e.g., "textDocument/didChange", "textDocument/didOpen")
• params (object, optional): Notification parameters

Example:

{
  "name": "lsp_notify",
  "arguments": {
    "root_uri": "file:///path/to/workspace",
    "method": "textDocument/didOpen",
    "params": {
      "textDocument": {
        "uri": "file:///path/to/workspace/main.go",
        "languageId": "go",
        "version": 1,
        "text": "package main\n\nfunc main() {\n}"
      }
    }
  }
}

lsp_subscribe_diagnostics

Subscribe to diagnostics published by an LSP session.

Parameters:

• root_uri (string, required): Workspace root URI

Example:

{
  "name": "lsp_subscribe_diagnostics",
  "arguments": {
    "root_uri": "file:///path/to/workspace"
  }
}

This enables receiving diagnostic notifications (errors, warnings, etc.) from the LSP server for the specified workspace.

This section provides practical, copy-pasteable examples demonstrating common workflows, tool combinations, and real-world scenarios.

Common Development Workflows

Quick Start Workflow

Initialize a new project, format code, run tests, and build:

{
  "name": "go_mod",
  "arguments": {
    "operation": "init",
    "module_path": "github.com/user/myproject"
  }
}

{
  "name": "go_fmt",
  "arguments": {
    "paths": ["./..."]
  }
}

{
  "name": "go_test",
  "arguments": {
    "verbose": true
  }
}

{
  "name": "go_build",
  "arguments": {
    "output": "myapp"
  }
}

Testing Workflow

Run comprehensive tests with coverage and race detection:

{
  "name": "go_test",
  "arguments": {
    "cover": true,
    "cover_pkg": "./...",
    "race": true,
    "verbose": true
  }
}

{
  "name": "go_race_detect",
  "arguments": {
    "package": "./..."
  }
}

Performance Analysis Workflow

Benchmark, profile, and optimize code:

{
  "name": "go_benchmark",
  "arguments": {
    "pattern": "Benchmark.*",
    "count": 5
  }
}

{
  "name": "go_profile",
  "arguments": {
    "type": "cpu",
    "output": "cpu.prof",
    "duration": "30s",
    "package": "./internal/processor"
  }
}

{
  "name": "go_memory_profile",
  "arguments": {
    "output": "mem.prof",
    "package": "./internal/processor"
  }
}

Cross-Compilation Workflow

Build for multiple platforms:

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "myapp-linux-amd64",
    "goos": "linux",
    "goarch": "amd64"
  }
}

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "myapp-darwin-arm64",
    "goos": "darwin",
    "goarch": "arm64"
  }
}

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "myapp-windows-amd64.exe",
    "goos": "windows",
    "goarch": "amd64"
  }
}

Multi-Tool Examples

Complete CI/CD-like Workflow

Format, lint, test, and build with production flags:

{
  "name": "go_fmt",
  "arguments": {
    "paths": ["./..."]
  }
}

{
  "name": "go_lint",
  "arguments": {
    "linter": "golangci-lint",
    "package": "./..."
  }
}

{
  "name": "go_test",
  "arguments": {
    "cover": true,
    "cover_pkg": "./...",
    "race": true
  }
}

{
  "name": "go_build",
  "arguments": {
    "output": "myapp",
    "trimpath": true,
    "ldflags": "-X main.version=1.0.0 -X main.buildTime=$(date +%s)"
  }
}

Server Development Workflow

Build, start, monitor, and stop a server:

{
  "name": "go_build",
  "arguments": {
    "output": "server"
  }
}

{
  "name": "go_server_start",
  "arguments": {
    "id": "api-server",
    "name": "API Server",
    "command": "./server",
    "args": ["--port", "8080"],
    "env_vars": {
      "ENV": "development",
      "LOG_LEVEL": "debug"
    }
  }
}

{
  "name": "go_server_logs",
  "arguments": {
    "id": "api-server",
    "count": 50
  }
}

{
  "name": "go_server_status",
  "arguments": {
    "id": "api-server"
  }
}

{
  "name": "go_server_stop",
  "arguments": {
    "id": "api-server"
  }
}

Package Research Workflow

Search for packages, fetch documentation, and extract examples:

{
  "name": "go_pkg_search",
  "arguments": {
    "query": "http router"
  }
}

{
  "name": "go_pkg_docs",
  "arguments": {
    "package": "github.com/gin-gonic/gin"
  }
}

{
  "name": "go_pkg_examples",
  "arguments": {
    "package": "github.com/gin-gonic/gin"
  }
}

Integration Examples

Claude Desktop Setup

macOS Configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true",
        "GOPROXY": "https://proxy.golang.org"
      }
    }
  }
}

Windows Configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "C:\\Program Files\\mcp-go\\mcp-go.exe",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true"
      }
    }
  }
}

Linux Configuration:

{
  "mcpServers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true",
        "GOROOT": "/usr/local/go"
      }
    }
  }
}

Troubleshooting:

• Verify installation: Check that mcp-go --version works in terminal
• Check permissions: Ensure the binary is executable (chmod +x /path/to/mcp-go)
• Test connection: Restart Claude Desktop after configuration changes
• View logs: Check Claude Desktop logs for connection errors

VS Code Setup

Workspace Settings (.vscode/settings.json):

{
  "mcp.servers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": [],
      "env": {
        "DISABLE_NOTIFICATIONS": "true"
      }
    }
  }
}

User Settings (Global):

{
  "mcp.servers": {
    "mcp-go": {
      "command": "/usr/local/bin/mcp-go",
      "args": []
    }
  }
}

Debugging Tips:

• Enable MCP logging in VS Code settings
• Check Output panel for MCP server messages
• Verify Go environment: Ensure go version works in integrated terminal
• Test tools: Try calling go_fmt or go_test to verify connection

Standalone Usage

Testing the Server Directly:

echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}' | mcp-go

JSON-RPC Request Example:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "go_run",
    "arguments": {
      "file": "main.go"
    }
  }
}

JSON-RPC Response Example:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Hello, World!"
      }
    ]
  }
}

Real-World Scenarios

Building a REST API

Complete workflow for developing and testing a REST API:

{
  "name": "go_pkg_search",
  "arguments": {
    "query": "gin echo fiber"
  }
}

{
  "name": "go_pkg_docs",
  "arguments": {
    "package": "github.com/gin-gonic/gin"
  }
}

{
  "name": "go_mod",
  "arguments": {
    "operation": "get",
    "packages": ["github.com/gin-gonic/gin@latest"]
  }
}

{
  "name": "go_server_start",
  "arguments": {
    "id": "rest-api",
    "name": "REST API Server",
    "command": "go",
    "args": ["run", "main.go"],
    "env_vars": {
      "PORT": "8080",
      "ENV": "development"
    }
  }
}

{
  "name": "go_server_logs",
  "arguments": {
    "id": "rest-api",
    "count": 100
  }
}

{
  "name": "go_profile",
  "arguments": {
    "type": "cpu",
    "output": "api-cpu.prof",
    "duration": "60s"
  }
}

{
  "name": "go_server_stop",
  "arguments": {
    "id": "rest-api"
  }
}

Library Development

Workflow for developing and publishing a Go library:

{
  "name": "go_fmt",
  "arguments": {
    "paths": ["./..."]
  }
}

{
  "name": "go_lint",
  "arguments": {
    "linter": "golangci-lint",
    "package": "./..."
  }
}

{
  "name": "go_test",
  "arguments": {
    "cover": true,
    "cover_pkg": "./...",
    "bench": true
  }
}

{
  "name": "go_benchmark",
  "arguments": {
    "pattern": "Benchmark.*",
    "count": 10
  }
}

{
  "name": "go_doc",
  "arguments": {
    "package": "./...",
    "all": false
  }
}

{
  "name": "go_cross_compile",
  "arguments": {
    "output": "lib-test-linux",
    "goos": "linux",
    "goarch": "amd64"
  }
}

Debugging Performance Issues

Identify and fix performance bottlenecks:

{
  "name": "go_benchmark",
  "arguments": {
    "pattern": "BenchmarkSlowFunction",
    "count": 20
  }
}

{
  "name": "go_profile",
  "arguments": {
    "type": "cpu",
    "output": "slow-cpu.prof",
    "duration": "30s",
    "package": "./internal/slow"
  }
}

{
  "name": "go_trace",
  "arguments": {
    "output": "slow-trace.out",
    "package": "./internal/slow"
  }
}

{
  "name": "go_memory_profile",
  "arguments": {
    "output": "slow-mem.prof",
    "package": "./internal/slow"
  }
}

{
  "name": "go_race_detect",
  "arguments": {
    "package": "./internal/slow"
  }
}

After profiling, analyze results:

go tool pprof cpu.prof
go tool trace trace.out
go tool pprof mem.prof

Resources Usage

Resources provide structured information about your Go workspace. Access them through the MCP resource protocol.

Using go://modules

Discover project dependencies and module information:

Access Pattern:

Resource URI: go://modules

Use Cases:

• Understanding project dependencies before adding new packages
• Checking module versions
• Identifying unused dependencies
• Planning dependency updates

Example Workflow:

1. Access go://modules to see current dependencies
2. Use go_pkg_search to find alternatives
3. Use go_mod with operation: "get" to add new packages
4. Use go_mod with operation: "tidy" to clean up

Using go://build-tags

Discover build tags and conditional compilation:

Access Pattern:

Resource URI: go://build-tags

Use Cases:

• Understanding platform-specific code
• Finding feature flags
• Planning cross-compilation
• Identifying conditional builds

Example Workflow:

1. Access go://build-tags to see available tags
2. Use go_build with tags: ["production", "linux"] for specific builds
3. Use go_cross_compile with appropriate tags for platform builds

Using go://tests

Discover test files and benchmarks:

Access Pattern:

Resource URI: go://tests

Use Cases:

• Finding all test files in the project
• Discovering benchmark functions
• Planning test coverage improvements
• Understanding test structure

Example Workflow:

1. Access go://tests to see all test files
2. Use go_test with cover: true to run with coverage
3. Use go_benchmark to run specific benchmarks
4. Use go_race_detect to check for race conditions

Using go://workspace

Understand project structure and configuration:

Access Pattern:

Resource URI: go://workspace

Use Cases:

• Understanding project layout
• Finding main packages
• Discovering module structure
• Planning refactoring

Example Workflow:

1. Access go://workspace to understand structure
2. Use go_build with appropriate package paths
3. Use go_test with specific package paths
4. Use go_fmt with targeted paths

Using go://pkg-docs/{path}

Access package documentation directly:

Access Pattern:

Resource URI: go://pkg-docs/net/http
Resource URI: go://pkg-docs/github.com/gin-gonic/gin

Use Cases:

• Quick access to standard library docs
• Viewing third-party package documentation
• Learning package APIs
• Finding usage examples

Example Workflow:

1. Access go://pkg-docs/net/http for HTTP package docs
2. Use go_pkg_examples to get code examples
3. Use go_doc for local package documentation
4. Integrate examples into your code

Example with version:

Resource URI: go://pkg-docs/github.com/gin-gonic/gin@v1.9.1

Using go://tools

Discover all available tools and their capabilities:

Access Pattern:

Resource URI: go://tools

Use Cases:

• Discovering available tools when starting with the server
• Understanding tool parameters and schemas
• Finding the right tool for a specific task
• Exploring tool capabilities

Example Workflow:

1. Access go://tools to see all 22 available tools
2. Review tool descriptions and parameter schemas
3. Select appropriate tools for your workflow
4. Use tools in combination for complex tasks

Example Response Structure: The resource returns a JSON object with:

• tools: Array of tool metadata including name, description, and input schema
• count: Total number of tools available

Using go://prompts

Discover all available prompts for guided workflows:

Access Pattern:

Resource URI: go://prompts

Use Cases:

• Finding prompts for specific development tasks
• Understanding prompt arguments and requirements
• Discovering guided workflows
• Planning development processes

Example Workflow:

1. Access go://prompts to see all 7 available prompts
2. Review prompt descriptions and arguments
3. Use appropriate prompts for your development phase
4. Combine prompts with tools for complete workflows

Example Response Structure: The resource returns a JSON object with:

• prompts: Array of prompt metadata including name, description, and arguments
• count: Total number of prompts available

Using go://resources

Discover all available resources:

Access Pattern:

Resource URI: go://resources

Use Cases:

• Understanding what resources are available
• Finding resource URIs and descriptions
• Planning resource-based workflows
• Discovering workspace discovery capabilities

Example Workflow:

1. Access go://resources to see all 8 available resources
2. Review resource URIs and descriptions
3. Use resources to gather workspace information
4. Combine resources with tools for informed decision-making

Example Response Structure: The resource returns a JSON object with:

• resources: Array of resource metadata including URI, name, description, and MIME type
• count: Total number of resources available

Resource Integration Examples

Complete Project Analysis Workflow

1. Understand project structure:

   • Access go://workspace to see project layout
   • Access go://modules to understand dependencies

2. Analyze code quality:

   • Access go://tests to see test coverage
   • Access go://build-tags to understand conditional compilation

3. Plan improvements:

   • Access go://tools to find appropriate tools
   • Access go://prompts for guided workflows

4. Execute improvements:

   • Use tools based on resource insights
   • Follow prompts for structured workflows

Dependency Management Workflow

1. Access go://modules to see current dependencies
2. Use go_pkg_search to find alternatives
3. Access go://pkg-docs/{package} to review documentation
4. Use go_mod to add dependencies
5. Access go://modules again to verify changes

Test Coverage Analysis Workflow

1. Access go://tests to see all test files
2. Use go_test with cover: true to get coverage report
3. Identify gaps in test coverage
4. Use write-go-tests prompt for guidance
5. Access go://tests again to verify new tests

Combining Tools in Complex Workflows

Pre-commit Workflow

Automated checks before committing code:

{
  "name": "go_fmt",
  "arguments": {
    "paths": ["./..."]
  }
}

{
  "name": "go_lint",
  "arguments": {
    "linter": "golangci-lint",
    "package": "./..."
  }
}

{
  "name": "go_test",
  "arguments": {
    "cover": true,
    "race": true
  }
}

Release Preparation Workflow

Prepare a release with multiple platform builds:

{
  "name": "go_mod",
  "arguments": {
    "operation": "tidy"
  }
}

{
  "name": "go_test",
  "arguments": {
    "cover": true,
    "cover_pkg": "./..."
  }
}

{
  "name": "go_build",
  "arguments": {
    "output": "myapp",
    "trimpath": true,
    "ldflags": "-X main.version=1.0.0"
  }
}

Then cross-compile for all target platforms.

Continuous Profiling Workflow

Monitor performance over time:

{
  "name": "go_server_start",
  "arguments": {
    "id": "monitored-server",
    "name": "Monitored Server",
    "command": "go",
    "args": ["run", "main.go"]
  }
}

{
  "name": "go_profile",
  "arguments": {
    "type": "cpu",
    "output": "profile-$(date +%s).prof",
    "duration": "5m"
  }
}

Periodically check logs and profiles to identify trends.

Using Resources with Tools

Dependency Management Workflow

Use resources to inform tool usage:

1. Access go://modules to see current dependencies
2. Use go_pkg_search to find alternatives
3. Compare with go_pkg_docs for each option
4. Use go_mod to add the chosen package
5. Access go://modules again to verify

Test-Driven Development Workflow

Use resources to guide testing:

1. Access go://tests to see existing test structure
2. Use go_test with cover: true to see coverage gaps
3. Write new tests based on coverage report
4. Use go_benchmark to ensure performance
5. Access go://tests to verify new tests are included

Error Handling and Troubleshooting

Build Failures

When builds fail, use this diagnostic workflow:

{
  "name": "go_fmt",
  "arguments": {
    "paths": ["./..."]
  }
}

{
  "name": "go_lint",
  "arguments": {
    "package": "./..."
  }
}

{
  "name": "go_mod",
  "arguments": {
    "operation": "tidy"
  }
}

{
  "name": "go_build",
  "arguments": {
    "output": "myapp"
  }
}

Test Failures

When tests fail, investigate systematically:

{
  "name": "go_test",
  "arguments": {
    "verbose": true,
    "package": "./internal/failing"
  }
}

{
  "name": "go_race_detect",
  "arguments": {
    "package": "./internal/failing"
  }
}

{
  "name": "go_trace",
  "arguments": {
    "output": "test-trace.out",
    "package": "./internal/failing"
  }
}

Server Issues

When servers behave unexpectedly:

{
  "name": "go_server_status",
  "arguments": {
    "id": "problematic-server"
  }
}

{
  "name": "go_server_logs",
  "arguments": {
    "id": "problematic-server",
    "count": 0
  }
}

{
  "name": "go_profile",
  "arguments": {
    "type": "mem",
    "output": "server-mem.prof",
    "duration": "60s"
  }
}

Best Practices

For Development

• Use go_fmt before every commit
• Run go_test with race: true for concurrent code
• Use go_lint regularly to catch issues early
• Access go://workspace to understand project structure

For Production

• Always use trimpath: true in builds
• Include version info via ldflags
• Test with go_race_detect before releases
• Cross-compile and test on target platforms

For Performance

• Benchmark before and after optimizations
• Profile with realistic workloads
• Use go_trace for concurrency issues
• Monitor memory profiles for leaks

For Package Management

• Use go://modules to understand dependencies
• Search packages before adding (go_pkg_search)
• Review docs (go_pkg_docs) before integration
• Use go_mod tidy regularly to clean up