给 Claude Code 装上 MCP Server：AI 直接连数据库查数据，排查 Bug 效率翻 3 倍

本文介绍如何给 Claude Code 配置 MCP Server，让它能直接连接 MySQL、Redis、RabbitMQ、Elasticsearch 等中间件查询数据。包含完整的技术架构、不同架构的适配方案、安全规范和 Skill 源码。

一、痛点：AI 排查 Bug 时的"信息盲区"

1.1 之前的排查流程

开发过程中遇到 Bug，交给 Claude Code 排查时的典型对话：

开发者：订单状态不对，帮我看看怎么回事
AI：看了 OrderServiceImpl 的 syncOrder 方法，逻辑上应该在支付后更新 status=2
开发者：那帮我查一下 t_order 表 order_no=20240301xxx 这条记录的 status 是多少
开发者：（人工登录数据库 → 执行查询 → 截图发回来）status=1，pay_time 是空的
AI：那可能是支付回调没走到更新逻辑，帮我查一下 order_log 表这条订单的操作日志
开发者：（再次人工登录数据库 → 执行查询 → 截图）没有日志记录
AI：再看下 RabbitMQ 的 ORDER_TO_ES_QUEUE 有没有堆积
开发者：（登录 RabbitMQ 管理界面 → 截图）队列里有 5000 条消息
...

每次数据查询都需要人工介入：登录数据库、执行 SQL、截图、复制结果。一轮 Bug 排查下来，开发者大部分时间在做"搬运工"，而不是分析问题。

1.2 核心问题

1. AI 看不到数据 — 只能读代码逻辑，看不到数据库实际状态
2. 沟通成本极高 — "你帮我查一下 X 表 Y 字段等于 Z 的值是多少"
3. 信息碎片化 — 数据库查一点、Redis 查一点、队列看一眼，难以全局判断
4. 上下文丢失 — 多轮对话后，前面的查询结果可能被遗忘
5. 验证困难 — AI 给出修复方案后，无法直接验证是否生效

1.3 解决思路

给 AI 装上"眼睛"，让它能直接看到数据。

通过 Model Context Protocol (MCP) 给 Claude Code 配置数据库和中间件连接，AI 就能：

• 直接执行 SQL 查询表结构和数据
• 直接读取 Redis key 的值和过期时间
• 直接查看 RabbitMQ 队列堆积情况
• 直接读取 Nacos 配置
• 直接搜索 Elasticsearch 索引

一句话：让 AI 从"猜数据"变成"查数据"。

二、方案设计：从 Nacos 自动发现所有中间件

2.1 为什么选择 Nacos 作为入口

我们的项目使用 Spring Cloud Alibaba，所有中间件的连接配置都集中在 Nacos 配置中心：

• MySQL 的 JDBC URL 和账号密码
• Redis 的 host、port、password、db
• RabbitMQ 的 host、port、username、password、vhost
• Elasticsearch 的 host、port、账号密码

如果让 AI 手动一个一个配，每个项目都要提供一堆连接信息，既麻烦又容易出错。

方案：AI 只需要 Nacos 的连接信息，自动读取 Nacos 里的所有中间件配置。

2.2 核心设计：动态发现，不依赖固定映射

每个项目的配置 key 名称可能不同：

• 有的用 spring.datasource.url，有的用 spring.datasource.jdbc-url
• 有的用 spring.redis.host，有的用 spring.data.redis.host
• 有的配置在 application.yml，有的在 bootstrap.yml，有的在 Nacos 的 common.yml

如果写死一个 key 映射表，换个项目就失效了。

正确做法是让 AI 先做三件事：

1. 扫描代码 — 读 pom.xml 看依赖了什么中间件，读配置类看用了哪些组件
2. 读取 Nacos 配置 — 拿到完整的配置文件内容
3. 动态匹配 — 在配置内容中搜索连接相关的关键词，提取 host、port、密码

这样不管项目的配置 key 叫什么名字、结构怎么嵌套，AI 都能自动适配。

