使用Go语言开发MCP服务器的全面指南

引言

MCP(Model Context Protocol，模型上下文协议)是由Anthropic推出的一种开源协议，旨在建立AI模型与开发环境之间的统一上下文交互标准。通过提供标准化的上下文信息访问方式，MCP使AI模型能够与各种外部数据源和工具进行无缝集成。本文将详细介绍如何使用Go语言开发一个MCP服务器，帮助开发者创建能够与AI模型高效交互的服务。

MCP协议简介

MCP协议是一种开放标准协议，用于标准化应用程序如何为大型语言模型(LLMs)提供上下文。它可以被想象为AI应用的USB-C接口，提供了一种将AI模型连接到不同数据源和工具的标准化方式[10]。 MCP协议遵循客户端-主机-服务器架构，MCP协议其实就是规定的组件之间的通信协议，而MCP中的所有消息必须遵循JSON-RPC 2.0规范[11]。这种架构使用户能够跨应用程序集成AI能力，同时保持清晰的安全边界并隔离不同服务[21]。

Go语言开发MCP服务器的优势

Go语言因其高效性、简洁性和并发处理能力而成为开发MCP服务器的理想选择。以下是使用Go语言开发MCP服务器的几个优势：

1. 高效性：Go语言的高性能使其能够处理大量并发连接，这对于MCP服务器至关重要。

2. 简洁性：Go语言的简洁语法使得代码易于编写和维护，有助于快速开发MCP服务器。

3. 内置JSON支持：Go标准库提供了强大的JSON处理能力，这对于实现基于JSON-RPC协议的MCP服务器非常有用。

4. 丰富的生态系统：Go语言拥有丰富的第三方库，可以简化MCP服务器的开发过程。

开发环境准备

在开始开发MCP服务器之前，需要确保已经安装了以下工具：

1. Go语言环境：确保已经安装了最新版本的Go语言环境。

2. 代码编辑器：选择一个支持Go语言的代码编辑器，如VSCode、GoLand等。

3. 构建工具：安装必要的构建工具，如go build、go run等。

4. 依赖管理工具：使用Go Modules来管理项目依赖。

MCP服务器的基本架构

一个基本的MCP服务器通常包含以下组件：

1. 资源管理：负责管理服务器提供的数据实体，可以是文件、数据库记录等。

2. JSON-RPC处理：负责处理客户端的JSON-RPC请求，这是MCP协议的核心。

3. 安全机制：确保服务器和客户端之间的通信是安全的。

4. 日志记录：记录服务器运行过程中的重要事件和错误信息。

5. 配置管理：管理服务器的配置信息，如端口、数据库连接等。

使用Go语言实现MCP服务器

步骤1：设置项目结构

首先，创建一个新的Go项目，并设置基本的项目结构。一个典型的MCP服务器项目结构如下：

mcp-server/
├── main.go
├── server/
│   ├── server.go
│   ├── handler.go
│   ├── resource.go
│   └── jsonrpc.go
├── config/
│   └── config.go
├── log/
│   └── log.go
└── go.mod

步骤2：实现资源管理

资源是服务器提供给客户端的数据实体，可以是文件、数据库记录等。在MCP服务器中，资源是核心概念，客户端通过资源ID来访问和操作资源。 以下是实现资源管理的基本代码：

