Golang Mcp Server

前置条件：

• 已安装 Claude Desktop
• 已安装 mcp-go 二进制文件（参见安装方式）

步骤：

1. 找到配置文件位置：

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

2. 打开或创建配置文件

3. 添加 MCP 服务配置：

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

4. 更新命令路径：

   • 将 /usr/local/bin/mcp-go 替换为实际的 mcp-go 路径
   • 使用以下命令查找：which mcp-go（macOS/Linux）或 where mcp-go（Windows）

5. 重启 Claude Desktop

✅ 验证：

• 打开 Claude Desktop
• 检查 MCP 工具是否可用
• 尝试让 Claude 运行 Go 命令

⚠️ 故障排除：

• 如果工具没有显示，请检查配置文件的 JSON 是否有效
• 确认二进制文件路径正确
• 检查 Claude Desktop 日志中是否有错误

前置条件：

• 已安装 Cursor
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Cursor 设置：

   • 按 Cmd+,（macOS）或 Ctrl+,（Windows/Linux）
   • 或者：Cursor → 设置 → 设置

2. 导航到 MCP Servers：

   • 在设置中搜索 “MCP”
   • 或者前往：设置 → 功能 → MCP Servers

3. 添加服务配置：

   • 点击 “Add Server” 或编辑设置 JSON
   • 添加配置：

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

4. 更新命令路径以匹配你的安装位置

5. 重新加载 Cursor（重启或重新加载窗口）

✅ 验证：

• 打开一个 Go 文件
• 检查命令面板中是否提供 MCP 工具
• 尝试使用 Go 相关的 AI 功能

前置条件：

• 已安装 MCP 扩展的 VS Code
• 已安装 mcp-go 二进制文件

步骤：

1. 选择配置位置：

   • 工作区： .vscode/settings.json（项目专用）
   • 用户： 用户设置 JSON（全局）

2. 打开设置 JSON：

   • 按 Cmd+Shift+P（macOS）或 Ctrl+Shift+P（Windows/Linux）
   • 输入 "Preferences: Open Settings (JSON)"
   • 或在工作区中编辑 .vscode/settings.json

3. 添加 MCP 服务配置：

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

4. 更新命令路径

5. 重新加载 VS Code 窗口

✅ 验证：

• 在“输出”面板中检查 MCP 服务消息
• 验证 Go 环境：在集成终端中运行 go version
• 测试工具：尝试调用 go_fmt 或 go_test

**💡 提示：**对于工作区设置，请在项目根目录中创建 .vscode/settings.json

前置条件：

• 已安装 Cline 扩展的 VS Code
• 已安装 mcp-go 二进制文件

步骤：

1. 从 VS Code 市场安装 Cline 扩展

2. 打开 Cline 设置：

   • 前往：设置 → 扩展 → Cline
   • 或编辑设置 JSON

3. 添加 MCP 服务：

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

4. 更新命令路径并重新加载

**✅ 验证：**Cline 应能识别 MCP Go 工具

前置条件：

• 已安装 Windsurf
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Windsurf 设置：

   • 前往设置 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启 Windsurf

**✅ 验证：**Windsurf 中可使用 MCP 工具

前置条件：

• 已安装 Zed
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Zed 设置：

   • Cmd+,（macOS）或 Ctrl+,（Windows/Linux）

2. 找到 MCP 配置：

   • 设置 → 功能 → MCP

3. 添加服务：

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

4. 更新路径并重启 Zed

**✅ 验证：**MCP 集成正常工作

前置条件：

• 已启用 AI Assistant 的 JetBrains IDE
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 IDE 设置：

   • 前往：设置/偏好设置 → 工具 → AI Assistant → MCP 服务

2. 添加 MCP 服务：

   • 点击“添加”或编辑配置
   • 添加：

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

3. 更新路径并重启 IDE

**✅ 验证：**AI Assistant 可以使用 Go 工具

**💡 提示：**适用于 IntelliJ IDEA、GoLand、WebStorm、PyCharm 等

前置条件：

• 已安装 Perplexity Desktop
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Perplexity 设置：

   • 设置 → 集成 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启

**✅ 验证：**Perplexity 可以访问 Go 工具

前置条件：

• 已安装 Amazon Q Developer CLI
• 已安装 mcp-go 二进制文件

步骤：

1. 创建或编辑配置文件：

   • 位置：~/.aws-q/config.json 或 %USERPROFILE%\.aws-q\config.json

2. 添加 MCP 服务：

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

3. 更新路径

**✅ 验证：**运行支持 Go 的 aws-q 命令

步骤：

