MCP官方Go SDK尝鲜

前言

此前在 MCP 官网就注意到官方提供了 Go SDK，近期由于在 Python 环境下开发 MCP Server 有点"审美疲劳"，因此决定使用 Go 语言尝尝鲜。
从个人实际体验来看，Go 语言在并发处理方面确实具有显著优势：无需纠结于同步阻塞、异步事件循环、多进程多线程通信等复杂的并发问题，goroutine 一把梭哈。同时，Go 语言的部署也非常便捷，编译后生成的静态二进制文件具有良好的可移植性，可以在不同环境中直接运行。
然而，这种便利性也伴随着一定的代价。相较于 Python，使用 Go 语言实现 MCP 功能相对复杂一些，开发效率略低。这就是软件工程中的经典权衡了：运行成本与开发成本往往难以兼得，需要根据具体场景进行取舍。
MCP 协议简介

可能都耳熟能详了，但以防还有不熟悉的朋友，先简单介绍下MCP
Model Context Protocol (MCP) 是一种标准化的协议，旨在为 AI 模型提供统一的工具调用接口。通过 MCP，开发者可以将各种工具、服务和数据源暴露给 AI 模型，使其能够执行超出基础语言模型能力范围的操作。MCP 支持多种传输协议，包括 HTTP 和 Stdio，为不同场景下的集成提供了灵活性。
一个简单的 MCP Server 示例

MCP 官方 Go SDK 在定义工具（Tool）时，要求明确指定输入参数和输出结果的数据结构。对于功能较为简单的工具，也可以直接使用 any 类型。以下是一个完整的 MCP Server 示例，提供了三个实用工具：

• getCurrentDatetime：获取当前时间，返回 RFC3339 格式（2006-01-02T15:04:05Z07:00）的时间戳字符串。由于不需要输入参数，因此参数类型定义为 any，输出同样使用 any 类型。
  
• getComputerStatus：获取当前系统的关键信息，包括 CPU 使用率、内存使用情况、系统版本等。该工具接受一个 CPUSampleTime 参数，对应的输入结构体为 GetComputerStatusIn，输出结构体为 GetComputerStatusOut（Go SDK 的示例中通常采用 xxxIn 和 xxxOut 的命名约定来区分工具的输入输出结构体）。
  
• getDiskInfo：获取所有硬盘分区的使用信息和文件系统详情。该工具无需输入参数，仅定义了输出结构体 GetDiskInfoOut。
  

在完成所有工具逻辑的实现后，最后一步是启动服务。以下示例采用 Streamable HTTP 模式启动，同时也保留了 Stdio Transport 模式的注释代码供参考。