package server
import (
    "time"
)
// 定义资源结构
type Resource struct {
    ID        string    `json:"id"`
    Type      string    `json:"type"`
    Content   string    `json:"content"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}
// 定义资源管理器
type ResourceManager struct {
    resources map[string]Resource
}
// 创建新的资源管理器
func NewResourceManager() *ResourceManager {
    return &ResourceManager{
        resources: make(map[string]Resource),
    }
}
// 添加资源
func (m *ResourceManager) AddResource(resource Resource) {
    m.resources[resource.ID] = resource
}
// 获取资源
func (m *ResourceManager) GetResource(id string) (Resource, bool) {
    resource, exists := m.resources[id]
    return resource, exists
}
// 更新资源
func (m *ResourceManager) UpdateResource(id string, resource Resource) bool {
    if _, exists := m.resources[id]; exists {
        m.resources[id] = resource
        return true
    }
    return false
}
// 删除资源
func (m *ResourceManager) DeleteResource(id string) bool {
    if _, exists := m.resources[id]; exists {
        delete(m.resources, id)
        return true
    }
    return false
}

步骤3：实现JSON-RPC处理

MCP协议基于JSON-RPC 2.0规范，因此需要实现JSON-RPC处理功能。Go语言的标准库提供了net/rpc包，可以用来实现RPC服务器。但是，net/rpc包默认使用gob编码，而不是JSON。因此，需要自定义一个JSON编码器。 以下是实现JSON-RPC处理的基本代码：

package server
import (
    "encoding/json"
    "errors"
    "io"
    "net/http"
    "reflect"
    "strings"
)
// 自定义JSON编码器
type jsonCodec struct{}
func (c *jsonCodec) ReadRequest(r io.Reader) (interface{}, error) {
    var req struct {
        Method string `json:"method"`
        Params json.RawMessage `json:"params"`
    }
    if err := json.NewDecoder(r).Decode(&req); err != nil {
        return nil, err
    }
    method, ok := req.Method.(string)
    if !ok {
        return nil, errors.New("method is not a string")
    }
    params, err := decodeParams(req.Params, method)
    if err != nil {
        return nil, err
    }
    return &rpcRequest{
        ServiceMethod: method,
        Args:         params,
    }, nil
}
func decodeParams(params json.RawMessage, method string) (interface{}, error) {
    // 这里可以添加具体的解码逻辑
    return nil, nil
}
type rpcRequest struct {
    ServiceMethod string
    Args         reflect.Value
}
func (c *jsonCodec) WriteResponse(rw io.Writer, response interface{}, error error) error {
    var resp struct {
        Result json.RawMessage `json:"result,omitempty"`
        Error  json.RawMessage `json:"error,omitempty"`
    }
    if error != nil {
        err := struct {
            Code    int    `json:"code"`
            Message string `json:"message"`
            Data   string `json:"data,omitempty"`
        }{
            Code:    -32000,
            Message: error.Error(),
            Data:   "",
        }
        if errData, ok := error.(*rpc.Error); ok {
            err.Code = errData.Code
            err.Message = errData.Message
            if errData.Data != nil {
                data, _ := json.Marshal(errData.Data)
                err.Data = string(data)
            }
        }
        resp.Error = json.RawMessage(strings.TrimPrefix(string(json.Marshal(err)), "{"))
    } else {
        // 编码结果
        // 这里可以添加具体的编码逻辑
        resp.Result = json.RawMessage("{}")
    }
    return json.NewEncoder(rw).Encode(resp)
}

步骤4：实现MCP服务器

现在，可以实现MCP服务器了。MCP服务器需要处理客户端的JSON-RPC请求，并根据请求类型调用相应的资源管理函数。 以下是实现MCP服务器的基本代码：

package main
import (
    "flag"
    "log"
    "net/http"
    "github.com/gorilla/mux"
)
import (
    "mcp-server/server"
)
func main() {
    // 定义命令行参数
    port := flag.Int("port", 8080, "服务器端口")
    flag.Parse()
    // 创建资源管理器
    resourceManager := server.NewResourceManager()
    // 创建一个新的RPC服务器
    jsonrpc_server := rpc.NewServer()
    // 注册服务
    jsonrpc_server.RegisterName("MCP_Server", resourceManager)
    // 设置自定义的JSON编码器
    jsonrpc_server.SetCodec(new(server.jsonCodec))
    // 设置路由
    r := mux.NewRouter()
    r.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
        if r.Method != "POST" {
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
            return
        }
        jsonrpc_server.ServeHTTP(w, r)
    })
    // 启动服务器
    log.Printf("服务器已启动，监听端口: %d", *port)
    log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), r))
}

步骤5：实现安全机制

为了确保MCP服务器的安全性，需要实现一些安全机制，如认证、授权等。 以下是实现基本认证的安全机制代码：

package server
import (
    "errors"
    "net/http"
    "github.com/gorilla/mux"
)
// 定义认证错误
var (
    ErrUnauthorized = errors.New("unauthorized")
)
// 认证中间件
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 获取认证头
        authHeader := r.Header.Get("Authorization")
        if authHeader == "" {
            http.Error(w, "Missing Authorization header", http.StatusUnauthorized)
            return
        }
        // 解析认证信息
        parts := strings.SplitN(authHeader, " ", 2)
        if len(parts) != 2 {
            http.Error(w, "Invalid Authorization header", http.StatusUnauthorized)
            return
        }
        // 验证认证信息
        if !isValidAuth(parts[1]) {
            http.Error(w, "Invalid credentials", http.StatusUnauthorized)
            return
        }
        // 继续处理请求
        next.ServeHTTP(w, r)
    })
}
// 验证认证信息
func isValidAuth(authInfo string) bool {
    // 这里可以添加具体的验证逻辑
    return true
}

步骤6：实现日志记录

为了记录服务器运行过程中的重要事件和错误信息，需要实现日志记录功能。 以下是实现基本日志记录的代码：

package log
import (
    "log"
    "os"
    "time"
)
// 定义日志级别
const (
    LevelDebug = iota
    LevelInfo
    LevelWarning
    LevelError
)
// 定义日志记录器
type Logger struct {
    level int
    out  *os.File
}
// 创建新的日志记录器
func NewLogger(level int, fileName string) (*Logger, error) {
    file, err := os.OpenFile(fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return nil, err
    }
    return &Logger{
        level: level,
        out:  file,
    }, nil
}
// 记录日志
func (l *Logger) Log(level int, msg string, args ...interface{}) {
    if level < l.level {
        return
    }
    timestamp := time.Now().Format("2006-01-02 15:04:05")
    logMsg := fmt.Sprintf("[%s] %s", timestamp, fmt.Sprintf(msg, args...))
    l.out.WriteString(logMsg + "\n")
}
// 关闭日志记录器
func (l *Logger) Close() error {
    return l.out.Close()
}

步骤7：实现配置管理

为了管理服务器的配置信息，如端口、数据库连接等，需要实现配置管理功能。 以下是实现基本配置管理的代码：

package config
import (
    "encoding/json"
    "io/ioutil"
    "os"
)
// 定义配置结构
type Config struct {
    Port     int    `json:"port"`
    Database  string `json:"database"`
    LogLevel string `json:"log_level"`
}
// 加载配置
func LoadConfig(configFile string) (*Config, error) {
    // 读取配置文件
    configBytes, err := ioutil.ReadFile(configFile)
    if err != nil {
        return nil, err
    }
    // 解析配置
    var config Config
    if err := json.Unmarshal(configBytes, &config); err != nil {
        return nil, err
    }
    // 设置默认值
    if config.Port == 0 {
        config.Port = 8080
    }
    if config.LogLevel == "" {
        config.LogLevel = "info"
    }
    return &config, nil
}
// 获取配置文件路径
func GetConfigPath() string {
    // 获取当前工作目录
    currentDir, err := os.Getwd()
    if err != nil {
        panic(err)
    }
    // 构建配置文件路径
    return currentDir + "/config.json"
}

完整代码示例

以下是完整的MCP服务器代码示例，结合了上述所有组件：

// server/resource.go
package server
import (
    "time"
)
// 定义资源结构
type Resource struct {
    ID        string    `json:"id"`
    Type      string    `json:"type"`
    Content   string    `json:"content"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}