1. 打开 Smithery 配置：

   • 编辑 ~/.smithery/config.json，或使用 Smithery UI

2. 添加服务：

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

3. 更新路径并重启 Smithery

✅ 验证： 服务显示在 Smithery 中

前置条件：

• 已安装 Claude Code CLI
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置文件：

   • 位置：~/.claude-code/config.json

2. 添加配置：

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

3. 更新路径

✅ 验证： CLI 可以使用 Go 工具

前置条件：

• 已安装 Amp
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Amp 设置：

   • 设置 → MCP 服务

2. 添加服务：

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

3. 更新路径并重启

✅ 验证： Amp 集成正常运行

前置条件：

• 已安装 Warp Terminal
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Warp 设置：

   • Cmd+,（macOS）或 Ctrl+,（Windows/Linux）

2. 导航至 AI → MCP 服务

3. 添加配置：

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

4. 更新路径并重启 Warp

✅ 验证： Warp 中的 AI 功能可以使用 Go 工具

前置条件：

• 已安装 Copilot Coding Agent
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.copilot/config.json

2. 添加 MCP 服务：

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

3. 更新路径

✅ 验证： Copilot Agent 可以使用 Go 工具

前置条件：

• 已安装 GitHub Copilot CLI
• 已安装 mcp-go 二进制文件

步骤：

1. 配置 Copilot CLI：

   • 编辑 ~/.github/copilot/config.json

2. 添加服务：

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

3. 更新路径

✅ 验证： CLI 命令可以与 Go 配合使用

前置条件：

• 已安装 LM Studio
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 LM Studio 设置：

   • 设置 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启

✅ 验证： LM Studio 可以使用 Go 工具

前置条件：

• 已安装带 MCP 扩展的 Visual Studio 2022
• 已安装 mcp-go 二进制文件

步骤：

1. 安装 MCP 扩展以用于 Visual Studio 2022

2. 打开“工具 → 选项 → MCP 服务”

3. 添加服务：

   • 名称：mcp-go
   • 命令：mcp-go.exe 的路径
   • 参数：（留空）

4. 保存并重启 Visual Studio

✅ 验证： Visual Studio 中可以使用 MCP 工具

前置条件：

• 已安装 Roo Code
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Roo Code 设置：

   • 设置 → MCP 配置

2. 添加服务：

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

3. 更新路径并重启

✅ 验证： Roo Code 集成正常运行

前置条件：

• 已安装 Gemini CLI
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.gemini/config.json

2. 添加 MCP 服务：

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

3. 更新路径

✅ 验证： Gemini CLI 可以使用 Go 工具

前置条件：

• 已安装 Qwen Coder
• 已安装 mcp-go 二进制文件

步骤：

1. 打开设置：

   • 设置 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启

**✅ 验证：**Qwen Coder 集成正常工作

前置条件：

• 已安装 Opencode
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.opencode/config.json

2. 添加服务：

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

3. 更新路径

**✅ 验证：**Opencode 可以使用 Go 工具

前置条件：

• 可访问 OpenAI Codex
• 已安装 mcp-go 二进制文件

步骤：

1. 配置 Codex：

   • 编辑 ~/.openai/codex/config.json

2. 添加 MCP 服务：

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

3. 更新路径

**✅ 验证：**Codex 集成正常工作

前置条件：

• 已安装 Kiro
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Kiro 设置：

   • 设置 → MCP Servers

2. 添加配置：

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

3. 更新路径并重启

**✅ 验证：**Kiro 可以使用 Go 工具

前置条件：

• 已安装 Trae
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.trae/config.json

2. 添加服务：

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

3. 更新路径

**✅ 验证：**Trae 集成正常工作

前置条件：

• 已安装 Bun
• 已安装 mcp-go 二进制文件

步骤：

1. 创建 MCP 配置：

   • 位置：~/.bun/mcp/config.json

2. 添加配置：

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

3. 更新路径

**✅ 验证：**Bun 可以使用 MCP Go 服务

前置条件：

• 已安装 Deno
• 已安装 mcp-go 二进制文件

步骤：

1. 配置 Deno MCP：

   • 编辑 ~/.deno/mcp/config.json

2. 添加服务：

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

3. 更新路径

**✅ 验证：**Deno MCP 集成正常工作

前置条件：

• 已安装 Docker
• Docker Compose（可选，便于管理）

步骤：

1. 拉取镜像：

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

2. 运行容器：

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

3. 或使用 docker-compose：
   • 创建 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. 使用 docker-compose 启动：

docker-compose up

✅ 验证：

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

**💡 提示：**使用卷将 Go 项目挂载到容器中

前置条件：