1. package main
3. import (
4.         "context"
5.         "fmt"
6.         "log"
7.         "net"
8.         "net/http"
9.         "time"
11.         "github.com/modelcontextprotocol/go-sdk/mcp"
12.         "github.com/shirou/gopsutil/v4/cpu"
13.         "github.com/shirou/gopsutil/v4/disk"
14.         "github.com/shirou/gopsutil/v4/host"
15.         "github.com/shirou/gopsutil/v4/mem"
16. )
18. func getCurrentDatetime(ctx context.Context, req *mcp.CallToolRequest, arg any) (*mcp.CallToolResult, any, error) {
19.         now := time.Now().Format(time.RFC3339)
20.         return nil, now, nil
21. }
23. type GetComputerStatusIn struct {
24.         CPUSampleTime time.Duration `json:"cpu_sample_time" jsonschema:"the sample time of cpu usage. Default is 1s"`
25. }
27. type GetComputerStatusOut struct {
28.         Hostinfo    string `json:"host info" jsonschema:"the hostinfo of the computer"`
29.         TimeZone    string `json:"time_zone" jsonschema:"the time zone of the computer"`
30.         IPAddress   string `json:"ip_address" jsonschema:"the ip address of the computer"`
31.         CPUUsage    string `json:"cpu_usage" jsonschema:"the cpu usage of the computer"`
32.         MemoryUsage string `json:"memory_usage" jsonschema:"the memory usage of the computer"`
33. }
35. func getComputerStatus(ctx context.Context, req *mcp.CallToolRequest, args GetComputerStatusIn) (*mcp.CallToolResult, GetComputerStatusOut, error) {
36.         if args.CPUSampleTime == 0 {
37.                 args.CPUSampleTime = time.Second
38.         }
39.         hInfo, err := host.Info()
40.         if err != nil {
41.                 return nil, GetComputerStatusOut{}, err
42.         }
44.         var resp GetComputerStatusOut
45.         resp.Hostinfo = fmt.Sprintf("%+v", *hInfo)
47.         name, offset := time.Now().Zone()
48.         resp.TimeZone = fmt.Sprintf("Timezone: %s (UTC%+d)\n", name, offset/3600)
50.         // CPU Usage
51.         percent, err := cpu.Percent(time.Second, false)
52.         if err != nil {
53.                 return nil, GetComputerStatusOut{}, err
54.         }
55.         resp.CPUUsage = fmt.Sprintf("CPU Usage: %.2f%%\n", percent[0])
57.         // Memory Usage
58.         v, err := mem.VirtualMemory()
59.         if err != nil {
60.                 return nil, GetComputerStatusOut{}, err
61.         }
62.         resp.MemoryUsage = fmt.Sprintf("Mem Usage: %.2f%% (Used: %vMB / Total: %vMB)\n",
63.                 v.UsedPercent, v.Used/1024/1024, v.Total/1024/1024)
65.         // Ip Address
66.         conn, err := net.Dial("udp", "8.8.8.8:80")
67.         if err != nil {
68.                 return nil, GetComputerStatusOut{}, err
69.         }
70.         defer conn.Close()
71.         localAddr := conn.LocalAddr().(*net.UDPAddr)
72.         resp.IPAddress = localAddr.IP.String()
74.         return nil, resp, nil
75. }
77. type DiskInfo struct {
78.         Device     string   `json:"device" jsonschema:"the device name"`
79.         Mountpoint string   `json:"mountpoint" jsonschema:"the mountpoint"`
80.         Fstype     string   `json:"fstype" jsonschema:"the filesystem type"`
81.         Opts       []string `json:"opts" jsonschema:"the mount options"`
82.         DiskTotal  uint64   `json:"disk_total" jsonschema:"the total disk space in GiB"`
83.         DiskUsage  float64  `json:"disk_usage" jsonschema:"the disk usage percentage"`
84. }
86. type GetDiskInfoOut struct {
87.         PartInfos []DiskInfo `json:"part_infos" jsonschema:"the disk partitions"`
88. }
90. func getDiskInfo(ctx context.Context, req *mcp.CallToolRequest, args any) (*mcp.CallToolResult, GetDiskInfoOut, error) {
91.         partInfos, err := disk.Partitions(false)
92.         if err != nil {
93.                 return nil, GetDiskInfoOut{}, err
94.         }
96.         var resp []DiskInfo
97.         for _, part := range partInfos {
98.                 diskUsage, err := disk.Usage(part.Mountpoint)
99.                 if err != nil {
100.                         continue
101.                 }
102.                 resp = append(resp, DiskInfo{
103.                         Device:     part.Device,
104.                         Mountpoint: part.Mountpoint,
105.                         Fstype:     part.Fstype,
106.                         Opts:       part.Opts,
107.                         DiskTotal:  diskUsage.Total / 1024 / 1024 / 1024,
108.                         DiskUsage:  diskUsage.UsedPercent,
109.                 })
110.         }
111.         return nil, GetDiskInfoOut{PartInfos: resp}, nil
112. }
114. func main() {
115.         // ctx := context.Background()
117.         server := mcp.NewServer(&mcp.Implementation{Name: "MCP_Demo", Version: "0.0.1"}, &mcp.ServerOptions{
118.                 Instructions: "日期时间相关的 Server",
119.         })
120.         mcp.AddTool(server, &mcp.Tool{
121.                 Name:        "get_current_datetime",
122.                 Description: "Get current datetime in RFC3339 format",
123.         }, getCurrentDatetime)
125.         mcp.AddTool(server, &mcp.Tool{
126.                 Name:        "get_computer_status",
127.                 Description: "Get computer status",
128.         }, getComputerStatus)
130.         mcp.AddTool(server, &mcp.Tool{
131.                 Name:        "get_disk_info",
132.                 Description: "Get disk information",
133.         }, getDiskInfo)
135.         // if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {
136.         //         log.Fatalln(err)
137.         // }
138.         //
139.         handler := mcp.NewStreamableHTTPHandler(func(req *http.Request) *mcp.Server {
140.                 path := req.URL.Path
141.                 switch path {
142.                 case "/api/mcp":
143.                         return server
144.                 default:
145.                         return nil
146.                 }
147.         }, nil)
148.         url := "127.0.0.1:18001"
149.         if err := http.ListenAndServe(url, handler); err != nil {
150.                 log.Fatalln(err)
151.         }
152. }

复制代码

MCP Server 代码编译通过后，可以在支持 MCP 协议的开发工具（如 VS Code）中进行测试验证。以下是一个典型的 .vscode/mcp.json 配置示例：