2.3 技术选型：用什么 MCP Server

不使用 npm install，全程用 npx -y，避免在项目目录创建 node_modules 污染代码。

2.4 配置方式：.mcp.json

Claude Code v2.1+ 使用 .mcp.json 管理 MCP 配置（不再从 settings.json 读取）。每个 server 的配置格式：

{
  "mcpServers": {
    "mysql": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mysql-mcp-server"],
      "env": {
        "MYSQL_HOST": "172.31.252.151",
        "MYSQL_DATABASE": "group_order"
      }
    }
  }
}

三、技术架构

3.1 整体架构图

─────────────────────────────────────────────────────────────┐
│                     Claude Code (IDE / CLI)                  │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │   MCP: MySQL │  │  MCP: Redis  │  │ MCP: RabbitMQ│         │
│  │  (npx -y)   │  │  (npx -y)   │  │  (npx -y)   │         │
│  └──────┬──────┘  └──────┬──────  └──────┬──────┘         │
│         │                │                 │                 │
│         ▼                ▼                 ▼                 │
│  ┌───────────────────────────────────────────────────────┐  │
│  │                   .mcp.json (本地配置)                  │  │
│  │  - type: stdio / command: npx / args / env            │  │
│  └───────────────────────────────────────────────────────┘  │
─────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
       ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
       │    MySQL     │ │    Redis     │ │  RabbitMQ    │
       │ 172.31.x.x  │ │ 172.31.x.x  │ │ 172.31.x.x  │
       └─────────────┘ └─────────────┘ └─────────────┘
              ▲               ▲               ▲
              │               │               │
       ┌──────────────────────────────────────────────────────┐
       │                   Nacos 配置中心                       │
       │  spring.datasource.* → host/port/user/pass            │
       │  spring.redis.*      → host/port/pass/db              │
       │  spring.rabbitmq.*   → host/port/user/pass/vhost      │
       │  spring.elasticsearch.* → host/port/user/pass         │
       └──────────────────────────────────────────────────────┘

3.2 数据流：配置是如何被发现的

Step 1: 用户提供 Nacos 连接信息
   ↓
Step 2: AI 配置 Nacos MCP Server → 连上 Nacos
   ↓
Step 3: AI 扫描项目代码（pom.xml + 注解 + yml）
   → 发现项目依赖了 MySQL、Redis、RabbitMQ、ES
   ↓
Step 4: AI 通过 Nacos MCP 读取项目配置文件
   → 搜索配置内容中的 host/port/password 关键词
   → 解析 JDBC URL 提取数据库名
   → 解析 Redis database 编号
   ↓
Step 5: AI 构建 .mcp.json 并逐个添加 MCP Server
   → claude mcp add-json mysql '{"type":"stdio","command":"npx",...}'
   → claude mcp add-json redis '{"type":"stdio","command":"npx",...}'
   → ...
   ↓
Step 6: AI 执行实际查询验证每个连接
   → SHOW TABLES / PING / list_queues / _cat/indices
   ↓
Step 7: 输出汇总报告，完成

3.3 核心组件说明

四、架构适配：不同项目怎么改

4.1 适配原则

核心思想不变，入口和扫描方式随架构调整。

整个方案依赖两个核心能力：

1. 配置入口 — 从中读取所有中间件的连接信息
2. 代码扫描 — 确认项目用了哪些中间件

不同架构的项目，只需要替换这两个环节的实现方式。

4.2 常见架构场景对照表

4.3 场景 A：Apollo 配置中心

如果你的项目用 Apollo 而不是 Nacos，需要做以下替换：

1. 替换入口 MCP 包

Apollo 有官方 MCP：@apollo/mcp-server（或搜索 npm 上可用的 Apollo MCP 包）

# 原 Nacos 配置方式
claude mcp add-json -s project nacos '{"type":"stdio","command":"npx","args":["-y","@hzkj/nacos-mcp-server"],"env":{...}}'