• 支持 .mcpb 文件的 MCP 兼容客户端

步骤：

1. 从发布页面下载 .mcpb 文件

2. 安装捆绑包：

   • 双击 .mcpb 文件，或
   • 使用 MCP 客户端的“Install Bundle”功能

3. 按照客户端特定的安装提示操作

**✅ 验证：**捆绑包出现在 MCP 客户端的服务列表中

💡 提示：.mcpb 文件是包含所有依赖项的独立捆绑包

前置条件：

• Windows 10/11
• 已安装 Go 1.24+（可选，用于从源代码构建）

步骤：

1. 下载 Windows 二进制文件：

   • 前往 发布页面
   • 下载 golang-mcp_Windows_x86_64.zip

2. 解压存档：

   • 右键单击 → 全部解压
   • 或使用：Expand-Archive golang-mcp_Windows_x86_64.zip

3. 移动到永久位置：

   • 创建文件夹：C:\Program Files\mcp-go\
   • 将 mcp-go.exe 移到该位置

4. 添加到 PATH：

   • 打开“系统属性”→“环境变量”
   • 编辑“Path”变量
   • 添加：C:\Program Files\mcp-go
   • 在所有对话框中点击“确定”

5. 验证安装：

   • 打开 PowerShell 或命令提示符
   • 运行：mcp-go --version

**✅ 成功：**你应该会看到版本号

⚠️ 故障排除：

• 如果提示找不到命令，请在添加到 PATH 后重启终端
• 检查 PATH：$env:PATH（PowerShell）或 echo %PATH%（CMD）
• 验证文件是否存在：Test-Path "C:\Program Files\mcp-go\mcp-go.exe"

前置条件：

• 已安装 BoltAI
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 BoltAI 设置：

   • 设置 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启

**✅ 验证：**BoltAI 集成正常运行

前置条件：

• 已安装 Rovo Dev CLI
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.rovo/config.json

2. 添加 MCP 服务：

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

3. 更新路径

**✅ 验证：**Rovo CLI 可以使用 Go 工具

前置条件：

• 已安装 Zencoder
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Zencoder 设置：

   • 设置 → MCP 配置

2. 添加服务：

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

3. 更新路径并重启

**✅ 验证：**Zencoder 可以使用 Go 工具

前置条件：

• 已安装 Qodo Gen
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.qodo/config.json

2. 添加 MCP 服务：

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

3. 更新路径

**✅ 验证：**Qodo Gen 集成正常运行

前置条件：

• 已安装 Factory
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Factory 设置：

   • 设置 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启

**✅ 验证：**Factory 可以使用 Go 工具

前置条件：

• 已安装 Crush
• 已安装 mcp-go 二进制文件

步骤：

1. 编辑配置：

   • 位置：~/.crush/config.json

2. 添加服务：

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

3. 更新路径

**✅ 验证：**Crush 集成正常运行

前置条件：

• 已安装 Augment Code
• 已安装 mcp-go 二进制文件

步骤：

1. 打开 Augment Code 设置：

   • 设置 → MCP 服务

2. 添加配置：

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

3. 更新路径并重启

**✅ 验证：**Augment Code 可以使用 Go 工具

常见问题及解决方案。根据症状快速查找问题。

安装问题

❌ “找不到命令：mcp-go”

症状：

• 终端提示 mcp-go: command not found
• 二进制文件存在，但无法运行

解决方案：

1. 检查是否已安装二进制文件：

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

2. 添加到 PATH：

   • **macOS/Linux：**将 $HOME/go/bin 添加到 PATH

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

   • **Windows：**在“环境变量”中将 %USERPROFILE%\go\bin 添加到 PATH

3. 验证 PATH：

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

✅ 成功：mcp-go --version 应该可以正常运行

❌ “Permission denied”

症状：

• 运行 mcp-go 时出现 Permission denied 错误

解决方案：

1. 使二进制文件可执行：

   chmod +x /path/to/mcp-go
   

2. 检查文件权限：

   ls -l /path/to/mcp-go
   

3. 在 Windows 上： 如有需要，请以管理员身份运行

❌ “Go 版本过旧”

症状：

• 出现有关 Go 版本的错误
• 要求 Go 1.24+

解决方案：

1. 检查 Go 版本：

   go version
   

2. 更新 Go：

   • 访问 golang.org
   • 下载最新版本
   • 安装后重启终端

配置问题

❌ “找不到配置文件”

症状：

• 平台无法找到配置文件
• 服务无法启动

解决方案：

1. 创建配置文件（如果文件不存在）
2. 检查文件位置（参见平台专属指南）
3. 验证 JSON 语法是否有效
4. 检查文件权限（确保可读）

