MCP 协议中台
慧策 · MCP-Protokoll-Middleware
Kurz gesagt: Eine MCP-Protokoll-Infrastruktur – Produktionslinien können Datenquellen und Tools selbstständig registrieren, nachgelagerte Agents entdecken und rufen sie über das Standard-MCP-Protokoll auf. Die Plattform ist eine "Protokoll-Pipeline" und trägt keinerlei Geschäftslogik.
Inhaltsverzeichnis
Positionierung und Abgrenzung
Warum eine MCP-Protokoll-Middleware?
Das Unternehmen hat mehrere Produktionslinien (Cross-Border-ERP, Inlands-E-Commerce, WMS-Lagerhaltung, Finanzabrechnung ...), und jede Produktionslinie hat Datenabfrageanforderungen. Wenn man für jede neue Produktionslinie eine eigene MCP-Server-Instanz forkt und die Tool-Implementierung anpasst, gerät man in die Falle "bei jeder neuen Produktionslinie Code ändern".
Kernidee: Eine Infrastruktur bauen, die ausschließlich für die MCP-Protokollimplementierung und das Tool-Dispatch-Framework zuständig ist. Die Plattform definiert den Protokollvertrag, die Produktionslinien binden sich selbstständig gemäß dem Vertrag an.
Was die Plattform tut und was nicht
┌─────────── 本平台范围 ───────────┐
│ │
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 / ... │
└──────────────────────────────────────┘✅ Im Scope | ❌ Außerhalb des Scopes |
Vollständige MCP-Protokollimplementierung (basierend auf Spring AI MCP Server 1.1.2) | Jegliche SQL-/API-Logik konkreter Tools (machen die Produktionslinien) |
Tool-Registry (CRUD + Versionsverwaltung + Hot-Reload) | ETL-Pipelines / Breitentabellen-Aufbau / Datenbereinigung |
Datenquellen-Adapter-Framework (MySQL/PG/Doris/HTTP/Redis) | Anbindung von Upstream-APIs (ERP, BI, Drittanbieter) |
Middleware-Pipeline (Authentifizierung/Rate-Limiting/Caching/Degradation/Logging/Monitoring) | Geschäftsformeln / Algorithmen / Regeln |
Admin-Konsole (Datenquellenverwaltung + Tool-Verwaltung + Monitoring-Dashboard) | OAuth2.0 / RBAC / Multi-Tenancy (Phase 2) |
Produktionslinien-SDK (Java + Python) | Einführungsbetreuung der Produktionslinien / Tool-Entwicklung |
Zentrales Designprinzip: Die Plattform versteht kein Geschäft. Ein Tool ist nur ein Konfigurationsdatensatz in MySQL (Name + JSON-Schema + Datenquellen-Referenz + Abfragevorlage). Die Produktionslinie entscheidet, wie das Tool heißt, wie das SQL geschrieben wird und wie hoch der Cache-TTL ist.
Kernkonzept: Was ist MCP
MCP (Model Context Protocol) ist ein Standardprotokoll für die Interaktion zwischen KI-Agents und externen Tools/Daten, entwickelt von Anthropic. Analogie zu USB-C: Vor MCP musste jede KI-Anwendung maßgeschneiderten Klebecode für die Datenquellen-Anbindung schreiben; mit MCP entdecken und rufen Agents Tools über das einheitliche tools/list → tools/call-Protokoll auf.
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"]Zentrales Designprinzip: Der Agent verwaltet die "Absicht" (versteht, was der Nutzer will), die Plattform verwaltet das "Protokoll" (MCP-Implementierung + Tool-Routing + Middleware), die Produktionslinie verwaltet die "Daten" (Datenquelle registrieren + SQL/Konfiguration schreiben).
Architekturübersicht
Schichtenarchitektur
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 --> DatasourcesVerantwortlichkeiten der Schichten
Ebene | Kernverantwortung | Grenzen |
MCP-Protokollschicht |
| Die Protokollschicht kümmert sich nicht darum, woher Tools kommen oder was die Datenquelle ist |
Middleware-Pipeline | Authentifizierung → Rate-Limiting → Caching → Degradation → Logging/Monitoring, Filter-Chain-Muster, Pflichtpfad für Anfragen | Vollständig konfigurationsgetrieben, Produktionslinien wählen Strategien in der Tool-Konfiguration |
Tool-Engine | ToolDispatcher für Routing-Auflösung, Tool-Registry für Metadatenverwaltung, Tool-Executor für Parametervalidierung + Vorlagen-Rendering + Ergebnis-Mapping | Entkopplung von Protokoll und Registry über ToolDispatcher |
Adapter-Framework | Adapter-SPI-Schnittstellenvertrag + 5 eingebaute Adapter + Abfrage-Schutzmechanismen (max_rows/timeout/DDL-Blacklist) | Die Plattform macht nur die Adaption, kümmert sich nicht um Dateninhalte |
Admin-Konsole | Datenquellenverwaltung, Tool-Registrierungsverwaltung, Monitoring-Dashboard, Alarmkonfiguration (Vue 3 + Arco Design) | Selbstbedienung für Produktionslinien-Administratoren |
Kerndesign
Tool = Metadaten, kein Code
Aus Sicht der Plattform ist ein Tool nur ein MySQL-Datensatz. Produktionslinien registrieren Tools über API oder Konsole:
{
"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 }
}Was die Plattform tut: Parametervalidierung → Vorlagen-Rendering → Ausführung über Adapter → Ergebnis-Mapping → Rückgabe. Die Produktionslinie entscheidet über die gesamte Geschäftslogik.
Datenmodell (6 Kerntabellen)
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 天"
}Middleware-Fähigkeiten (von der Plattform "geschenkt" an die Produktionslinien)
Fähigkeit | Beschreibung |
Authentifizierung | API-Key + BCrypt, basierend auf |
Rate-Limiting | Token-Bucket, 3 Ebenen: global / Produktionslinie / Tool |
Caching | Caffeine L1 (lokal <1ms) + Redis L2 (verteilt geteilt), TTL von Produktionslinie konfigurierbar |
Degradation | 4-stufige automatische Degradation: abgelaufener Cache → nur lokaler Cache → statischer Standardwert → 503-Ablehnung |
Observability | Automatische Instrumentierung: Aufrufvolumen/Erfolgsrate/P95/Cache-Trefferquote/Degradationsanzahl, Prometheus + Grafana |
Aufrufprotokoll |
|
Drei Anbindungsarten
Art | Anwendungsszenario | Aufwand für Produktionslinie |
SQL-Vorlage | Einzeltabellenabfrage, einfache JOINs, Aggregation | 1 SQL schreiben + Formular ausfüllen |
HTTP-Vorlage | Aufruf vorhandener REST-APIs der Produktionslinie | URL-Vorlage ausfüllen |
SDK-Plugin | Mehrstufige Aggregation, komplexe Berechnungen | 50–200 Zeilen Java/Python schreiben |
Technologie-Stack
Ebene | Auswahl | Version | Begründung |
MCP-Protokollimplementierung | Spring AI MCP Server | 1.1.2 | Internes Demo bereits verifiziert, eingebauter JSON-RPC-Router + Transport + |
Authentifizierung |
| 0.0.5 | Community-Bibliothek, im Demo verifiziert. API-Key + BCrypt |
Basis-Framework | Java 21 + Spring Boot | 3.4.7 | Unternehmens-Java-Stack, Version an internem Demo ausgerichtet |
Admin-Konsolen-Frontend | Vue 3 + Vite + Arco Design | — | Leichtgewichtig, Technologie-Stack der Frontend-Abteilung |
Metadaten-Speicher | MySQL 8.0 | — | Tool-Konfiguration, Datenquellen-Konfiguration, Aufrufprotokolle |
Cache | Caffeine (L1) + Redis 6.2 (L2) | — | L1 lokal <1ms, L2 verteilt geteilt |
Monitoring | Micrometer + Prometheus + Grafana | — | Native Spring-Boot-Integration |
Konfigurationszentrum | Nacos 2.x | — | Bereits im Unternehmen vorhanden, Speicherung von Zugangsdaten + Konfiguration |
Bereitstellung | Docker Compose (Entwicklung) + K8s (Produktion) | — | An Unternehmensinfrastruktur ausgerichtet |
Framework-Auswahl: Spring AI MCP Server 1.1.2 implementiert das MCP-Protokoll 2024-11-05 vollständig. Diese Plattform implementiert die Protokollschicht nicht neu, sondern baut auf Spring AI drei Dinge auf: (1) dynamische Tool-Registrierung (ersetzt die statische
@McpTool-Annotation), (2) Datenquellen-Adaption und Vorlagenausführung, (3) generische Middleware-Pipeline.
Projektstruktur
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.mdSchnellstart
⚠️ Projekt in Entwicklung, folgendes ist der erwartete Startablauf.
Voraussetzungen
JDK 21 + Maven 3.9+
Docker 20.10+ & Docker Compose 2.20+
Zugriff auf das interne Unternehmensnetzwerk (Nacos / MySQL / Redis)
Lokale Entwicklung
# 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}'Dienst-Ports
Dienst | Port | Beschreibung |
MCP Server | 8080 | MCP-JSON-RPC-Endpunkt ( |
Admin Console | 8080 | Admin-Konsole ( |
MySQL | 3306 | Metadaten-Speicher |
Redis | 6379 | L2-Cache |
Nacos | 8848 | Konfigurationszentrum / Service-Discovery |
Anbindung der Produktionslinien
Die Anbindung einer Produktionslinie erfordert nur 3 Schritte, ohne dass die Plattformentwicklung eingreifen muss:
Schritt 1: Datenquelle registrieren
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 }
}'Schritt 2: Tool registrieren
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}}" }
}'Schritt 3: Agent-Aufruf
Nach der Tool-Registrierung ist es innerhalb von 30 s auf allen Instanzen wirksam. Nachgelagerte Agents rufen über das Standard-MCP-Protokoll auf:
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}Dokumentationsindex
Dokument | Zweck | Leser |
Plattformarchitektur, WBS-Aufschlüsselung, Meilensteine, Risiken | Alle | |
Kollaborationsvertrag der Produktionslinien, Anbindungsprotokoll | Plattformteam + Produktionslinienteams |
Projekt-Roadmap
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, 5dPhase | Ziel | Zeit |
Phase 1 · MVP | Kernfähigkeiten der MCP-Protokoll-Middleware: dynamische Tool-Registrierung + 5 Datenquellen-Adapter + Middleware-Pipeline + Admin-Konsole + SDK | 6 Wochen |
Phase 2 · Erweiterung | Plugin-Hot-Reload + OAuth2.0/RBAC/Multi-Tenancy + benutzerdefinierte ClassLoader-Isolation + weitere Adapter (ES/Mongo/GraphQL) | 3–6 Monate |
Phase 3 · Kommerzialisierung | MCP-Marketplace + Abrechnung/Messung + Multi-Cluster-Scheduling + Datenmaskierungsspiegel | 6+ Monate |
Projektstatus:
Entwurfsphase · ausstehende Überprüfung| Team: 2,5 Personen (TL + BE + FE geteilt) | Zeitraum: 6 WochenFragen? Zuerst den MCP-Plattform-Implementierungsplan lesen.
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