Skip to main content
Glama

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/listtools/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 --> Datasources

Responsabilidades por capa

Capa

Responsabilidad central

Restricciones de límite

Capa Protocolo MCP

Handshake initialize, Router JSON-RPC 2.0, Transport SSE/Streamable HTTP (basado en Spring AI MCP Server 1.1.2, sin reinventar la rueda)

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 mcp-server-security 0.0.5 + Spring Security

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 InvocationLog, la línea de producción puede consultar "qué parámetros pasó el Agent a mi Tool y qué devolvió"

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 initialize. No reinventar la rueda del protocolo

Autenticación

mcp-server-security + Spring Security

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.md

Inicio 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 (:8080/mcp)

Admin Console

8080

Consola de administración (:8080/admin/*)

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

Plan de construcción de la plataforma MCP de protocolo

Arquitectura de la plataforma, desglose WBS, hitos, riesgos

Todos

Diseño de límites de responsabilidad del servicio MCP

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, 5d

Fase

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.

-
license - not tested
Not graded
quality - not tested
B
maintenance

Maintenance

Maintainers
Response time
Release cycle
Releases (12mo)
Commit activity

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.

View all MCP Connectors

Latest Blog Posts

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