Skip to main content
Glama

慧策 · 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/listtools/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 --> Datasources

Verantwortlichkeiten der Schichten

Ebene

Kernverantwortung

Grenzen

MCP-Protokollschicht

initialize-Handshake, JSON-RPC-2.0-Router, SSE/Streamable-HTTP-Transport (basierend auf Spring AI MCP Server 1.1.2, kein Rad neu erfinden)

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

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

InvocationLog-Tabelle, Produktionslinien können abfragen "welche Parameter hat der Agent an mein Tool übergeben, was wurde zurückgegeben"

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 + initialize-Handshake. Kein neues Protokollrad erfinden

Authentifizierung

mcp-server-security + Spring Security

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

Schnellstart

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

Admin Console

8080

Admin-Konsole (:8080/admin/*)

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

MCP-Plattform-Implementierungsplan

Plattformarchitektur, WBS-Aufschlüsselung, Meilensteine, Risiken

Alle

MCP-Service-Verantwortungsgrenzen-Design

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

Phase

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 Wochen

Fragen? Zuerst den MCP-Plattform-Implementierungsplan lesen.

-
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