GoDevMCP

Introduction

GoDevMCP is a Model Context Protocol (MCP) server that provides development tools with a focus on Go, and additional support for Rust and Python. It offers documentation lookup, code search, project navigation, and more.

Installation

Prerequisites

• GitHub authentication is required only for the GitHub tools (code search, content, diffs, issues, pull requests, workflow runs). The other tools (Go/Rust/Python docs, directory tree, local search, outline, markdown, validation) work without it.
• The server resolves a GitHub token in this order:
  1. The GITHUB_TOKEN or GH_TOKEN environment variable, if set.
  2. Otherwise, the locally-installed and authenticated gh CLI (gh auth login).

Using go install

You can install GoDevMCP directly using Go's install command:

go install github.com/fpt/go-dev-mcp/godevmcp@latest

This will download, compile, and install the binary to your $GOPATH/bin directory (typically ~/go/bin). Make sure this directory is in your system's PATH.

Building from Source

1. Clone the repository
2. Run make build to build the application and make install to install.

MCP setup

Claude code

Run this command to add to user scope

claude mcp add godevmcp -s user godevmcp serve

VSCode

Add this section in your user's settings.json

    "mcp": {
        "servers": {
            "go-dev-mcp": {
                "type": "stdio",
                "command": "godevmcp",
                "args": [
                    "serve"
                ],
            }
        }
    }

Tools

Go Documentation

Rust Documentation

Python Documentation

Project Navigation

GitHub Integration

Instructions

1. Build the application

   make build
   

2. Run the application

   make run
   

Available Make Commands

• make run - Run the application
• make build - Build the application and install to ~/bin
• make test - Run unit tests
• make fmt - Format code using gofumpt
• make lint - Run golangci-lint
• make inspect - Run in MCP inspector
• make help - Display help information

Development

Project Structure

.
├── godevmcp/       # Application entry point
│   └── main.go     # Main application entry point
├── doc/            # Documentation files
├── internal/       # Private application and library code
│   ├── app/        # Application core functionality
│   ├── infra/      # Infrastructure code
│   ├── mcptool/    # MCP tooling implementations
│   ├── repository/ # Repository implementations
│   └── subcmd/     # Subcommand implementations
├── output/         # Build artifacts
│   └── godevmcp    # Compiled binary
├── pkg/            # Public library code
│   └── dq/         # Document query utility package
├── Makefile        # Build automation
├── go.mod          # Go module definition
└── go.sum          # Go module checksum

Package Dependencies

The following Mermaid graph shows the internal package dependencies within the project:

graph TD
    %% Entry point
    main[godevmcp/main] --> subcmd[internal/subcmd]
    
    %% Core application layer
    subcmd --> app[internal/app]
    subcmd --> mcptool[internal/mcptool]
    mcptool --> app
    
    %% Application modules
    app --> repository[internal/repository]
    app --> infra[internal/infra]
    app --> contentsearch[internal/contentsearch]
    app --> model[internal/model]
    app --> dq[pkg/dq]
    
    %% MCP layer
    mcptool --> infra
    
    %% Infrastructure dependencies
    infra --> repository
    contentsearch --> model
    
    %% External dependencies (key ones)
    subcmd -.-> subcommands[google/subcommands]
    mcptool -.-> mcp[mark3labs/mcp-go]
    infra -.-> github[google/go-github]
    app -.-> errors[pkg/errors]
    app -.-> goldmark[yuin/goldmark]
    app -.-> cache[patrickmn/go-cache]
    
    %% Styling
    classDef entryPoint fill:#e1f5fe
    classDef coreLayer fill:#f3e5f5
    classDef appLayer fill:#e8f5e8
    classDef infraLayer fill:#fff3e0
    classDef external fill:#fce4ec,stroke-dasharray: 5 5
    
    class main entryPoint
    class subcmd,mcptool coreLayer
    class app,repository,infra,contentsearch,model appLayer
    class dq infraLayer
    class subcommands,mcp,github,errors,goldmark,cache external

This graph illustrates:

• Entry Point: main package coordinates subcommands
• Core Layer: subcmd (CLI) and mcptool (MCP server) provide user interfaces
• Application Layer: app contains business logic, supported by infrastructure packages
• Infrastructure Layer: Shared utilities and external integrations
• External Dependencies: Key third-party packages (shown with dashed lines)

Common Development Workflow

1. Make changes to the code
2. Run make fmt to format code
3. Run make lint to check for issues
4. Run make test to ensure tests pass
5. Build with make build

For AI Development

• Follow instructions in CONTRIBUTING.md
• Use run_make and tree_dir tools rather than using shell commands.
• Use search_godoc and read_godoc tools to understand how to use Go packages.
• Use search_rustdoc and read_rustdoc tools for Rust crate documentation.
• Use search_pydoc and read_pydoc tools for Python standard library documentation.
• Use tree_github_repo, search_github_code, get_github_content to inspect github repository.
• Remember to update README.md when making significant changes