Integration App MCP Server for Membrane Integrations

Overview

The Integration App MCP Server is a Model Context Protocol (MCP) server implementation designed to surface actions (tools) from Membrane-connected integrations as callable tools for LLM agents and other MCP clients. It lets you expose integration-specific operations (for example: send email, create calendar events, read docs) over a single MCP endpoint so AI agents can discover and invoke them programmatically.

This server supports modern streamable HTTP transport for bidirectional streaming and a deprecated SSE transport (kept for backward compatibility). It includes features for static and dynamic tool discovery, optional per-chat persistent sessions, and simple authentication via Membrane access tokens—making it straightforward to integrate with agent frameworks and to host in your infrastructure.

Features

• Exposes tools/actions from all active Membrane connections for an access token
• Streamable HTTP transport (recommended) with bidirectional streaming
• SSE transport (deprecated in MCP spec) still supported for legacy clients
• Static mode: return all available tools for a session
• Dynamic mode: return only an enable-tools tool to selectively enable tools on demand
• Optional apps query to limit tools to specific integrations
• Experimental persistent chat sessions via x-chat-id header (streamable HTTP only)
• Dockerfile for containerized deployment and standard Node.js development workflow

Installation / Configuration

Prerequisites:

• Node.js v18+
• Membrane account and access token

Clone, install, build:

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

Run locally (development):

npm run dev
# Server runs at http://localhost:3000 by default

Run tests:

npm run start:test
npm test

Docker:

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

Transports

Authentication: pass a Membrane access token either as a query parameter (?token=ACCESS_TOKEN) or via Authorization: Bearer ACCESS_TOKEN header.

Example: Streamable HTTP client connect (Node):

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

const client = new Client({ name: 'example', version: '1.0.0' });
const transport = new StreamableHTTPClientTransport(
  new URL('https://<HOSTED_MCP_SERVER_URL>/mcp'),
  {
    requestInit: {
      headers: { Authorization: `Bearer ${ACCESS_TOKEN}` },
    },
  }
);

await client.connect(transport);

Static vs Dynamic Mode

• Static mode (default): server returns all available tools for connections associated with the provided token.
• Dynamic mode (?mode=dynamic): server returns a single enable-tools tool. Use this to enable only the tools relevant to the current session.

Example: request dynamic mode and then enable specific tools:

// connect to /mcp?mode=dynamic, then call:
await client.callTool({
  name: 'enable-tools',
  arguments: { tools: ['gmail-send-email', 'google-calendar-create-event'] },
});

Available Tools / Resources

The actual set of tools depends on the connected integrations for the access token — each active connection on Membrane maps to one or more tools. Typical examples:

• gmail-send-email
• gmail-read-email
• google-calendar-create-event
• google-docs-create
• slack-post-message

Use the apps query param to limit tool discovery to specific integrations:

GET /mcp?apps=google-calendar,google-docs

Chat Session Management (Experimental)

For streamable HTTP, the server can maintain a persistent chat session keyed by an x-chat-id header. This ties multiple MCP requests to the same session:

Start/continue session:

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

List sessions:

GET /mcp/sessions
Authorization: Bearer YOUR_ACCESS_TOKEN

Response maps chat IDs to internal session UUIDs:

{
  "my-chat-123": "session-uuid-1"
}

Use Cases

• AI assistants that need to call third-party app actions (send emails, schedule meetings, post Slack messages) without custom plumbing for each API.
• Agent orchestration where tool availability is controlled dynamically per user/session (dynamic mode + enable-tools).
• Multi-tenant MCP hosting where a single MCP server surfaces tools for different user tokens and connected apps.
• Local development and testing of agent workflows using the provided Dockerfile and dev server.

Available Resources

• GitHub: https://github.com/integration-app/mcp-server
• Membrane MCP spec: https://modelcontextprotocol.io/introduction
• Example agent using this server: refer to the AI Agent Example in Membrane repositories

If you’re new to MCP, start by running the server locally, connect an MCP client using streamable HTTP, try both static and dynamic modes, and experiment with enabling tools for a focused agent workflow.