❌ “配置文件中的 JSON 无效”

症状：

• 配置文件存在语法错误
• 服务启动失败

解决方案：

1. 验证 JSON：

   • 使用在线 JSON 验证工具
   • 或运行：python -m json.tool config.json

2. 常见错误：

   • 缺少逗号
   • 多余的逗号
   • 括号未闭合

3. 修复后重启 MCP 客户端

❌ “二进制文件路径不正确”

症状：

• 服务找不到 mcp-go 二进制文件
• 日志中出现路径错误

解决方案：

1. 查找正确路径：

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

2. 在配置中使用绝对路径（而非相对路径）

3. 在 Windows 上： 使用正斜杠或双反斜杠：

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

平台专属问题

❌ Claude Desktop：工具未显示

症状：

• 配置文件看起来正确
• Claude 中没有可用工具

解决方案：

1. 彻底重启 Claude Desktop
2. 检查配置文件位置：
   • macOS：~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows：%APPDATA%\Claude\claude_desktop_config.json
3. 验证 JSON 语法
4. 检查 Claude Desktop 日志中是否有错误
5. 确认二进制文件路径正确且可执行

❌ VS Code：MCP 扩展无法正常工作

症状：

• 已安装 MCP 扩展，但无法正常工作
• 没有可用工具

解决方案：

1. 检查扩展是否已启用
2. 重新加载 VS Code 窗口： Cmd+Shift+P → “Reload Window”
3. 检查输出面板中的 MCP 消息
4. 验证设置 JSON 语法
5. 尝试使用工作区设置，而非用户设置

❌ Docker：容器无法启动

症状：

• Docker 容器立即退出
• 出现权限错误

解决方案：

1. 检查 Docker 是否正在运行：

   docker ps
   

2. 检查镜像是否存在：

   docker images | grep golang-mcp
   

3. 检查卷挂载：

   • 确认路径正确
   • 检查挂载目录的权限

4. 查看日志：

   docker logs <container-id>
   

运行时问题

❌ “找不到 Go 命令”

症状：

• MCP 服务找不到 go 命令
• Go 工具运行失败

解决方案：

1. 确认已安装 Go：

   go version
   

2. 检查 PATH 是否包含 Go：

   echo $PATH  # Should include Go bin directory
   

3. 如有需要，设置 GOROOT：

   export GOROOT=/usr/local/go
   

❌ “LSP 工具不可用”

症状：

• LSP 工具未显示
• 已设置 ENABLE_LSP=true，但没有工具

解决方案：

1. 检查是否已安装 gopls：

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

2. 确认已设置 ENABLE_LSP：

   echo $ENABLE_LSP  # Should be "true"
   

3. 设置环境变量后重启 MCP 服务

❌ “权限提示反复出现”

症状：

• 每个命令都会触发权限提示
• 希望禁用这些提示

解决方案：

1. 设置 DISABLE_NOTIFICATIONS：

   export DISABLE_NOTIFICATIONS=true
   

2. 在配置文件的 env 部分中添加：

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

3. 重启 MCP 客户端

性能问题

❌ “服务运行缓慢”

症状：

• 命令执行时间过长
• 出现超时

解决方案：

1. 启用调试日志：

   export DEBUG_MCP=true
   

2. 检查系统资源（CPU、内存）

3. 检查 Go 代理：

   go env GOPROXY
   

4. 尝试使用其他 GOPROXY：

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

获取更多帮助

仍然遇到问题？

1. 检查日志：

   • 启用 DEBUG_MCP=true
   • 检查平台特定的日志位置

2. 验证安装：

   mcp-go --version
   go version
   

3. 独立测试：

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

4. 查看 GitHub Issues：

   • 搜索现有问题
   • 创建新问题，并附上：
     • 错误消息
     • 平台信息
     • 配置文件（已清理敏感信息）
     • 调试日志

代码执行工具

✅ go_run

使用 go run 直接执行 Go 文件。

参数：

• file（字符串，必需）：要运行的 Go 文件路径
• args（[]string，可选）：传递给程序的命令行参数
• working_dir（字符串，可选）：命令的工作目录
• env_vars（map[string]string，可选）：附加环境变量

示例：

运行一个简单的 Go 文件：

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

使用命令行参数运行：

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

使用环境变量运行：

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

Go 工具

🔧 7 个工具，用于构建、测试、格式化和管理 Go 代码。

✅ go_build

使用各种构建标志构建 Go 包及其依赖项。

参数：

