使用Gone MCP 组件编写MCP Server

go mod init quickstart
go get github.com/gone-io/goner/mcp

// 这是一个基于MCP(Model-Controller-Provider)的服务器端示例程序
// 展示了如何创建一个简单的MCP工具，该工具可以接收一个名字参数并返回问候语

package main

import (
	"context"
	"errors"
	"fmt"
	"os"

	"github.com/gone-io/gone/v2"
	goneMcp "github.com/gone-io/goner/mcp"
	"github.com/mark3labs/mcp-go/mcp"
)

// main 函数初始化并启动MCP服务器
// 加载必要的组件并注册helloTool工具
func main() {
	_ = os.Setenv("GONE_MCP", `{"name":"quick-start", "version": "0.0.1"}`)
	gone.
		Loads(goneMcp.ServerLoad). // 加载MCP服务器组件
		Load(&helloTool{}). // 加载helloTool工具
		Serve() // 启动服务
}

// helloTool 实现了一个简单的问候工具
// 继承gone.Flag以支持MCP工具的基本功能
type helloTool struct {
	gone.Flag
}

// Define 定义了工具的名称、描述和参数
// 返回值: goneMcp.Tool - 工具的定义信息
func (h helloTool) Define() goneMcp.Tool {
	return mcp.NewTool("hello_world",
		mcp.WithDescription("Say hello to someone"), // 工具描述
		mcp.WithString("name", // 定义字符串类型的name参数
			mcp.Required(),                                 // 将name参数设置为必填
			mcp.Description("Name of the person to greet"), // name参数的描述
		),
	)
}

// Handler 处理工具的调用请求
// 参数:
//   - ctx: 上下文信息
//   - request: 调用请求，包含参数信息
//
// 返回值:
//   - *mcp.CallToolResult: 调用结果
//   - error: 错误信息
func (h helloTool) Handler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	// 获取并验证name参数
	name, ok := request.Params.Arguments["name"].(string)
	if !ok {
		return nil, errors.New("name must be a string") // 参数类型错误时返回错误
	}
	// 返回格式化的问候语
	return mcp.NewToolResultText(fmt.Sprintf("Hello, %s!", name)), nil
}

// 编译时类型检查，确保helloTool实现了goneMcp.ITool接口
var _ goneMcp.ITool = (*helloTool)(nil)

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"time"

	"github.com/gone-io/gone/v2"
	goneMcp "github.com/gone-io/goner/mcp"
	"github.com/mark3labs/mcp-go/client"
	"github.com/mark3labs/mcp-go/mcp"
)

// main 函数是程序的入口点
// 这是一个基于MCP（Message Communication Protocol）的客户端示例程序
// 演示了如何初始化MCP客户端、连接服务器、列出可用工具并调用工具
func main() {
	gone.
		NewApp(goneMcp.ClientLoad). // 创建一个新的Gone应用，使用MCP客户端加载器
		Run(func(in struct {
			// 注入MCP客户端，使用stdio类型通信，并通过本地服务器运行，运行命令为：go run ./server
			client *client.Client `gone:"*,type=stdio,param=go run ./server"`
		}) {
			c := in.client
			// 创建一个带30秒超时的上下文
			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
			defer cancel()

			// 启动客户端
			err := c.Start(ctx)
			if err != nil {
				log.Fatalf("Failed to start client: %v", err)
			}

			// 准备初始化请求
			initRequest := mcp.InitializeRequest{}
			// 设置协议版本和客户端信息
			initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
			initRequest.Params.ClientInfo = mcp.Implementation{
				Name:    "example-client",
				Version: "1.0.0",
			}

			// 发送初始化请求到服务器
			initResult, err := c.Initialize(ctx, initRequest)
			if err != nil {
				log.Fatalf("Failed to initialize: %v", err)
			}
			// 打印服务器信息
			fmt.Printf(
				"Initialized with server: %s %s\n\n",
				initResult.ServerInfo.Name,
				initResult.ServerInfo.Version,
			)

			// 列出服务器提供的所有可用工具
			fmt.Println("Listing available tools...")
			toolsRequest := mcp.ListToolsRequest{}
			tools, err := c.ListTools(ctx, toolsRequest)
			if err != nil {
				log.Fatalf("Failed to list tools: %v", err)
			}
			// 遍历并打印每个工具的名称和描述
			for _, tool := range tools.Tools {
				fmt.Printf("- %s: %s\n", tool.Name, tool.Description)
			}
			fmt.Println()

			// 调用hello_world工具示例
			fmt.Println("Calling `hello_world`")
			request := mcp.CallToolRequest{}
			// 设置要调用的工具名称和参数
			request.Params.Name = "hello_world"
			request.Params.Arguments = map[string]any{
				"name": "John",
			}
			// 执行工具调用
			tool, err := c.CallTool(ctx, request)
			if err != nil {
				log.Fatalf("Failed to call tool: %v", err)
			}
			// 打印工具执行结果
			printToolResult(tool)
		})
}

