What is Mcp Go Tools

mcp-go-tools is a Go-focused Model Context Protocol (MCP) server designed to facilitate idiomatic Go code generation, style guidelines, and best practices. It aids Language Models in understanding and producing high-quality Go code that adheres to established patterns and conventions.

Use cases

mcp-go-tools can be used for generating Go code templates, enforcing coding standards, and assisting in the development of Go applications by providing idiomatic code structures and patterns. It is particularly useful for developers looking to maintain consistency and quality in their Go projects.

How to use

To use mcp-go-tools, install it via the command go install github.com/ksysoev/mcp-go-tools/cmd/mcp-go-tools@latest. Start the server with the command mcp-go-tools start --config config.yaml, and configure logging and other settings using the provided flags.

Key features

Key features include Go-specific code generation and style guidelines, a command-line interface built with Cobra, flexible configuration options using YAML/JSON, structured logging, server management commands, and graceful shutdown handling.

Where to use

undefined

MCP GO Tools

A Go-focused Model Context Protocol (MCP) server that provides idiomatic Go code generation, style guidelines, and best practices. This tool helps Language Models understand and generate high-quality Go code following established patterns and conventions.

Note: This project is under active development. The following features are currently being implemented:

• Go-specific code pattern recognition and generation
• Idiomatic Go code style enforcement
• Go project structure templates

The project follows clean architecture principles and is designed for extensibility.

About MCP Protocol

The Model Context Protocol (MCP) is implemented using the github.com/metoro-io/mcp-golang library. The server:

• Uses stdio transport for communication
• Supports graceful shutdown
• Handles concurrent operations using errgroups
• Provides Go-specific code generation tools

Installation

go install github.com/ksysoev/mcp-go-tools/cmd/mcp-go-tools@latest

Features

• Go-specific code generation and style guidelines
• Command-line interface built with Cobra
• Flexible configuration using YAML/JSON files
• Structured logging with slog
  • File output support with --log-file flag (writes to file instead of stdout)
  • JSON and text formats
  • Configurable log levels
  • Debug logging for request tracking
• Server management commands
• Signal handling for graceful shutdown

Quick Start

Basic Command Structure

mcp-go-tools [command] [flags]

For detailed usage examples and patterns, see USAGE.md.

Common Commands

Start Server

Starts the MCP server with the specified configuration:

mcp-go-tools start --config config.yaml

Run with File Logging

Run the server with logs written to a file instead of stdout:

# JSON format (default)
mcp-go-tools start --config config.yaml --log-file=server.log

# Text format with debug level for request tracking
mcp-go-tools start --config config.yaml --log-file=server.log --log-text --log-level=debug

Note: When --log-file is provided, logs will be written only to the specified file, not to stdout.

Architecture

The application follows a clean, layered architecture typical of Go projects:

1. API Layer (pkg/api)

   • Handles MCP protocol communication via stdio transport
   • Manages server lifecycle with graceful shutdown
   • Implements Go code generation tools
   • Uses errgroups for concurrent operations

2. Core Layer (pkg/core)

   • Implements Go code pattern recognition
   • Manages code style rules
   • Processes MCP requests
   • Designed for extensibility with interface-based components

3. Repository Layer (pkg/repo)

   • Manages Go code patterns and templates
   • Supports named resource definitions
   • Implements simple data persistence
   • Uses Viper for resource configuration mapping

4. Command Layer (pkg/cmd)

   • Implements CLI commands
   • Handles configuration and logging setup

Global Flags

--config string      Config file path
--log-level string   Log level (debug, info, warn, error) (default "info")
--log-text          Log in text format, otherwise JSON
--log-file string   Log file path (if set, logs to stdout)

Configuration File

The tool supports configuration via a JSON/YAML file. Specify the config file path using the --config flag. See example.config.yaml for Go-specific patterns and rules.

Project Structure

.
├── cmd/
│   └── mcp-go-tools/              # Main application entry point
├── pkg/
│   ├── api/             # API service implementation
│   ├── cmd/             # Command implementations
│   ├── core/            # Core business logic
│   └── repo/            # Data repositories

Dependencies

• Go 1.23.4 or higher
• github.com/metoro-io/mcp-golang - MCP protocol implementation
• github.com/spf13/cobra - CLI framework
• github.com/spf13/viper - Configuration management
• golang.org/x/sync - Synchronization primitives

Development

Project Status

The project is in active development with the following components:

• ✅ CLI framework and command structure
• ✅ Configuration management
• ✅ MCP protocol integration
• ✅ Idiomatic Go code generation
• ✅ Go project templates
• ✅ Mockery support
• 🚧 Add integration linters

Building from Source

go build -o mcp-go-tools ./cmd/mcp-go-tools

Running Tests

go test ./...

Using with Cline

To use this MCP server with Cline, add it to Cline’s MCP settings

Add the following configuration to the mcpServers object in the settings file:

{
  "mcpServers": {
    "code-tools": {
      "command": "mcp-go-tools",
      "args": [
        "server",
        "--config=/Users/user/mcp-go-tools/example.config.yaml"
      ],
      "env": {}
    }
  }
}

Custom instructions example:

Use project template to initialize new applications in GoLang, it's available in MCP server code-tools `codestyle` with category `template`

Every time you need to generate code use MCP server code-tools to `codestyle` for required category `code`, `documentation`, `testing`

example of request to MCP server code-tool:
{
  "method": "tools/call",
  "params": {
    "name": "codestyle",
    "arguments": {
      "categories": "testing" #Comma separate list
    },
  }
}

Before finishing task you should run `golangci-lint` and recursively address issues until all issues are fixed

to fix field alignment issues you should use `fieldalignment -fix ./...`

License

This project is licensed under the MIT License - see the LICENSE file for details.