• package（字符串，可选）：要构建的包路径（默认：当前目录）
• output（字符串，可选）：输出文件名
• race（bool，可选）：启用竞态检测器
• tags（[]string，可选）：构建标签
• ldflags（字符串，可选）：链接器标志
• trimpath（bool，可选）：从可执行文件中移除文件系统路径
• working_dir（字符串，可选）：工作目录

示例：

基本构建：

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

使用竞态检测器构建：

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

使用构建标签和版本信息构建：

{
  "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

运行 Go 测试，支持覆盖率分析、基准测试和竞态检测。

参数：

• package（字符串，可选）：要测试的包路径
• cover（bool，可选）：启用覆盖率分析
• cover_pkg（字符串，可选）：要分析覆盖率的包
• bench（bool，可选）：运行基准测试
• race（bool，可选）：启用竞态检测器
• verbose（bool，可选）：输出详细信息
• timeout（字符串，可选）：测试超时时间

示例：

运行所有测试：

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

运行测试并分析覆盖率：

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

运行测试、基准测试并启用竞态检测：

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

go_fmt

使用 go fmt 格式化 Go 代码。

参数：

• paths（[]string，可选）：要格式化的路径（默认：当前目录）
• working_dir（字符串，可选）：工作目录

示例：

格式化当前目录：

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

格式化指定文件：

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

go_mod

管理 Go 模块（init、tidy、download、vendor、get）。

参数：

• operation（字符串，必需）：模块操作：init、tidy、download、vendor、get
• module_path（字符串，可选）：模块路径（用于 init 或 get）
• packages（[]string，可选）：包路径（用于 get）
• working_dir（字符串，可选）：工作目录

示例：

初始化新模块：

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

整理依赖项：

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

添加依赖项：

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

为依赖项创建 vendor 副本：

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

go_doc

为 Go 包生成文档。

参数：

• package（字符串，必需）：包路径
• all（bool，可选）：显示所有文档
• working_dir（字符串，可选）：工作目录

示例：

查看包文档：

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

查看所有文档，包括未导出的符号：

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

go_lint

使用 golangci-lint 或 go vet 检查 Go 代码。

参数：

• package（字符串，可选）：要检查的包路径
• linter（字符串，可选）：要使用的检查工具：golangci-lint 或 vet（默认：vet）
• working_dir（字符串，可选）：工作目录

示例：

使用 go vet 检查：

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

使用 golangci-lint 检查：

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

go_cross_compile

为不同平台交叉编译 Go 代码。

参数：

• package（字符串，可选）：要构建的包路径
• output（字符串，必需）：输出文件名
• goos（字符串，必需）：目标操作系统（例如：linux、darwin、windows）
• goarch（字符串，必需）：目标架构（例如：amd64、arm64）
• working_dir（字符串，可选）：工作目录

示例：

为 Linux 构建：

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

为 Windows 构建：

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

为 macOS ARM 构建：

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

优化工具

⚡ 6 个工具，用于分析性能、运行基准测试和优化 Go 代码性能。

✅ go_profile

使用 pprof 生成性能分析文件。

参数：

• type (string, 必填)：性能分析类型：cpu 或 mem
• output (string, 必填)：输出性能分析文件路径
• duration (string, 可选)：性能分析时长
• package (string, 可选)：要分析的包
• working_dir (string, 可选)：工作目录

示例：

生成 CPU 性能分析文件：

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

生成内存性能分析文件：

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

go_trace

为 Go 程序生成执行跟踪。

参数：

• output (string, 必填)：输出跟踪文件路径
• package (string, 可选)：要跟踪的包
• working_dir (string, 可选)：工作目录

示例：

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

go_benchmark

运行基准测试并分析结果。

参数：

• pattern (string, 可选)：要匹配的基准测试模式
• count (int, 可选)：迭代次数
• timeout (string, 可选)：基准测试超时时间
• package (string, 可选)：要进行基准测试的包
• working_dir (string, 可选)：工作目录

示例：

运行所有基准测试：

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

运行指定模式的基准测试：

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

运行带超时时间的基准测试：

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

go_race_detect

检测 Go 代码中的竞态条件。

参数：

• package (string, 可选)：要测试的包
• working_dir (string, 可选)：工作目录

示例：

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

go_memory_profile

生成内存性能分析文件以供分析。

参数：

• output (string, 必填)：输出性能分析文件路径
• package (string, 可选)：要分析的包
• working_dir (string, 可选)：工作目录

示例：

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

go_optimize_suggest

分析代码，并根据性能分析和基准测试结果提供优化建议。

参数：

• package (string, 可选)：要分析的包
• working_dir (string, 可选)：工作目录

示例：

分析当前包：

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

分析指定包：

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

此工具会运行基准测试和静态分析，提供以下优化建议：

• 用于建立性能基线的基准测试结果
• 来自 go vet 的静态分析问题
• 通用优化建议
• 关于竞态检测、性能分析和并发改进的建议

服务管理工具

🚀 5 个工具，用于在后台管理长时间运行的 Go 服务。

✅ go_server_start

在后台启动长时间运行的 Go 服务。

参数：

• id (string, 必填)：唯一服务 ID
• name (string, 必填)：服务名称
• command (string, 必填)：要运行的命令（通常是 'go' 或二进制文件路径）
• args ([]string, 必填)：命令参数
• working_dir (string, 可选)：工作目录
• env_vars (map[string]string, 可选)：环境变量
• log_size (int, 可选)：保留的最大日志行数（默认值：1000）

go_server_stop

停止正在运行的服务。

参数：

• id (string, 必填)：服务 ID
• force (bool, 可选)：强制终止服务（SIGKILL）

go_server_list

列出所有正在运行的服务。

go_server_logs

获取正在运行的服务的日志。

参数：

• id (string, 必填)：服务 ID
• count (int, 可选)：最近的日志行数（0 表示全部）

go_server_status

获取服务的详细状态。

参数：

• id (string, 必填)：服务 ID

包文档工具

📚 3 个工具，用于发现和浏览 Go 包文档。

✅ go_pkg_docs

从 go.dev（pkg.go.dev）获取包文档。返回包概览、函数、类型和示例。

参数：

• package（string，必填）：包路径（例如，github.com/gin-gonic/gin、net/http）
• version（string，可选）：包版本

示例：

获取标准库文档：

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

获取第三方包文档：

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

该工具会返回：

• 包概览和说明
• 函数列表，包括签名和说明
• 类型列表，包括类型种类和说明
• 代码示例（如果有）

go_pkg_search

在 go.dev 上搜索包。返回匹配的包路径列表。

参数：

• query（string，必填）：搜索查询

示例：

搜索 HTTP 路由器：

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

搜索数据库驱动：

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

该工具会返回与你的查询匹配的包路径列表。随后，你可以使用 go_pkg_docs 查看文档。

go_pkg_examples

从包文档中提取示例。

参数：

• package（string，必填）：包路径
• version（string，可选）：包版本

示例：

从标准库中提取示例：

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

从第三方包中提取示例：

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

LSP 工具

🔌 5 个工具用于语言服务器协议集成（可选）。

⚠️ 注意：LSP 工具为可选功能，需设置 ENABLE_LSP=true 环境变量。这些工具提供语言服务器协议集成，以支持高级 IDE 功能。

✅ lsp_start_session

为工作区根 URI 启动 LSP 会话。

参数：

• root_uri（string，必填）：工作区根 URI（file:// 路径）
• gopls_path（string，可选）：gopls 二进制文件的路径（默认：从 PATH 中查找）
• args（[]string，可选）：传递给 gopls 的其他参数
• env（map[string]string，可选）：gopls 的环境变量

示例：

使用默认 gopls 启动会话：

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

使用自定义 gopls 路径启动会话：

{
  "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

关闭工作区根 URI 对应的 LSP 会话。

参数：

• root_uri（string，必填）：工作区根 URI

示例：

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

lsp_request

向 LSP 会话发送请求并等待结果。

参数：

• root_uri（string，必填）：工作区根 URI
• method（string，必填）：LSP 方法名称（例如，“textDocument/hover”、“textDocument/completion”）
• params（object，可选）：请求参数

示例：

获取悬停信息：

{
  "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
      }
    }
  }
}