// 定义资源管理器
type ResourceManager struct {
    resources map[string]Resource
}
// 创建新的资源管理器
func NewResourceManager() *ResourceManager {
    return &ResourceManager{
        resources: make(map[string]Resource),
    }
}
// 添加资源
func (m *ResourceManager) AddResource(resource Resource) {
    m.resources[resource.ID] = resource
}
// 获取资源
func (m *ResourceManager) GetResource(id string) (Resource, bool) {
    resource, exists := m.resources[id]
    return resource, exists
}
// 更新资源
func (m *ResourceManager) UpdateResource(id string, resource Resource) bool {
    if _, exists := m.resources[id]; exists {
        m.resources[id] = resource
        return true
    }
    return false
}
// 删除资源
func (m *ResourceManager) DeleteResource(id string) bool {
    if _, exists := m.resources[id]; exists {
        delete(m.resources, id)
        return true
    }
    return false
}

// server/jsonrpc.go
package server
import (
    "encoding/json"
    "errors"
    "io"
    "net/http"
    "reflect"
    "strings"
)
// 自定义JSON编码器
type jsonCodec struct{}
func (c *jsonCodec) ReadRequest(r io.Reader) (interface{}, error) {
    var req struct {
        Method string `json:"method"`
        Params json.RawMessage `json:"params"`
    }
    if err := json.NewDecoder(r).Decode(&req); err != nil {
        return nil, err
    }
    method, ok := req.Method.(string)
    if !ok {
        return nil, errors.New("method is not a string")
    }
    params, err := decodeParams(req.Params, method)
    if err != nil {
        return nil, err
    }
    return &rpcRequest{
        ServiceMethod: method,
        Args:         params,
    }, nil
}
func decodeParams(params json.RawMessage, method string) (interface{}, error) {
    // 这里可以添加具体的解码逻辑
    return nil, nil
}
type rpcRequest struct {
    ServiceMethod string
    Args         reflect.Value
}
func (c *jsonCodec) WriteResponse(rw io.Writer, response interface{}, error error) error {
    var resp struct {
        Result json.RawMessage `json:"result,omitempty"`
        Error  json.RawMessage `json:"error,omitempty"`
    }
    if error != nil {
        err := struct {
            Code    int    `json:"code"`
            Message string `json:"message"`
            Data   string `json:"data,omitempty"`
        }{
            Code:    -32000,
            Message: error.Error(),
            Data:   "",
        }
        if errData, ok := error.(*rpc.Error); ok {
            err.Code = errData.Code
            err.Message = errData.Message
            if errData.Data != nil {
                data, _ := json.Marshal(errData.Data)
                err.Data = string(data)
            }
        }
        resp.Error = json.RawMessage(strings.TrimPrefix(string(json.Marshal(err)), "{"))
    } else {
        // 编码结果
        // 这里可以添加具体的编码逻辑
        resp.Result = json.RawMessage("{}")
    }
    return json.NewEncoder(rw).Encode(resp)
}

