┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP: The USB-C Standard for AI Integration                    │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Before MCP (2023-2024):                          After MCP (2025-2026):        │
│   ┌─────────────┐    ┌─────────────┐              ┌─────────────┐              │
│   │   Claude    │───▶│  Custom     │              │   MCP       │              │
│   │             │    │  Integration│              │   Client    │              │
│   └─────────────┘    └──────┬──────┘              └──────┬──────┘              │
│                             │                           │                      │
│   ┌─────────────┐    ┌──────┴──────┐              ┌──────┴──────┐              │
│   │   GPT-4     │───▶│  Custom     │              │  MCP Server │              │
│   │             │    │  Integration│              │  (Database) │              │
│   └─────────────┘    └──────┬──────┘              └─────────────┘              │
│                             │                                                   │
│   ┌─────────────┐    ┌──────┴──────┐              ┌─────────────┐              │
│   │   Gemini    │───▶│  Custom     │              │  MCP Server │              │
│   │             │    │  Integration│              │  (Slack)    │              │
│   └─────────────┘    └─────────────┘              └─────────────┘              │
│                                                                                 │
│   Result: 10 integrations                      Result: 1 protocol, any tool    │
│   for 10 tools × 3 models                     Write once, use everywhere       │
│   = 30 custom builds                          = Universal compatibility        │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                     The MCP Security Reality Gap                               │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  Adoption Metrics:                    Security Reality:                        │
│  • 97M monthly SDK downloads          • 1,800+ servers with NO auth           │
│  • 10,000+ public servers             • OAuth remains OPTIONAL in spec          │
│  • Fortune 1000 deploying             • Many tutorials predate security       │
│  • Official backing: Anthropic,         updates                               │
│    OpenAI, Google, Microsoft          • CVE-2025-49596: RCE in reference      │
│                                                                                 │
│  The Problem: Most "production" MCP deployments follow tutorials from         │
│  October 2024—before authentication existed. They're technically               │
│  compliant but operationally insecure.                                        │
│                                                                                 │
│  Real Incidents:                                                               │
│  • May 2025: Tenant isolation flaw affected 1,000 businesses                 │
│  • September 2025: Malicious MCP server copied emails to attacker             │
│  • Q1 2026: Cross-org data contamination through misconfigured servers        │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                Production AI Architecture: MCP + n8n                            │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                        Presentation Layer                                │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │  │
│   │  │   Claude    │  │   ChatGPT   │  │   Cursor    │  │   Custom    │     │  │
│   │  │   Desktop   │  │   Desktop   │  │     IDE     │  │    Agent    │     │  │
│   │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘     │  │
│   └─────────┼────────────────┼────────────────┼────────────────┼────────────┘  │
│             │                │                │                │                 │
│             └────────────────┴────────────────┴────────────────┘                 │
│                                     │                                           │
│   ┌─────────────────────────────────┴─────────────────────────────────────────┐  │
│   │                      MCP Gateway Layer (Optional)                        │  │
│   │              • Centralized authentication                                │  │
│   │              • Policy enforcement                                        │  │
│   │              • Rate limiting                                             │  │
│   └─────────────────────────────────┬───────────────────────────────────────┘  │
│                                     │                                           │
│   ┌─────────────────────────────────▼─────────────────────────────────────────┐  │
│   │                     n8n Orchestration Layer                              │  │
│   │  ┌───────────────────────────────────────────────────────────────────┐   │  │
│   │  │  Workflow Engine                                                  │   │  │
│   │  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌───────────┐│   │  │
│   │  │  │ MCP Nodes   │  │  Auth Mgmt  │  │   Error     │  │  Human-   ││   │  │
│   │  │  │ (Tools)     │  │ (OAuth/SSO) │  │  Handling   │  │ in-Loop  ││   │  │
│   │  │  └─────────────┘  └─────────────┘  └─────────────┘  └───────────┘│   │  │
│   │  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌───────────┐│   │  │
│   │  │  │  Audit      │  │  Queue      │  │   Batch     │  │  Notify   ││   │  │
│   │  │  │  Logging    │  │  Management │  │ Processing  │  │  & Alert  ││   │  │
│   │  │  └─────────────┘  └─────────────┘  └─────────────┘  └───────────┘│   │  │
│   │  └───────────────────────────────────────────────────────────────────┘   │  │
│   └─────────────────────────────────┬─────────────────────────────────────────┘  │
│                                     │                                           │
│   ┌─────────────────────────────────▼─────────────────────────────────────────┐  │
│   │                      MCP Server Layer                                    │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │  │
│   │  │  Database   │  │    Slack    │  │   GitHub    │  │   Stripe    │     │  │
│   │  │   (Supabase)│  │             │  │             │  │             │     │  │
│   │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘     │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │  │
│   │  │    CRM      │  │     ERP     │  │    Email    │  │  Internal   │     │  │
│   │  │(Salesforce) │  │             │  │             │  │    APIs     │     │  │
│   │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘     │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# PostgreSQL Database Server
npm install -g @modelcontextprotocol/server-postgres

# Slack Integration
npm install -g @modelcontextprotocol/server-slack

# GitHub Access
npm install -g @modelcontextprotocol/server-github

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token",
        "SLACK_TEAM_ID": "T0123456789"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    }
  }
}

