n8n MCP Server: Connect Your AI Agent to Any Tool

🔌 In 2026, the Model Context Protocol (MCP) changed how AI agents interact with the world. Instead of writing custom code for every integration, MCP provides a universal language for AI agents to discover and call external tools. And n8n is now one of the best platforms to build an MCP server.

In this guide, I'll walk you through the entire process – from understanding what MCP is, to building the server workflow, connecting it to Claude Desktop, and securing it for production. You'll also get a complete, downloadable JSON workflow that you can import and run immediately.

Why this guide is different: Most articles stop at the basic "here's a workflow" stage. I'll show you how to deploy this in production, handle errors, scale to dozens of workflows, and secure your server against unauthorised access. These are the exact patterns I use in my own n8n deployments for enterprise clients.

Figure 1: MCP provides a standardised layer between AI agents and external tools – n8n is the perfect MCP server.

1. What is MCP and Why Does It Matter?

The Model Context Protocol (MCP) is an open standard that allows AI agents to interact with external tools and data sources through a unified interface. Think of it as a USB‑C port for AI – instead of building a custom adapter for every tool, you build one MCP server that exposes all your tools through a consistent API.

In the context of n8n, MCP enables:

• Tool discovery – AI agents can ask "what can you do?" and get a list of available workflows with their input schemas.
• Parameter validation – The agent knows exactly what input each workflow expects, including required fields, data types, and descriptions.
• Execution management – The agent can run workflows and get structured results back, including success/failure status and execution details.
• Persistent connections – Using Server‑Sent Events (SSE) for real‑time communication and long‑running workflows.

Why is this a game‑changer? Before MCP, integrating an AI agent with n8n meant building custom webhook endpoints for every workflow, hard‑coding authentication and parameter formats, writing custom error handling, and having no standard way for the agent to discover what workflows exist. MCP solves all of these problems in one protocol.

MCP vs. Webhooks: Key Differences

"MCP is the protocol that makes AI agents truly useful in production. Instead of hard‑coding every possible action, you expose a set of capabilities and let the agent decide which ones to use. This is the pattern that scales." — From a production deployment serving 100+ AI agents across 15+ n8n instances

2. MCP Server Architecture in n8n

The n8n MCP Server pattern is built around one rule that trips up almost everyone the first time: the MCP Server Trigger node does not behave like a normal trigger. A normal trigger starts a workflow and passes data forward through "main" connections. The MCP Server Trigger only connects to Tool nodes — it does not run a linear chain of nodes itself. Whatever tools you attach to it are exactly the tools an AI agent will see and be able to call. Let's break down the five core components of a production‑ready setup:

2.1 The MCP Server Trigger

The MCP Server Trigger node is the entry point for all MCP traffic. It exposes a test URL and a production URL that MCP clients connect to, handles the MCP protocol handshake, and lets a connected client list and call whatever Tool nodes you've attached to it. This node is available from n8n v1.88.0 onward and supports both Server‑Sent Events (SSE) and streamable HTTP — it does not support stdio transport.

2.2 Exposing a Single Workflow as a Tool

The simplest pattern: attach a Custom n8n Workflow Tool node directly to the MCP Server Trigger. This node calls a specific workflow (which must start with a Subworkflow / Execute Workflow Trigger and have its Input Schema defined) and returns the result. This is enough if you only want to expose one or two workflows.

2.3 Exposing Many Workflows ("Available Workflows" Pattern)

If you want to expose dozens of workflows without hard‑coding a Tool node for each one, use n8n's official multi‑tool pattern: tag every workflow you want to expose (e.g., "mcp"), then attach four or five small helper tools to the MCP Server Trigger — search workflows, list available workflows, add to available, remove from available, and execute. The search/list tools internally use the built‑in n8n node (Core Nodes → n8n, Resource: Workflow) to query your instance for tagged workflows, while the add/remove/list tools use a Redis node as lightweight, fast memory for which workflows the agent has currently marked "available." The agent decides for itself which workflows to activate before using them — you are not manually wiring a Redis step into a single linear chain.

2.4 The Tool Execution Layer

Execution happens through a Subworkflow trigger with passthrough parameters: whatever the agent sends as input is forwarded to the target workflow, run, and the result is returned to the MCP client. Input validation comes from the Subworkflow trigger's Input Schema — this is what the agent reads to know exactly what parameters a tool expects.

2.5 The MCP Client (Optional, Reverse Direction)

