Make.com MCP Server — Build & Deploy Automation Scenarios with AI

⚠️ Disclaimer: This is an unofficial, community-driven project created by a passionate fan of Make.com. It is NOT affiliated with, endorsed by, or officially supported by Make.com.

A Model Context Protocol (MCP) server that gives AI assistants like Claude, GitHub Copilot, and Cursor full access to Make.com module documentation, scenario validation, and one-click deployment. Search 200+ automation modules across 40+ apps, build blueprints with auto-healing, and deploy directly to Make.com — all from your AI chat.

Features

• 🔍 200+ Modules — Full-text search across 200+ Make.com modules (Slack, Gmail, Google Sheets, Notion, OpenAI, and 35+ more apps)
• 📋 Module Details — Retrieve parameters, types, descriptions, and usage docs for any module
• ✅ Blueprint Validation — Check scenarios for missing parameters, unknown modules, structural issues, and router sub-routes before deploying
• 🛡️ Account-Aware Compatibility — Verify module IDs against your live Make account/region before deployment to prevent "Module not found" scenarios
• 🚀 Deploy to Make.com — Push validated blueprints directly to Make.com via API
• 🩹 Auto-Healing — Automatically fixes LLM-generated blueprints: injects missing metadata, adds designer coordinates, strips unsupported properties like router filter
• 🔀 Router Support — Full support for builtin:BasicRouter with multiple routes and recursive validation
• 📚 Scenario Templates — Browse reusable scenario templates for common workflows
• 📖 Guided Prompts — MCP prompts for guided scenario building and module exploration
• 📊 Resource Catalog — MCP resources for browsing available apps
• 🧪 43 Tests — Unit + integration test suite with Vitest
• ⚡ Fast Response — Optimized SQLite with FTS5 full-text search

🚀 Quick Start — Self-Hosting Options

Option A: npx (No Installation Needed!) 🚀

The fastest way to get started — no cloning, no building:

Prerequisites: Node.js installed on your system

# Run directly — no installation needed!
npx -y make-mcp-server

The package includes a pre-built database with all 200+ Make.com modules. Just add it to your MCP client config and go.

Claude Desktop config (claude_desktop_config.json):

Basic configuration (documentation tools only):

{
  "mcpServers": {
    "make-mcp-server": {
      "command": "npx",
      "args": ["-y", "make-mcp-server"],
      "env": {
        "LOG_LEVEL": "error"
      }
    }
  }
}

Full configuration (with Make.com deployment):

{
  "mcpServers": {
    "make-mcp-server": {
      "command": "npx",
      "args": ["-y", "make-mcp-server"],
      "env": {
        "LOG_LEVEL": "error",
        "MAKE_API_KEY": "your_api_key_here",
        "MAKE_TEAM_ID": "your_team_id",
        "MAKE_API_URL": "https://eu1.make.com/api/v2"
      }
    }
  }
}

Note: npx will download and cache the latest version automatically. The package includes a pre-built database with all Make.com module information — no setup required.

Option B: Docker (Isolated & Reproducible) 🐳

Prerequisites: Docker installed on your system

# Build the Docker image
docker build -t make-mcp-server .

# Test it works
echo '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"0.1"}},"id":1}' | docker run -i --rm make-mcp-server

Claude Desktop config:

Basic configuration (documentation tools only):

{
  "mcpServers": {
    "make-mcp-server": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm", "--init",
        "-e", "LOG_LEVEL=error",
        "make-mcp-server"
      ]
    }
  }
}

Full configuration (with Make.com deployment):

{
  "mcpServers": {
    "make-mcp-server": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm", "--init",
        "-e", "LOG_LEVEL=error",
        "-e", "MAKE_API_KEY=your_api_key_here",
        "-e", "MAKE_TEAM_ID=your_team_id",
        "-e", "MAKE_API_URL=https://eu1.make.com/api/v2",
        "make-mcp-server"
      ]
    }
  }
}

Important: The -i flag is required for MCP stdio communication.

Option C: Local Installation (For Development) 🛠️

Prerequisites: Node.js and Git

# 1. Clone and install
git clone https://github.com/danishashko/make-mcp.git
cd make-mcp
npm install

# 2. Build
npm run build

# 3. Populate the module database (already done if using npm package)
npm run scrape:prod

# 4. Test it works
npm start

Claude Desktop config:

{
  "mcpServers": {
    "make-mcp-server": {
      "command": "node",
      "args": ["/absolute/path/to/make-mcp/dist/mcp/server.js"],
      "env": {
        "LOG_LEVEL": "error",
        "MAKE_API_KEY": "your_api_key_here",
        "MAKE_TEAM_ID": "your_team_id"
      }
    }
  }
}

Note: The Make.com API credentials are optional. Without them, you'll have access to all documentation, search, and validation tools. With them, you'll additionally get scenario deployment capabilities.

