MCP GO Tools

Tests

CodeQL

codecov

Go Report Card

License: MIT

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:

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
Core Layer (pkg/core)
- Implements Go code pattern recognition
- Manages code style rules
- Processes MCP requests
- Designed for extensibility with interface-based components
Repository Layer (pkg/repo)
- Manages Go code patterns and templates
- Supports named resource definitions
- Implements simple data persistence
- Uses Viper for resource configuration mapping
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.