Integration App MCP Server

Membrane MCP Server

Der Membrane MCP Server ist ein Model Context Protocol (MCP)-Server, der Aktionen für verbundene Integrationen auf Membrane als Werkzeuge bereitstellt.

Hier ist unser offizielles KI-Agenten-Beispiel, das zeigt, wie Sie diesen MCP-Server in Ihrer Anwendung verwenden können.

📋 Voraussetzungen

• Node.js (v18 oder höher)
• Ein Membrane-Konto

⚙️ Installation

git clone https://github.com/membranehq/mcp-server.git
cd mcp-server
npm install
npm run build

🛠️ Lokale Entwicklung

Um den Entwicklungsserver lokal auszuführen, starten Sie ihn mit:

npm run dev

Der Server ist dann unter http://localhost:3000 erreichbar ⚡️

🧪 Tests ausführen

# Run the server in test mode
npm run start:test

# then run tests
npm test

🚀 Bereitstellung

Stellen Sie Ihre eigene Instanz dieses MCP-Servers bei einem beliebigen Cloud-Hosting-Dienst Ihrer Wahl bereit.

🐳 Docker

Das Projekt enthält ein Dockerfile für eine einfache containerisierte Bereitstellung.

docker build -t membrane-mcp-server .
docker run -p 3000:3000 membrane-mcp-server

🔗 Verbindung zum MCP-Server

Dieser MCP-Server unterstützt zwei Transportarten:

Transport	Endpunkt	Status
SSE (Server‑Sent Events)	/sse	🔴 Veraltet — veraltet seit 5. November 2024 in der MCP-Spezifikation
HTTP (Streamable HTTP)	/mcp	🟢 Empfohlen — ersetzt SSE und unterstützt bidirektionales Streaming

🔐 Authentifizierung

Geben Sie ein Membrane-Zugriffstoken über die Abfrage oder den Authorization-Header an:

?token=ACCESS_TOKEN
Authorization: Bearer ACCESS_TOKEN

SSE (Veraltet)

await client.connect(
  new SSEClientTransport(
    new URL(
      `https://<HOSTED_MCP_SERVER_URL>/sse`
    )
    {
      requestInit: {
        headers: {
          Authorization: `Bearer ${ACCESS_TOKEN}`,
        },
      },
    }
  )
);

Streamable HTTP (Empfohlen)

await client.connect(
  new StreamableHTTPClientTransport(
    new URL(`https://<HOSTED_MCP_SERVER_URL>/mcp`)
    {
      requestInit: {
        headers: {
          Authorization: `Bearer ${ACCESS_TOKEN}`,
        },
      },
    }
  )
);

⚡ Statischer vs. dynamischer Modus

Standardmäßig läuft der MCP-Server im statischen Modus, was bedeutet, dass er alle verfügbaren Werkzeuge (Aktionen) für alle verbundenen Integrationen zurückgibt.

Im dynamischen Modus (?mode=dynamic) gibt der Server nur ein Werkzeug zurück: enable-tools. Mit diesem Werkzeug können Sie gezielt die Werkzeuge aktivieren, die Sie für diese Sitzung tatsächlich benötigen.

Im dynamischen Modus sollte Ihre Implementierung herausfinden, welche Werkzeuge für die Anfrage des Benutzers am relevantesten sind. Sobald Sie diese identifiziert haben, fordern Sie das LLM auf, das enable-tools-Werkzeug mit der entsprechenden Liste aufzurufen.

Möchten Sie sehen, wie das in der Praxis funktioniert? Sehen Sie sich unser KI-Agenten-Beispiel an.

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

const client = new Client({
  name: 'example-membrane-mcp-client',
  version: '1.0.0',
});

const transport = new StreamableHTTPClientTransport(
  new URL(`https://<HOSTED_MCP_SERVER_URL>/mcp?mode=dynamic`),
  {
    requestInit: {
      headers: {
        Authorization: `Bearer ${ACCESS_TOKEN}`,
      },
    },
  }
);

await client.connect(transport);

await client.callTool({
  name: 'enable-tools',
  arguments: {
    tools: ['gmail-send-email', 'gmail-read-email'],
  },
});

🔧 Werkzeuge für bestimmte Integrationen abrufen

Im statischen Modus ruft der MCP-Server Werkzeuge von allen aktiven Verbindungen ab, die mit dem bereitgestellten Token verknüpft sind.

Sie können festlegen, dass nur Werkzeuge für eine bestimmte Integration abgerufen werden, indem Sie den Abfrageparameter apps übergeben: /mcp?apps=google-calendar,google-docs

💬 Chat-Sitzungsverwaltung (Experimentell)

Der MCP-Server (nur Streamable-HTTP-Transport) unterstützt persistente Chat-Sitzungen. Fügen Sie einen x-chat-id-Header in Ihre Anfragen ein, um Sitzungen für diesen spezifischen Chat automatisch zu verfolgen. Dies ist eine experimentelle Funktion, die wir zusätzlich zu den standardmäßigen MCP-Sitzungen anbieten.

Eine neue Chat-Sitzung starten:

POST /mcp
Authorization: Bearer YOUR_ACCESS_TOKEN
x-chat-id: my-awesome-chat-123

Ihre Chat-Sitzungen abrufen:

GET /mcp/sessions
Authorization: Bearer YOUR_ACCESS_TOKEN

Antwort:

{
  "my-awesome-chat-123": "session-uuid-1",
  "another-chat-456": "session-uuid-2"
}

Diese Funktion ermöglicht es Ihnen, dieselbe Sitzung für eine Konversation zu verwenden. Sehen Sie sich unser KI-Agenten-Beispiel an, um zu sehen, wie das in der Praxis funktioniert.

Andere MCP-Clients konfigurieren

📝 Cursor

Um diesen Server mit Cursor zu verwenden, aktualisieren Sie die ~/.cursor/mcp.json-Datei:

{
  "mcpServers": {
    "membrane": {
      "url": "https://<HOSTED_MCP_SERVER_URL>/sse?token={ACCESS_TOKEN}"
    }
  }
}

Starten Sie Cursor neu, damit die Änderungen wirksam werden.

🤖 Claude Desktop

Um diesen Server mit Claude zu verwenden, aktualisieren Sie die Konfigurationsdatei (Einstellungen > Entwickler > Konfiguration bearbeiten):

{
  "mcpServers": {
    "membrane": {
      "url": "https://<HOSTED_MCP_SERVER_URL>/sse?token={ACCESS_TOKEN}"
    }
  }
}

🔧 Fehlerbehebung

• Stellen Sie sicher, dass Ihr Zugriffstoken gültig ist und Sie es gemäß dieser Anleitung generieren.
• Überprüfen Sie die Protokolle des MCP-Servers auf Fehler oder Probleme beim Start oder bei Verbindungsversuchen.
• Verwenden Sie den MCP Inspector zum Testen und Debuggen.