package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"log/slog"
	"net"
	"net/http"
	"os"
	"os/signal"
	"sync/atomic"
	"syscall"
	"time"

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

	"github.com/VictoriaMetrics/metrics"

	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/config"
	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/hooks"
	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/logging"
	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/prompts"
	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/resources"
	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/tools"
)

// 全局变量：版本号、构建日期，编译时可通过 ldflags 注入
var (
	version = "dev"   // 默认开发版
	date    = "unknown" // 构建时间
)

// 常量定义：优雅关机、健康检查相关超时时间（统一管理，便于维护）
const (
	_shutdownPeriod      = 15 * time.Second // 优雅关机最大等待时间
	_shutdownHardPeriod  = 3 * time.Second  // 强制关机等待时间
	_readinessDrainDelay = 3 * time.Second // 就绪状态关闭后延迟时间
)

// main 函数：程序唯一入口，【新手重点：所有 Go 程序启动都从这里开始】
func main() {
	// 1. 初始化配置：读取命令行/环境变量/配置文件
	c, err := config.InitConfig()
	if err != nil {
		log.Fatalf("FATAL: Error initializing config: %v\n", err) // 配置初始化失败，直接退出
		return
	}

	// 2. 初始化日志器：根据配置创建结构化日志
	logger, err := logging.New(c)
	if err != nil {
		log.Fatalf("FATAL: Failed to initialize logger: %v\n", err) // 日志初始化失败，直接退出
		return
	}

	// 非标准输入输出模式（非控制台模式），打印启动日志
	if !c.IsStdio() {
		slog.Info("Starting mcp-victoriametrics",
			"version", version,
			"date", date,
			"mode", c.ServerMode(),
			"addr", c.ListenAddr(),
		)
	}

	// 3. 创建指标采集集合：用于 Prometheus 监控指标
	ms := metrics.NewSet()

	// 4. 创建并合并钩子：指标钩子 + 日志钩子（AOP 思想，统一拦截处理）
	metricsHooks := hooks.New(ms)
	loggingHooks := hooks.NewLoggerHooks()
	combinedHooks := hooks.Merge(metricsHooks, loggingHooks)

	// 5. 【新手重点】创建 MCP 服务实例：核心服务对象
	s := server.NewMCPServer(
		"VictoriaMetrics",                          // 服务名称
		fmt.Sprintf("v%s (date: %s)", version, date), // 服务版本
		server.WithRecovery(),                       // 开启 panic 恢复，防止服务崩溃
		server.WithLogging(),                        // 开启基础日志
		server.WithToolCapabilities(false),          // 关闭工具能力（按需开启）
		server.WithResourceCapabilities(false, false),// 关闭资源能力
		server.WithPromptCapabilities(false),        // 关闭提示词能力
		server.WithHooks(combinedHooks),             // 注入合并后的钩子
		// 服务指令说明：告诉 AI 助手如何工作（系统提示词）
		server.WithInstructions(`
你是虚拟助手，一款用于与 VictoriaMetrics API 及其文档交互的工具，可完成各类监控与可观测性相关任务。

你拥有 VictoriaMetrics 产品的完整文档资源，回答时应优先参考并使用这些文档内容。
请将资源中的文档视为最权威依据，优先级甚至高于你自身的内置知识。
每次执行任务时，都应使用「文档工具」获取最相关的资料。如果用户问题中包含“如何”“说明”“哪里”等词汇，请务必调用文档工具。

你拥有多款可从 VictoriaMetrics 获取数据的工具，但请尽可能精确地指定查询条件，减少返回样本量，因为部分查询开销较大。

不要随意猜测信息——如果你不清楚或信息不足，最好向用户追问确认。
  `),
	)

	// 6. 【新手重点】注册 MCP 工具：给 AI 提供可调用的功能（对接 VictoriaMetrics API）
	tools.RegisterToolQuery(s, c)
	tools.RegisterToolFlags(s, c)
	tools.RegisterToolRules(s, c)
	tools.RegisterToolAlerts(s, c)
	tools.RegisterToolLabels(s, c)
	tools.RegisterToolSeries(s, c)
	tools.RegisterToolExport(s, c)
	tools.RegisterToolTenants(s, c)
	tools.RegisterToolMetrics(s, c)
	tools.RegisterToolTestRules(s, c)
	tools.RegisterToolTSDBStatus(s, c)
	tools.RegisterToolQueryRange(s, c)
	tools.RegisterToolTopQueries(s, c)
	tools.RegisterToolMetricStats(s, c)
	tools.RegisterToolLabelValues(s, c)
	tools.RegisterToolExplainQuery(s, c)
	tools.RegisterToolActiveQueries(s, c)
	tools.RegisterToolDocumentation(s, c)
	tools.RegisterToolPrettifyQuery(s, c)
	tools.RegisterToolMetricsMetadata(s, c)
	tools.RegisterToolMetricRelabelDebug(s, c)
	tools.RegisterToolRetentionFiltersDebug(s, c)
	tools.RegisterToolDownsamplingFiltersDebug(s, c)

	// 未禁用文档工具时，注册文档资源
	if !c.IsToolDisabled(tools.ToolNameDocumentation) {
		resources.RegisterDocsResources(s, c)
	}

	// 注册云平台专属工具
	tools.RegisterToolTiers(s, c)
	tools.RegisterToolRegions(s, c)
	tools.RegisterToolRuleFile(s, c)
	tools.RegisterToolDeployments(s, c)
	tools.RegisterToolAccessTokens(s, c)
	tools.RegisterToolRuleFilenames(s, c)
	tools.RegisterToolCloudProviders(s, c)

	// 注册 AI 提示词模板
	prompts.RegisterPromptUnusedMetrics(s, c)
	prompts.RegisterPromptDocumentation(s, c)
	prompts.RegisterPromptRarelyUsedCardinalMetrics(s, c)

	// 判断是否为 stdio 模式（控制台直接交互）
	if c.IsStdio() {
		// 启动标准输入输出 MCP 服务
		if err := server.ServeStdio(s, server.WithErrorLogger(logger.Logger)); err != nil {
			slog.Error("failed to start server in stdio mode", "addr", c.ListenAddr(), "error", err)
			os.Exit(1)
		}
		return // stdio 模式执行完毕，直接退出
	}

	// 【新手重点】原子布尔值：标记服务是否就绪（线程安全，用于健康检查）
	var isReady atomic.Bool

	// 【新手重点】创建系统信号监听上下文：监听 Ctrl+C、kill 等退出信号
	rootCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop() // 函数退出时，取消信号监听

	// 创建 HTTP 路由多路复用器：管理不同 URL 路径的处理逻辑
	mux := http.NewServeMux()

	// 注册 /metrics 路由：暴露 Prometheus 监控指标
	mux.HandleFunc("/metrics", func(w http.ResponseWriter, _ *http.Request) {
		ms.WritePrometheus(w)           // 写入自定义指标
		metrics.WriteProcessMetrics(w)  // 写入进程基础指标（CPU、内存等）
	})

	// 注册 /health/liveness 路由：存活检查（服务是否运行）
	mux.HandleFunc("/health/liveness", func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		w.Header().Set("X-Content-Type-Options", "nosniff")
		_, _ = w.Write([]byte("OK\n"))
	})

	// 注册 /health/readiness 路由：就绪检查（服务是否能处理请求）
	mux.HandleFunc("/health/readiness", func(w http.ResponseWriter, _ *http.Request) {
		if !isReady.Load() { // 未就绪返回 503
			http.Error(w, "Not ready", http.StatusServiceUnavailable)
		}
		w.WriteHeader(http.StatusOK)
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		w.Header().Set("X-Content-Type-Options", "nosniff")
		_, _ = w.Write([]byte("Ready\n"))
	})

	// 根据配置选择服务模式：SSE / HTTP
	switch c.ServerMode() {
	case "sse":
		// SSE 模式：服务端推送事件
		slog.Info("Starting server in SSE mode", "addr", c.ListenAddr())
		srv := server.NewSSEServer(s)
		mux.Handle(srv.CompleteSsePath(), srv.SSEHandler())       // SSE 连接路由
		mux.Handle(srv.CompleteMessagePath(), srv.MessageHandler()) // 消息收发路由
	case "http":
		// HTTP 标准模式
		slog.Info("Starting server in HTTP mode", "addr", c.ListenAddr())
		heartBeatOption := server.WithHeartbeatInterval(c.HeartbeatInterval())
		loggerOption := server.WithLogger(logger)
		srv := server.NewStreamableHTTPServer(s, heartBeatOption, loggerOption)
		mux.Handle("/mcp", srv)       // MCP 核心接口
		mux.Handle("/", spaHandler()) // 单页应用首页
	default:
		// 未知模式，退出程序
		slog.Error("Unknown server mode", "mode", c.ServerMode())
		os.Exit(1)
	}

	// 创建上下文：用于控制正在处理的请求
	ongoingCtx, stopOngoingGracefully := context.WithCancel(context.Background())

	// 【新手重点】初始化 HTTP 服务器
	hs := &http.Server{
		Addr:    c.ListenAddr(),      // 监听地址（IP:端口）
		Handler: logger.Middleware(mux), // 注入日志中间件
		BaseContext: func(_ net.Listener) context.Context {
			return ongoingCtx // 所有请求共用基础上下文
		},
	}

	// 【新手重点】创建 TCP 监听器：绑定端口
	listener, err := net.Listen("tcp", c.ListenAddr())
	if err != nil {
		slog.Error("Failed to listen", "addr", c.ListenAddr(), "error", err)
		os.Exit(1)
	}
	slog.Info("Server is listening", "addr", c.ListenAddr())

	// 【新手重点】启动 HTTP 服务（协程异步运行，不阻塞主流程）
	go func() {
		if err := hs.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
			slog.Error("Failed to start server", "error", err)
			os.Exit(1)
		}
	}()

	// 服务启动完成，标记为就绪状态
	isReady.Store(true)

	// 【新手重点】阻塞等待退出信号（Ctrl+C / kill）
	<-rootCtx.Done()

	// 收到退出信号，开始关闭流程
	stop()
	isReady.Store(false) // 标记服务未就绪，不再接收新请求
	slog.Info("Received shutdown signal, shutting down.")

	// 延迟：让健康检查状态同步到负载均衡/探针
	time.Sleep(_readinessDrainDelay)
	slog.Info("Readiness check propagated, now waiting for ongoing requests to finish.")

	// 【新手重点】优雅关机：等待现有请求处理完成
	shutdownCtx, cancel := context.WithTimeout(context.Background(), _shutdownPeriod)
	defer cancel()
	err = hs.Shutdown(shutdownCtx)
	stopOngoingGracefully() // 取消请求上下文

	// 优雅关机超时，强制关闭
	if err != nil {
		slog.Warn("Failed to wait for ongoing requests to finish, waiting for forced cancellation.")
		time.Sleep(_shutdownHardPeriod)
	}

	// 服务完全停止
	slog.Info("Server stopped.")
}