// main.go
package main
import (
    "flag"
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/mux"
)
import (
    "mcp-server/server"
)
func main() {
    // 定义命令行参数
    port := flag.Int("port", 8080, "服务器端口")
    flag.Parse()
    // 创建资源管理器
    resourceManager := server.NewResourceManager()
    // 创建一个新的RPC服务器
    jsonrpc_server := rpc.NewServer()
    // 注册服务
    jsonrpc_server.RegisterName("MCP_Server", resourceManager)
    // 设置自定义的JSON编码器
    jsonrpc_server.SetCodec(new(server.jsonCodec))
    // 设置路由
    r := mux.NewRouter()
    r.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
        if r.Method != "POST" {
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
            return
        }
        jsonrpc_server.ServeHTTP(w, r)
    }).Methods("POST")
    // 启动服务器
    log.Printf("服务器已启动，监听端口: %d", *port)
    log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), r))
}

// config/config.go
package config
import (
    "encoding/json"
    "io/ioutil"
    "os"
)
// 定义配置结构
type Config struct {
    Port     int    `json:"port"`
    Database  string `json:"database"`
    LogLevel string `json:"log_level"`
}
// 加载配置
func LoadConfig(configFile string) (*Config, error) {
    // 读取配置文件
    configBytes, err := ioutil.ReadFile(configFile)
    if err != nil {
        return nil, err
    }
    // 解析配置
    var config Config
    if err := json.Unmarshal(configBytes, &config); err != nil {
        return nil, err
    }
    // 设置默认值
    if config.Port == 0 {
        config.Port = 8080
    }
    if config.LogLevel == "" {
        config.LogLevel = "info"
    }
    return &config, nil
}
// 获取配置文件路径
func GetConfigPath() string {
    // 获取当前工作目录
    currentDir, err := os.Getwd()
    if err != nil {
        panic(err)
    }
    // 构建配置文件路径
    return currentDir + "/config.json"
}

