GoDevMCP

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

Tool	Description
search_godoc	Search for Go packages on pkg.go.dev
read_godoc	Read Go package documentation with line-based paging
search_within_godoc	Search for keywords within a specific Go package's documentation
outline_go_package	Get a comprehensive outline of a Go package: dependencies, exported declarations, and call graph
validate_go_code	Validate Go code using go vet, build checks, formatting, and module tidiness

Rust Documentation

Tool	Description
search_rustdoc	Search for Rust crates on docs.rs
read_rustdoc	Read Rust crate documentation with line-based paging
search_within_rustdoc	Search for keywords within a specific Rust crate's documentation

Python Documentation

Tool	Description
search_pydoc	Search Python standard library modules on docs.python.org
read_pydoc	Read Python standard library module documentation with line-based paging
search_within_pydoc	Search for keywords within a specific Python module's documentation

Project Navigation

Tool	Description
tree_dir	Display local directory tree structure with depth limiting
search_local_files	Search file contents in local directories with match limiting
scan_markdown	Scan markdown files to extract headings with line numbers

GitHub Integration

Tool	Description
search_github_code	Search code in GitHub repositories with compact formatting
get_github_content	Get file content from GitHub with line-based paging
tree_github_repo	Display GitHub repository tree structure with depth limiting

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