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
Related MCP server: OmniMCP
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 deployed
Maintenance
Related MCP Connectors
AI agent registry — search, discover, register, and connect agents via MCP.
AgencyAI's public MCP for service discovery and AI-readiness assessment.
A registry of AI agent tools — MCP servers, APIs, CLIs, SDKs — kept current by automated ingestion.
A marketplace for AI agents. Tools and data for agents, on one MCP address. No account, no API key.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to access a unified catalog of tools from various APIs (OpenAPI, GraphQL, MCP, Google Discovery) through the MCP protocol.7 npmMIT
- AlicenseAqualityDmaintenanceEnables AI agents to discover, monitor, and control industrial hardware like ESP32 machine controllers and inspection cameras through a standardized MCP interface.5MIT
- FlicenseAqualityCmaintenanceCentral registry for AI tools with vector search and knowledge graph, enabling intelligent tool discovery, chaining, and execution via MCP.12-
- AlicenseNot gradedqualityBmaintenanceEnables enterprise AI agents to discover and invoke MCP tools, resources, and prompts across GitHub, ITSM, and business systems through a policy-controlled gateway with human approval and auditability.MIT