1. {
2.     "servers": {
3.         "demo-http": {
4.             // "command": "/home/rainux/Documents/workspace/go-dev/mcp-dev/mcp-server-dev/mcp-server-dev"
5.             "type": "http",
6.             "url": "http://127.0.0.1:18001/api/mcp"
7.         }
8.     }
9. }

复制代码

启动 MCP Server 后，可以通过向 LLM 提出相关问题来验证工具是否能够被正确调度和执行。
一个完整的 MCP Client 实现

为了构建端到端的 MCP 应用，我们还需要实现一个 MCP Client，使其能够与 LLM 协同工作，自动选择并调用合适的工具。以下是一个功能完整的 MCP Client 实现，其中包含了与 OpenAI 兼容 API 的集成示例（callOpenAI 函数）。

1. package main
3. import (
4.         "context"
5.         "encoding/json"
6.         "flag"
7.         "fmt"
8.         "log"
9.         "net/http"
10.         "os/exec"
11.         "time"
13.         "github.com/modelcontextprotocol/go-sdk/mcp"
14.         "github.com/openai/openai-go/v3"
15.         "github.com/openai/openai-go/v3/option"
16.         "github.com/openai/openai-go/v3/packages/param"
17. )
19. var (
20.         FLAG_ModelName     string
21.         FLAG_BaseURL       string
22.         FLAG_APIKEY        string
23.         FLAG_MCP_TRANSPORT string
24.         FLAG_MCP_URI       string
25.         FLAG_QUESTION      string
26.         FLAG_STREAM        bool
27. )
29. func main() {
30.         // Parse command-line flags
31.         flag.StringVar(&FLAG_BaseURL, "base-url", "https://dashscope.aliyuncs.com/compatible-mode/v1", "llm base url")
32.         flag.StringVar(&FLAG_ModelName, "model", "qwen-plus", "LLM Model Name")
33.         flag.StringVar(&FLAG_MCP_TRANSPORT, "mcp-transport", "http", "MCP transport protocol (stdio or http)")
34.         flag.StringVar(&FLAG_MCP_URI, "mcp-uri", "", "MCP server address")
35.         flag.StringVar(&FLAG_APIKEY, "api-key", "", "llm api key")
36.         flag.StringVar(&FLAG_QUESTION, "q", "Hi", "question")
37.         flag.BoolVar(&FLAG_STREAM, "s", false, "stream response")
39.         flag.Parse()
41.         // Get configuration from environment variables with flag overrides
42.         if FLAG_APIKEY == "" {
43.                 log.Fatalln("api key is empty")
44.         }
46.         if FLAG_QUESTION == "" {
47.                 log.Fatalln("question is empty")
48.         }
50.         // Configure OpenAI client
51.         // config :=
52.         ctx := context.Background()
54.         // question := "Write me a haiku about computers"
55.         if FLAG_MCP_URI != "" {
56.                 callOpenAIWithTools(ctx, FLAG_QUESTION)
57.         } else {
58.                 callOpenAI(ctx, FLAG_QUESTION, FLAG_STREAM)
59.         }
60. }
62. // callOpenAI 调用 OpenAI API 接口处理用户问题
63. // 该函数支持流式（stream）和非流式（non-stream）两种响应方式
64. //
65. // 参数:
66. //   - ctx: 控制操作生命周期的上下文
67. //   - question: 用户提出的问题字符串
68. //   - stream: 布尔值，指定是否使用流式响应
69. func callOpenAI(ctx context.Context, question string, stream bool) {
70.         client := openai.NewClient(option.WithAPIKey(FLAG_APIKEY), option.WithBaseURL(FLAG_BaseURL))
71.         systemPrompt := "请用亲切热情的风格回答用户的问题"
73.         if stream {
74.                 // 创建流式响应请求
75.                 streamResp := client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
76.                         Messages: []openai.ChatCompletionMessageParamUnion{
77.                                 openai.SystemMessage(systemPrompt),
78.                                 openai.UserMessage(question),
79.                         },
80.                         Model: FLAG_ModelName,
81.                 })
82.                 // defer streamResp.Close()
83.                 defer func() {
84.                         err := streamResp.Close()
85.                         if err != nil {
86.                                 log.Fatalln(err)
87.                         }
88.                 }()
89.                 // 遍历流式响应并逐块输出内容
90.                 for streamResp.Next() {
91.                         data := streamResp.Current()
92.                         fmt.Print(data.Choices[0].Delta.Content)
94.                         if err := streamResp.Err(); err != nil {
95.                                 log.Fatalln(err)
96.                         }
97.                 }
99.         } else {
100.                 // 创建非流式响应请求
101.                 chatCompletion, err := client.Chat.Completions.New(ctx, openai.ChatCompletionNewParams{
102.                         Messages: []openai.ChatCompletionMessageParamUnion{
103.                                 openai.SystemMessage(systemPrompt),
104.                                 openai.UserMessage(question),
105.                         },
106.                         Model: FLAG_ModelName,
107.                 })
108.                 if err != nil {
109.                         log.Fatalln(err)
110.                 }
111.                 // 输出非流式响应内容
112.                 fmt.Println(chatCompletion.Choices[0].Message.Content)
113.         }
114. }
116. // callOpenAIWithTools 使用 OpenAI API 和 MCP 工具调用来处理用户问题
117. // 该函数创建一个 OpenAI 客户端和 MCP 客户端，将 MCP 工具转换为 OpenAI 可使用的格式，
118. // 并执行完整的工具调用流程，包括初始调用和可能的后续调用
119. //
120. // 参数:
121. //   - ctx: 控制操作生命周期的上下文
122. //   - question: 用户提出的问题字符串
123. func callOpenAIWithTools(ctx context.Context, question string) {
124.         // 创建 OpenAI 客户端，使用 API 密钥和基础 URL 配置
125.         llmClient := openai.NewClient(option.WithAPIKey(FLAG_APIKEY), option.WithBaseURL(FLAG_BaseURL))
126.         // 创建 MCP 客户端，指定名称和版本
127.         mcpClient := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "0.0.1"}, nil)
128.         var transport mcp.Transport
129.         // 根据命令行标志选择传输协议（stdio 或 http）
130.         switch FLAG_MCP_TRANSPORT {
131.         case "stdio":
132.                 transport = &mcp.CommandTransport{Command: exec.Command(FLAG_MCP_URI)}
133.         case "http":
134.                 transport = &mcp.StreamableClientTransport{HTTPClient: &http.Client{Timeout: time.Second * 10}, Endpoint: FLAG_MCP_URI}
135.         default:
136.                 log.Fatalf("unknown transport, %s", FLAG_MCP_TRANSPORT)
137.         }
138.         // 建立与 MCP 服务器的连接
139.         session, err := mcpClient.Connect(ctx, transport, nil)
140.         if err != nil {
141.                 log.Fatalf("MCP client connects to mcp server failed, err: %v", err)
142.         }
143.         defer func() {
144.                 err := session.Close()
145.                 if err != nil {
146.                         log.Fatalln(err)
147.                 }
148.         }()
150.         // 获取可用的 MCP 工具列表
151.         mcpTools, err := session.ListTools(ctx, &mcp.ListToolsParams{})
152.         if err != nil {
153.                 log.Fatalf("List mcp tools failed, err: %v", err)
154.         }
156.         var legacyTools []openai.ChatCompletionToolUnionParam
157.         // 遍历所有 MCP 工具并将其转换为 OpenAI 兼容的工具格式
158.         for _, tool := range mcpTools.Tools {
159.                 // 将 MCP 工具输入模式转换为 OpenAI 函数参数
160.                 if inputSchema, ok := tool.InputSchema.(map[string]any); ok {
161.                         legacyTools = append(legacyTools, openai.ChatCompletionFunctionTool(
162.                                 openai.FunctionDefinitionParam{
163.                                         Name:        tool.Name,
164.                                         Description: openai.String(tool.Description),
165.                                         Parameters:  openai.FunctionParameters(inputSchema),
166.                                 },
167.                         ))
168.                 } else {
169.                         // 如果 InputSchema 不是 map[string]any，使用空参数
170.                         legacyTools = append(legacyTools, openai.ChatCompletionFunctionTool(
171.                                 openai.FunctionDefinitionParam{
172.                                         Name:        tool.Name,
173.                                         Description: openai.String(tool.Description),
174.                                         Parameters:  openai.FunctionParameters{},
175.                                 },
176.                         ))
177.                 }
178.         }
180.         // 设置初始聊天消息，包括系统提示和用户问题
181.         messages := []openai.ChatCompletionMessageParamUnion{
182.                 openai.SystemMessage("请用亲切热情的风格回答用户的问题。你可以使用可用的工具来获取信息。"),
183.                 openai.UserMessage(question),
184.         }
186.         // 调用 LLM 获取初步响应
187.         chatCompletion, err := llmClient.Chat.Completions.New(ctx, openai.ChatCompletionNewParams{
188.                 Messages: messages,
189.                 Model:    FLAG_ModelName,
190.                 Tools:    legacyTools,
191.                 ToolChoice: openai.ChatCompletionToolChoiceOptionUnionParam{
192.                         OfAuto: param.Opt[string]{
193.                                 Value: "auto",
194.                         },
195.                 },
196.         })
197.         if err != nil {
198.                 log.Fatalf("LLM call failed, err: %v", err)
199.         }
201.         choice := chatCompletion.Choices[0]
202.         fmt.Printf("LLM response: %s\n", choice.Message.Content)
204.         // 检查是否需要调用工具
205.         if choice.FinishReason == "tool_calls" && len(choice.Message.ToolCalls) > 0 {
206.                 // 遍历所有需要调用的工具
207.                 for _, toolCall := range choice.Message.ToolCalls {
208.                         if toolCall.Type != "function" {
209.                                 continue
210.                         }
212.                         fmt.Printf("Executing tool: %s with args: %s\n", toolCall.Function.Name, toolCall.Function.Arguments)
214.                         // 解析 JSON 参数
215.                         var argsObj map[string]any
216.                         args := toolCall.Function.Arguments
218.                         if args != "" {
219.                                 if err := json.Unmarshal([]byte(args), &argsObj); err != nil {
220.                                         log.Printf("Failed to parse tool arguments: %v", err)
221.                                         argsObj = make(map[string]any)
222.                                 }
223.                         } else {
224.                                 argsObj = make(map[string]any)
225.                         }
227.                         fmt.Printf("Executing tool: %s with parsed args: %v\n", toolCall.Function.Name, argsObj)
229.                         // 执行 MCP 工具调用
230.                         result, err := session.CallTool(ctx, &mcp.CallToolParams{
231.                                 Name:      toolCall.Function.Name,
232.                                 Arguments: argsObj,
233.                         })
234.                         if err != nil {
235.                                 log.Printf("Tool call failed: %v", err)
236.                                 continue
237.                         }
239.                         // 将 MCP 内容转换为字符串
240.                         var toolResult string
241.                         if len(result.Content) > 0 {
242.                                 if textContent, ok := result.Content[0].(*mcp.TextContent); ok {
243.                                         toolResult = textContent.Text
244.                                 } else {
245.                                         // 如果不是 TextContent，转换为 JSON
246.                                         if jsonBytes, err := json.Marshal(result.Content[0]); err == nil {
247.                                                 toolResult = string(jsonBytes)
248.                                         } else {
249.                                                 toolResult = "Tool executed successfully"
250.                                         }
251.                                 }
252.                         }
254.                         fmt.Printf("Tool result: %s\n", toolResult)
256.                         // 添加工具调用消息和工具响应消息
257.                         messages = append(messages, openai.ChatCompletionMessageParamUnion{
258.                                 OfAssistant: &openai.ChatCompletionAssistantMessageParam{
259.                                         Role: "assistant",
260.                                         ToolCalls: []openai.ChatCompletionMessageToolCallUnionParam{
261.                                                 {
262.                                                         OfFunction: &openai.ChatCompletionMessageFunctionToolCallParam{
263.                                                                 ID: toolCall.ID,
264.                                                                 Function: openai.ChatCompletionMessageFunctionToolCallFunctionParam{
265.                                                                         Name:      toolCall.Function.Name,
266.                                                                         Arguments: toolCall.Function.Arguments,
267.                                                                 },
268.                                                         },
269.                                                 },
270.                                         },
271.                                 },
272.                         })
274.                         messages = append(messages, openai.ToolMessage(
275.                                 toolResult,
276.                                 toolCall.ID,
277.                         ))
279.                         // 进行后续调用以获得最终响应
280.                         chatCompletion, err = llmClient.Chat.Completions.New(ctx, openai.ChatCompletionNewParams{
281.                                 Messages: messages,
282.                                 Model:    FLAG_ModelName,
283.                         })
284.                         if err != nil {
285.                                 log.Fatalf("LLM follow-up failed, err: %v", err)
286.                         }
288.                         fmt.Printf("Final response: %s\n", chatCompletion.Choices[0].Message.Content)
289.                 }
290.         }
291. }

复制代码

运行测试验证

编译完成后，我们可以进行多轮测试来验证功能的正确性。
普通问答测试：

1. ./mcp-client-dev -api-key "sk-xxx" -q "how are you"

复制代码

还可以加上 -s 参数启用流式输出：

1. ./mcp-client-dev -api-key "sk-xxx" -q "how are you" -s

复制代码

预期输出：
[code]Hi there!
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！