"github.com/modelcontextprotocol/go-sdk/mcp"

type TimeInput struct {
	TimeZone string `json:"time_zone" jsonschema:"时区"`
}

type TimeOutput struct {
	Time string `json:"time" jsonschema:"当前时间"`
}

func GetCurrentTime(ctx context.Context, req *mcp.CallToolRequest, intput *TimeInput) (*mcp.CallToolResult, *TimeOutput, error) {
	if len(intput.TimeZone) == 0 {
		intput.TimeZone = "Asia/Shanghai"
	}
	loc, err := time.LoadLocation(intput.TimeZone)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to load location: %w", err)
	}
	now := time.Now().In(loc)
	return nil, &TimeOutput{Time: now.Format("2006-01-02 15:04:05")}, nil
}

const (
	ip        = "XX.XX.XX.XX"
	GAODE_KEY = "xxxx"
)

type LocationResponse struct {
	Status   string `json:"status"`
	Province string `json:"province"`
	City     string `json:"city"`
	Adcode   string `json:"adcode"`
}

func GetLocation(ctx context.Context, req *mcp.CallToolRequest, intput struct{}) (*mcp.CallToolResult, *LocationResponse, error) {
	url := fmt.Sprintf("https://restapi.amap.com/v3/ip?key=%s&ip=%s", GAODE_KEY, ip)
	data, err := HttpGet(url)//HttpGet为包装的http的get请求方法，返回值为请求体
	if err != nil {
		return nil, nil, fmt.Errorf("failed to get location: %w", err)
	}
	var location LocationResponse
	err = sonic.Unmarshal(data, &location)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to unmarshal location: %w", err)
	}
	if location.Status != "1" {
		return nil, nil, fmt.Errorf("failed to get location: %w", err)
	}
	return nil, &location, nil
}

func main() {
	server := mcp.NewServer(&mcp.Implementation{
		Name:    "easy_mcp",
		Version: "1.0.0",
	}, nil)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "time_tool",
		Description: "获取当前时间",
	}, GetCurrentTime)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "location_tool",
		Description: "获取当前位置",
	}, GetLocation)

	//http的server
	handler := mcp.NewStreamableHTTPHandler(
		func(*http.Request) *mcp.Server {
			return server
		}, &mcp.StreamableHTTPOptions{},
	)
	http.HandleFunc("/mcp", handler.ServeHTTP)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func main() {
	ctx := context.Background()
	client := mcp.NewClient(&mcp.Implementation{
		Name:    "easy_mcp",
		Version: "1.0.0",
	}, nil)

	transport := &mcp.StreamableClientTransport{
		Endpoint: "http://127.0.0.1:8080/mcp",
		HTTPClient: &http.Client{
			Timeout: 10 * time.Second,
		},
	}
	session, err := client.Connect(ctx, transport, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	resp, err := session.CallTool(ctx, &mcp.CallToolParams{
		Name: "time_tool",
		Arguments: map[string]any{
			"time_zone": "Asia/Shanghai",
		},
	})
	if err != nil {
		log.Fatal("time_tool call failed:", err)
	}
	if resp.IsError {
		log.Fatal("time_tool returned error, content:", resp.Content)
	}

	resp1, err := session.CallTool(ctx, &mcp.CallToolParams{
		Name:      "location_tool",
		Arguments: map[string]any{},
	})
	if err != nil {
		log.Fatal("location_tool call failed:", err)
	}
	if resp1.IsError {
		log.Fatal("location_tool returned error, content:", resp1.Content)
	}
	for _, c := range resp.Content {
		fmt.Println(c.(*mcp.TextContent).Text)
	}
	for _, c := range resp1.Content {
		fmt.Println(c.(*mcp.TextContent).Text)
	}
}

{"time":"2026-01-12 15:29:07"}
{"adcode":"150000","city":"呼和浩特市","province":"内蒙古自治区","status":"1"}