# 改为 Apollo 方式
claude mcp add-json -s project apollo '{"type":"stdio","command":"npx","args":["-y","<apollo-mcp-package>"],"env":{"APOLLO_PORTAL_URL":"http://<ip>:8070","APOLLO_TOKEN":"<token>"}}'

2. 修改 Skill 中的配置读取步骤

在 SKILL.md 中，将 "Step 3: Configure Nacos MCP" 和 "Step 4: Read Nacos Configs" 改为 Apollo 的对应操作：

• 用 Apollo MCP 的 get_config 读取 application.yml 或 common.yml
• Apollo 的 key 命名方式与 Nacos 不同，搜索关键词保持一致

3. 代码扫描不变

pom.xml 和注解扫描不依赖配置中心，保持不变。

4.4 场景 B：Spring Cloud Config

Spring Cloud Config Server 没有成熟的 MCP 包，可以用 HTTP API 替代：

1. 不用 MCP 读配置，直接用 HTTP 请求

# Spring Cloud Config 的 REST API
curl http://<config-server>:8888/<application>/<profile>/<branch>

AI 可以通过 Bash 工具直接调用这个 API 获取配置内容，后续解析逻辑不变。

2. 修改 Skill 提示词

在 Skill 中，将 "读取 Nacos 配置" 改为 "调用 Config Server REST API"：

使用 curl 访问 Config Server:
curl http://<ip>:8888/<application>/default/master

4.5 场景 C：Kubernetes ConfigMap/Secret

如果你的配置存在 K8s ConfigMap 里：

1. 先配置 Kubernetes MCP

claude mcp add-json -s project kubernetes '{"type":"stdio","command":"npx","args":["-y","kubernetes-mcp-server"],"env":{"KUBECONFIG":"/path/to/kubeconfig"}}'

2. 用 K8s MCP 读 ConfigMap

# AI 可以执行类似操作
kubectl get configmap <app-config> -o jsonpath='{.data.application\.yml}'

3. 后续解析不变

拿到 YAML 内容后，搜索 host/port/password 的逻辑完全一样。

4.6 场景 D：纯本地配置文件（无配置中心）

最简单的场景 — 配置直接写在项目的 application.yml 里：

1. 跳过配置中心 MCP

不需要 Nacos/Apollo 等入口 MCP。

2. AI 直接读本地文件

AI 直接 Read application.yml → 搜索 host/port/password → 构建 MCP 配置

3. Skill 简化

Skill 的 Step 2（代码扫描）和 Step 3（配置读取）合并为一步：

扫描代码 + 读取 application.yml → 发现中间件 + 提取连接信息 → 构建 MCP 配置

4.7 场景 E：中间件不同（不用 RabbitMQ 用 Kafka / 不用 ES 用 MongoDB）

1. 替换对应的 MCP 包

2. 代码扫描增加对应依赖识别

在 pom.xml 扫描步骤中，添加对应的依赖关键词：

• Kafka → spring-kafka, kafka-clients
• MongoDB → mongodb-driver, spring-data-mongodb
• PostgreSQL → postgresql JDBC driver

3. 配置提取增加对应 key 搜索

在配置内容中搜索对应的配置前缀：

• Kafka → spring.kafka.*
• MongoDB → spring.data.mongodb.*
• PostgreSQL → spring.datasource.*（与 MySQL 共用）

4.8 快速适配检查清单

换到新项目时，按以下清单逐项确认：

• 配置中心是什么？ → 选择对应的入口 MCP 或读取方式
• 项目用了哪些中间件？ → 扫描 pom.xml 确认
• 配置 key 命名规范？ → 读取配置文件，搜索关键词
• 数据库是哪种？ → MySQL/PostgreSQL/Oracle → 选择对应 MCP 包
• 缓存是哪种？ → Redis/Memcached → 选择对应 MCP 包
• 消息队列是哪种？ → RabbitMQ/Kafka/RocketMQ → 选择对应 MCP 包
• 搜索引擎是哪种？ → ES/MongoDB Solr → 选择对应 MCP 包
• 账号是只读的吗？ → 确认安全底线
• 有外网吗？ → 首次 npx 拉包需要

