This MCP server is a Go-based implementation that exposes a high-performance JSON-RPC 2.0 interface for managing and invoking a collection of modular tools. It provides a web management UI for monitoring tools, enabling/disabling tools, viewing invocation records, and analyzing statistics. The server is designed to work with Cherry Studio and Dify platforms, and it supports a plugin-driven architecture where tools live under the tools/ directory and are registered at startup. Clients interact via the /mcp endpoint using standard JSON-RPC 2.0 payloads to initialize, list available tools, and call specific tools.

To use it, run the server (via Go tooling or Docker) and open the web UI at http://localhost:8000. The MCP API endpoint is exposed at POST /mcp and supports methods such as initialize, tools/list, and tools/call. Tools themselves are designed with a common interface and can be extended by adding new tool implementations under tools/ and registering them in the tool registry. The documentation notes that several tools are available, with read_file already implemented and other tools (like prometheus_tools, docker_tools, jenkins_tools, mysql_query_tools, files_query_tools, system_check_tools) currently in development or pending completion. The web UI also exposes REST endpoints for status, tool management, configuration saving, and viewing records and analytics.

When integrating with Cherry Studio or Dify, you configure the MCP server address (for example, http://localhost:8000/mcp) in the respective platform and rely on the tools/list and tools/call methods to enumerate and execute tools within your workflow or chat-based interactions.

Prerequisites:

• Go 1.21 or higher (for local build). Alternatively, you can deploy via Docker as described below.
• Git
• Optional: Docker if you prefer containerized deployment

Installation steps (local Go build):

1. Ensure Go is installed: go version
2. Clone the repository: git clone https://github.com/isYaoNoistu/mcp-server-go.git cd mcp-server-go
3. Install dependencies and build: go mod download go build -o mcp-server-go
4. Prepare environment: Copy the example env to a real config: cp .env.example .env Edit .env to configure servers/tools as needed
5. Run the server: ./mcp-server-go

   By default it will start on http://localhost:8000

Alternative Docker deployment (recommended if you want isolation):

1. Build the Docker image (example tag): docker build -t mcp-server-go .
2. Run the container exposing port 8000 and using an env file: docker run -p 8000:8000 --env-file .env mcp-server-go The server will be accessible at http://localhost:8000/mcp

Notes:

• If you prefer to run via Go directly without Docker, use go run main.go or the prebuilt binary as shown above. Adjust PORT and HOST via the .env file as needed.

Tips and common considerations:

• The server exposes a web UI at http://localhost:8000 for tool management, records, and stats. Use it to enable/disable tools and adjust tool parameters.
• Environment variables in .env control server behavior (PORT, HOST, GIN_MODE) and tool configurations (READ_FILE_PATH, PROMETHEUS_API_URL, MYSQL_DEFAULT_* values, Jenkins credentials, etc.).
• The project supports persistent states for tool enable/disable status; ensure you have write permissions to any paths used by tools.
• If some tools show as pending or disabled (as indicated in the README), they may not be fully implemented yet. Check the web UI or repository for tool status and upcoming releases.
• When using Docker, the recommended image name is mcp-server-go-image or your own built image; adapt the docker run command to your image tag. If you switch to a different host/port, update the Cherry Studio or Dify configurations accordingly (server address and protocol: JSON-RPC 2.0).
• For production deployments, consider enabling Prometheus metrics and setting appropriate database credentials in .env; ensure your firewall and reverse proxy configurations allow access to the MCP endpoint.