// log/log.go
package log
import (
    "log"
    "os"
    "time"
)
// 定义日志级别
const (
    LevelDebug = iota
    LevelInfo
    LevelWarning
    LevelError
)
// 定义日志记录器
type Logger struct {
    level int
    out  *os.File
}
// 创建新的日志记录器
func NewLogger(level int, fileName string) (*Logger, error) {
    file, err := os.OpenFile(fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return nil, err
    }
    return &Logger{
        level: level,
        out:  file,
    }, nil
}
// 记录日志
func (l *Logger) Log(level int, msg string, args ...interface{}) {
    if level < l.level {
        return
    }
    timestamp := time.Now().Format("2006-01-02 15:04:05")
    logMsg := fmt.Sprintf("[%s] %s", timestamp, fmt.Sprintf(msg, args...))
    l.out.WriteString(logMsg + "\n")
}
// 关闭日志记录器
func (l *Logger) Close() error {
    return l.out.Close()
}

测试MCP服务器

为了确保MCP服务器正常工作，可以使用以下测试代码：

package main
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "testing"
)
func TestMCP_Server(t *testing.T) {
    // 启动测试服务器
    go func() {
        main()
    }()
    time.Sleep(1 * time.Second)
    // 测试添加资源
    resource := server.Resource{
        ID:        "1",
        Type:      "text",
        Content:   "Hello, World!",
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }
    resourceJSON, _ := json.Marshal(resource)
    reqBody := fmt.Sprintf(`{"method": "MCP_Server.AddResource", "params": {"resource": %s}}`, string(resourceJSON))
    req, _ := http.NewRequest("POST", "http://localhost:8080/jsonrpc", bytes.NewBuffer([]byte(reqBody)))
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Printf("添加资源响应: %s\n", string(body))
    // 测试获取资源
    reqBody = `{"method": "MCP_Server.GetResource", "params": {"id": "1"}}`
    req, _ = http.NewRequest("POST", "http://localhost:8080/jsonrpc", bytes.NewBuffer([]byte(reqBody)))
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Printf("获取资源响应: %s\n", string(body))
}

结论

通过本文的介绍，我们详细讲解了如何使用Go语言开发一个MCP服务器。从项目结构的设置，到资源管理、JSON-RPC处理、安全机制、日志记录和配置管理，我们提供了一个完整的开发指南。希望本文能够帮助开发者快速上手MCP服务器的开发工作。随着AI技术的不断发展，MCP协议将会在AI应用中扮演越来越重要的角色，掌握MCP服务器的开发技能将为开发者打开更广阔的发展空间。

参考资料

[10] Model Context Protocol (MCP) 文档中心. https://www.claudemcp.com/zh/docs. [11] MCP 文档- 协议. https://www.claudemcp.com/zh/docs/protocol. [21] MCP 协议规范. https://www.claudemcp.com/zh/specification.