五、能力展示：配置后 AI 能做什么

3.1 能力对比

3.2 实际查询示例

查数据库：

AI：让我查一下 order_no=20240301xxx 的订单状态和支付时间
→ [执行 SELECT * FROM t_order WHERE order_no='20240301xxx']
→ 发现 status=1（待支付），pay_time=NULL，confirm_time=NULL
→ 结论：支付回调未执行，订单停留在待支付状态

查 Redis 缓存：

AI：看下 Redis 里有没有这个订单的缓存
→ [执行 KEYS order:*:20240301xxx]
→ 发现 key=order:cache:20240301xxx，TTL=3600
→ [执行 HGETALL order:cache:20240301xxx]
→ 缓存数据 status=2（已支付），与数据库 status=1 不一致
→ 结论：缓存未更新，数据库和缓存数据不一致

查 RabbitMQ 队列：

AI：看下 ORDER_TO_ES_QUEUE 队列有没有堆积
→ [执行 list_queues]
→ ORDER_TO_ES_QUEUE: messages=5023, consumers=0
→ 结论：队列严重堆积且没有消费者，ES 同步完全停滞

3.3 每个中间件的具体能力

MySQL MCP：

• SHOW DATABASES / SHOW TABLES — 发现库表结构
• DESCRIBE table_name — 查看表字段
• SELECT ... — 查询数据
• EXPLAIN ... — 分析 SQL 执行计划
• 注意：如果账号有写权限，也能执行 INSERT/UPDATE/DELETE（安全见第四节）

Redis MCP：

• PING — 健康检查
• KEYS pattern — 搜索 key（生产环境建议用 SCAN）
• GET / HGET / SMEMBERS — 读取值
• TTL — 查看过期时间

RabbitMQ MCP：

• list_queues — 列出所有队列及消息数
• list_exchanges — 列出交换机
• list_bindings — 查看绑定关系

Nacos MCP：

• get_config — 读取指定 DataId 的配置
• list_configs — 列出所有配置
• list_instances — 查看服务注册实例

Elasticsearch MCP：

• _cat/indices — 列出所有索引
• GET /index/_search — 搜索文档
• GET /index/_mapping — 查看 mapping

六、安全风险与最佳实践

4.1 核心原则：只读账号

所有 MCP 连接必须使用只读账号。 这是整个方案的安全底线。

4.2 风险清单

4.3 最佳实践

1. 测试环境优先：MCP 连接优先指向测试环境数据库
2. 生产环境谨慎：如必须连生产，用只读账号 + 脱敏数据
3. 不提交配置：.mcp.json 和包含密码的配置不提交到 Git
4. 查询加限制：AI 查询时自动加 LIMIT 100 等限制
5. 操作留痕：AI 在执行查询前先说明"我要查什么、为什么查"
6. 按需开启：只在需要深度排查时配置 MCP，日常开发可关闭
7. 定期轮换密码：MCP 使用的数据库账号密码定期更换

七、完整教程：从零开始配置

5.1 前置条件

• Claude Code >= v2.1
• 项目使用 Nacos 作为配置中心
• 能访问 npm registry（首次拉包需要外网）
• Nacos 的连接信息（URL、namespace、账号、密码）

5.2 方式一：使用 Skill 自动化（推荐）

步骤 1：复制 Skill 文件

把项目的 .claude/skills/mcp-setup/ 整个目录复制到新项目的相同路径。

步骤 2：启动 Skill

在新项目里启动 Claude Code，输入：

/mcp-setup

步骤 3：提供 Nacos 信息

AI 会问你 4 个信息：

• Nacos Server URL（如 http://172.31.252.147:8848）
• Namespace ID
• Username（通常 nacos）
• Password

步骤 4：全自动

AI 自动完成：

1. 扫描代码（pom.xml、配置类）发现使用了哪些中间件
2. 配置 Nacos MCP
3. 读取 Nacos 配置文件
4. 从配置中提取每个中间件的连接信息
5. 逐个添加 MCP Server
6. 实际查询验证每个连接

