使用 Go 构建 MCP Server

package main

import (
	"context"
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	gourl "net/url"
	"strings"
	"time"

	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
)

func main() {
	// GetWeaher("北京")
	// Create MCP server
	s := server.NewMCPServer("MCPDemo", "1.0.0")
	// Add Get time tool
	timetool := mcp.NewTool("current_time",
		mcp.WithDescription("Get current time with timezone, Asia/Shanghai is default"),
		mcp.WithString("timezone", mcp.Required(), mcp.Description("current time timezone")))
	// Add tool handler
	s.AddTool(timetool, currentTimeHandler)

	// add weather tool
	weathertool := mcp.NewTool("current_weather",
		mcp.WithDescription("Get current weather with city name, 北京 is default, 需要输入中文"),
		mcp.WithString("city", mcp.Required(), mcp.Description("city name")))
	// Add tool handler
	s.AddTool(weathertool, weatherHandler)
	// Start the stdio server
	if err := server.ServeStdio(s); err != nil {
		fmt.Printf("Server error: %v\n", err)
	}
}

func currentTimeHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	timezone, ok := request.Params.Arguments["timezone"].(string)
	if !ok {
		return mcp.NewToolResultError("timezone must be a string"), nil
	}
	loc, err := time.LoadLocation(timezone)
	if err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("parse timezone with error: %v", err)), nil
	}
	return mcp.NewToolResultText(fmt.Sprintf(`current time is %s`, time.Now().In(loc))), nil
}

func weatherHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	city, ok := request.Params.Arguments["city"].(string)
	if !ok {
		return mcp.NewToolResultError("city must be a string"), nil
	} 
	body, err := GetWeaher(city)
	if err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("read response body with error: %v", err)), nil
	}
	return mcp.NewToolResultText(string(body)), nil
}

func calcAuthorization(source string, secretId string, secretKey string) (auth string, datetime string, err error) {
	timeLocation, _ := time.LoadLocation("Etc/GMT")
	datetime = time.Now().In(timeLocation).Format("Mon, 02 Jan 2006 15:04:05 GMT")
	signStr := fmt.Sprintf("x-date: %s\nx-source: %s", datetime, source)

	// hmac-sha1
	mac := hmac.New(sha1.New, []byte(secretKey))
	mac.Write([]byte(signStr))
	sign := base64.StdEncoding.EncodeToString(mac.Sum(nil))

	auth = fmt.Sprintf("hmac id=\"%s\", algorithm=\"hmac-sha1\", headers=\"x-date x-source\", signature=\"%s\"",
		secretId, sign)

	return auth, datetime, nil
}

func urlencode(params map[string]string) string {
	var p = gourl.Values{}
	for k, v := range params {
		p.Add(k, v)
	}
	return p.Encode()
}

func GetWeaher(city string) (ret string, err error) {
	// 云市场分配的密钥Id
	secretId := "xxx"
	// 云市场分配的密钥Key
	secretKey := "xxx"
	source := "usagePlan-xxx"

	// 签名
	auth, datetime, _ := calcAuthorization(source, secretId, secretKey)

	// 请求方法
	method := "GET"
	// 请求头
	headers := map[string]string{"X-Source": source, "X-Date": datetime, "Authorization": auth}

	// 查询参数
	queryParams := make(map[string]string)
	queryParams["areaCn"] = city
	queryParams["areaCode"] = ""
	queryParams["ip"] = ""
	queryParams["lat"] = ""
	queryParams["lng"] = ""
	queryParams["need1hour"] = ""
	queryParams["need3hour"] = ""
	queryParams["needIndex"] = ""
	queryParams["needObserve"] = ""
	queryParams["needalarm"] = ""
	// body参数
	bodyParams := make(map[string]string)

	// url参数拼接
	url := "https://service-6drgk6su-1258850945.gz.apigw.tencentcs.com/release/lundear/weather1d"
	if len(queryParams) > 0 {
		url = fmt.Sprintf("%s?%s", url, urlencode(queryParams))
	}

	bodyMethods := map[string]bool{"POST": true, "PUT": true, "PATCH": true}
	var body io.Reader = nil
	if bodyMethods[method] {
		body = strings.NewReader(urlencode(bodyParams))
		headers["Content-Type"] = "application/x-www-form-urlencoded"
	}

	client := &http.Client{
		Timeout: 5 * time.Second,
	}
	request, err := http.NewRequest(method, url, body)
	if err != nil {
		panic(err)
	}
	for k, v := range headers {
		request.Header.Set(k, v)
	}
	response, err := client.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	bodyBytes, err := ioutil.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(bodyBytes))
	return string(bodyBytes), nil
}

{
  "mcpServers": {
    "helight-mcpServers": {
      "command": "/Users/helightxu/aillm/mcpgolangtest/mcp-server",
      "args": [],
      "env": {},
      "disabled": false,
      "autoApprove": [
        "current_weather",
        "current_time"
      ]
    }
  }
}