获取代码补全：

{
  "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

向 LSP 会话发送通知（不等待响应）。

参数：

• root_uri（string，必填）：工作区根 URI
• method（string，必填）：LSP 方法名称（例如，“textDocument/didChange”、“textDocument/didOpen”）
• params（object，可选）：通知参数

示例：

{
  "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

订阅 LSP 会话发布的诊断信息。

参数：

• root_uri（string，必填）：工作区根 URI

示例：

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

此功能可接收指定工作区的 LSP 服务发送的诊断通知（错误、警告等）。

本节提供实用、可直接复制粘贴的示例，展示常见工作流、工具组合和实际场景。

常见开发工作流

快速入门工作流

初始化新项目、格式化代码、运行测试并构建：

{
  "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"
  }
}

测试工作流

运行全面测试，并启用覆盖率和竞态检测：

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

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

性能分析工作流

对代码进行基准测试、性能分析和优化：

{
  "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"
  }
}

交叉编译工作流

为多个平台构建：

{
  "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"
  }
}

多工具示例

完整的类 CI/CD 工作流

使用生产环境标志格式化、lint、测试和构建：

{
  "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)"
  }
}

服务端开发工作流

构建、启动、监控并停止服务端：

{
  "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"
  }
}

软件包调研工作流

搜索软件包、获取文档并提取示例：