全程 2-5 分钟，无需手动写任何配置。

5.3 方式二：手动配置

如果不想用 Skill，可以直接给 AI 以下提示词：

请帮我配置项目的 MCP Server。全程用 npx -y 执行，不要 npm install。
Claude Code v2.1+ 使用 .mcp.json 管理 MCP 配置。

Nacos 信息：
- Server: http://<IP>:8848
- Namespace: <namespace_id>
- Username: nacos
- Password: <密码>

请完成：
1. 先配置 Nacos MCP：claude mcp add-json -s project nacos '{"type":"stdio","command":"npx","args":["-y","@hzkj/nacos-mcp-server"],"env":{"NACOS_SERVER_URL":"...","NACOS_NAMESPACE_ID":"...","NACOS_USERNAME":"nacos","NACOS_PASSWORD":"..."}}'
2. 扫描 pom.xml 和代码，确认项目用了哪些中间件
3. 从 Nacos 读取项目配置，提取每个中间件的连接信息
4. 用 claude mcp add-json 逐个添加 MCP Server
5. 通过实际查询验证每个连接（不要依赖 claude mcp list，它有 UI bug）

5.4 验证方式

不要信任 claude mcp list 或 /mcp 命令 — 它们可能显示 "No MCP servers configured" 但实际已连接（这是已知 UI bug）。

正确验证方式：让 AI 执行一个实际查询，比如：

• MySQL：SHOW TABLES;
• Redis：PING
• RabbitMQ：list_queues
• Nacos：list_configs
• Elasticsearch：GET /_cat/indices

能返回结果就说明连接成功。

5.5 常见问题

Q：npx 需要外网吗？
A：首次拉包需要（从 npm registry 下载），下载后缓存到 ~/.npm/_npx/，后续运行不需要外网。

Q：会污染项目目录吗？
A：不会。全程用 npx -y，不会创建 node_modules 或 package.json。

Q：配置能跨项目共享吗？
A：可以。复制 .mcp.json 到新项目即可，但每个项目的连接信息不同，需要根据实际情况调整。

Q：AI 能执行 DELETE 吗？
A：取决于数据库账号的权限。如果账号只有 SELECT 权限，AI 无法执行写操作。强烈建议使用只读账号。

八、Skill 源码：完整的 mcp-setup SKILL.md

以下是完整的 Skill 定义文件，可以直接复制到任何项目使用：

---
name: mcp-setup
description: Auto-configure MCP Servers from Nacos. User provides Nacos credentials, you dynamically discover all middleware from code and config, then configure each MCP automatically.
license: MIT
metadata:
  author: penglianyu
  version: "2.0"
---

# MCP Setup Skill

Automatically configure MCP Servers for any Java/Spring project. User provides only Nacos connection info. You dynamically discover all middleware from the codebase and Nacos configuration — no hardcoded key mappings.

## IMPORTANT: Configuration Format

Claude Code v2.1+ uses `.mcp.json` (NOT `settings.json`) for MCP configuration.
Always use `claude mcp add-json -s project <name> '<json>'` to add servers.
The JSON must include `"type": "stdio"`.

**Warning**: `claude mcp list` and `/mcp` in the IDE may show "No MCP servers configured" even when servers ARE configured and working. This is a known UI bug. Always verify by actually using the MCP tool.

## Core Principle: Dynamic Discovery

**Do NOT rely on a fixed mapping table.** Every project's config keys may differ (different prefixes, custom property names, YAML nested structures, etc.). Instead:

1. **Scan the codebase first** — find what middleware the project actually uses:
   - Check `pom.xml` / `build.gradle` for dependency names (mysql-connector, spring-data-redis, spring-rabbit, elasticsearch-rest-client, etc.)
   - Grep for config classes: `@EnableRedis`, `@EnableRabbit`, `@FeignClient`, `@ElasticsearchClient`, `DataSource` beans
   - Check `application.yml` / `bootstrap.yml` for any `spring.*` config prefixes
   - Look at import statements: `redis.*`, `rabbit.*`, `elasticsearch.*`, `nacos.*`