// printToolResult 辅助函数，用于打印工具执行的结果
// 支持文本内容和其他类型内容的格式化输出
func printToolResult(result *mcp.CallToolResult) {
	for _, content := range result.Content {
		// 如果是文本内容，直接打印
		if textContent, ok := content.(mcp.TextContent); ok {
			fmt.Println(textContent.Text)
		} else {
			// 其他类型内容，转换为JSON格式打印
			jsonBytes, _ := json.MarshalIndent(content, "", "  ")
			fmt.Println(string(jsonBytes))
		}
	}
}

go mod tidy
go run client/main.go

运行结果：

Initialized with server: quick-start 0.0.1

Listing available tools...
- hello_world: Say hello to someone

Calling `hello_world`
Hello, John!

package goner_define

import (
	"context"
	"errors"
	"fmt"
	"github.com/gone-io/gone/v2"
	"github.com/gone-io/goner/mcp"
	"github.com/mark3labs/mcp-go/mcp"
)

type helloTool struct {
	gone.Flag
}

func (h helloTool) Define() goneMcp.Tool {
	return mcp.NewTool("hello_world",
		mcp.WithDescription("Say hello to someone"),
		mcp.WithString("name",
			mcp.Required(),
			mcp.Description("Name of the person to greet"),
		),
	)
}

func (h helloTool) Handler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	name, ok := request.Params.Arguments["name"].(string)
	if !ok {
		return nil, errors.New("name must be a string")
	}
	return mcp.NewToolResultText(fmt.Sprintf("Hello, %s!", name)), nil
}

var _ goneMcp.ITool = (*helloTool)(nil)

package goner_define

import (
	"context"
	"fmt"
	"github.com/gone-io/gone/v2"
	goneMcp "github.com/gone-io/goner/mcp"
	"github.com/mark3labs/mcp-go/mcp"
)

type greeting struct {
	gone.Flag
}

func (g greeting) Define() goneMcp.Prompt {
	return mcp.NewPrompt("greeting",
		mcp.WithPromptDescription("A friendly greeting prompt"),
		mcp.WithArgument("name",
			mcp.ArgumentDescription("Name of the person to greet"),
		),
	)
}

func (g greeting) Handler(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
	name := request.Params.Arguments["name"]
	if name == "" {
		name = "friend"
	}

	return mcp.NewGetPromptResult(
		"A friendly greeting",
		[]mcp.PromptMessage{
			mcp.NewPromptMessage(
				mcp.RoleAssistant,
				mcp.NewTextContent(fmt.Sprintf("Hello, %s! How can I help you today?", name)),
			),
		},
	), nil
}

var _ goneMcp.IPrompt = (*greeting)(nil)

package goner_define

import (
	"context"
	"github.com/gone-io/gone/v2"
	goneMcp "github.com/gone-io/goner/mcp"
	"github.com/mark3labs/mcp-go/mcp"
)

type readmeResource struct {
	gone.Flag
}

func (r readmeResource) Define() goneMcp.Resource {
	return mcp.NewResource(
		"docs://readme",
		"Project README",
		mcp.WithResourceDescription("The project's README file"),
		mcp.WithMIMEType("text/markdown"),
	)
}

func (r readmeResource) Handler(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
	return []mcp.ResourceContents{
		mcp.TextResourceContents{
			URI:      "docs://readme",
			MIMEType: "text/markdown",
			Text:     "readme content",
		},
	}, nil
}

var _ goneMcp.IResource = (*readmeResource)(nil)