MCP Setup-Anleitung

Governance für die MCP-Server, die Ihre Coding-Agenten (Cursor, Windsurf, Claude Code) aufrufen.

Das MCP-(Model-Context-Protocol-)Gateway governt die Tool-Aufrufe Ihrer Coding-Agenten. Cursor, Windsurf und Claude Code sind MCP-Clients: Sie registrieren den Ziel-MCP-Server, den sie aufrufen (einen Datenbank-, Dateisystem- oder GitHub-MCP-Server), und leiten den Client über Palveron. Auf dem MCP-Weg prüft Palveron Werkzeugaufrufe gegen Ihre Regeln: Ein Werkzeug ist erst erreichbar, wenn ein Admin es zugelassen hat, und für jedes Werkzeug gilt eine Regel, etwa erlaubt, nur mit Freigabe oder verboten. Eine inhaltliche Erkennung personenbezogener Daten in den Aufrufen findet auf diesem Weg heute nicht statt.

So funktioniert es

Sie registrieren den Ziel-MCP-Server bei Palveron — aus dem Katalog oder per eigener Adresse
Palveron scannt ihn und ein Admin genehmigt ihn und lässt dabei jedes Werkzeug mit einer Regel zu (nur zugelassene Werkzeuge eines ACTIVE-Servers werden bedient)
Ihr Coding-Agent spricht mit Palverons Proxy-Endpunkt pro Server statt direkt mit dem MCP-Server
Ihre Richtlinien prüfen Tool-Name, Parameter und Kontext
Lassen die Regeln den Aufruf durch, wird er an den tatsächlichen MCP-Server weitergeleitet. Anschließend zeichnet Palveron den Aufruf auf. Scheitert diese Aufzeichnung, ist der Aufruf trotzdem ausgeführt und erscheint nicht unter Trace Explorer.

Schritt 1 — Ziel-MCP-Server registrieren

Palveron kann Anfragen an jeden erreichbaren MCP-Server proxen. Registrieren und Scannen ist eine Editor-Aktion.

Dashboard

Navigieren Sie zu Integrationen → MCP (/integration/mcp)
Klicken Sie auf Server hinzufügen und wählen Sie entweder einen Server aus dem Katalog (durchsuchbares offizielles MCP-Registry, 1-Klick-Verbindung) oder geben Sie eine eigene Adresse ein
Tragen Sie die Server-URL und Authentifizierungsdaten ein

Die Registrierung scannt nicht automatisch; führen Sie den Scan als separaten Schritt aus (siehe Schritt 1b).

API

curl -X POST https://gateway.palveron.com/api/v1/mcp/servers \
  -H "Authorization: Bearer pv_live_your_project_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "GitHub MCP",
    "server_url": "https://api.githubcopilot.com/mcp/"
  }'

Pflichtfelder: name, server_url (ein Streamable-HTTP-MCP-Endpunkt). Optional: description, connector_type (freies Label, Standard custom), auth_method, auth_config (freies JSON), is_proxied. Die Antwort enthält die Server-id — Sie benötigen sie für die Proxy-URL unten. Neue Server starten in PENDING_APPROVAL.

Schritt 1b — Server scannen

curl -X POST https://gateway.palveron.com/api/v1/mcp/servers/{id}/scan \
  -H "Authorization: Bearer pv_live_your_project_key"

Der Scan entdeckt die Werkzeuge des Servers und bestimmt je Werkzeug Aktion und Risiko. Er setzt keine Regel: Palveron schlägt je Werkzeug eine vor, und ein Admin entscheidet mit der Genehmigung (siehe Tool-Richtlinien). Ist das Ziel nicht erreichbar, ist der Scan ehrlich: er liefert 200 { "scanned": false, "reason": "unreachable", "target": "…" }, keinen Server-Fehler.

Schritt 1c: Genehmigung (Admin)

Ein neu registrierter Server ist PENDING_APPROVAL und bedient nichts: Der Proxy lehnt jeden Aufruf an einen Nicht-ACTIVE-Server ab (ein PENDING_APPROVAL-Server liefert JSON-RPC -32002). Nach einem erfolgreichen Scan genehmigt ein Admin den Server (Integrationen → MCP → Genehmigen); vorher ist Genehmigen mit Grund gesperrt. Der Genehmigungsdialog zeigt jedes entdeckte Werkzeug mit einer vorgeschlagenen Regel; der Admin behält oder ändert jede und bestätigt mit Vorschläge übernehmen (N). Genehmigen, Pausieren und Ablehnen sind eigene, protokollierte Admin-Aktionen. Diese Funktionstrennung (Editor verbindet und scannt, Admin genehmigt und lässt zu) hält einen Menschen in der Schleife, bevor Verkehr fließt.

Schritt 2 — Coding-Agent auf den Proxy richten

Der governte Endpunkt ist der JSON-RPC-Proxy pro Server:

https://gateway.palveron.com/api/v1/mcp/proxy/{server_id}