2. **Read Nacos configs** — for each discovered middleware, search Nacos for its connection config:
   - Read the application's DataId (e.g., `group-order.yml`) and shared configs (e.g., `common.yml`)
   - Search the full config content for connection-related keywords: `host`, `port`, `url`, `password`, `username`, `virtual-host`
   - Map whatever keys you find to the MCP's expected env var names

3. **Build MCP configs dynamically** — based on what you actually found, not a template.

## MCP Package Registry (Reference Only)

| Middleware | npm Package | Notes |
|-----------|-------------|-------|
| MySQL | `mysql-mcp-server` | Env vars: MYSQL_HOST, MYSQL_PORT, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE |
| Redis | `@hamaster/redis-mcp-server` | Env vars: REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, REDIS_DB. **Must use @hamaster** — plain `redis-mcp` ignores env vars |
| RabbitMQ | `rabbitmq-mcp` | Env vars: RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USERNAME, RABBITMQ_PASSWORD, RABBITMQ_VHOST |
| Nacos | `@hzkj/nacos-mcp-server` | Env vars: NACOS_SERVER_URL, NACOS_NAMESPACE_ID, NACOS_USERNAME, NACOS_PASSWORD |
| Elasticsearch | `elasticsearch-mcp-server` | Env vars: ELASTICSEARCH_HOST, ELASTICSEARCH_PORT, ELASTICSEARCH_USERNAME, ELASTICSEARCH_PASSWORD |
| Kubernetes | `kubernetes-mcp-server` | Skip — needs kubeconfig file, cannot be auto-configured |

## Do-Not-Repeat (Known Pitfalls)

- **`redis-mcp` is broken** — it ignores env vars and only accepts CLI args. Always use `@hamaster/redis-mcp-server`.
- **Kubernetes MCP needs a kubeconfig file** — cannot be configured via env vars alone. Skip unless user provides kubeconfig.
- **Never `npm install`** — always use `npx -y` to avoid polluting the project with node_modules.
- **npx needs external network only on first run** — packages are cached in ~/.npm/_npx/ after first pull. Subsequent runs work offline.
- **Use `claude mcp add-json` not `settings.json`** — v2.1+ reads `.mcp.json`, ignores `settings.json` mcpServers.
- **JSON must include `"type": "stdio"`** — required by Claude Code MCP format.
- **`claude mcp list` / `/mcp` UI is unreliable** — it may show "No MCP servers configured" when servers are actually connected. Always verify by running a real query.
- **Do NOT use hardcoded Nacos key mappings** — every project may use different config key names, prefixes, or nested structures. Always scan code + read actual config content.

## Execution Steps

### Step 1: Ask for Nacos Credentials

Ask the user for:
- Nacos Server URL (e.g., `http://172.31.252.147:8848`)
- Namespace ID
- Username (usually `nacos`)
- Password

### Step 2: Scan Codebase for Middleware

Before configuring anything, identify what middleware this project actually uses:

1. **Check dependencies**: Read `pom.xml` (or `build.gradle`) — look for connector/driver dependencies:
   - `mysql-connector-java`, `mybatis` → MySQL
   - `spring-data-redis`, `spring-boot-starter-data-redis`, `jedis`, `lettuce` → Redis
   - `spring-rabbit`, `amqp-client` → RabbitMQ
   - `elasticsearch-rest-client`, `elasticsearch-java` → Elasticsearch
   - `nacos-client`, `spring-cloud-starter-alibaba-nacos` → Nacos

2. **Check config classes**: Grep for bean definitions:
   - `@EnableCaching`, `RedisTemplate`, `StringRedisTemplate` → Redis
   - `@EnableRabbit`, `RabbitTemplate`, `ConnectionFactory` → RabbitMQ
   - `ElasticsearchRestTemplate`, `RestHighLevelClient` → Elasticsearch
   - `DataSource`, `@MapperScan` → MySQL