• • • MCP 协议专属优化：源码中为 MCP 服务配置了心跳、日志钩子、崩溃恢复

server.WithRecovery()    // 崩溃恢复，避免单个请求panic导致整个服务崩溃
server.WithLogging()     // 协议级日志
server.WithHooks(combinedHooks) // 监控+日志钩子，可观测性增强

package tools

import (
	"context"

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

	"github.com/VictoriaMetrics/mcp-victoriametrics/cmd/mcp-victoriametrics/config"
)

// 定义工具名称常量：metrics，全局唯一标识该MCP工具
const toolNameMetrics = "metrics"

// toolMetrics 函数：构建MCP协议标准的Tool（工具定义）
// 作用：向LLM/AI Agent声明这个工具的名称、入参、描述、权限等元数据
// 入参：全局配置Config
// 返回值：mcp.Tool 标准工具结构体
func toolMetrics(c *config.Config) mcp.Tool {
	// 初始化工具配置选项切片，用于存储工具的所有描述、参数、注解
	options := []mcp.ToolOption{
		// 工具描述：告诉AI这个工具是做什么的
		// 功能：获取VictoriaMetrics实例的可用指标列表，底层调用VM原生API /api/v1/label/__name__/values
		mcp.WithDescription("List of available metrics of the VictoriaMetrics instance. This tool uses `/api/v1/label/__name__/values` endpoint of VictoriaMetrics API."),
		// 工具注解：MCP协议扩展字段，用于AI理解工具特性
		mcp.WithToolAnnotation(mcp.ToolAnnotation{
			Title:           "List of metric names", // 工具友好名称：指标名称列表
			ReadOnlyHint:    ptr(true),              // 只读提示：告诉AI这是只读操作，无数据修改
			DestructiveHint: ptr(false),             // 非破坏性提示：无删除/修改风险
			OpenWorldHint:   ptr(true),              // 开放世界提示：支持通用查询场景
		}),
	}

	// ===================== 条件参数：Cloud环境专属 =====================
	// 如果当前配置是VictoriaMetrics Cloud环境，则追加 deployment_id 必填参数
	if c.IsCloud() {
		options = append(
			options,
			// 定义字符串类型参数：deployment_id
			mcp.WithString("deployment_id",
				mcp.Required(),                              // 必填参数
				mcp.Title("Deployment ID"),                  // 参数标题
				mcp.Description("Unique identifier of the deployment in VictoriaMetrics Cloud"), // 参数描述
				mcp.Pattern(`^[a-zA-Z0-9\-_]+$`),            // 参数正则校验：字母数字下划线横杠
			),
		)
	}

	// ===================== 条件参数：Cluster/Cloud 环境专属 =====================
	// 如果是集群版 或 Cloud版，追加 tenant（租户）参数
	if c.IsCluster() || c.IsCloud() {
		options = append(
			options,
			// 定义字符串类型参数：tenant
			mcp.WithString("tenant",
				mcp.Title("Tenant name"),                     // 参数标题
				mcp.Description("Name of the tenant for which the list of metrics will be displayed"), // 参数描述
				mcp.DefaultString("0"),                       // 默认值：0（默认租户）
				mcp.Pattern(`^([0-9]+)(:[0-9]+)?$`),          // 正则校验：数字/数字:数字格式（VM租户规范）
			),
		)
	}

	// ===================== 通用查询参数 =====================
	// 追加 match 参数：指标匹配表达式（PromQL时间序列选择器）
	options = append(
		options,
		mcp.WithString("match",
			mcp.Title("Match series for metric names"),      // 参数标题
			mcp.Description("Time series selector argument that selects the series from which to read the metrics"), // 描述
			mcp.DefaultString(""),                           // 默认空：匹配所有指标
		),
		// start 参数：指标时间范围起始时间
		mcp.WithString("start",
			mcp.Title("Start timestamp"),                    // 参数标题
			mcp.Description("Start timestamp for selection metric names"), // 描述
			mcp.DefaultString(""),                           // 默认空
			mcp.Pattern(`^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[\+-]\d{2}:\d{2})?)|([0-9]+)$`), // 时间格式校验：RFC3339 / 时间戳
		),
		// end 参数：指标时间范围结束时间
		mcp.WithString("end",
			mcp.Title("End timestamp"),                      // 参数标题
			mcp.Description("End timestamp for selection metric names"), // 描述
			mcp.DefaultString(""),                           // 默认空
			mcp.Pattern(`^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[\+-]\d{2}:\d{2})?)|([0-9]+)$`), // 时间格式校验
		),
		// limit 参数：返回指标数量上限
		mcp.WithNumber("limit",
			mcp.Title("Maximum number of metric names"),     // 参数标题
			mcp.Description("Maximum number of metric names to return"), // 描述
			mcp.DefaultNumber(0),                            // 默认0：不限制
			mcp.Min(0),                                       // 最小值校验：不能为负数
		),
	)

	// 构造并返回 MCP 标准 Tool 对象
	return mcp.NewTool(toolNameMetrics, options...)
}