{
  "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"
  }
}

集成示例

Claude Desktop 配置

macOS 配置：

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

Windows 配置：

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

Linux 配置：

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

故障排查：

• 验证安装：在终端中检查 mcp-go --version 是否正常运行
• 检查权限：确保二进制文件可执行（chmod +x /path/to/mcp-go）
• 测试连接：更改配置后重启 Claude Desktop
• 查看日志：检查 Claude Desktop 日志中的连接错误

VS Code 配置

工作区设置（.vscode/settings.json）：

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

用户设置（全局）：

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

调试提示：

• 在 VS Code 设置中启用 MCP 日志记录
• 检查“输出”面板中的 MCP 服务消息
• 验证 Go 环境：确保在集成终端中 go version 正常运行
• 测试工具：尝试调用 go_fmt 或 go_test 以验证连接

独立使用

直接测试服务端：

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

JSON-RPC 请求示例：

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

JSON-RPC 响应示例：

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

实际场景

构建 REST API

开发和测试 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"
  }
}

库开发

开发并发布 Go 库的工作流：

{
  "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"
  }
}

性能问题调试

识别并修复性能瓶颈：

{
  "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"
  }
}

分析性能分析结果：

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

资源用法

资源提供有关 Go 工作区的结构化信息。可通过 MCP 资源协议访问这些信息。

使用 go://modules

发现项目依赖项和模块信息：

访问方式：

Resource URI: go://modules

使用场景：

• 添加新软件包前了解项目依赖项
• 检查模块版本
• 识别未使用的依赖项
• 规划依赖项更新

示例工作流：

1. 访问 go://modules 查看当前依赖项
2. 使用 go_pkg_search 查找替代方案
3. 使用 go_mod 并设置 operation: "get" 添加新软件包
4. 使用 go_mod 并设置 operation: "tidy" 进行清理

使用 go://build-tags

发现构建标签和条件编译：

访问方式：

Resource URI: go://build-tags

使用场景：

• 了解特定平台的代码
• 查找功能标志
• 规划交叉编译
• 识别条件构建

示例工作流：

1. 访问 go://build-tags 查看可用标签
2. 使用 go_build 并设置 tags: ["production", "linux"] 进行特定构建
3. 使用 go_cross_compile 并设置适当的标签进行平台构建

使用 go://tests

发现测试文件和基准测试：

访问方式：

Resource URI: go://tests

使用场景：

• 查找项目中的所有测试文件
• 发现基准测试函数
• 规划测试覆盖率改进
• 了解测试结构

示例工作流：

1. 访问 go://tests 查看所有测试文件
2. 使用 go_test 并设置 cover: true，运行测试并生成覆盖率数据
3. 使用 go_benchmark 运行指定的基准测试
4. 使用 go_race_detect 检查竞态条件

使用 go://workspace

了解项目结构和配置：

访问方式：

Resource URI: go://workspace

使用场景：

• 了解项目布局
• 查找主程序包
• 发现模块结构
• 规划重构

示例工作流：

1. 访问 go://workspace 了解项目结构
2. 使用 go_build 并设置适当的软件包路径
3. 使用 go_test 并设置指定的软件包路径
4. 使用 go_fmt 并设置目标路径

使用 go://pkg-docs/{path}

直接访问软件包文档：

访问模式：

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

使用场景：

• 快速查阅标准库文档
• 查看第三方软件包文档
• 学习软件包 API
• 查找用法示例

示例工作流：

1. 访问 go://pkg-docs/net/http 查阅 HTTP 软件包文档
2. 使用 go_pkg_examples 获取代码示例
3. 使用 go_doc 查阅本地软件包文档
4. 将示例集成到代码中

带版本的示例：

Resource URI: go://pkg-docs/github.com/gin-gonic/[email protected]

使用 go://tools

了解所有可用工具及其功能：

访问模式：

Resource URI: go://tools

使用场景：

• 开始使用服务时了解可用工具
• 理解工具参数和架构
• 为特定任务查找合适的工具
• 探索工具功能

示例工作流：

1. 访问 go://tools 查看全部 22 个可用工具
2. 查看工具说明和参数架构
3. 为工作流选择合适的工具
4. 组合使用工具以完成复杂任务

示例响应结构： 该资源会返回一个 JSON 对象，其中包含：