3. **Check config files**: Read `application.yml`, `bootstrap.yml`, `application-*.yml` for any `spring.*` config sections

4. **Build a discovery list** of which middlewares are actually in use

### Step 3: Configure Nacos MCP

```bash
claude mcp add-json -s project nacos '{"type":"stdio","command":"npx","args":["-y","@hzkj/nacos-mcp-server"],"env":{"NACOS_SERVER_URL":"<url>","NACOS_NAMESPACE_ID":"<id>","NACOS_USERNAME":"<user>","NACOS_PASSWORD":"<pass>"}}'

Wait a few seconds for the server to start. Do NOT rely on claude mcp list for status.

Step 4: Read Nacos Configs for Each Middleware

For each middleware discovered in Step 2:

1. Use Nacos MCP to read the project's configuration DataId(s)
2. Typical DataId patterns: application name (e.g., group-order), common, shared configs
3. Search the config content for connection-related properties — look for whatever keys the project uses (not a fixed list)
4. Common patterns to search for (adapt based on what you find):
   • JDBC URL parsing: extract host, port, database from jdbc:mysql://host:port/dbname
   • Redis: look for redis section with host/port/password/db
   • RabbitMQ: look for rabbitmq section with host/port/username/password/virtual-host
   • Elasticsearch: look for elasticsearch section with uris/username/password
5. Report what you found for each middleware and confirm with the user before proceeding

Step 5: Discover MySQL Database Name (If MySQL Is In Use)

If MySQL was discovered:

1. Add MySQL MCP with the credentials found
2. Run SHOW DATABASES; to list all databases
3. Help user identify which database belongs to this project:
   • Match application name (e.g., group_order for group-order)
   • Check table count and names
   • Cross-reference with @TableName annotations found via Grep

Step 6: Add All MCP Servers

For each confirmed middleware, use:

claude mcp add-json -s project <name> '{"type":"stdio","command":"npx","args":["-y","<package>"],"env":{<discovered-env-vars>}}'

Add them one at a time with a brief pause between each.

For any middleware NOT found in Nacos or not used by the project, skip it and report what was skipped.

Step 7: Verify All Connections (Actual Queries)

Do NOT trust claude mcp list — it shows false negatives. Verify each connection by running an actual query:

Step 8: Summary

Provide a final summary:

| MCP           | Package                     | Status |
|---------------|----------------------------|--------|
| MySQL         | mysql-mcp-server            | ✓/✗/⏭️ |
| Redis         | @hamaster/redis-mcp-server  | ✓/✗/⏭️ |
| RabbitMQ      | rabbitmq-mcp                | ✓/✗/️ |
| Nacos         | @hzkj/nacos-mcp-server      | ✓/✗   |
| Elasticsearch | elasticsearch-mcp-server    | ✓/✗/⏭️ |

Legend: ✓ = connected, ✗ = failed, ⏭️ = not used by this project

Remind the user that /mcp may still show "No MCP servers configured" — this is a UI bug and does not affect functionality.

External Network Note

npx downloads packages from npm registry on first use. Ensure proxy/external network is available during first run. After first pull, all packages are cached locally — no external network needed for subsequent uses.

---

## 九、总结

给 Claude Code 配置 MCP Server 的核心价值就一句话：**让 AI 能直接查数据，不再靠猜。**

- **痛点**：AI 排查 Bug 时看不到数据库实际状态，全靠人工搬运数据
- **架构**：Claude Code + MCP Server + 配置中心 + 中间件，四层架构可扩展到任意技术栈
- **安全**：只读账号是底线，测试环境优先，不提交配置到 Git
- **用法**：复制 Skill 文件 → `/mcp-setup` → 提供 Nacos 信息 → 全自动完成
- **效果**：Bug 排查从"问-查-答"的三轮对话，变成 AI 直接查数据出结论

整个方案的源码和文档已开源在项目的 `docs/` 和 `.claude/skills/mcp-setup/` 目录下，欢迎拿去用。