feat: mcp能力调整为 streamhttp的独立服务 不再依赖gva本体

Author: pixelmaxQm

server/api/v1/example/enter.go

@@ -4,12 +4,14 @@ import "github.com/flipped-aurora/gin-vue-admin/server/service"
 
 type ApiGroup struct {
 	CustomerApi
-	FileUploadAndDownloadApi
+
 	AttachmentCategoryApi
+	FileUploadAndDownloadApi
 }
 
 var (
-	customerService              = service.ServiceGroupApp.ExampleServiceGroup.CustomerService
-	fileUploadAndDownloadService = service.ServiceGroupApp.ExampleServiceGroup.FileUploadAndDownloadService
+	customerService = service.ServiceGroupApp.ExampleServiceGroup.CustomerService
+
 	attachmentCategoryService    = service.ServiceGroupApp.ExampleServiceGroup.AttachmentCategoryService
+	fileUploadAndDownloadService = service.ServiceGroupApp.ExampleServiceGroup.FileUploadAndDownloadService
 )

server/api/v1/system/auto_code_mcp.go

@@ -1,28 +1,18 @@
 package system
 
 import (
-	"fmt"
 	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	mcpTool "github.com/flipped-aurora/gin-vue-admin/server/mcp"
 	"github.com/flipped-aurora/gin-vue-admin/server/mcp/client"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
 	"github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
 	"github.com/gin-gonic/gin"
 	"github.com/mark3labs/mcp-go/mcp"
 )
 
