Go 6b789a34

MCPAI代理

提供方 未标注

AI代理 未标注 未标注 社区 / 第三方

全面解析Go Dev MCPMCP Server的核心功能、安装配置和实用案例。作为顶级Model Context Protocol服务器,Go Dev MCP能让AI助手访问实时数据、执行操作,为您提供更智能的工作体验和自动化解决方案。

一句话选型结论

按资料字段整理

Go 6b789a34 属于AI代理类 MCP 服务器,传输方式未标注,鉴权方式未标注,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式未标注 鉴权未标注 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

AI代理
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

安装与配置

未标注 未标注
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 基础信息齐全,可以先按官方文档接入试跑。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Go 6b789a34当前 未标注 未标注 未标注 无 2026-05-17
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类AI代理本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

11.4 KB
来自项目仓库与上游目录的原文,未做删改

# 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:```json
{
"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:

1. **Go Testing Framework**: Modern, parallel test framework using Go's native testing facilities and testify
2. **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)```powershell
# 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)```powershell

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

1. Clone the repository:```bash
   git clone https://github.com/MrFixit96/go-dev-mcp.git
   cd go-dev-mcp
   ```

2. Build the executable:```bash
   go build -o go-dev-mcp.exe ./cmd/server
   ```

3. Move the executable to a location in your PATH or reference it directly in your Claude Desktop configuration.

#### Using WinGet (Coming Soon)```powershell
winget install go-dev-mcp

macOS

Using Homebrew (Coming Soon)```bash

brew install go-dev-mcp


#### Manual Installation (macOS)

1. Clone the repository:```bash
   git clone https://github.com/MrFixit96/go-dev-mcp.git
   cd go-dev-mcp
   ```

2. Build the executable:```bash
   go build -o go-dev-mcp ./cmd/server
   ```

3. Move the executable to a location in your PATH:```bash
   sudo mv go-dev-mcp /usr/local/bin/
   ```

### Linux

1. Clone the repository:```bash
   git clone https://github.com/MrFixit96/go-dev-mcp.git
   cd go-dev-mcp
   ```

2. Build the executable:```bash
   go build -o go-dev-mcp ./cmd/server
   ```

3. Move the executable to a location in your PATH:```bash
   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```json
{
  "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:```json
{
"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```json
{
  "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:```go
// 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:```go
// 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:```json
{
"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```json
{
  "tool": "go_workspace",
  "arguments": {
    "command": "init",
    "workspace_path": "/path/to/my-workspace",
    "modules": ["./module1", "./module2"]
  }
}

Adding Modules to Existing Workspace```json

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


#### Getting Workspace Information```json
{
  "tool": "go_workspace",
  "arguments": {
    "command": "info",
    "workspace_path": "/path/to/my-workspace"
  }
}

Multi-Module Development Workflow

1. Initialize Workspace Structure```bash

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```json
{
  "tool": "go_build",
  "arguments": {
    "workspace_path": "/path/to/my-workspace"
  }
}

3. Test Specific Module```json

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


#### 4. Synchronize Dependencies```json
{
  "tool": "go_workspace",
  "arguments": {
    "command": "sync",
    "workspace_path": "/path/to/my-workspace"
  }
}

Advanced Workspace Features

Workspace with Custom Code```json

{
"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```json
{
  "tool": "go_workspace",
  "arguments": {
    "command": "vendor",
    "workspace_path": "/path/to/my-workspace"
  }
}

Format All Modules```json

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


### Error Handling and Troubleshooting

#### Common Workspace Issues

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

#### Workspace Validation```json
{
  "tool": "go_workspace",
  "arguments": {
    "command": "info",
    "workspace_path": "/path/to/my-workspace"
  }
}

Returns detailed workspace structure and validation status.

常见问题

5 问
答案由本站依据条目字段整理,不引用上游原文
Go 6b789a34 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Go 6b789a34 怎么在客户端里配置?

它的传输方式未标注,在客户端 MCP 配置里按官方文档填写启动命令和参数,保存后重启客户端生效。

Go 6b789a34 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Go 6b789a34 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Go 6b789a34 能提供哪些能力?

资料显示能力标签包括 工作区管理、AI代理、工作流自动化。具体工具清单以官方文档为准。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。