n8n can also act as an MCP client inside an AI Agent node, consuming tools from external MCP servers via the MCP Client Tool node. This lets one workflow orchestrate tools from several MCP servers at once, creating a federated tool ecosystem.

Figure 2: The MCP Server workflow – MCP Server Trigger, n8n discovery, Redis memory, and Execute Workflow.

3. Prerequisites & Setup

Before you build anything, make sure you have the following in place. Skipping these is the single biggest cause of failed first attempts.

• n8n v1.88.0 or higher for the per‑workflow MCP Server Trigger, or v2.18.4+ if you want the newer instance‑level MCP server covered in Section 9. Check your version under Settings → About.
• An n8n API key (Settings → API → Create API Key) if you plan to use the "search/list available workflows" tools, since they query your instance via the n8n node.
• A Redis instance (self‑hosted, Redis Cloud, or Upstash) only if you're using the multi‑workflow "available pool" pattern from Section 2.3. A single‑workflow setup with one Custom n8n Workflow Tool node doesn't need Redis at all.
• An MCP client to test with — Claude Desktop, Cursor, Windsurf, or ChatGPT with MCP support.
• HTTPS on your production n8n URL. MCP clients connecting over SSE/streamable HTTP will refuse plain HTTP in most setups.

4. Step‑by‑Step Build Guide

Now let's build the MCP server workflow. I'll walk you through each step with exact node configurations and code examples.

Path: /mcp (auto-generated, can be customised)
Authentication: Bearer token (recommended for production)
Transport: SSE / Streamable HTTP (stdio is not supported)

After publishing, copy the Production URL from the node panel.
It will look like: https://your-n8n-instance.com/mcp/your-path

// Operation: SET
// Key: available_workflows:{{ $json.sessionId }}
// Value: {{ $json.workflowId }}  (appended to a Redis list)
// Expire: 3600  (1 hour – adjust as needed)

// Credentials: your Redis connection
// Host: your-redis-host.com
// Port: 6379
// Password: YOUR_REDIS_PASSWORD (if applicable)

5. Connect an MCP Client (Claude Desktop)

Once your MCP Server is running, you can connect any MCP client to it. Here's how to configure Claude Desktop – the most popular MCP client in 2026.

Claude Desktop Configuration

Edit your Claude Desktop configuration file. On macOS, it's located at:

Add the n8n MCP server configuration:

{
  "mcpServers": {
    "n8n-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "MCP_MODE=stdio",
        "-e", "LOG_LEVEL=error",
        "-e", "DISABLE_CONSOLE_OUTPUT=true",
        "-e", "N8N_API_URL=https://your-n8n-instance.com",
        "-e", "N8N_API_KEY=your-api-key-here",
        "ghcr.io/czlonkowski/n8n-mcp:latest"
      ]
    }
  }
}

If you prefer not to use Docker, you can connect directly to the n8n MCP Server URL (SSE endpoint) using the MCP Client Tool node inside n8n itself. This allows you to orchestrate multiple MCP servers in a single workflow.

6. Security & Best Practices

Exposing your n8n instance to AI agents introduces significant security considerations. Here's how to protect your MCP server.

6.1 Authentication

MCP supports Bearer tokens, custom headers, and OAuth2. Always enable authentication on your MCP Server. The n8n MCP Server Trigger node can be configured with authentication requirements – add a Bearer token that clients must provide.

6.2 Tag‑Based Access Control

Only expose workflows tagged with a specific label (e.g., "mcp"). This prevents the agent from accidentally discovering and executing sensitive workflows like credential management or data deletion. Never expose workflows that handle passwords, API keys, or personal data.

6.3 Input Validation

Ensure every exposed workflow validates its input parameters. The Subworkflow trigger's input schema is the first line of defence. Add additional validation inside the workflow using Code nodes or IF nodes – check that email addresses are valid, that numbers are within range, and that required fields are provided.

6.4 Audit Logging

Enable n8n's execution history to track every time an agent executes a workflow. This gives you visibility into what the agent is doing, which tools it's using, and which parameters it's sending. You can also log to Google Sheets or a database for long‑term auditing.

6.5 Production Deployment Checklist

• Use HTTPS – Never expose MCP over HTTP in production.
• Use a reverse proxy – Nginx or Caddy should handle SSL termination.
• Rate limiting – Implement rate limiting on your MCP endpoint to prevent abuse.
• Monitor usage – Track which workflows are executed and by which agents.
• Regular audits – Review exposed workflows monthly and remove unused ones.

7. Common Errors & Fixes