// Workflow: Secure MCP Gateway
// Purpose: Centralize authentication and policy enforcement

// Node 1: Webhook Trigger (receives MCP requests)
{
  "name": "MCP Request",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "https://your-n8n.com/webhook/mcp-gateway",
  "responseMode": "responseNode",
  "path": "mcp-gateway"
}

// Node 2: Authentication Verification
{
  "name": "Verify API Key",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const apiKey = $headers['x-api-key'];
    const validKeys = await getValidApiKeys(); // Fetch from secure vault
    
    if (!validKeys.includes(apiKey)) {
      throw new Error('Unauthorized: Invalid API key');
    }
    
    // Extract user context from API key
    const userContext = await getUserFromApiKey(apiKey);
    
    return [{
      json: {
        ...$json,
        user_id: userContext.id,
        user_role: userContext.role,
        permissions: userContext.permissions
      }
    }];
  `
}

// Node 3: Policy Enforcement
{
  "name": "Check Permissions",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const { user_role, permissions, mcp_server, operation } = $json;
    
    // Define permission matrix
    const permissionMatrix = {
      'postgres': {
        'read': ['developer', 'analyst', 'admin'],
        'write': ['developer', 'admin'],
        'admin': ['admin']
      },
      'slack': {
        'post': ['developer', 'manager', 'admin'],
        'read': ['developer', 'analyst', 'manager', 'admin']
      },
      'github': {
        'read': ['developer', 'analyst', 'admin'],
        'write': ['developer', 'admin']
      }
    };
    
    const requiredPerm = permissionMatrix[mcp_server]?.[operation];
    if (!requiredPerm || !requiredPerm.includes(user_role)) {
      throw new Error(\`Forbidden: \${user_role} cannot perform \${operation} on \${mcp_server}\`);
    }
    
    return [$json];
  `
}