-// Create
-// @Tags      mcp
-// @Summary   自动McpTool
-// @Security  ApiKeyAuth
-// @accept    application/json
-// @Produce   application/json
-// @Param     data  body      request.AutoMcpTool  true  "创建自动代码"
-// @Success   200   {string}  string                 "{"success":true,"data":{},"msg":"创建成功"}"
-// @Router    /autoCode/mcp [post]
 func (a *AutoCodeTemplateApi) MCP(c *gin.Context) {
 	var info request.AutoMcpTool
-	err := c.ShouldBindJSON(&info)
-	if err != nil {
+	if err := c.ShouldBindJSON(&info); err != nil {
 		response.FailWithMessage(err.Error(), c)
 		return
 	}
@@ -36,109 +26,88 @@ func (a *AutoCodeTemplateApi) MCP(c *gin.Context) {
 	response.OkWithMessage("创建成功,MCP Tool路径:"+toolFilePath, c)
 }
 
-// Create
-// @Tags      mcp
-// @Summary   自动McpTool
-// @Security  ApiKeyAuth
-// @accept    application/json
-// @Produce   application/json
-// @Param     data  body      request.AutoMcpTool  true  "创建自动代码"
-// @Success   200   {string}  string                 "{"success":true,"data":{},"msg":"创建成功"}"
-// @Router    /autoCode/mcpList [post]
 func (a *AutoCodeTemplateApi) MCPList(c *gin.Context) {
-
-	baseUrl := fmt.Sprintf("http://127.0.0.1:%d%s", global.GVA_CONFIG.System.Addr, global.GVA_CONFIG.MCP.SSEPath)
-
-	testClient, err := client.NewClient(baseUrl, "testClient", "v1.0.0", global.GVA_CONFIG.MCP.Name)
+	baseURL := mcpTool.ResolveMCPServiceURL()
+	testClient, err := client.NewClient(baseURL, "testClient", "v1.0.0", global.GVA_CONFIG.MCP.Name, incomingMCPHeaders(c))
+	if err != nil {
+		response.FailWithMessage("连接MCP服务失败:"+err.Error(), c)
+		return
+	}
 	defer testClient.Close()
-	toolsRequest := mcp.ListToolsRequest{}
-
-	list, err := testClient.ListTools(c.Request.Context(), toolsRequest)
 
+	list, err := testClient.ListTools(c.Request.Context(), mcp.ListToolsRequest{})
 	if err != nil {
-		response.FailWithMessage("创建失败", c)
-		global.GVA_LOG.Error(err.Error())
+		response.FailWithMessage("获取工具列表失败:"+err.Error(), c)
 		return
 	}
 
+	authHeader := mcpTool.ConfiguredAuthHeader()
 	mcpServerConfig := map[string]interface{}{
 		"mcpServers": map[string]interface{}{
-			global.GVA_CONFIG.MCP.Name: map[string]string{
-				"url": baseUrl,
+			global.GVA_CONFIG.MCP.Name: map[string]interface{}{
+				"url": baseURL,
+				"headers": map[string]string{
+					authHeader: "${YOUR_GVA_TOKEN}",
+				},
 			},
 		},
 	}
+
 	response.OkWithData(gin.H{
 		"mcpServerConfig": mcpServerConfig,
 		"list":            list,
 	}, c)
 }
 
-// Create
-// @Tags      mcp
-// @Summary   测试McpTool
-// @Security  ApiKeyAuth
-// @accept    application/json
-// @Produce   application/json
-// @Param     data  body      object  true  "调用MCP Tool的参数"
-// @Success   200   {object}  response.Response  "{"success":true,"data":{},"msg":"测试成功"}"
-// @Router    /autoCode/mcpTest [post]
+func (a *AutoCodeTemplateApi) MCPRoutes(c *gin.Context) {
+	response.OkWithData(gin.H{
+		"routes": global.GVA_ROUTERS,
+	}, c)
+}
+
 func (a *AutoCodeTemplateApi) MCPTest(c *gin.Context) {
-	// 定义接口请求结构
 	var testRequest struct {
-		Name      string                 `json:"name" binding:"required"`      // 工具名称
-		Arguments map[string]interface{} `json:"arguments" binding:"required"` // 工具参数
+		Name      string                 `json:"name" binding:"required"`
+		Arguments map[string]interface{} `json:"arguments" binding:"required"`
 	}
-
-	// 绑定JSON请求体
 	if err := c.ShouldBindJSON(&testRequest); err != nil {
 		response.FailWithMessage("参数解析失败:"+err.Error(), c)
 		return
 	}
 
-	// 创建MCP客户端
-	baseUrl := fmt.Sprintf("http://127.0.0.1:%d%s", global.GVA_CONFIG.System.Addr, global.GVA_CONFIG.MCP.SSEPath)
-	testClient, err := client.NewClient(baseUrl, "testClient", "v1.0.0", global.GVA_CONFIG.MCP.Name)
+	baseURL := mcpTool.ResolveMCPServiceURL()
+	testClient, err := client.NewClient(baseURL, "testClient", "v1.0.0", global.GVA_CONFIG.MCP.Name, incomingMCPHeaders(c))
 	if err != nil {
-		response.FailWithMessage("创建MCP客户端失败:"+err.Error(), c)
+		response.FailWithMessage("连接MCP服务失败:"+err.Error(), c)
 		return
 	}
 	defer testClient.Close()
 
-	ctx := c.Request.Context()
-
-	// 初始化MCP连接
-	initRequest := mcp.InitializeRequest{}
-	initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
-	initRequest.Params.ClientInfo = mcp.Implementation{
-		Name:    "testClient",
-		Version: "v1.0.0",
-	}
-
-	_, err = testClient.Initialize(ctx, initRequest)
-	if err != nil {
-		response.FailWithMessage("初始化MCP连接失败:"+err.Error(), c)
-		return
-	}
-
-	// 构建工具调用请求
-	request := mcp.CallToolRequest{}
-	request.Params.Name = testRequest.Name
-	request.Params.Arguments = testRequest.Arguments
+	callRequest := mcp.CallToolRequest{}
+	callRequest.Params.Name = testRequest.Name
+	callRequest.Params.Arguments = testRequest.Arguments
 
-	// 调用工具
-	result, err := testClient.CallTool(ctx, request)
+	result, err := testClient.CallTool(c.Request.Context(), callRequest)
 	if err != nil {
 		response.FailWithMessage("工具调用失败:"+err.Error(), c)
 		return
 	}
-
-	// 处理响应结果
 	if len(result.Content) == 0 {
 		response.FailWithMessage("工具未返回任何内容", c)
 		return
 	}
 
-	// 返回结果
 	response.OkWithData(result.Content, c)
 }
+
+func incomingMCPHeaders(c *gin.Context) map[string]string {
+	headerName := mcpTool.ConfiguredAuthHeader()
+	headerValue := c.GetHeader(headerName)
+	if headerValue == "" {
+		return nil
+	}
+
+	return map[string]string{
+		headerName: headerValue,
+	}
+}

server/cmd/mcp/config.go

@@ -0,0 +1,192 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/config"
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"gopkg.in/yaml.v3"
+)
+
+type standaloneConfig struct {
+	MCP      config.MCP      `yaml:"mcp"`
+	AutoCode config.Autocode `yaml:"autocode"`
+}
+
+func loadStandaloneConfig() (string, error) {
+	configPath, err := resolveConfigPath()
+	if err != nil {
+		return "", err
+	}
+
+	content, err := os.ReadFile(configPath)
+	if err != nil {
+		return "", fmt.Errorf("读取 MCP 配置失败: %w", err)
+	}
+
+	var cfg standaloneConfig
+	if err := yaml.Unmarshal(content, &cfg); err != nil {
+		return "", fmt.Errorf("解析 MCP 配置失败: %w", err)
+	}
+
+	applyStandaloneDefaults(configPath, &cfg)
+
+	global.GVA_CONFIG.MCP = cfg.MCP
+	global.GVA_CONFIG.AutoCode = cfg.AutoCode
+
+	return configPath, nil
+}
+
+func resolveConfigPath() (string, error) {
+	explicit, err := parseConfigFlag(os.Args[1:])
+	if err != nil {
+		return "", err
+	}
+	if explicit != "" {
+		return filepath.Abs(explicit)
+	}
+
+	if envPath := strings.TrimSpace(os.Getenv("GVA_MCP_CONFIG")); envPath != "" {
+		return filepath.Abs(envPath)
+	}
+
+	wd, _ := os.Getwd()
+	exe, _ := os.Executable()
+	exeDir := filepath.Dir(exe)
+
+	candidates := []string{
+		filepath.Join(wd, "config.yaml"),
+		filepath.Join(wd, "mcp.yaml"),
+		filepath.Join(wd, "cmd", "mcp", "config.yaml"),
+		filepath.Join(wd, "server", "cmd", "mcp", "config.yaml"),
+		filepath.Join(exeDir, "config.yaml"),
+		filepath.Join(exeDir, "mcp.yaml"),
+	}
+
+	for _, candidate := range candidates {
+		if candidate == "" {
+			continue
+		}
+		if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
+			return filepath.Abs(candidate)
+		}
+	}
+
+	return "", errors.New("未找到 MCP 独立配置文件，请在当前目录、cmd/mcp 目录或通过 -config / GVA_MCP_CONFIG 指定 config.yaml")
+}
+
+func parseConfigFlag(args []string) (string, error) {
+	fs := flag.NewFlagSet("gva-mcp", flag.ContinueOnError)
+	fs.SetOutput(io.Discard)
+
+	var configPath string
+	fs.StringVar(&configPath, "c", "", "MCP config file path")
+	fs.StringVar(&configPath, "config", "", "MCP config file path")
+	if err := fs.Parse(args); err != nil {
+		return "", err
+	}
+
+	return strings.TrimSpace(configPath), nil
+}
+
+func applyStandaloneDefaults(configPath string, cfg *standaloneConfig) {
+	if cfg.MCP.Name == "" {
+		cfg.MCP.Name = "GVA_MCP"
+	}
+	if cfg.MCP.Version == "" {
+		cfg.MCP.Version = "v1.0.0"
+	}
+	if cfg.MCP.Path == "" {
+		cfg.MCP.Path = "/mcp"
+	}
+	if cfg.MCP.Addr == 0 {
+		cfg.MCP.Addr = 8889
+	}
+	if cfg.MCP.AuthHeader == "" {
+		cfg.MCP.AuthHeader = "x-token"
+	}
+	if cfg.MCP.RequestTimeout <= 0 {
+		cfg.MCP.RequestTimeout = 15
+	}
+	if cfg.MCP.UpstreamBaseURL == "" {
+		cfg.MCP.UpstreamBaseURL = "http://127.0.0.1:8888"
+	}
+	if cfg.MCP.BaseURL == "" {
+		cfg.MCP.BaseURL = fmt.Sprintf("http://127.0.0.1:%d%s", cfg.MCP.Addr, cfg.MCP.Path)
+	}
+
+	configDir := filepath.Dir(configPath)
+	if cfg.AutoCode.Server == "" {
+		cfg.AutoCode.Server = "server"
+	}
+	if cfg.AutoCode.Web == "" {
+		cfg.AutoCode.Web = "web/src"
+	}
+	if cfg.AutoCode.Root == "" {
+		if root, err := detectProjectRoot(configDir); err == nil {
+			cfg.AutoCode.Root = root
+		}
+	} else if !filepath.IsAbs(cfg.AutoCode.Root) {
+		cfg.AutoCode.Root = filepath.Clean(filepath.Join(configDir, cfg.AutoCode.Root))
+	}
+
+	if cfg.AutoCode.Module == "" && cfg.AutoCode.Root != "" {
+		goModPath := filepath.Join(cfg.AutoCode.Root, cfg.AutoCode.Server, "go.mod")
+		if module, err := detectGoModule(goModPath); err == nil {
+			cfg.AutoCode.Module = module
+		}
+	}
+}
+
+func detectProjectRoot(startDir string) (string, error) {
+	dir := startDir
+	for {
+		serverDir := filepath.Join(dir, "server")
+		webDir := filepath.Join(dir, "web")
+		if isDir(serverDir) && isDir(webDir) {
+			return dir, nil
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break
+		}
+		dir = parent
+	}
+
+	return "", errors.New("未能自动识别项目根目录，请在 MCP 配置中设置 autocode.root")
+}
+
+func detectGoModule(goModPath string) (string, error) {
+	file, err := os.Open(goModPath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if strings.HasPrefix(line, "module ") {
+			return strings.TrimSpace(strings.TrimPrefix(line, "module ")), nil
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return "", err
+	}
+
+	return "", errors.New("go.mod 中未找到 module 定义")
+}
+
+func isDir(path string) bool {
+	info, err := os.Stat(path)
+	return err == nil && info.IsDir()
+}