// toolMetricsHandler 函数：metrics工具的**核心业务处理函数**
// 作用：接收AI的MCP请求 → 解析参数 → 调用底层方法 → 返回指标数据
// 入参：上下文、配置、MCP工具调用请求
// 返回值：MCP标准响应结果 / 错误
func toolMetricsHandler(ctx context.Context, cfg *config.Config, tcr mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	// ===================== 解析请求参数 =====================
	// 解析 match 参数：字符串类型，非必填
	match, err := GetToolReqParam[string](tcr, "match", false)
	if err != nil {
		// 参数解析失败，返回MCP标准错误响应
		return mcp.NewToolResultError(err.Error()), nil
	}

	// 解析 start 参数：字符串类型，非必填
	start, err := GetToolReqParam[string](tcr, "start", false)
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	// 解析 end 参数：字符串类型，非必填
	end, err := GetToolReqParam[string](tcr, "end", false)
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	// 解析 limit 参数：float64类型（MCP协议数字统一用float64），非必填
	limit, err := GetToolReqParam[float64](tcr, "limit", false)
	if err != nil {
		return mcp.NewToolResultError(err.Error()), nil
	}

	// ===================== 调用底层通用方法 =====================
	// 指标名称本质是 __name__ 标签的值
	// 直接复用 getLabelValues 通用方法，获取指标名称列表
	// 入参：上下文、配置、请求、固定标签名__name__、解析后的参数
	return getLabelValues(ctx, cfg, tcr, "__name__", match, start, end, limit)
}