• tools：工具元数据数组，包括名称、说明和输入架构
• count：可用工具总数

使用 go://prompts

了解所有可用于引导工作流的提示词：

访问模式：

Resource URI: go://prompts

使用场景：

• 查找适用于特定开发任务的提示词
• 理解提示词参数和要求
• 了解引导式工作流
• 规划开发流程

示例工作流：

1. 访问 go://prompts 查看全部 7 个可用提示词
2. 查看提示词说明和参数
3. 在开发的相应阶段使用合适的提示词
4. 将提示词与工具结合，完成完整工作流

示例响应结构： 该资源会返回一个 JSON 对象，其中包含：

• prompts：提示词元数据数组，包括名称、说明和参数
• count：可用提示词总数

使用 go://resources

了解所有可用资源：

访问模式：

Resource URI: go://resources

使用场景：

• 了解有哪些可用资源
• 查找资源 URI 和说明
• 规划基于资源的工作流
• 了解工作区发现功能

示例工作流：

1. 访问 go://resources 查看全部 8 个可用资源
2. 查看资源 URI 和说明
3. 使用资源收集工作区信息
4. 将资源与工具结合，以便做出明智决策

示例响应结构： 该资源会返回一个 JSON 对象，其中包含：

• resources：资源元数据数组，包括 URI、名称、说明和 MIME 类型
• count：可用资源总数

资源集成示例

完整的项目分析工作流

1. 了解项目结构：

   • 访问 go://workspace 查看项目布局
   • 访问 go://modules 了解依赖项

2. 分析代码质量：

   • 访问 go://tests 查看测试覆盖情况
   • 访问 go://build-tags 了解条件编译

3. 规划改进：

   • 访问 go://tools 查找合适的工具
   • 访问 go://prompts 获取引导式工作流

4. 实施改进：

   • 根据资源提供的信息使用工具
   • 遵循提示词执行结构化工作流

依赖项管理工作流

1. 访问 go://modules 查看当前依赖项
2. 使用 go_pkg_search 查找替代项
3. 访问 go://pkg-docs/{package} 查阅文档
4. 使用 go_mod 添加依赖项
5. 再次访问 go://modules 验证更改

测试覆盖率分析工作流

1. 访问 go://tests 查看所有测试文件
2. 使用 go_test 并设置 cover: true 获取覆盖率报告
3. 找出测试覆盖率中的缺口
4. 使用 write-go-tests 提示词获取指导
5. 再次访问 go://tests 验证新增测试

在复杂工作流中组合使用工具

提交前工作流

提交代码前的自动检查：

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

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

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

发布准备工作流

通过多个平台构建准备发布：

{
  "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"
  }
}

然后为所有目标平台进行交叉编译。

持续性能分析工作流

持续监控性能变化：

{
  "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"
  }
}

定期检查日志和性能分析结果，以识别趋势。

将资源与工具配合使用

依赖管理工作流

利用资源为工具使用提供依据：

1. 访问 go://modules 查看当前依赖
2. 使用 go_pkg_search 查找替代方案
3. 使用 go_pkg_docs 比较各个选项
4. 使用 go_mod 添加选定的包
5. 再次访问 go://modules 进行验证

测试驱动开发工作流

利用资源指导测试：

1. 访问 go://tests 查看现有测试结构
2. 使用 go_test 和 cover: true 查看覆盖率缺口
3. 根据覆盖率报告编写新测试
4. 使用 go_benchmark 确保性能
5. 访问 go://tests 验证是否包含新测试

错误处理与故障排除

构建失败

构建失败时，使用以下诊断工作流：

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

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

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

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

测试失败

测试失败时，按步骤进行排查：

{
  "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"
  }
}

服务问题

服务行为异常时：

{
  "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"
  }
}

最佳实践

开发方面

• 每次提交前使用 go_fmt
• 对并发代码使用 go_test 并设置 race: true
• 定期使用 go_lint，尽早发现问题
• 访问 go://workspace 了解项目结构

生产方面

• 构建时始终使用 trimpath: true
• 通过 ldflags 添加版本信息
• 发布前使用 go_race_detect 进行测试
• 在目标平台上进行交叉编译和测试

性能方面

• 优化前后都进行基准测试
• 使用符合实际情况的工作负载进行性能分析
• 使用 go_trace 排查并发问题
• 监控内存性能分析结果，检查是否存在泄漏

包管理方面

• 使用 go://modules 了解依赖
• 添加包之前先进行搜索（go_pkg_search）
• 集成之前先查阅文档（go_pkg_docs）
• 定期使用 go_mod tidy 清理