05 Make Your MCP Server

🚀 Creating an MCP Server with Go and Serving via Docker

This guide explores how to create an MCP server using Go and deploy it via Docker.

🚀 Quick Start

Today, we'll discuss how to create an MCP server using the Go language and deploy it via Docker.

Prerequisites: Read Understanding the Model Context Protocol (MCP).

To write an MCP server, there are several official SDKs available:

• TypeScript SDK
• Python SDK

In this tutorial, we'll use Go for implementation.

✨ Features

• MCP Server Creation: Demonstrates how to build a basic MCP server using Go.
• Docker Deployment: Guides you through packaging the MCP server with Docker.
• Server Testing: Shows how to test the MCP server using the mcphost tool.

📦 Installation

There are no specific installation steps provided in the original text. However, to follow this tutorial, you need to have the following installed:

• Go programming language
• Docker
• mcphost tool

💻 Usage Examples

Basic Usage

First, we need a basic MCP server structure. Here is a simple example:

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"os"

	pb "github.com/protocolbuffers/protobuf/proto"
	emptypb "google.golang.org/protobuf/types/descriptorpb"
)

func main() {
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Server listening at %v\n", listener.Addr())

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Fatalf("Accept: %v", err)
		}
		defer conn.Close()

		go handleConnection(conn)
	}
}

func handleConnection(conn net.Conn) {
	ctx := context.Background()
	stream := pb.NewStream(conn)

	for {
		select {
		case <-ctx.Done():
			return
		default:
			frame, err := stream.ReadFrame()
			if err != nil {
				log.Printf("Read: %v", err)
				break
			}

			switch frame.(type) {
			case *pb.Frame_Data:
				dataFrame := frame.(*pb.Frame_Data)
				fmt.Printf("Received data: %s\n", dataFrame.GetData())
			case *emptypb.Frame_End:
				log.Println("Connection closed by client")
				return
			default:
				log.Printf("Unexpected frame type")
			}
		}
	}
}

This example shows how to use Go's protobuf package to create a simple TCP server that can receive and process data frames.

Advanced Usage

To package the MCP server using Docker, we need a Dockerfile. Here is the corresponding Dockerfile:

FROM golang:1.23.4-alpine AS builder
WORKDIR /app
COPY go.mod .
COPY main.go .

RUN <<EOF
go mod tidy 
go build
EOF

FROM curlimages/curl:8.6.0
WORKDIR /app
COPY --from=builder /app/mcp-curl .
ENTRYPOINT ["./mcp-curl"]

Explanation of the Dockerfile:

1. Use golang:1.23.4-alpine as the base image for building.
2. Set the working directory to /app.
3. Copy go.mod and main.go to the working directory.
4. Run go mod tidy to clean up dependencies and compile the executable file.
5. Use curlimages/curl:8.6.0 as the base image for runtime and copy the built executable file to the /app directory.
6. Set the default startup command to run mcp-curl.

To build the Docker image, run the following command:

docker build -t mcp-curl .

📚 Documentation

To test our MCP server, we can use the mcphost tool. First, create a configuration file mcp.json:

{
  "mcpServers": {
    "mcp-curl-with-docker" :{
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "mcp-curl"
      ]
    }
  }
}

Then, start mcphost and specify the configuration file and model:

mcphost --config ./mcp.json --model ollama:qwen2.5-coder:14b

Here are examples of the running results:

1. The MCP server is recognized:

2. Request a list of available tools:

3. Call the curl tool to get the web page content:

4. Wait for the processing to complete:

5. The returned web page content:

🔚 Conclusion

Through the above steps, we can easily empower LLMs with more powerful capabilities. In subsequent articles, we'll show how to create an MCP client using Go and interact with our server.

We hope this article helps you understand how to implement a complete MCP server using Go and Docker!