Integration App MCP Server

Serveur MCP Membrane

Le serveur MCP Membrane est un serveur Model Context Protocol (MCP), il fournit des actions pour les intégrations connectées sur Membrane sous forme d'outils.

Voici notre exemple d'agent IA officiel qui vous montre comment utiliser ce serveur MCP dans votre application.

📋 Prérequis

• Node.js (v18 ou supérieur)
• Un compte Membrane

⚙️ Installation

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

🛠️ Développement local

Pour exécuter le serveur de développement en local, démarrez-le avec :

npm run dev

Le serveur sera accessible à l'adresse http://localhost:3000 ⚡️

🧪 Exécution des tests

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

# then run tests
npm test

🚀 Déploiement

Déployez votre propre instance de ce serveur MCP sur le service d'hébergement cloud de votre choix.

🐳 Docker

Le projet inclut un Dockerfile pour un déploiement conteneurisé facile.

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

🔗 Connexion au serveur MCP

Ce serveur MCP prend en charge deux transports :

Transport	Point de terminaison	Statut
SSE (Server‑Sent Events)	/sse	🔴 Obsolète — obsolète depuis le 5 novembre 2024 dans la spécification MCP
HTTP (HTTP streamable)	/mcp	🟢 Recommandé — remplace SSE et prend en charge le streaming bidirectionnel

🔐 Authentification

Fournissez un jeton d'accès Membrane via la requête ou l'en-tête Authorization :

?token=ACCESS_TOKEN
Authorization: Bearer ACCESS_TOKEN

SSE (Obsolète)

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

HTTP streamable (Recommandé)

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

⚡ Mode statique vs dynamique

Par défaut, le serveur MCP fonctionne en mode statique, ce qui signifie qu'il renvoie tous les outils disponibles (actions) pour toutes les intégrations connectées.

Avec le mode dynamique (?mode=dynamic), le serveur ne renverra qu'un seul outil : enable-tools. Vous pouvez utiliser cet outil pour activer sélectivement les outils dont vous avez réellement besoin pour cette session.

En mode dynamique, votre implémentation doit déterminer quels outils sont les plus pertinents pour la requête de l'utilisateur. Une fois que vous les avez identifiés, invitez le LLM à appeler l'outil enable-tools avec la liste appropriée.

Vous voulez voir comment cela fonctionne en pratique ? Consultez notre exemple d'agent IA.

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'],
  },
});

🔧 Obtenir les outils pour des intégrations spécifiques

En mode statique, le serveur MCP récupère les outils de toutes les connexions actives associées au jeton fourni.

Vous pouvez choisir de ne récupérer les outils que pour une intégration spécifique en passant le paramètre de requête apps : /mcp?apps=google-calendar,google-docs

💬 Gestion des sessions de chat (Expérimental)

Le serveur MCP (transport HTTP streamable uniquement) prend en charge les sessions de chat persistantes. Incluez un en-tête x-chat-id dans vos requêtes pour suivre automatiquement les sessions pour ce chat spécifique. Il s'agit d'une fonctionnalité expérimentale que nous fournissons en complément des sessions MCP standard.

Démarrer une nouvelle session de chat :

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

Récupérer vos sessions de chat :

GET /mcp/sessions
Authorization: Bearer YOUR_ACCESS_TOKEN

Réponse :

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

Cette fonctionnalité vous permet d'utiliser la même session pour une conversation. Consultez notre exemple d'agent IA pour voir comment cela fonctionne en pratique.

Configuration d'autres clients MCP

📝 Cursor

Pour utiliser ce serveur avec Cursor, mettez à jour le fichier ~/.cursor/mcp.json :

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

Redémarrez Cursor pour que les modifications prennent effet.

🤖 Claude Desktop

Pour utiliser ce serveur avec Claude, mettez à jour le fichier de configuration (Paramètres > Développeur > Modifier la configuration) :

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

🔧 Dépannage

• Assurez-vous que votre jeton d'accès est valide et que vous le générez conformément à ces instructions
• Vérifiez les journaux du serveur MCP pour toute erreur ou problème lors du démarrage ou des tentatives de connexion.
• Utilisez l'Inspecteur MCP pour les tests et le débogage