Er akzeptiert jede JSON-RPC-2.0-Anfrage (initialize und tools/list passieren; tools/call wird policy-geprüft). Optional senden Sie einen X-Agent-Id-Header mit einer registrierten Agent-ID, damit Aufrufe diesem Agenten zugeordnet werden — eine unbekannte ID gilt als anonym.

Cursor

Öffnen Sie Cursor-Einstellungen → MCP Servers → Add Server (Typ: HTTP, Bearer = Ihr Projekt-API-Key):

{
  "mcpServers": {
    "palveron-governed-github": {
      "url": "https://gateway.palveron.com/api/v1/mcp/proxy/{server_id}",
      "headers": {
        "Authorization": "Bearer pv_live_your_project_key",
        "X-Agent-Id": "ckagent..."
      }
    }
  }
}

Windsurf

Windsurf verwendet dasselbe MCP-Konfigurationsformat — fügen Sie denselben Eintrag unter Windsurf-Einstellungen → MCP hinzu.

Claude Code

Für Claude Code (Anthropics CLI-Agent) fügen Sie denselben MCP-Server-Eintrag zu Ihrer Konfiguration hinzu.

Für selbstgehostete Deployments ersetzen Sie den Host durch Ihr Gateway (z. B. http://localhost:8080/api/v1/mcp/proxy/{server_id}).

Schritt 3 — Tool-Richtlinien

Mit der Genehmigung erhält jedes Werkzeug die Regel, die ein Admin bestätigt hat. Sie können strengere Regeln ergänzen, etwa für einen einzelnen Agenten. Binden Sie eine Richtlinie über mcp_tool_id aus GET /api/v1/mcp/servers/{id}/tools an ein gescanntes Werkzeug:

curl -X POST https://gateway.palveron.com/api/v1/mcp/policies \
  -H "Authorization: Bearer pv_live_your_project_key" \
  -H "Content-Type: application/json" \
  -d '{
    "mcp_tool_id": "clxyz...",
    "action": "REQUIRE_APPROVAL",
    "reason": "Destructive database operations require human approval"
  }'

Aktion	Verhalten
`ALLOW`	Tool-Aufruf wird ohne Eingriff weitergeleitet
`LOG_ONLY`	Tool-Aufruf wird weitergeleitet, aber zur Prüfung markiert
`REQUIRE_APPROVAL`	Tool-Aufruf pausiert, bis ein Mensch ihn freigibt oder ablehnt
`DENY`	Tool-Aufruf wird mit Begründung abgelehnt

Jeder andere Aktionswert liefert 400 mit der erlaubten Menge. Eine strengere Richtlinie zu erstellen ist eine Editor-Aktion; eine erlaubende (ALLOW, LOG_ONLY) zu erstellen und eine Richtlinie zu löschen sind Admin-Aktionen. Mit agent_id sind nur REQUIRE_APPROVAL und DENY erlaubt. Siehe die MCP-API-Referenz für den vollständigen Body.

Freigabeanfragen

Trifft ein Tool-Aufruf auf eine REQUIRE_APPROVAL-Regel oder gilt keine Regel, wird er eingereiht:

Der Aufruf des Coding-Agenten pausiert (JSON-RPC -32004, mit der Request-ID)
Ein Admin prüft die Anfrage unter Freigaben
Bei Freigabe wird der Aufruf einmalig weitergeleitet; die Freigabe ist einmalig und an die exakten Argumente gebunden, für die sie angefragt wurde (andere Argumente eröffnen eine neue Freigabe-Anfrage); bei Ablehnung wird ein Fehler zurückgegeben

Werkzeug-Governance & Drift-Erkennung

Wenn ein Admin ein Werkzeug zulässt (mit der Genehmigung des Servers oder einzeln auf der Werkzeugseite), hält Palveron einen Fingerabdruck über Name, Beschreibung und Eingabe-Parameter fest: den zugelassenen Stand. Bei jedem späteren Aufruf wird die aktuelle Werkzeug-Oberfläche damit verglichen:

Unverändert → der Aufruf läuft unter seiner Regel.
Geändert seit der Zulassung (ein klassischer Rug-Pull-/Tool-Poisoning-Vektor) → der Aufruf wird gesperrt (-32002, APPROVED_FINGERPRINT_MISMATCH) und protokolliert (McpToolDrift → OCSF/SIEM), bis ein Admin den aktuellen Stand prüft und das Werkzeug auf der Werkzeugseite erneut zulässt. Das Fortsetzen eines pausierten Servers tut das nicht.

Ein nicht zugelassenes Werkzeug wird gesperrt (-32002, TOOL_NOT_RELEASED).

Überwachung

MCP-Tool-Aufrufe erscheinen im Command Center und im Trace-Explorer mit dem Typ MCP_TOOL_CALL, mit Metriken für gesamte und blockierte Tool-Aufrufe, aktive Server, Server mit fehlgeschlagenem letztem Scan und offene Freigabeanfragen.

Nächste Schritte

MCP-Server — Server-Registrierung und -Verwaltung
Tool-Richtlinien — Feingranulare Werkzeug-Governance
API-Referenz: MCP — Vollständige MCP-Endpunkt-Dokumentation
Schnellstart — Allgemeine Onboarding-Anleitung

On this page