MCP 协议中台
Plataforma MCP de Protocolo · HuiCe
En una frase: una infraestructura de protocolo MCP — permite que las líneas de producción registren fuentes de datos y Tools de forma autónoma, y que los Agent aguas abajo los descubran e invoquen mediante el protocolo MCP estándar. La plataforma es un "conducto de protocolo", no aloja ninguna lógica de negocio.
Índice
Posicionamiento y límites
¿Por qué crear una plataforma MCP de protocolo?
La empresa tiene varias líneas de producción (ERP transfronterizo, e-commerce nacional, WMS de almacenes, liquidación financiera...), y cada una tiene necesidades de consulta de datos. Si por cada línea que se integra se hace un fork del MCP Server y se modifican las implementaciones de los Tools, se cae en el dilema de "cada vez que se integra una línea, hay que cambiar código".
Idea central: construir una infraestructura que solo se encargue de la implementación del protocolo MCP y del marco de despacho de Tools. La plataforma define el contrato del protocolo, y las líneas de producción se integran de forma autónoma según el contrato.
Qué hace la plataforma y qué no hace
┌─────────── 本平台范围 ───────────┐
│ │
AI Agent ──MCP──→ │ MCP Protocol Tool Registry │ ←── API 契约 ←── 产线
│ Auth / Rate Cache / Degrade │
│ Adapter Framework │
│ Admin Console Observability │
│ │
└────────────┬─────────────────────┘
│ Data Source Adapter SPI
▼
┌──────────────────────────────────────┐
│ 产线数据源(产线自管) │
│ MySQL / Doris / StarRocks / HTTP API │
│ Redis / ES / ... │
└──────────────────────────────────────┘✅ Dentro del alcance | ❌ Fuera del alcance |
Implementación completa del protocolo MCP (basada en Spring AI MCP Server 1.1.2) | Cualquier lógica SQL/API de Tools concretos (la hacen las líneas de producción) |
Centro de registro de Tools (CRUD + gestión de versiones + recarga en caliente) | Pipelines ETL / construcción de tablas anchas / limpieza de datos |
Marco de adaptadores de fuentes de datos (MySQL/PG/Doris/HTTP/Redis) | Integración con APIs upstream (ERP, BI, terceros) |
Pipeline de middleware (autenticación/límite de tasa/caché/degradación/logs/monitorización) | Fórmulas de negocio / algoritmos / reglas |
Consola de administración (gestión de fuentes de datos + gestión de Tools + panel de monitorización) | OAuth2.0 / RBAC / multi-tenant (Fase 2) |
SDK para líneas de producción (Java + Python) | Acompañamiento en la integración / desarrollo de Tools |
Principio de diseño clave: la plataforma no entiende de negocio. Un Tool es solo un registro de configuración en MySQL (nombre + JSON Schema + referencia a fuente de datos + plantilla de consulta). La línea de producción decide cómo se llama el Tool, cómo se escribe el SQL y cuánto TTL de caché se configura.
Concepto central: qué es MCP
MCP (Model Context Protocol) es el protocolo estándar para la interacción entre Agent de IA y herramientas/datos externos, abierto por Anthropic. Analogía con USB-C: antes de MCP, cada aplicación de IA necesitaba escribir código de pegamento a medida para conectarse a fuentes de datos; con MCP, el Agent descubre e invoca herramientas mediante el protocolo unificado tools/list → tools/call.
flowchart LR
A["🤖 AI Agent<br/>Claude Desktop / LangChain / OpenAI"] -->|"tools/list<br/>tools/call<br/>JSON-RPC 2.0"| B["🔌 MCP 协议中台<br/>Spring AI MCP Server"]
B -->|"Adapter SPI"| C["🗄️ MySQL"]
B -->|"Adapter SPI"| D["🗄️ Doris"]
B -->|"Adapter SPI"| E["🌐 HTTP API"]
B -->|"Adapter SPI"| F["📦 Redis"]Principio de diseño clave: el Agent gestiona la "intención" (entiende qué quiere el usuario), la plataforma gestiona el "protocolo" (implementación de MCP + enrutamiento de Tools + middleware), y la línea de producción gestiona los "datos" (registra fuentes de datos + escribe SQL/configuración).
Visión general de la arquitectura
Arquitectura por capas
flowchart TB
subgraph Agent["AI Agent 层(外部)"]
Claude["Claude Desktop"]
LangChain["LangChain Client"]
OpenAI["OpenAI Agent SDK"]
end
subgraph Platform["MCP 协议中台(本平台)"]
direction TB
subgraph Protocol["MCP Protocol Layer"]
Handshake["initialize 握手<br/>协议版本协商 · 能力交换"]
JSONRPC["JSON-RPC 2.0 Router<br/>tools/list · tools/call · tools/schema<br/>resources/list · resources/read"]
Transport["Transport: HTTP SSE / Streamable HTTP"]
end
subgraph Middleware["Middleware Pipeline(Filter Chain)"]
direction LR
Auth["鉴权<br/>API Key + BCrypt"] --> RateLimit["限流<br/>Token Bucket"]
RateLimit --> Cache["缓存<br/>Caffeine L1 + Redis L2"]
Cache --> Degrade["降级<br/>4 级状态机"]
Degrade --> Log["日志·监控<br/>TraceId · Prometheus"]
end
subgraph Core["Tool Engine"]
Dispatcher["ToolDispatcher<br/>Tool 解析 · 路由"]
Registry["Tool Registry<br/>元数据管理 · 版本管理 · 热加载"]
Executor["Tool Executor<br/>参数校验 · 模板渲染<br/>结果映射 · 输出校验"]
end
subgraph Adapter["Data Source Adapter Framework"]
SPI["Adapter SPI<br/>接口契约 · 连接池 · 健康检查 · 查询护栏"]
Builtin["内置适配器<br/>MySQL · PostgreSQL · Doris · HTTP · Redis"]
end
subgraph Admin["Admin Console"]
ToolMgmt["Tool 管理"]
DSMgmt["数据源管理"]
Dashboard["监控大盘"]
Alarm["告警配置"]
end
end
subgraph Datasources["产线数据源(产线自管)"]
MySQL_DS["MySQL 产线 A"]
Doris_DS["Doris 产线 B"]
HTTP_API["HTTP API 产线 C"]
Redis_DS["Redis 产线 D"]
end
Agent -->|"MCP Protocol"| Handshake
Handshake --> JSONRPC
JSONRPC --> Auth
Middleware --> Dispatcher
Dispatcher --> Registry
Dispatcher --> Executor
Executor --> SPI
Admin --> Registry
Admin --> DSMgmt
SPI --> Builtin
Builtin --> DatasourcesResponsabilidades por capa
Capa | Responsabilidad central | Restricciones de límite |
Capa Protocolo MCP | Handshake | La capa de protocolo no se preocupa de dónde vienen los Tools ni de qué es la fuente de datos |
Pipeline de Middleware | Autenticación → límite de tasa → caché → degradación → logs y monitorización, patrón Filter Chain, ruta obligatoria para todas las peticiones | Totalmente impulsado por configuración; la línea de producción selecciona las políticas en la configuración del Tool |
Motor de Tools | ToolDispatcher analiza el enrutamiento, Tool Registry gestiona metadatos, Tool Executor valida parámetros + renderiza plantillas + mapea resultados | Desacopla Protocol y Registry mediante ToolDispatcher |
Marco de Adaptadores | Contrato de interfaz SPI de adaptadores + 5 adaptadores integrados + salvaguardas de consulta (max_rows/timeout/lista negra DDL) | La plataforma solo adapta, no se preocupa del contenido de los datos |
Consola de Administración | Gestión de fuentes de datos, gestión de registro de Tools, panel de monitorización, configuración de alertas (Vue 3 + Arco Design) | Operación autónoma orientada a administradores de líneas de producción |
Diseño central
Tool = metadatos, no código
Desde la perspectiva de la plataforma, un Tool es solo un registro de MySQL. La línea de producción registra el Tool mediante API o consola:
{
"id": "my_query_tool",
"name": "my_query_tool",
"description": "查询最近 N 条订单(给 LLM 看的描述)",
"parameters": {
"type": "object",
"properties": {
"limit": { "type": "integer", "default": 20, "maximum": 100 }
}
},
"datasource_id": "ds_my_line",
"query": {
"type": "SQL",
"template": "SELECT a, b, c FROM orders ORDER BY created_at DESC LIMIT {{.limit}}"
},
"cache": { "level": "BOTH", "l1_ttl_sec": 60, "l2_ttl_sec": 300 }
}Lo que hace la plataforma: validar la legalidad de los parámetros → renderizar la plantilla → ejecutar mediante el adaptador → mapear el resultado → devolver. La línea de producción decide toda la lógica de negocio.
Modelo de datos (6 tablas centrales)
erDiagram
Datasource ||--o{ Tool : "绑定"
Tool ||--o{ ToolVersion : "版本"
Tool ||--o{ CachePolicy : "缓存策略"
Tool ||--o{ DegradePolicy : "降级策略"
Tool ||--o{ InvocationLog : "调用记录"
Datasource {
string id PK "ds_example"
string type "DORIS / MYSQL / PG / HTTP / REDIS"
json connection "主机·端口·库名·凭据引用"
json pool_config "连接池配置"
string status "ONLINE / OFFLINE / ERROR"
}
Tool {
string id PK "my_tool_001"
string name "对 Agent 可见的工具名"
string description "详细的工具描述给 LLM 看"
json parameters "JSON Schema — 输入参数定义"
string datasource_id FK "绑定数据源"
string query_template "SQL 或 HTTP URL 模板"
json result_mapping "字段映射"
json transform "字段级转换规则"
string status "DRAFT / ONLINE / OFFLINE"
}
InvocationLog {
bigint id PK
string tool_id FK
string trace_id "全链路追踪 ID"
int latency_ms "执行耗时"
boolean cache_hit "是否命中缓存"
int degrade_level "降级级别"
timestamp created_at "TTL 7 天"
}Capacidades de middleware (lo que la plataforma "regala" a las líneas de producción)
Capacidad | Descripción |
Autenticación | API Key + BCrypt, basado en |
Límite de tasa | Token Bucket, 3 niveles: global / línea de producción / Tool |
Caché | Caffeine L1 (local <1ms) + Redis L2 (compartido distribuido), TTL configurable por línea de producción |
Degradación | Degradación automática en 4 niveles: caché caducada → solo caché local → valor estático por defecto → rechazo 503 |
Observabilidad | Instrumentación automática: volumen de llamadas/tasa de éxito/P95/tasa de acierto de caché/número de degradaciones, Prometheus + Grafana |
Logs de invocación | Tabla |
Tres formas de integración
Forma | Escenario de aplicación | Trabajo de la línea de producción |
Plantilla SQL | Consulta de tabla única, JOIN simple, agregación | Escribir 1 SQL + rellenar formulario |
Plantilla HTTP | Invocar API REST existente de la línea de producción | Rellenar plantilla de URL |
Plugin SDK | Agregación multi-paso, cálculo complejo | Escribir 50-200 líneas de Java/Python |
Stack tecnológico
Capa | Selección | Versión | Razón |
Implementación del protocolo MCP | Spring AI MCP Server | 1.1.2 | Validado en la demo interna de la empresa; incluye Router JSON-RPC + Transport + handshake |
Autenticación |
| 0.0.5 | Librería comunitaria, validada en la demo. API Key + BCrypt |
Framework base | Java 21 + Spring Boot | 3.4.7 | Stack Java de la empresa, alineado con la versión de la demo interna |
Frontend de la consola de administración | Vue 3 + Vite + Arco Design | — | Ligero, stack del equipo frontend de la empresa |
Almacenamiento de metadatos | MySQL 8.0 | — | Configuración de Tools, configuración de fuentes de datos, logs de invocación |
Caché | Caffeine (L1) + Redis 6.2 (L2) | — | L1 local <1ms, L2 compartido distribuido |
Monitorización | Micrometer + Prometheus + Grafana | — | Integración nativa de Spring Boot |
Centro de configuración | Nacos 2.x | — | Ya existente en la empresa, almacenamiento de credenciales y configuración |
Despliegue | Docker Compose (desarrollo) + K8s (producción) | — | Alineado con la infraestructura de la empresa |
Selección del framework base: Spring AI MCP Server 1.1.2 ya implementa completamente el protocolo MCP 2024-11-05. Esta plataforma no reimplementa la capa de protocolo, sino que sobre Spring AI hace tres cosas: (1) registro dinámico de Tools (sustituyendo la anotación estática
@McpTool), (2) adaptación de fuentes de datos y ejecución de plantillas, (3) pipeline de middleware genérico.
Estructura del proyecto
intent_plan/
├── docs/
│ └── superpowers/
│ └── specs/
│ ├── 2026-07-16-mcp-platform-plan.md # MCP 协议中台建设计划(主文档)
│ └── 2026-07-16-cross-border-mcp-boundary-design.md # 产线协作契约
├── mcp-server/ # MCP Server 核心(Spring Boot)
│ └── src/main/java/com/wangdian/mcp/
│ ├── protocol/ # MCP 协议层(Spring AI 集成)
│ ├── registry/ # Tool 注册中心(动态注册 + 版本管理)
│ ├── executor/ # Tool 执行器(校验 + 模板 + 映射)
│ ├── adapter/ # 数据源适配框架(SPI + 内置适配器)
│ ├── middleware/ # 中间件管道(鉴权/限流/缓存/降级)
│ ├── admin/ # 管理控制台 API(/admin/*)
│ └── sdk/ # 产线 SDK(Java)
├── mcp-server-admin/ # 管理控制台前端(Vue 3 + Arco Design)
├── mcp-sdk-python/ # 产线 SDK(Python)
├── docker-compose.yml # 本地开发环境
└── README.mdInicio rápido
⚠️ Proyecto en desarrollo; el siguiente es el flujo de arranque previsto.
Requisitos previos
JDK 21 + Maven 3.9+
Docker 20.10+ y Docker Compose 2.20+
Acceso a la red interna de la empresa (Nacos / MySQL / Redis)
Desarrollo local
# 1. 克隆项目
git clone <repo-url> && cd intent_plan
# 2. 启动开发环境中间件
docker compose up -d mysql redis nacos-standalone
# 3. 初始化数据库
# 执行 docs/superpowers/specs/ 下的 DDL 脚本
# 4. 启动 MCP Server
cd mcp-server
mvn spring-boot:run
# 5. 验证 MCP 协议
curl -X POST http://localhost:8080/mcp \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":0}'Puertos de servicio
Servicio | Puerto | Descripción |
MCP Server | 8080 | Endpoint MCP JSON-RPC ( |
Admin Console | 8080 | Consola de administración ( |
MySQL | 3306 | Almacenamiento de metadatos |
Redis | 6379 | Caché L2 |
Nacos | 8848 | Centro de configuración / descubrimiento de servicios |
Integración de líneas de producción
La integración de una línea de producción solo requiere 3 pasos, sin intervención del desarrollo de la plataforma:
Paso 1: Registrar la fuente de datos
curl -X POST http://mcp-platform:8080/api/v1/datasources \
-H "Content-Type: application/json" \
-H "X-API-Key: <your_api_key>" \
-d '{
"id": "ds_my_line",
"type": "MYSQL",
"connection": {
"host": "10.x.x.x", "port": 3306, "database": "my_db",
"credential_ref": "nacos:my-line/db-pwd"
},
"pool_config": { "min": 2, "max": 10, "timeout_sec": 30 }
}'Paso 2: Registrar el Tool
curl -X POST http://mcp-platform:8080/api/v1/tools \
-H "Content-Type: application/json" \
-H "X-API-Key: <your_api_key>" \
-d '{
"id": "my_query",
"name": "my_query",
"description": "查询我的订单数据",
"parameters": { "type": "object", "properties": { "limit": { "type": "integer" } } },
"datasource_id": "ds_my_line",
"query": { "type": "SQL", "template": "SELECT * FROM orders LIMIT {{.limit}}" }
}'Paso 3: Invocación del Agent
Tras el registro del Tool, surte efecto en todas las instancias en 30s. El Agent aguas abajo invoca mediante el protocolo MCP estándar:
Agent → POST /mcp
{"jsonrpc":"2.0", "method":"tools/list", "id":1}
Agent ← {"jsonrpc":"2.0", "result":{"tools":[..., {"name":"my_query", ...}]}, "id":1}
Agent → POST /mcp
{"jsonrpc":"2.0", "method":"tools/call", "params":{"name":"my_query","arguments":{"limit":20}}, "id":2}
Agent ← {"jsonrpc":"2.0", "result":{"content":[{"type":"text","text":"[{\"col\":\"val\"}]"}]}, "id":2}Índice de documentación
Documento | Uso | Lectores |
Arquitectura de la plataforma, desglose WBS, hitos, riesgos | Todos | |
Contrato de colaboración entre líneas de producción, protocolo de integración | Equipo de plataforma + equipos de líneas de producción |
Hoja de ruta del proyecto
gantt
title MCP 协议中台路线图
dateFormat YYYY-MM-DD
axisFormat W%W
section M1 · 协议核心(W1)
Spring AI 集成 + 动态 Tool 注册 POC :m1, 2026-07-20, 5d
section M2 · 工具引擎(W2)
Tool Registry + Executor + Adapter :m2, after m1, 5d
section M3 · 生产就绪(W3)
Middleware Pipeline + 降级演练 :m3, after m2, 5d
section M4 · 管理控制台(W4-W5)
Admin Console + SDK :m4, after m3, 10d
section M5 · 上线(W6)
集成测试 + 压测 + 灰度 :m5, after m4, 5dFase | Objetivo | Tiempo |
Fase 1 · MVP | Capacidades centrales de la plataforma MCP de protocolo: registro dinámico de Tools + 5 adaptadores de fuentes de datos + pipeline de middleware + consola de administración + SDK | 6 semanas |
Fase 2 · Mejora | Recarga en caliente de plugins + OAuth2.0/RBAC/multi-tenant + aislamiento con ClassLoader personalizado + más adaptadores (ES/Mongo/GraphQL) | 3-6 meses |
Fase 3 · Comercialización | MCP Marketplace + medición y facturación + programación multi-clúster + espejos de enmascaramiento de datos | 6 meses+ |
Estado del proyecto:
Fase de diseño · pendiente de revisión| Equipo: 2,5 personas (TL + BE + FE compartido) | Periodo: 6 semanas¿Tienes dudas? Consulta primero el Plan de construcción de la plataforma MCP de protocolo.
This server cannot be installed
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Hosted MCP endpoint with realistic fake data for prototyping agents. 12 tools, no setup.
Self-hosted MCP gateway: turn any API, database or MCP server into AI connectors — no code.
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/qiyingshicaiji/mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server