Configuration File Locations

Restart Claude Desktop after updating configuration.

💻 Connect Your IDE

make-mcp-server works with any MCP-compatible client:

• Claude Desktop — See configurations above
• VS Code (GitHub Copilot) — Add to .vscode/mcp.json
• Cursor — Add to MCP settings
• Claude Code — Use claude mcp add command
• Windsurf — Add to MCP configuration

Usage

Then ask your AI assistant things like:

"Create a Make scenario that watches a Slack channel for new messages and logs them to a Google Sheet"

"What modules does Make have for sending emails?"

"Validate this scenario blueprint..."

Tip: The AI will automatically call tools_documentation first to understand how to use the server effectively.

Available Tools

Auto-Healing

The create_scenario tool automatically fixes common issues in LLM-generated blueprints:

Tip: Do NOT hardcode "version": 1 on modules. Some apps (e.g., HTTP) are on v4+ and specifying the wrong version causes "Module not found" errors.

MCP Prompts

MCP Resources

CLI Usage

make-mcp-server              # Start the MCP server (stdio transport)
make-mcp-server --scrape     # Populate/refresh the module database
make-mcp-server --version    # Print version
make-mcp-server --help       # Show help

Environment Variables

Development

npm run build         # Compile TypeScript + copy schema + add shebang
npm run build:tsc     # TypeScript only (no packaging)
npm run start:dev     # Start with tsx (no build needed)
npm run dev           # Start with file watching
npm run scrape        # Populate DB with tsx (dev)
npm run scrape:prod   # Populate DB from compiled JS
npm run smoke:compat  # One-command account compatibility + validation smoke check
npm test              # Run all 43 tests
npm run test:watch    # Run tests in watch mode

Publishing to npm

npm run prepublishOnly   # Build + populate DB + verify (runs automatically on npm publish)
npm publish              # Publish to npm registry

Testing

The test suite includes 43 tests across 3 files:

• Database tests (14 tests) — Insert, search, template operations, FTS5 queries
• Logger tests (7 tests) — Stderr-only output, log levels, data serialization
• Server integration tests (22 tests) — Full MCP protocol compliance via SDK client

npm test

Fast Verification (2-3 minutes)

Use this when you just changed validation/deploy logic and want confidence quickly:

# 1) Fast regression check
npm test

# 2) One-command smoke check (compatibility + validation)
npm run smoke:compat

# 3) (Optional) Manual MCP exploration
npm run start:dev

Then in your MCP client (Claude/Cursor/Copilot), run this sequence:

1. check_account_compatibility with a known module, e.g. gateway:CustomWebHook
2. validate_scenario with your blueprint
3. create_scenario only if compatibility is good

If step 1 reports incompatible modules, use the suggested replacement IDs before deploying.

Architecture

src/
├── mcp/
│   └── server.ts          # MCP server with tools, prompts, resources
├── database/
│   ├── schema.sql         # SQLite + FTS5 schema
│   └── db.ts              # Database access layer (npx-safe path resolution)
├── scrapers/
│   └── scrape-modules.ts  # Module data population (224 modules)
└── utils/
    └── logger.ts          # Structured stderr-only logger
bin/
├── make-mcp.js            # CLI entry point (npx, --help, --version, --scrape)
└── postinstall.js         # Post-install verification
scripts/
├── build.js               # Build: tsc + copy schema + add shebang
├── prepublish.js          # Publish prep: build + populate DB + verify
└── smoke-compat.js        # Fast local smoke test for module compatibility + validation
data/
└── make-modules.db        # Pre-built SQLite database (bundled in npm package)
tests/
├── database.test.ts       # Database unit tests (14)
├── logger.test.ts         # Logger unit tests (7)
└── server.test.ts         # MCP integration tests (22)
Dockerfile                 # Multi-stage Docker image

Tech Stack

• TypeScript + Node.js (ESM)
• @modelcontextprotocol/sdk v1.26.0 — MCP protocol implementation
• better-sqlite3 — Synchronous SQLite with FTS5 full-text search
• zod — Schema validation for tool parameters
• axios — HTTP client for Make.com API
• vitest — Test framework

Supported Apps (40+)

Google Sheets, Slack, OpenAI, Google Drive, Notion, Telegram Bot, HubSpot CRM, Gmail, Airtable, Tools, Flow Control, Google Calendar, Jira, Trello, Shopify, Google Docs, Microsoft Teams, Microsoft Outlook, Discord, Asana, monday.com, Salesforce, Stripe, GitHub, HTTP, Mailchimp, WordPress, Dropbox, Data Store, JSON, Twilio, Google Gemini AI, WhatsApp Business, Text Parser, Webhooks, Anthropic Claude, CSV, RSS, Email, Schedule

Author

Built by Daniel Shashko

License

MIT License — see LICENSE for details.