After deploying this on multiple production environments, I've seen the same errors repeatedly. Here are the exact fixes:

8. Scaling & Optimization

As you add more workflows to your MCP server, performance can degrade. Here's how to scale:

8.1 Caching Strategies

The n8n discovery node queries your entire n8n instance for tagged workflows. For large instances (50+ workflows), this query can become slow. Use Redis to cache the discovery results – set a TTL of 60 seconds so the cache refreshes periodically without overloading the n8n API.

8.2 Batch Discovery

If you're using the MCP client to discover workflows, batch the discovery requests. Instead of querying one workflow at a time, the agent should discover all available workflows in a single request.

8.3 Redis Memory Management

Redis stores the entire list of available workflows. For large lists (100+ workflows), consider compressing the data or using a more efficient serialization format like MessagePack instead of JSON.

9. 2026 Update: The New Instance‑Level MCP Server

In April 2026, n8n shipped something that changes this whole picture: a first‑party, instance‑level MCP server built directly into n8n (Cloud, Enterprise, and self‑hosted Community Edition, v2.18.4+). This is different from everything covered in Sections 2–8, and it's worth understanding before you commit to a workflow‑based setup.

To use it: an instance owner or admin enables MCP access in Settings, then toggles Available in MCP on each workflow you want exposed (individually, or in bulk per project/folder). Any connected MCP client — Claude Desktop, ChatGPT, Cursor — can then call search_workflows, get_workflow, execute_workflow, and related tools across every enabled workflow, without you building a single custom node.

Which should you use? If you want an AI agent to browse and run a growing library of workflows with minimal setup, the instance‑level server is faster to stand up and is now n8n's recommended default. If you need a tightly curated, single‑purpose set of tools — or you're on an n8n version below 2.18.4 — the MCP Server Trigger pattern from Sections 2–8 still applies and gives you finer control over exactly what's exposed.

10. Complete Workflow JSON

Below is the full MCP Server workflow JSON. Import it into n8n (Workflows → Import from File). Replace the placeholders for your n8n API key, Redis connection, and production URL.

{
  "name": "n8n MCP Server – Expose Workflows as Tools",
  "nodes": [
    {
      "parameters": {
        "path": "mcp",
        "authentication": "bearerAuth",
        "options": {}
      },
      "id": "mcp-trigger",
      "name": "MCP Server Trigger",
      "type": "@n8n/n8n-nodes-langchain.mcpTrigger",
      "typeVersion": 1,
      "position": [400, 300]
    },
    {
      "parameters": {
        "resource": "workflow",
        "operation": "getAll",
        "returnAll": true,
        "filters": { "tags": ["mcp"] },
        "descriptionType": "manual",
        "toolDescription": "Search for workflows tagged 'mcp' that are available to use as tools."
      },
      "id": "search-tool",
      "name": "Search Workflows (Tool)",
      "type": "n8n-nodes-base.n8nTool",
      "typeVersion": 1,
      "position": [250, 500],
      "credentials": { "n8nApi": { "id": "YOUR_N8N_API_CREDENTIAL_ID" } }
    },
    {
      "parameters": {
        "operation": "set",
        "key": "=available_workflows:{{ $json.sessionId }}",
        "value": "={{ $json.workflowId }}",
        "expire": 3600,
        "descriptionType": "manual",
        "toolDescription": "Add a workflow ID to this session's list of available tools."
      },
      "id": "add-available-tool",
      "name": "Add to Available (Tool)",
      "type": "n8n-nodes-base.redisTool",
      "typeVersion": 1,
      "position": [450, 500],
      "credentials": { "redis": { "id": "YOUR_REDIS_CREDENTIAL_ID" } }
    },
    {
      "parameters": {
        "source": "database",
        "workflowId": "={{ $json.selectedWorkflowId }}",
        "waitForSubWorkflow": true
      },
      "id": "execute-tool",
      "name": "Execute Workflow (Tool)",
      "type": "n8n-nodes-base.executeWorkflowTool",
      "typeVersion": 1,
      "position": [650, 500]
    }
  ],
  "connections": {
    "MCP Server Trigger": {
      "ai_tool": [
        [
          { "node": "Search Workflows (Tool)", "type": "ai_tool", "index": 0 },
          { "node": "Add to Available (Tool)", "type": "ai_tool", "index": 0 },
          { "node": "Execute Workflow (Tool)", "type": "ai_tool", "index": 0 }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1",
    "saveManualExecutions": true,
    "executionTimeout": 120
  }
}

11. Frequently Asked Questions