Troubleshooting Integration Between Make and Claude via Model Context Protocol (MCP)

Issue Synopsis

I have been attempting to construct a functional bridge between the Make automation platform (previously known as Integromat) and the Claude Desktop application utilizing the specified Model Context Protocol (MCP). Despite extensive iterative development and configuration adjustments across multiple attempts, establishing a reliable communication channel remains unsuccessful.

Development Efforts Undertaken

1. Custom MCP Server Construction: Built a dedicated Node.js server designed specifically to interface with Make, incorporating:
2. Integration logic to interface with the Make API.
3. A WebSocket listener tailored for connection with Claude Desktop.
4. Adherence to the JSON-RPC 2.0 specification as mandated by the MCP framework.

5. Utility functions for managing Make scenarios.

6. Configuration Variations Tested: Explored numerous operational setups:

7. Iterating through various network ports (3000, 3001, 3333, 5555).
8. Alternating communication methods (RESTful endpoints versus dedicated WebSockets).
9. Adjusting parameters within the claude_desktop_config.json manifest.
10. Testing both autonomous startup scripts and manual server initiation.

Obstacles Encountered

1. Port Contention: Discovered that Claude Desktop attempts to self-initialize a local server instance, leading to binding conflicts on shared ports:

Error: listen EADDRINUSE: address already in use :::3001

1. Protocol Handshake Failure: Despite correct JSON-RPC 2.0 implementation on the adapter, Claude repeatedly reported disconnection, suggesting a protocol mismatch:

Server disconnected. For troubleshooting guidance, please visit our debugging documentation

and

Could not attach to MCP server make

1. Serialization Mismatch: Server logs indicated that Claude requires a specific message payload structure that is difficult to replicate without explicit protocol documentation:

Message from client: {"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"claude-ai","version":"0.1.0"}},"jsonrpc":"2.0","id":0}

Visual Evidence

Connection Failure Indicator within Claude Desktop

Errors Logged by the Custom Server

Environment Variable Configuration Snippet

Core Adapter Source Code

The primary implementation for the Make MCP interfacing service:

javascript const express = require('express'); const WebSocket = require('ws'); const http = require('http'); const axios = require('axios'); const dotenv = require('dotenv');

// Load environment variables from .env file dotenv.config();

const PORT = process.env.PORT || 5555; const MAKE_API_TOKEN = process.env.MAKE_API_TOKEN;

// Initialize Express application instance const app = express(); const server = http.createServer(app); const wss = new WebSocket.Server({ server });

// WebSocket Connection Handling Logic wss.on('connection', (ws) => { console.log('New WebSocket session established');

ws.on('message', (message) => { try { const data = JSON.parse(message); console.log('Received payload:', data);

  // Handle initialization request payload
  if (data.method === 'initialize') {
    console.log('Processing initialization directive');
    ws.send(JSON.stringify({
      jsonrpc: "2.0",
      id: data.id,
      result: {
        serverInfo: {
          name: "simple-make-mcp-server",
          version: "1.0.0"
        },
        capabilities: {}
      }
    }));
  }
  // Handle tool listing request payload
  else if (data.method === 'tools/list') {
    console.log('Processing tools/list directive');
    ws.send(JSON.stringify({
      jsonrpc: "2.0",
      id: data.id,
      result: {
        tools: [
          {
            name: "list_scenarios",
            description: "Retrieves the complete catalog of scenarios hosted in Make"
          },
          {
            name: "run_scenario",
            description: "Executes a specified scenario within the Make ecosystem"
          }
        ]
      }
    }));
  }
  // Handle unsupported method errors
  else {
    console.log(`Unsupported method encountered: ${data.method}`);
    ws.send(JSON.stringify({
      jsonrpc: "2.0",
      id: data.id,
      error: {
        code: -32601,
        message: `Method '${data.method}' is not currently supported`
      }
    }));
  }
} catch (error) {
  console.error('Error parsing incoming message stream:', error);
}

});

ws.on('close', () => { console.log('WebSocket session terminated'); }); });

// Baseline HTTP health check endpoint app.get('/', (req, res) => { res.send('Health check OK: Make MCP Adapter Service operational'); });

// Initiate server listening sequence server.listen(PORT, () => { console.log(Make MCP Adapter is active and listening on port ${PORT}); });

Claude Desktop Configuration Attempts

Various payloads tested within the claude_desktop_config.json file, including:

"make": { "command": "node", "args": ["/Users/krzyk/google-workspace-mcp/make-mcp-server/make-mcp-server.js"], "env": { "MAKE_API_TOKEN": "[token_placeholder]", "PORT": "3001" }, "url": "ws://localhost:3001", "disabled": true }

And a simplified structure:

"make": { "disabled": true, "url": "ws://localhost:5555" }

Queries and Requests for Assistance

1. Is there access to the definitive technical specification for the MCP protocol that details the required message formats and sequencing?

2. Has anyone in the community successfully deployed a bespoke MCP server implementation compatible with the current version of Claude Desktop?

3. Are there any nuanced or undocumented constraints regarding the WebSocket implementation or the JSON-RPC 2.0 serialization expected by the client?

4. Are there official SDKs or established libraries available that simplify the creation of compliant MCP adapter instances?

Any diagnostic input or directional advice would be highly beneficial. I have briefly pivoted to evaluate n8n, which appears to possess pre-built MCP server capabilities, but resolving this specific Make integration remains the primary objective.