// RegisterToolMetrics 函数：将metrics工具注册到MCP服务器
// 作用：MCP服务启动时，把工具+处理器绑定到MCPServer
// 入参：MCP服务器实例、全局配置
func RegisterToolMetrics(s *server.MCPServer, c *config.Config) {
	// ===================== 工具禁用校验 =====================
	// 如果配置中禁用了该工具，则直接返回，不注册
	if c.IsToolDisabled(toolNameMetrics) {
		return
	}

	// ===================== 注册工具 + 绑定处理器 =====================
	// 把 toolMetrics 定义的工具元数据 + toolMetricsHandler 处理器注册到MCP服务
	s.AddTool(toolMetrics(c), func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		// 包装调用：传入全局配置，执行真正的处理函数
		return toolMetricsHandler(ctx, c, request)
	})
}

四、MCP-VictoriaMetrics 完整并发调用链路

客户端请求（MCP Client: Claude/Cursor/etc.）
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  1. HTTP 接入层 (main.go)                                           │
│                                                                     │
│  net.Listener (TCP, c.ListenAddr())                                │
│       │                                                             │
│       ▼                                                             │
│  http.Server.Serve(listener)                                       │
│  ── 每个连接由 Go runtime 自动分配 goroutine ──                      │
│       │                                                             │
│       ▼                                                             │
│  http.ServeMux 路由分发                                              │
│  ├── /metrics          → ms.WritePrometheus (指标导出，非 MCP 链路)   │
│  ├── /health/liveness  → 200 OK                                    │
│  ├── /health/readiness → atomic.Bool isReady 检查                   │
│  ├── /mcp (http模式)   → StreamableHTTPServer                      │
│  ├── /sse + /message   → SSEServer (sse模式)                       │
│  └── / (fallback)      → spaHandler() 前端静态资源                   │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  2. 日志中间件层 (logging/middleware.go)                              │
│                                                                     │
│  Logger.Middleware(mux)                                             │
│  ├── 跳过 /health、/metrics 噪声端点                                 │
│  ├── 包装 responseWriter 捕获 statusCode + size                     │
│  ├── 提取 session_id (server.ClientSessionFromContext)              │
│  ├── slog.Info("HTTP request started", method, path, remote_addr)  │
│  ├── next.ServeHTTP(wrapped, r)  ── 进入 MCP 协议层 ──              │
│  └── slog.Info("HTTP request completed", status, size, duration_ms)│
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  3. MCP 协议传输层 (mcp-go SDK)                                      │
│                                                                     │
│  三种模式（由 MCP_SERVER_MODE 决定）:                                 │
│                                                                     │
│  ┌─ stdio 模式 ─────────────────────────────────────────────┐       │
│  │  server.ServeStdio(s) — 单连接，stdin/stdout 读写        │       │
│  │  无 HTTP 层，直接进入 MCP Server 处理                     │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ SSE 模式 ───────────────────────────────────────────────┐       │
│  │  SSEServer.SSEHandler()    → 长连接 SSE 流（server→client）│      │
│  │  SSEServer.MessageHandler()→ POST 接收 client→server 消息 │      │
│  │  每个 SSE 连接维持独立 session goroutine                   │      │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ HTTP (Streamable) 模式 ─────────────────────────────────┐       │
│  │  StreamableHTTPServer                                     │      │
│  │  ├── WithHeartbeatInterval(cfg.HeartbeatInterval())       │      │
│  │  │   默认 30s 心跳保活                                    │      │
│  │  ├── WithLogger(logger)                                   │      │
│  │  └── 每个请求解析 JSON-RPC → 分发到 MCPServer             │      │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  JSON-RPC 消息解码 → MCPServer 方法路由                              │
│  ├── tools/list      → ListTools                                   │
│  ├── tools/call      → CallTool ── 核心链路 ──                      │
│  ├── resources/list  → ListResources                               │
│  ├── resources/read  → ReadResource                                │
│  ├── prompts/list    → ListPrompts                                 │
│  └── prompts/get     → GetPrompt                                   │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  4. MCP 钩子链 (hooks/hooks.go) — BeforeAny → 业务处理 → After/Error│
│                                                                     │
│  ┌─ BeforeAny 阶段 ────────────────────────────────────────┐       │
│  │  loggingHooks.BeforeAny:                                 │       │
│  │    slog.Info("MCP request received",                     │       │
│  │      request_id, session_id, method, message_json)       │       │
│  └──────────────────────────────────────────────────────────┘       │
│       │                                                             │
│       ▼  执行实际 Tool/Resource/Prompt Handler                       │
│       │                                                             │
│  ┌─ OnSuccess 阶段 ────────────────────────────────────────┐       │
│  │  loggingHooks.OnSuccess:                                 │       │
│  │    slog.Info("MCP request succeeded", result_json)       │       │
│  │  metricsHooks.AfterCallTool:                             │       │
│  │    counter++ mcp_victoriametrics_call_tool_total          │       │
│  │    {name="<tool>", is_error="false"}                     │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ OnError 阶段 ──────────────────────────────────────────┐       │
│  │  loggingHooks.OnError:                                   │       │
│  │    slog.Error("MCP request failed", error)               │       │
│  │  metricsHooks.OnError:                                   │       │
│  │    counter++ mcp_victoriametrics_error_total              │       │
│  │    {method="<method>", error="<msg>"}                    │       │
│  └──────────────────────────────────────────────────────────┘       │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  5. 工具分发层 (tools/*.go — RegisterTool* 注册的 handler)            │
│                                                                     │
│  MCPServer.CallTool 根据 tool name 路由到对应 handler                │
│                                                                     │
│  ┌─ 禁用检查 ──────────────────────────────────────────────┐       │
│  │  RegisterTool* 注册时:                                   │       │
│  │  if c.IsToolDisabled(toolName) { return } // 不注册      │       │
│  │  Cloud 专属工具: if !c.IsCloud() { return }              │       │
│  │  Cluster 专属工具: if !c.IsCluster() && !c.IsCloud()...  │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  handler 入口 (以 toolQueryHandler 为例):                            │
│  func(ctx, cfg, tcr) (*CallToolResult, error)                      │
│       │                                                             │
│       ▼                                                             │
│  5a. 参数提取: GetToolReqParam[T](tcr, "query", required)          │
│      泛型支持 string / float64 / bool / []string / []any            │
│      参数校验失败 → 直接返回 mcp.NewToolResultError                   │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  6. VM API 请求构建层 (tools/utils.go)                               │
│                                                                     │
│  ┌─ URL 路由构建 ──────────────────────────────────────────┐       │
│  │                                                          │       │
│  │  CreateSelectRequest(ctx, cfg, tcr, path...)             │       │
│  │       │                                                  │       │
│  │       ├─ 本地 Single 模式:                               │       │
│  │       │  entrypointURL.JoinPath("api","v1","query")      │       │
│  │       │  → http://vm:8428/api/v1/query                   │       │
│  │       │                                                  │       │
│  │       ├─ 本地 Cluster 模式:                              │       │
│  │       │  getSelectURL → 插入 tenant 路由                 │       │
│  │       │  entrypointURL/select/{tenant}/prometheus/api/... │       │
│  │       │  → http://vmselect:8481/select/0/prometheus/...   │       │
│  │       │                                                  │       │
│  │       └─ Cloud 模式:                                     │       │
│  │          getCloudDeploymentInfo(ctx, cfg, deploymentID)  │       │
│  │          ├─ 读缓存 cloudDeploymentInfoCache (sync.RWMutex)│      │
│  │          ├─ 缓存未命中 → cfg.VMC().GetDeploymentDetails()│       │
│  │          │  (HTTP 调用 VM Cloud API)                     │       │
│  │          ├─ 写缓存                                       │       │
│  │          └─ 解析 accessEndpoint + deploymentType         │       │
│  │             → https://<cloud-endpoint>/select/0/prom/... │       │
│  └──────────────────────────────────────────────────────────┘       │
│       │                                                             │
│       ▼                                                             │
│  ┌─ 认证注入 ──────────────────────────────────────────────┐       │
│  │                                                          │       │
│  │  getBearerToken(ctx, cfg, tcr)                           │       │
│  │  ├─ 本地模式: 直接返回 cfg.BearerToken() (环境变量)       │       │
│  │  └─ Cloud 模式:                                          │       │
│  │     ├─ 读缓存 cloudAccessTokenCache (sync.RWMutex)       │       │
│  │     ├─ 缓存未命中:                                       │       │
│  │     │  cfg.VMC().ListDeploymentAccessTokens(ctx, id)     │       │
│  │     │  → 遍历找到 read 权限 + 无 tenant 限制的 token      │       │
│  │     │  cfg.VMC().RevealDeploymentAccessToken(ctx, id, t) │       │
│  │     │  → 获取 token secret                               │       │
│  │     └─ 写缓存，返回 token                                │       │
│  │                                                          │       │
│  │  req.Header.Set("Authorization", "Bearer "+token)        │       │
│  └──────────────────────────────────────────────────────────┘       │
│       │                                                             │
│       ▼                                                             │
│  ┌─ Header 注入 ───────────────────────────────────────────┐       │
│  │  cfg.CustomHeaders() → req.Header.Set(k, v)             │       │
│  │  cfg.PassthroughHeaders() → 从 MCP 请求透传到 VM 请求    │       │
│  │    tcr.Header.Get(name) → req.Header.Set(name, value)   │       │
│  └──────────────────────────────────────────────────────────┘       │
│       │                                                             │
│       ▼                                                             │
│  ┌─ Query 参数拼装 ────────────────────────────────────────┐       │
│  │  (回到各 tool handler 中)                                │       │
│  │  q := req.URL.Query()                                    │       │
│  │  q.Add("query", query)                                   │       │
│  │  q.Add("time", time) / q.Add("step", step) / ...        │       │
│  │  req.URL.RawQuery = q.Encode()                           │       │
│  └──────────────────────────────────────────────────────────┘       │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  7. HTTP 出站调用层 (tools/utils.go — GetTextBodyForRequest)         │
│                                                                     │
│  http.DefaultClient.Do(req)                                        │
│  ├── Go net/http 连接池（DefaultTransport）                          │
│  │   ├── MaxIdleConns: 100                                         │
│  │   ├── MaxIdleConnsPerHost: 2 (默认)                              │
│  │   ├── IdleConnTimeout: 90s                                      │
│  │   └── 连接复用: keep-alive                                       │
│  │                                                                  │
│  ├── DNS 解析 → TCP 连接 (或复用) → TLS 握手 (如 HTTPS)              │
│  ├── 发送 HTTP GET 请求到 VictoriaMetrics 实例                       │
│  └── 等待响应...                                                     │
│       │                                                             │
│       ▼                                                             │
│  响应处理:                                                           │
│  ├── resp.StatusCode != 200                                        │
│  │   → NewToolResultError("unexpected status code: <body>")        │
│  ├── io.ReadAll(resp.Body) — 全量读取响应体到内存                     │
│  ├── defer resp.Body.Close()                                       │
│  │                                                                  │
│  ├── 可选后处理函数链 f ...func(s string)(string, error):            │
│  │   例如 alerts.go 的 processResult:                               │
│  │   ├── json.Unmarshal 解析响应                                    │
│  │   ├── 按 state/group 过滤                                        │
│  │   ├── slices.SortFunc 排序                                       │
│  │   ├── offset+limit 分页截取                                      │
│  │   └── json.Marshal 重新序列化                                    │
│  │                                                                  │
│  │   例如 metrics_metadata.go 的客户端侧过滤:                        │
│  │   ├── json.Unmarshal 解析 API 响应                               │
│  │   ├── 按 search/type/unit 字段过滤                                │
│  │   ├── 应用 limit 截断                                            │
│  │   └── json.Marshal 返回过滤后结果                                 │
│  │                                                                  │
│  └── mcp.NewToolResultText(result) — 封装为 MCP 响应                 │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  8. 特殊链路分支                                                     │
│                                                                     │
│  ┌─ 文档搜索链路 (docs.go tool → resources/docs.go) ───────┐       │
│  │  toolDocumentationHandler                                │       │
│  │  ├── resources.SearchDocResources(query, limit)          │       │
│  │  │   └── bleve.Index.Search (内存全文索引，无网络 IO)     │       │
│  │  │       matchQuery + fuzziness=1                        │       │
│  │  └── 遍历结果 → resources.GetDocResourceContent(uri)     │       │
│  │      └── 从 contents map 读取（内存，O(1)）              │       │
│  │  返回 []EmbeddedResource                                 │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ 查询解释链路 (explain_query.go) ───────────────────────┐       │
│  │  toolExplainQueryHandler                                 │       │
│  │  ├── getSyntaxTree(query) — metricsql AST 解析（纯 CPU） │       │
│  │  ├── getFunctionsInfo() — 内置函数描述（内存查表）         │       │
│  │  ├── getMetricsInfo() — 先查内置 metrics_metadata_db/    │       │
│  │  │   └── 未命中 → fetchMetricsMetadataFromAPI()          │       │
│  │  │       └── CreateSelectRequest → http.DefaultClient.Do │       │
│  │  │           (回到链路第 6-7 步)                          │       │
│  │  └── getTypesDescriptions() — 内置类型描述（内存查表）     │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ 查询格式化链路 (prettify_query.go) ────────────────────┐       │
│  │  toolPrettifyQueryHandler                                │       │
│  │  ├── metricsql.Prettify(query) — 本地格式化（纯 CPU）     │       │
│  │  │   成功 → 直接返回，不走网络                            │       │
│  │  └── 失败 → CreateSelectRequest("prettify-query")        │       │
│  │      → http.DefaultClient.Do (回退到 VM API)             │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ 规则测试链路 (test_rules.go) ──────────────────────────┐       │
│  │  toolTestRulesHandler                                    │       │
│  │  ├── os.MkdirTemp → 写规则文件到临时目录（磁盘 IO）       │       │
│  │  ├── yaml.Marshal 测试配置 → os.WriteFile                │       │
│  │  ├── os.Pipe() 捕获 stdout                               │       │
│  │  ├── unittest.UnitTest(paths) — 内嵌 vmalert-tool 引擎   │       │
│  │  │   (纯 CPU + 内存计算，无网络)                          │       │
│  │  ├── io.ReadAll(pipe) 读取输出                            │       │
│  │  └── os.RemoveAll(tmpDir) 清理                            │       │
│  └──────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ┌─ Cloud API 链路 (deployments/access_tokens/regions/...) ┐       │
│  │  toolDeploymentsHandler 等                                │       │
│  │  ├── withCloudAccessKey(ctx, tcr) — 共享实例注入 API Key  │       │
│  │  ├── cfg.VMC().ListDeployments(ctx)                      │       │
│  │  │   └── victoriametrics-cloud-api-go HTTP Client         │       │
│  │  │       → VM Cloud REST API                              │       │
│  │  ├── json.Marshal(result)                                │       │
│  │  └── mcp.NewToolResultText(json)                         │       │
│  └──────────────────────────────────────────────────────────┘       │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│  9. 响应回传链路                                                     │
│                                                                     │
│  *mcp.CallToolResult                                               │
│       │                                                             │
│       ▼                                                             │
│  hooks.AfterCallTool 执行                                           │
│  ├── metricsHooks: counter++ (tool_name, is_error)                 │
│  └── loggingHooks: slog.Info("Tool called", tool_name, is_error)   │
│       │                                                             │
│       ▼                                                             │
│  hooks.OnSuccess 执行                                               │
│  └── slog.Info("MCP request succeeded", result_json)               │
│       │                                                             │
│       ▼                                                             │
│  MCP SDK 序列化 JSON-RPC Response                                   │
│       │                                                             │
│       ▼                                                             │
│  传输层回写:                                                         │
│  ├── stdio: 写入 stdout                                            │
│  ├── SSE: 通过 SSE 事件流推送                                       │
│  └── HTTP: 写入 HTTP Response Body (可能带 streaming)               │
│       │                                                             │
│       ▼                                                             │
│  logging.Middleware 记录:                                            │
│  slog.Info("HTTP request completed", status, size, duration_ms)    │
└─────────────────────────────────────────────────────────────────────┘

• • • 每个 MCP 请求由 http.Server 自动分配独立 goroutine 处理，请求之间天然并行，无全局锁阻塞主链路
    • Cloud 模式下有两个共享缓存使用 sync.RWMutex 保护：cloudDeploymentInfoCache（部署信息）和 cloudAccessTokenCache（访问令牌），读多写少场景下 RWMutex 是合理的
    • 出站 HTTP 调用使用 http.DefaultClient，底层 DefaultTransport 的连接池是全局共享的（MaxIdleConnsPerHost 默认仅 2），高并发场景下这可能成为瓶颈
    • bleve 全文索引在启动时一次性构建到内存，运行时搜索是并发安全的，不涉及网络 IO
    • test_rules 工具涉及临时文件写入和 stdout 管道劫持（os.Pipe + 替换 os.Stdout），这在并发调用时存在竞态风险——多个 goroutine 同时替换全局 os.Stdout 会互相干扰
    • metrics.Set（VictoriaMetrics/metrics 库）的计数器操作本身是原子的，hooks 层的指标采集不会引入锁竞争

// GetTextBodyForRequest 发送HTTP请求并获取响应文本体，支持传入多个自定义处理函数对响应体进行处理
// 参数说明：
//   req: 待发送的HTTP请求对象
//   _: 配置对象（当前未使用，保留参数位可能为了接口兼容）
//   f: 可变参数，接收多个处理函数，每个函数接收字符串并返回处理后的字符串和错误，用于链式处理响应体
// 返回值：封装了处理结果的mcp.CallToolResult对象（成功返回文本结果，失败返回错误信息）
func GetTextBodyForRequest(req *http.Request, _ *config.Config, f ...func(s string) (string, error)) *mcp.CallToolResult {
	// 使用默认HTTP客户端执行请求，获取响应和错误
	resp, err := http.DefaultClient.Do(req)
	// 如果请求执行失败，返回封装后的错误结果
	if err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("failed to do request: %v", err))
	}

	// 读取响应体的全部内容到字节数组
	body, err := io.ReadAll(resp.Body)
	// 如果读取响应体失败，返回封装后的错误结果
	if err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("failed to read response body: %v", err))
	}

	// 延迟关闭响应体（使用匿名函数忽略关闭错误），确保资源释放
	defer func() { _ = resp.Body.Close() }()

	// 检查响应状态码是否为200 OK，非200则返回错误结果
	if resp.StatusCode != http.StatusOK {
		return mcp.NewToolResultError(fmt.Sprintf("unexpected response status code %v: %s", resp.StatusCode, string(body)))
	}

	// 将字节数组格式的响应体转换为字符串
	result := string(body)

	// 遍历所有传入的处理函数，依次处理响应体字符串
	for _, fn := range f {
		// 执行当前处理函数，更新结果字符串
		if result, err = fn(result); err != nil {
			// 如果处理函数执行失败，返回封装后的错误结果
			return mcp.NewToolResultError(fmt.Sprintf("failed to process response body: %v", err))
		}
	}

	// 所有处理完成后，返回封装后的文本结果
	return mcp.NewToolResultText(result)
}

// ToolReqParamType 定义工具请求参数的类型约束
// 支持的类型：字符串、64位浮点数、布尔值、字符串切片、任意类型切片
type ToolReqParamType interface {
	string | float64 | bool | []string | []any
} 

originalStdout := os.Stdout
r, w, _ := os.Pipe()           // ← 没有 error 检查，直接 _ 忽略
os.Stdout = w
failed := unittest.UnitTest([]string{testFilePath}, false, nil, "", "", "")
_ = w.Close()                  // ← 不是 defer，是顺序执行
out, _ := io.ReadAll(r)
os.Stdout = originalStdout     // ← 恢复在最后，不是 defer　

5.5、日志 / 指标采集的额外开销

 5.5.1、指标采集（metricsHooks）：非纯原子操作，存在锁竞争与 key 膨胀风险

metricsHooks 的核心逻辑依赖 ms.GetOrCreateCounter(...).Inc() 实现指标计数，但该逻辑并非 纯原子操作，具体问题如下：

loggingHooks 的 OnSuccess 钩子函数中，对每个请求的返回结果 result 执行 toJSON(result) 全量序列化操作，是更核心的性能开销来源：

hooks.AddOnSuccess(func(ctx context.Context, id any, method mcp.MCPMethod, message any, result any) {
    // 关键开销点：对全量result做JSON序列化
    "result", toJSON(result),  
})

对于 documentation 这类返回大量文档内容的工具，result 体积可达几十 KB 甚至几百 KB。每次请求都触发一次完整的 JSON 序列化，会持续占用大量 CPU 资源，成为高并发场景下的核心性能瓶颈。 

// 新增自定义 HTTP Client 初始化函数
func newVMHTTPClient(cfg *config.Config) *http.Client {
    transport := &http.Transport{
        Proxy: http.ProxyFromEnvironment,
        DialContext: (&net.Dialer{
            Timeout:   10 * time.Second, // 缩短拨号超时
            KeepAlive: 60 * time.Second,  // 延长长连接存活时间
        }).DialContext,
        ForceAttemptHTTP2:     true,
        MaxIdleConns:          1000,     // 全局最大空闲连接提升至 1000
        MaxIdleConnsPerHost:   100,      // 单 Host 空闲连接提升至 100（核心）
        IdleConnTimeout:       300 * time.Second, // 延长空闲连接超时
        TLSHandshakeTimeout:   5 * time.Second,
        ExpectContinueTimeout: 1 * time.Second,
    }
    return &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second, // 自定义请求超时（根据业务调整）
    }
}

// 替换所有工具中的 http.DefaultClient 为自定义 Client
// 例如在 CreateSelectRequest 函数中：
func CreateSelectRequest(...) (*http.Request, error) {
    // ... 原有逻辑 ...
    client := newVMHTTPClient(cfg)
    resp, err := client.Do(req)
    // ...
}

// 新增 Client 池管理
var vmClientPool = sync.Map{} // key: vm entrypoint URL, value: *http.Client

func getVMHTTPClient(entrypoint string) *http.Client {
    if v, ok := vmClientPool.Load(entrypoint); ok {
        return v.(*http.Client)
    }
    // 初始化自定义 Client
    client := newVMHTTPClient(nil)
    vmClientPool.Store(entrypoint, client)
    return client
}　　

// 改造后的 test_rules 处理逻辑
func toolTestRulesHandler(ctx context.Context, cfg *config.Config, tcr mcp.CallToolRequest) (*mcp.CallToolResult, error) {
    // 1. 创建临时目录（原有逻辑）
    tmpDir, err := os.MkdirTemp("", "vm-mcp-test-rules-*")
    if err != nil {
        return mcp.NewToolResultError(err.Error()), nil
    }
    defer os.RemoveAll(tmpDir)

    // 2. 写入规则文件（原有逻辑）
    // ...

    // 3. 替换：使用 exec.Cmd 执行 vmalert-tool，捕获 stdout/stderr
    cmd := exec.CommandContext(ctx, "vmalert-tool", "unittest", tmpDir)
    output, err := cmd.CombinedOutput()
    if err != nil {
        return mcp.NewToolResultError(fmt.Sprintf("unittest failed: %v, output: %s", err, output)), nil
    }

    // 4. 返回结果
    return mcp.NewToolResultText(string(output)), nil
}

import (
    "context"
    "sync"

    "github.com/your-org/mcp-go/mcp"
    "github.com/your-org/mcp-victoriametrics/config"
    "github.com/your-org/mcp-victoriametrics/server"
)

// RegisterToolWithLimit 为指定工具注册带 Worker Pool 限流的处理器
// 参数说明：
//   s: MCP 服务器实例
//   c: 配置实例
//   tool: 待注册的工具结构体
//   workerChan: 限流用的 Worker 通道（外部创建，控制并发数）
//   handler: 工具实际处理逻辑
func RegisterToolWithLimit(
    s *server.MCPServer,
    c *config.Config,
    tool mcp.Tool,
    workerChan chan struct{},
    handler func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error),
) {
    // 修正：通过结构体字段访问工具名（需确认 mcp.Tool 实际字段名，如 Name/toolName 等）
    toolName := tool.Name // 核心修正：替换原错误的 tool.Name() 调用
    
    // 检查工具是否被禁用
    if c.IsToolDisabled(toolName) {
        s.RegisterTool(tool, func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
            return mcp.NewToolResultError("tool " + toolName + " is disabled"), nil
        })
        return
    }

    // 注册带限流的处理器
    s.RegisterTool(tool, func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        // Worker Pool 限流：获取空闲 worker 槽位
        select {
        case workerChan <- struct{}{}:
            // 执行完成后释放槽位
            defer func() { <-workerChan }()
        case <-ctx.Done():
            return mcp.NewToolResultError("request canceled: " + ctx.Err().Error()), nil
        }

        // 执行实际处理逻辑
        return handler(ctx, req)
    })
}

// 示例：外部创建 WorkerChan 并调用注册函数
func ExampleRegisterToolWithLimit(s *server.MCPServer, c *config.Config) {
    // 定义并发数（如 10）
    workerChan := make(chan struct{}, 10)
    
    // 构建工具实例（假设通过 mcp.NewTool 传入工具名）
    queryTool := mcp.NewTool("vm_query", "VictoriaMetrics query tool")
    
    // 注册带限流的工具
    RegisterToolWithLimit(s, c, queryTool, workerChan, func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        // 工具实际处理逻辑
        return mcp.NewToolResultText("query success"), nil
    })
}

// HTTP 模式超时配置
heartBeatOption := server.WithHeartbeatInterval(c.HeartbeatInterval())
timeoutOption := server.WithTimeout(60 * time.Second) // 空闲连接超时
loggerOption := server.WithLogger(logger)
srv := server.NewStreamableHTTPServer(s, heartBeatOption, timeoutOption, loggerOption)

// SSE 模式连接数限制
var sseConnLimit = make(chan struct{}, 200) // 限制最大 SSE 连接数
mux.Handle(srv.CompleteSsePath(), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    select {
    case sseConnLimit <- struct{}{}:
        defer func() { <-sseConnLimit }()
        srv.SSEHandler().ServeHTTP(w, r)
    default:
        http.Error(w, "too many SSE connections", http.StatusTooManyRequests)
    }
}))

// main.go 关机逻辑
// 原有 shutdownCtx 逻辑后添加
slog.Info("Closing all long-lived connections")
// 关闭 SSE/Streamable HTTP 连接（需扩展 MCP SDK 暴露关闭方法）
if srv != nil {
    srv.Close()
}

// 新增指标
var (
    goroutineCount = metrics.NewGauge(`mcp_victoriametrics_goroutine_count`)
    activeRequests = metrics.NewGauge(`mcp_victoriametrics_active_requests`)
    httpClientConn = metrics.NewGauge(`mcp_victoriametrics_http_client_connections{state="idle"}`)
)

// 定期采集 Goroutine 数
go func() {
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()
    for range ticker.C {
        goroutineCount.Set(float64(runtime.NumGoroutine()))
        // 采集 HTTP Client 空闲连接数（需自定义 Transport 暴露统计）
        if t, ok := client.Transport.(*http.Transport); ok {
            httpClientConn.Set(float64(t.IdleConnCount()))
        }
    }
}()

// 钩子中统计活跃请求
metricsHooks.BeforeAny = func(ctx context.Context, m mcp.Metadata, req json.RawMessage) {
    activeRequests.Inc()
    // 原有逻辑...
}
metricsHooks.AfterAny = func(ctx context.Context, m mcp.Metadata, resp json.RawMessage, err error) {
    activeRequests.Dec()
    // 原有逻辑...
}　　

7.1、配置层面

• • 优先调整 HTTP Client 连接池参数（MaxIdleConnsPerHost 建议设为 CPU 核心数 * 10）；
  • 为不同 VM 实例配置独立的 Client，避免连接池竞争；
  • 长连接超时设为 30-60s，心跳间隔设为 15s，平衡保活与资源占用。

7.2、代码层面

• • 所有涉及全局资源（stdout / 临时文件）的工具必须做隔离改造；
  • 核心工具调用层添加 Worker Pool 限流，避免 Goroutine 膨胀；
  • Cloud 模式必须启用缓存分片 + singleflight 防击穿。

7.3、运维层面 

• • 监控 Goroutine 数、活跃请求数、缓存命中率，设置告警阈值；
  • 压测验证：单节点压测 QPS 建议逐步提升（20→50→100），观察瓶颈点；
  • 多实例部署：通过负载均衡分散并发压力，单实例并发不超过 100 QPS。

7.4、应急处理

• • 突发高并发时，临时禁用高开销工具（如 test_rules/tsdb_status）；
  • 连接池耗尽时，可临时重启服务释放连接，或调整 MaxIdleConnsPerHost 热更新（需代码支持动态配置）。

通过上述调优方案，MCP-VictoriaMetrics 可稳定承载单节点 100+ QPS 的高并发 MCP 请求，满足企业级 AI Agent 平台对 VictoriaMetrics 可观测性能力的规模化调用需求，为 AI 驱动的可观测性体系落地提供稳定的中间件支撑。