// Node 4: Rate Limiting
{
  "name": "Check Rate Limit",
  "type": "n8n-nodes-base.redis",
  "operation": "eval",
  "script": \`
    local key = KEYS[1]
    local limit = tonumber(ARGV[1])
    local window = tonumber(ARGV[2])
    
    local current = redis.call('GET', key)
    if current == false then
      redis.call('SET', key, 1, 'EX', window)
      return {1, limit}
    end
    
    current = tonumber(current)
    if current >= limit then
      return {0, limit - current}
    end
    
    redis.call('INCR', key)
    return {1, limit - current - 1}
  \`,
  "keys": ["rate_limit:{{ $json.user_id }}:{{ $json.mcp_server }}"],
  "args": ["100", "3600"] // 100 requests per hour
}

// Node 5: Route to MCP Handler
{
  "name": "Route to Handler",
  "type": "n8n-nodes-base.switch",
  "rules": {
    "rules": [
      { "value": "={{ $json.mcp_server }}", "output": 0 },
      { "value": "={{ $json.mcp_server }}", "output": 1 },
      { "value": "={{ $json.mcp_server }}", "output": 2 }
    ]
  }
}

// Workflow: Secure Database Operations via MCP

// Node 1: PostgreSQL MCP Handler
{
  "name": "Execute Postgres Query",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "connectionString": "={{ $credentials.postgres.connectionString }}",
  "query": "={{ $json.query }}",
  "parameters": "={{ $json.parameters }}"
}

// Node 2: Comprehensive Audit Log
{
  "name": "Log Database Access",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "mcp_audit_log",
  "columns": {
    "timestamp": "={{ $now }}",
    "user_id": "={{ $json.user_id }}",
    "mcp_server": "postgres",
    "operation": "query",
    "query_hash": "={{ $crypto.md5($json.query) }}",
    "row_count": "={{ $json.row_count }}",
    "execution_time_ms": "={{ $json.execution_time }}",
    "client_ip": "={{ $headers['x-forwarded-for'] }}",
    "request_id": "={{ $execution.id }}"
  }
}

// Node 3: PII Detection and Alerting
{
  "name": "Detect Sensitive Data",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const sensitivePatterns = [
      /\\b\\d{3}-\\d{2}-\\d{4}\\b/g, // SSN
      /\\b\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}\\b/g, // Credit cards
      /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b/g, // Emails
      /\\b(?:\\+?1[-.\\s]?)?\\(?[0-9]{3}\\)?[-.\\s]?[0-9]{3}[-.\\s]?[0-9]{4}\\b/g // Phone
    ];
    
    const results = JSON.stringify($json.results);
    const detectedPatterns = [];
    
    sensitivePatterns.forEach((pattern, index) => {
      if (pattern.test(results)) {
        detectedPatterns.push(['SSN', 'Credit Card', 'Email', 'Phone'][index]);
      }
    });
    
    if (detectedPatterns.length > 0) {
      // Trigger security alert
      await sendSecurityAlert({
        user_id: $json.user_id,
        detected_types: detectedPatterns,
        request_id: $execution.id
      });
    }
    
    return [$json];
  \`
}

// Node 4: Return Results
{
  "name": "Return Response",
  "type": "n8n-nodes-base.respondToWebhook",
  "respondWith": "json",
  "responseBody": {
    "success": true,
    "data": "={{ $json.results }}",
    "metadata": {
      "row_count": "={{ $json.row_count }}",
      "execution_time_ms": "={{ $json.execution_time }}"
    }
  }
}

// Workflow: Human Approval for Sensitive MCP Operations

// Node 1: Classify Risk Level
{
  "name": "Risk Assessment",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const { mcp_server, operation, parameters } = $json;
    
    // Risk scoring matrix
    let riskScore = 0;
    let riskFactors = [];
    
    // Server risk
    const serverRisk = {
      'postgres': 2,
      'slack': 1,
      'github': 2,
      'stripe': 3
    };
    riskScore += serverRisk[mcp_server] || 1;
    
    // Operation risk
    if (operation.includes('delete') || operation.includes('drop')) {
      riskScore += 3;
      riskFactors.push('destructive_operation');
    }
    if (operation.includes('write') || operation.includes('update')) {
      riskScore += 2;
      riskFactors.push('write_operation');
    }
    
    // Data volume risk
    if (parameters?.row_limit > 10000) {
      riskScore += 1;
      riskFactors.push('high_volume');
    }
    
    // Determine approval requirement
    const requiresApproval = riskScore >= 4;
    const approverLevel = riskScore >= 6 ? 'director' : 'manager';
    
    return [{
      json: {
        ...$json,
        risk_score: riskScore,
        risk_factors: riskFactors,
        requires_approval: requiresApproval,
        approver_level: approverLevel,
        auto_execute: !requiresApproval
      }
    }];
  \`
}

// Node 2: Decision Routing
{
  "name": "Route by Risk",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "boolean": [
      { "value1": "={{ $json.requires_approval }}", "value2": true }
    ]
  }
}

// Branch 1: Auto-Execute (Low Risk)
{
  "name": "Execute Directly",
  "type": "n8n-nodes-base.executeWorkflow",
  "workflowId": "mcp-auto-execute",
  "data": "={{ $json }}"
}

// Branch 2: Request Approval (High Risk)
{
  "name": "Create Approval Request",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "mcp_approvals",
  "columns": {
    "request_id": "={{ $execution.id }}",
    "user_id": "={{ $json.user_id }}",
    "mcp_server": "={{ $json.mcp_server }}",
    "operation": "={{ $json.operation }}",
    "parameters": "={{ JSON.stringify($json.parameters) }}",
    "risk_score": "={{ $json.risk_score }}",
    "risk_factors": "={{ JSON.stringify($json.risk_factors) }}",
    "required_approver_level": "={{ $json.approver_level }}",
    "status": "pending",
    "created_at": "={{ $now }}"
  },
  "options": {
    "returnFields": ["id"]
  }
}

// Node 3: Send Approval Notification
{
  "name": "Notify Approver",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "#mcp-approvals",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "⚠️ High-Risk MCP Operation Requires Approval" }
    },
    {
      "type": "section",
      "fields": [
        { "type": "mrkdwn", "text": "*Request ID:*\n{{ $json.request_id }}" },
        { "type": "mrkdwn", "text": "*Requested By:*\n{{ $json.user_id }}" },
        { "type": "mrkdwn", "text": "*Server:*\n{{ $json.mcp_server }}" },
        { "type": "mrkdwn", "text": "*Operation:*\n{{ $json.operation }}" },
        { "type": "mrkdwn", "text": "*Risk Score:*\n{{ $json.risk_score }}/10" },
        { "type": "mrkdwn", "text": "*Required Level:*\n{{ $json.approver_level }}" }
      ]
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Risk Factors:* {{ $json.risk_factors.join(', ') }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✅ Approve" },
          "style": "primary",
          "action_id": "approve_mcp",
          "value": "{{ $json.request_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "❌ Reject" },
          "style": "danger",
          "action_id": "reject_mcp",
          "value": "{{ $json.request_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "👀 Review Details" },
          "url": "https://approvals.example.com/mcp/{{ $json.request_id }}"
        }
      ]
    }
  ]
}

// Node 4: Wait for Approval Response
{
  "name": "Wait for Decision",
  "type": "n8n-nodes-base.wait",
  "waitType": "webhook",
  "webhookSuffix": "mcp-approval-response",
  "continue": "receiveWebhook",
  "options": {
    "timeout": 86400 // 24 hours
  }
}

// Node 5: Process Approval Decision
{
  "name": "Process Decision",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const decision = $json.decision;
    const approver = $json.approver;
    
    // Update approval record
    await updateApprovalStatus({
      request_id: $json.request_id,
      status: decision,
      approver: approver,
      decided_at: new Date().toISOString()
    });
    
    if (decision === 'approved') {
      // Execute the MCP operation
      return [{
        json: {
          ...$json,
          approved: true,
          approved_by: approver,
          execute: true
        }
      }];
    } else {
      // Log rejection and notify requester
      await notifyRejection($json.user_id, $json.request_id, $json.rejection_reason);
      return [{
        json: {
          ...$json,
          approved: false,
          rejection_reason: $json.rejection_reason
        }
      }];
    }
  \`
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│           Enterprise Support AI: MCP + n8n Implementation                        │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  Customer Query                                                                 │
│       │                                                                         │
│       ▼                                                                         │
│  ┌─────────────────────────────────┐                                           │
│  │   Claude Desktop (MCP Host)     │                                           │
│  │   • Natural language query        │                                           │
│  │   • Intent classification         │                                           │
│  └──────────────┬──────────────────┘                                           │
│                 │                                                               │
│                 ▼                                                               │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    n8n Workflow: Support AI Orchestrator                 │   │
│  │                                                                          │   │
│  │  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐               │   │
│  │  │  Auth Check │────▶│  Rate Limit │────▶│  Intent     │               │   │
│  │  │             │     │  Check      │     │  Router     │               │   │
│  │  └─────────────┘     └─────────────┘     └──────┬──────┘               │   │
│  │                                                  │                      │   │
│  │                    ┌─────────────┬───────────────┼─────────────┐        │   │
│  │                    ▼             ▼               ▼             ▼        │   │
│  │             ┌──────────┐ ┌──────────┐  ┌──────────┐ ┌──────────┐     │   │
│  │             │  Data    │ │  Ticket  │  │  Slack   │ │  Human   │     │   │
│  │             │  Query   │ │  Lookup  │  │  Notify  │ │  Escalate│     │   │
│  │             └────┬─────┘ └────┬─────┘  └────┬─────┘ └────┬─────┘     │   │
│  │                  │            │             │            │            │   │
│  │                  ▼            ▼             ▼            ▼            │   │
│  │  ┌─────────────────────────────────────────────────────────────────┐ │   │
│  │  │                    Audit & Compliance Layer                      │ │   │
│  │  │  • All queries logged                                          │ │   │
│  │  │  • PII detection and masking                                     │ │   │
│  │  │  • Approval workflows for sensitive data                       │ │   │
│  │  │  • Retention policy enforcement                                  │ │   │
│  │  └─────────────────────────────────────────────────────────────────┘ │   │
│  │                                                                     │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────────┐│
│  │                     MCP Server Layer                                     ││
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐   ││
│  │  │  PostgreSQL │  │  Zendesk    │  │   Slack     │  │  Internal   │   ││
│  │  │  (Customer  │  │  (Tickets)  │  │  (Updates)  │  │  CRM        │   ││
│  │  │   Data)     │  │             │  │             │  │             │   ││
│  │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘   ││
│  └─────────────────────────────────────────────────────────────────────────┘│
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// Complete Support AI Workflow

// Node 1: Request Intake
{
  "name": "Support Request",
  "type": "n8n-nodes-base.webhook",
  "path": "support-ai",
  "webhookUri": "https://n8n.example.com/webhook/support-ai"
}

// Node 2: Authentication & Authorization
{
  "name": "Verify Session",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": \`
    SELECT u.id, u.role, u.department, u.clearance_level,
           s.created_at as session_started
    FROM users u
    JOIN sessions s ON s.user_id = u.id
    WHERE s.token = $1 AND s.expires_at > NOW()
  \`,
  "parameters": ["={{ $headers.authorization.replace('Bearer ', '') }}"]
}

// Node 3: Intent Classification via MCP
{
  "name": "Classify Intent",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": \`
    Classify this support query into one of these intents:
    - account_lookup: Customer asking about their account/status
    - technical_issue: Product bug or technical problem
    - billing_question: Invoice, payment, or subscription
    - feature_request: New functionality request
    - complaint: Dissatisfied customer feedback
    - urgent_escalation: Time-sensitive critical issue
    
    Query: {{ $json.query }}
    
    Return JSON: { "intent": "...", "confidence": 0.0-1.0, "entities": {...} }
  \`,
  "options": {
    "systemMessage": "You are a support intent classifier. Be precise and conservative with confidence scores."
  }
}

// Node 4: Route by Intent
{
  "name": "Intent Router",
  "type": "n8n-nodes-base.switch",
  "rules": {
    "rules": [
      { "value": "={{ $json.intent }}", "output": 0 }, // account_lookup
      { "value": "={{ $json.intent }}", "output": 1 }, // technical_issue
      { "value": "={{ $json.intent }}", "output": 2 }, // billing_question
      { "value": "={{ $json.intent }}", "output": 3 }  // urgent_escalation
    ]
  }
}

// Branch 1: Account Lookup (via PostgreSQL MCP)
{
  "name": "Query Customer Data",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": \`
    SELECT 
      c.id, c.name, c.email, c.plan, c.status,
      c.created_at as customer_since,
      COUNT(t.id) as total_tickets,
      MAX(t.created_at) as last_ticket_date
    FROM customers c
    LEFT JOIN tickets t ON t.customer_id = c.id
    WHERE c.email = $1 OR c.id::text = $2
    GROUP BY c.id, c.name, c.email, c.plan, c.status, c.created_at
  \`,
  "parameters": [
    "={{ $json.entities.email }}",
    "={{ $json.entities.customer_id }}"
  ]
}

// Node: PII Check before returning data
{
  "name": "Data Sensitivity Check",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const userClearance = $json.clearance_level;
    const customerData = $json.customer;
    
    // Check if user has clearance for this customer
    if (customerData.clearance_required > userClearance) {
      throw new Error('Insufficient clearance to access this customer record');
    }
    
    // Mask sensitive data based on role
    if ($json.role !== 'senior_support') {
      delete customerData.billing_address;
      delete customerData.payment_method;
      customerData.email = maskEmail(customerData.email);
    }
    
    return [$json];
  \`
}

// Branch 2: Technical Issue (via Zendesk MCP)
{
  "name": "Search Related Tickets",
  "type": "n8n-nodes-base.httpRequest",
  "method": "GET",
  "url": "https://company.zendesk.com/api/v2/search.json",
  "query": {
    "query": "={{ 'type:ticket ' + $json.entities.issue_description }}"
  },
  "headerParameters": {
    "Authorization": "Basic {{ $credentials.zendesk.apiKey }}"
  }
}

// Branch 3: Billing Question (via Stripe MCP + Approval)
{
  "name": "Check Billing Access",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.role }}", "value2": "billing_team" },
      { "value1": "={{ $json.role }}", "value2": "admin" }
    ]
  },
  "combineOperation": "any"
}

// Execute billing query if authorized
{
  "name": "Query Stripe Data",
  "type": "n8n-nodes-base.stripe",
  "operation": "get",
  "resource": "customer",
  "id": "={{ $json.entities.customer_id }}"
}

// Branch 4: Urgent Escalation (Human-in-the-Loop)
{
  "name": "Create Urgent Ticket",
  "type": "n8n-nodes-base.zendesk",
  "operation": "create",
  "resource": "ticket",
  "subject": "URGENT: {{ $json.query }}",
  "description": "{{ $json.query }}\n\nAI Confidence: {{ $json.confidence }}\nDetected Urgency: High",
  "priority": "urgent",
  "custom_fields": [
    { "id": "ai_classified", "value": true },
    { "id": "confidence_score", "value": "{{ $json.confidence }}" }
  ]
}

// Notify on-call engineer
{
  "name": "Alert On-Call",
  "type": "n8n-nodes-base.pagerduty",
  "operation": "create",
  "incident": {
    "title": "Urgent Support Escalation",
    "service": "customer-support",
    "urgency": "high",
    "description": "{{ $json.query }}"
  }
}

// Final Node: Comprehensive Audit Log
{
  "name": "Log Complete Interaction",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "support_ai_audit",
  "columns": {
    "request_id": "={{ $execution.id }}",
    "user_id": "={{ $json.user_id }}",
    "customer_id": "={{ $json.entities.customer_id }}",
    "intent": "={{ $json.intent }}",
    "confidence": "={{ $json.confidence }}",
    "mcp_servers_used": "={{ JSON.stringify($json.mcp_calls) }}",
    "data_accessed": "={{ JSON.stringify($json.data_access_log) }}",
    "human_escalated": "={{ $json.escalated }}",
    "response_time_ms": "={{ Date.now() - $execution.startTime }}",
    "timestamp": "={{ $now }}"
  }
}

// Multi-Layer Authentication

// Layer 1: API Key Validation
{
  "name": "Validate API Key",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const apiKey = $headers['x-api-key'];
    const hash = $crypto.sha256(apiKey);
    
    // Check against hashed keys in database
    const keyData = await fetchApiKey(hash);
    
    if (!keyData || keyData.revoked || new Date(keyData.expires_at) < new Date()) {
      throw new Error('Invalid or expired API key');
    }
    
    // Rotate key if near expiration
    if (daysUntilExpiration(keyData.expires_at) < 7) {
      await notifyKeyRotation(keyData.user_id);
    }
    
    return [{
      json: {
        ...$json,
        authenticated: true,
        user: keyData.user,
        permissions: keyData.permissions,
        rate_limit: keyData.rate_limit
      }
    }];
  \`
}

// Layer 2: OAuth Token Management
{
  "name": "OAuth Token Refresh",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://oauth.provider.com/token",
  "body": {
    "grant_type": "refresh_token",
    "refresh_token": "={{ $credentials.oauth.refreshToken }}",
    "client_id": "={{ $credentials.oauth.clientId }}",
    "client_secret": "={{ $credentials.oauth.clientSecret }}"
  }
}

// Layer 3: MFA for High-Risk Operations
{
  "name": "Require MFA",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "number": [
      { "value1": "={{ $json.risk_score }}", "operation": "gt", "value2": 7 }
    ]
  }
}

// PII Detection and Masking

{
  "name": "PII Scanner",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const piiPatterns = {
      ssn: /\\b\\d{3}[-.]?\\d{2}[-.]?\\d{4}\\b/g,
      credit_card: /\\b(?:\\d{4}[-\\s]?){3}\\d{4}\\b/g,
      email: /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b/g,
      phone: /\\b(?:\\+?1[-.\\s]?)?\\(?[0-9]{3}\\)?[-.\\s]?[0-9]{3}[-.\\s]?[0-9]{4}\\b/g,
      ip_address: /\\b(?:[0-9]{1,3}\\.){3}[0-9]{1,3}\\b/g
    };
    
    function scanAndMask(data, path = '') {
      if (typeof data === 'string') {
        let masked = data;
        let detections = [];
        
        for (const [type, pattern] of Object.entries(piiPatterns)) {
          if (pattern.test(data)) {
            detections.push({ type, path });
            masked = masked.replace(pattern, (match) => {
              return match.slice(0, 2) + '***' + match.slice(-2);
            });
          }
        }
        
        return { value: masked, detections };
      }
      
      if (Array.isArray(data)) {
        return data.map((item, i) => scanAndMask(item, \`\${path}[\${i}]\`));
      }
      
      if (typeof data === 'object' && data !== null) {
        const result = {};
        for (const [key, value] of Object.entries(data)) {
          result[key] = scanAndMask(value, \`\${path}.\${key}\`);
        }
        return result;
      }
      
      return data;
    }
    
    const result = scanAndMask($json.data);
    
    // Log detections for security review
    if (result.detections?.length > 0) {
      await logPiiDetection($json.user_id, result.detections, $execution.id);
    }
    
    return [{
      json: {
        ...$json,
        data: result,
        pii_detected: result.detections?.length || 0
      }
    }];
  \`
}

// Comprehensive Audit Logging

{
  "name": "Audit Log Entry",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "mcp_audit_trail",
  "columns": {
    "event_id": "={{ $execution.id }}",
    "event_type": "mcp_operation",
    "timestamp": "={{ $now }}",
    "user_id": "={{ $json.user_id }}",
    "session_id": "={{ $json.session_id }}",
    "client_ip": "={{ $headers['x-forwarded-for'] || $headers['x-real-ip'] }}",
    "user_agent": "={{ $headers['user-agent'] }}",
    "mcp_server": "={{ $json.mcp_server }}",
    "operation": "={{ $json.operation }}",
    "parameters_hash": "={{ $crypto.sha256(JSON.stringify($json.parameters)) }}",
    "result_status": "={{ $json.success ? 'success' : 'failure' }}",
    "error_message": "={{ $json.error }}",
    "execution_time_ms": "={{ $json.execution_time }}",
    "data_volume_bytes": "={{ JSON.stringify($json.result).length }}",
    "approval_required": "={{ $json.requires_approval }}",
    "approval_id": "={{ $json.approval_id }}",
    "risk_score": "={{ $json.risk_score }}",
    "compliance_tags": "={{ JSON.stringify($json.compliance_tags) }}"
  }
}

// Immutable Audit Log (Append-Only)
{
  "name": "Append-Only Log",
  "type": "n8n-nodes-base.awsS3",
  "operation": "upload",
  "bucket": "audit-logs-immutable",
  "key": "mcp/{{ $now.format('YYYY/MM/DD') }}/{{ $execution.id }}.json",
  "data": "={{ JSON.stringify({
    timestamp: $now,
    event: $json,
    signature: $crypto.hmac('sha256', JSON.stringify($json), $credentials.audit.key)
  }) }}"
}

// Policy Engine Implementation

const policies = {
  // Server access policies
  serverAccess: {
    postgres: ['developer', 'analyst', 'data_engineer'],
    slack: ['all_authenticated'],
    github: ['developer', 'devops'],
    stripe: ['finance', 'billing_admin']
  },
  
  // Operation restrictions
  operationLimits: {
    postgres: {
      read: { max_rows: 10000, timeout: 30000 },
      write: { requires_approval: true, max_rows_affected: 100 }
    }
  },
  
  // Data classification rules
  dataSensitivity: {
    public: { servers: ['github'], operations: ['read'] },
    internal: { servers: ['slack', 'github'], operations: ['read', 'write'] },
    confidential: { 
      servers: ['postgres'], 
      operations: ['read'],
      requires_approval: true 
    },
    restricted: {
      servers: ['stripe', 'postgres'],
      operations: [],
      requires_approval: true,
      approver_level: 'director'
    }
  }
};

// Policy evaluation function
function evaluatePolicy(user, request) {
  const results = {
    allowed: true,
    restrictions: [],
    requiresApproval: false
  };
  
  // Check server access
  const allowedRoles = policies.serverAccess[request.server];
  if (!allowedRoles.includes('all_authenticated') && 
      !allowedRoles.includes(user.role)) {
    results.allowed = false;
    results.denialReason = 'Insufficient role for server access';
    return results;
  }
  
  // Check operation limits
  const limits = policies.operationLimits[request.server]?.[request.operation];
  if (limits) {
    if (request.estimatedRows > limits.max_rows) {
      results.restrictions.push('Query exceeds row limit');
      results.requiresApproval = true;
    }
  }
  
  // Check data sensitivity
  const classification = classifyData(request);
  const rules = policies.dataSensitivity[classification];
  if (rules.requires_approval) {
    results.requiresApproval = true;
    results.approverLevel = rules.approver_level || 'manager';
  }
  
  return results;
}

// Multi-Agent Orchestration Workflow

{
  "name": "Agent Coordinator",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    // Define agent roles and MCP access
    const agents = {
      'data_analyst': {
        mcp_servers: ['postgres', 'snowflake'],
        capabilities: ['query', 'analyze'],
        max_concurrent: 3
      },
      'communications': {
        mcp_servers: ['slack', 'email'],
        capabilities: ['send', 'draft'],
        max_concurrent: 5
      },
      'developer': {
        mcp_servers: ['github', 'postgres'],
        capabilities: ['read', 'write', 'deploy'],
        max_concurrent: 2
      }
    };
    
    // Task distribution
    const task = $json.task;
    const selectedAgents = selectAgentsForTask(task, agents);
    
    // Execute in parallel with coordination
    const results = await Promise.all(
      selectedAgents.map(agent => 
        executeAgentTask(agent, task, {
          timeout: 30000,
          retryAttempts: 3
        })
      )
    );
    
    // Synthesize results
    return [{
      json: {
        task_id: task.id,
        agents_involved: selectedAgents.map(a => a.id),
        results: results,
        synthesis: await synthesizeResults(results)
      }
    }];
  \`
}

// Circuit Breaker Implementation

{
  "name": "Circuit Breaker",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const CIRCUIT_STATES = {
      CLOSED: 'closed',      // Normal operation
      OPEN: 'open',          // Failing, reject requests
      HALF_OPEN: 'half_open' // Testing if recovered
    };
    
    async function checkCircuit(serverName) {
      const state = await redis.get(\`circuit:\${serverName}\`);
      const failures = parseInt(await redis.get(\`circuit:\${serverName}:failures\`) || '0');
      const lastFailure = await redis.get(\`circuit:\${serverName}:last_failure\`);
      
      if (state === CIRCUIT_STATES.OPEN) {
        // Check if timeout has elapsed
        const timeoutMs = 30000; // 30 seconds
        if (lastFailure && Date.now() - parseInt(lastFailure) > timeoutMs) {
          // Transition to half-open
          await redis.set(\`circuit:\${serverName}\`, CIRCUIT_STATES.HALF_OPEN);
          return CIRCUIT_STATES.HALF_OPEN;
        }
        throw new Error(\`Circuit breaker OPEN for \${serverName}\`);
      }
      
      return state || CIRCUIT_STATES.CLOSED;
    }
    
    async function recordSuccess(serverName) {
      await redis.del(\`circuit:\${serverName}:failures\`);
      await redis.set(\`circuit:\${serverName}\`, CIRCUIT_STATES.CLOSED);
    }
    
    async function recordFailure(serverName) {
      const failures = await redis.incr(\`circuit:\${serverName}:failures\`);
      await redis.set(\`circuit:\${serverName}:last_failure\`, Date.now());
      
      if (failures >= 5) { // Threshold
        await redis.set(\`circuit:\${serverName}\`, CIRCUIT_STATES.OPEN);
        await notifyOpsTeam(\`Circuit opened for \${serverName}\`);
      }
    }
    
    // Main execution
    const serverName = $json.mcp_server;
    const circuitState = await checkCircuit(serverName);
    
    try {
      const result = await executeMcpOperation($json);
      await recordSuccess(serverName);
      return [{ json: { ...$json, result, circuit_state: circuitState } }];
    } catch (error) {
      await recordFailure(serverName);
      throw error;
    }
  \`
}

// Metrics Collection Workflow

{
  "name": "Collect MCP Metrics",
  "type": "n8n-nodes-base.cron",
  "cronExpression": "*/5 * * * *" // Every 5 minutes
}

{
  "name": "Aggregate Metrics",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": \`
    WITH metrics AS (
      SELECT
        mcp_server,
        operation,
        COUNT(*) as request_count,
        AVG(execution_time_ms) as avg_response_time,
        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY execution_time_ms) as p95_response_time,
        SUM(CASE WHEN result_status = 'failure' THEN 1 ELSE 0 END) as error_count,
        AVG(CASE WHEN result_status = 'failure' THEN 1 ELSE 0 END) * 100 as error_rate
      FROM mcp_audit_trail
      WHERE timestamp > NOW() - INTERVAL '5 minutes'
      GROUP BY mcp_server, operation
    )
    SELECT
      mcp_server,
      operation,
      request_count,
      ROUND(avg_response_time, 2) as avg_response_time_ms,
      ROUND(p95_response_time, 2) as p95_response_time_ms,
      error_count,
      ROUND(error_rate, 2) as error_rate_pct
    FROM metrics
    ORDER BY request_count DESC
  \`
}

{
  "name": "Send to Monitoring",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://metrics.example.com/api/ingest",
  "body": "={{ $json }}"
}

// Alert on anomalies
{
  "name": "Check Thresholds",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const alerts = [];
    
    for (const metric of $json) {
      // Error rate threshold
      if (metric.error_rate_pct > 5) {
        alerts.push({
          severity: 'warning',
          message: \`High error rate on \${metric.mcp_server}/\${metric.operation}: \${metric.error_rate_pct}%\`,
          metric
        });
      }
      
      // Response time threshold
      if (metric.p95_response_time_ms > 5000) {
        alerts.push({
          severity: 'critical',
          message: \`High P95 latency on \${metric.mcp_server}/\${metric.operation}: \${metric.p95_response_time_ms}ms\`,
          metric
        });
      }
      
      // Request volume anomaly
      if (metric.request_count > 10000) {
        alerts.push({
          severity: 'info',
          message: \`Unusual request volume on \${metric.mcp_server}: \${metric.request_count} in 5min\`,
          metric
        });
      }
    }
    
    return [{
      json: {
        alerts,
        alert_count: alerts.length,
        timestamp: new Date().toISOString()
      }
    }];
  \`
}

{
  "name": "Send Alerts",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "number": [
      { "value1": "={{ $json.alert_count }}", "operation": "gt", "value2": 0 }
    ]
  }
}

{
  "name": "Notify Operations",
  "type": "n8n-nodes-base.slack",
  "channel": "#mcp-alerts",
  "blocks": "={{ formatAlertBlocks($json.alerts) }}"
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP Governance Organization                                   │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                     MCP Governance Board                                 │   │
│  │  • Sets policies and standards                                          │   │
│  │  • Reviews high-risk approvals                                          │   │
│  │  • Owns incident response                                             │   │
│  └───────────────────────────┬─────────────────────────────────────────────┘   │
│                              │                                                  │
│         ┌────────────────────┼────────────────────┐                             │
│         ▼                    ▼                    ▼                             │
│  ┌──────────────┐   ┌──────────────┐   ┌──────────────┐                        │
│  │ MCP Security │   │   MCP Ops    │   │ Compliance   │                        │
│  │    Team      │   │    Team      │   │    Team      │                        │
│  │              │   │              │   │              │                        │
│  │• Auth design │   │• Server mgmt │   │• Audit       │                        │
│  │• Pen testing │   │• Monitoring  │   │• Reporting   │                        │
│  │• Incident    │   │• Performance │   │• Compliance  │                        │
│  │  response    │   │• Scaling     │   │  reviews     │                        │
│  └──────────────┘   └──────────────┘   └──────────────┘                        │
│                                                                                 │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                     MCP Server Registry                                  │   │
│  │  Each production MCP server requires:                                     │   │
│  │  • Owner (named individual)                                              │   │
│  │  • Data classification (public/internal/confidential/restricted)        │   │
│  │  • Authentication method and verification date                          │   │
│  │  • Scope limitations (read/write, data boundaries)                        │   │
│  │  • Last security review date                                            │   │
│  │  • Approval workflow requirements                                         │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

MCP Server Production Approval Checklist

☐ Named owner assigned
☐ Security review completed (last 90 days)
☐ Authentication configured (OAuth 2.0)
☐ Data classification assigned
☐ Scope limitations documented
☐ Approval workflows configured (if required)
☐ Audit logging enabled
☐ Monitoring dashboards configured
☐ Incident response plan documented
☐ Business continuity plan documented

Approved by: _________________ Date: _______________

MCP Security Incident Response

SEVERITY 1 (Critical - Active Data Breach)
1. Immediately revoke affected API keys
2. Isolate compromised MCP servers
3. Page security team + legal
4. Begin forensic data collection
5. Notify affected parties within 4 hours

SEVERITY 2 (High - Potential Exposure)
1. Review audit logs for suspicious activity
2. Rotate credentials for affected systems
3. Assess scope of potential exposure
4. Document timeline and actions taken

SEVERITY 3 (Medium - Policy Violation)
1. Document violation details
2. Notify server owner
3. Require remediation within 48 hours
4. Update policies to prevent recurrence

// Future: WebSocket MCP Connections
{
  "name": "WebSocket MCP",
  "type": "n8n-nodes-base.websocket",
  "url": "wss://mcp-server.example.com/stream",
  "authentication": "oauth",
  "reconnect": {
    "enabled": true,
    "maxAttempts": 10,
    "backoff": "exponential"
  }
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                     Federated MCP Architecture                                   │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Company A                          Company B                         Company C│
│   ┌──────────────┐                   ┌──────────────┐                  ┌──────┐│
│   │  Internal MCP  │                   │  Internal MCP  │                  │      ││
│   │    Servers     │                   │    Servers     │                  │      ││
│   └──────┬─────────┘                   └──────┬─────────┘                  └──────┘│
│          │                                    │                                     │
│          └────────────────┬───────────────────┘                                     │
│                           │                                                         │
│                    ┌──────▼────────┐                                               │
│                    │  Federation   │                                               │
│                    │    Gateway    │                                               │
│                    │               │                                               │
│                    │ • Policy       │                                               │
│                    │   enforcement │                                               │
│                    │ • Cross-org    │                                               │
│                    │   auth         │                                               │
│                    │ • Billing      │                                               │
│                    └───────────────┘                                               │
│                                                                                     │
└─────────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│              Future: Native MCP Support in n8n                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   [MCP Server Browser]                                                          │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │ 🔍 Search 9,400+ MCP Servers...                                         │  │
│   │                                                                          │  │
│   │ ★ Supabase MCP Server      v2.1.3    [Add to Workflow]                  │  │
│   │ ★ Slack MCP Server         v1.8.2    [Add to Workflow]                  │  │
│   │ ★ GitHub MCP Server        v3.0.1    [Add to Workflow]                  │  │
│   │ ★ Stripe MCP Server        v2.5.0    [Add to Workflow]                  │  │
│   │                                                                          │  │
│   │ ⚙️ Configure:                                                             │  │
│   │    [✓] OAuth 2.0 Authentication                                         │  │
│   │    [✓] Scope: read-only                                                 │  │
│   │    [✓] Audit logging enabled                                            │  │
│   │    [✓] Rate limit: 100/hour                                             │  │
│   │                                                                          │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// Future: Autonomous MCP Integration
{
  "name": "Auto-Discover MCP",
  "type": "n8n-nodes-base.autoMcp",
  "action": "discover",
  "criteria": {
    "categories": ["database", "communication"],
    "security_rating": "enterprise",
    "popularity": "> 1000 installs"
  },
  "auto_configure": true,
  "approval_required": true
}