┌─────────────────────────────────────────────────────────────────┐
│                    สถาปัตยกรรม MCP                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐          ┌──────────────────┐               │
│  │  AI Agent    │◄────────►│   MCP Client     │               │
│  │  (n8n,       │          │   (Transport     │               │
│  │   OpenClaw,  │          │    Layer)        │               │
│  │   Claude)    │          │                  │               │
│  └──────────────┘          └────────┬─────────┘               │
│                                     │                          │
│                                     │ Stdio / HTTP / SSE       │
│                                     │                          │
│                            ┌────────▼─────────┐               │
│                            │   MCP Server     │               │
│                            │   (Tool Host)    │               │
│                            │                  │               │
│                            │  ┌────────────┐  │               │
│                            │  │  Tools     │  │               │
│                            │  │  Resources │  │               │
│                            │  │  Prompts   │  │               │
│                            │  └────────────┘  │               │
│                            └──────────────────┘               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# สำหรับการพัฒนาโหนด n8n แบบกำหนดเอง
npm install @modelcontextprotocol/sdk

# สำหรับใช้ในโหนดฟังก์ชัน (ผ่าน npm ในการตั้งค่า n8n)
npm install @modelcontextprotocol/sdk axios

// โหนดกำหนดค่า MCP Client
const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
const { HttpClientTransport } = require('@modelcontextprotocol/sdk/client/http.js');

class N8nMCPClient {
  constructor(config) {
    this.config = config;
    this.clients = new Map();
  }

  async connectToServer(serverConfig) {
    const { name, transport, connection } = serverConfig;
    
    let transportInstance;
    
    if (transport === 'stdio') {
      transportInstance = new StdioClientTransport({
        command: connection.command,
        args: connection.args,
        env: connection.env || {}
      });
    } else if (transport === 'http') {
      transportInstance = new HttpClientTransport({
        url: connection.url,
        headers: connection.headers || {}
      });
    }

    const client = new Client({
      name: `n8n-client-${name}`,
      version: '1.0.0'
    });

    await client.connect(transportInstance);
    
    // ค้นพบเครื่องมือที่มีอยู่
    const tools = await client.listTools();
    const resources = await client.listResources();
    
    this.clients.set(name, {
      client,
      transport: transportInstance,
      tools: tools.tools,
      resources: resources.resources
    });

    return {
      connected: true,
      server: name,
      toolCount: tools.tools.length,
      resourceCount: resources.resources.length,
      tools: tools.tools.map(t => ({ name: t.name, description: t.description }))
    };
  }

  async callTool(serverName, toolName, args) {
    const server = this.clients.get(serverName);
    if (!server) {
      throw new Error(`Server ${serverName} ไม่ได้เชื่อมต่อ`);
    }

    const result = await server.client.callTool({
      name: toolName,
      arguments: args
    });

    return result;
  }

  async disconnect(serverName) {
    const server = this.clients.get(serverName);
    if (server) {
      await server.client.close();
      this.clients.delete(serverName);
    }
  }
}

// การใช้งานในโหนดฟังก์ชัน n8n
const mcpClient = new N8nMCPClient();

const serverConfigs = [
  {
    name: 'postgresql',
    transport: 'stdio',
    connection: {
      command: 'npx',
      args: ['-y', '@modelcontextprotocol/server-postgres', 
             process.env.DATABASE_URL]
    }
  },
  {
    name: 'github',
    transport: 'stdio',
    connection: {
      command: 'npx',
      args: ['-y', '@modelcontextprotocol/server-github'],
      env: {
        GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_TOKEN
      }
    }
  }
];

const results = [];
for (const config of serverConfigs) {
  try {
    const result = await mcpClient.connectToServer(config);
    results.push(result);
  } catch (error) {
    results.push({
      connected: false,
      server: config.name,
      error: error.message
    });
  }
}

return [{ json: { connections: results } }];

// n8n-as-mcp-server.js
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema
} = require('@modelcontextprotocol/sdk/types.js');

class N8nMCPServer {
  constructor(n8nConfig) {
    this.n8nConfig = n8nConfig;
    this.server = new Server(
      {
        name: 'n8n-mcp-server',
        version: '1.0.0'
      },
      {
        capabilities: {
          tools: {},
          resources: {}
        }
      }
    );
    
    this.setupHandlers();
  }

  setupHandlers() {
    // แสดงรายการเครื่องมือที่มีอยู่ (workflows ของ n8n ที่เปิดเผย)
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'execute_n8n_workflow',
            description: 'ดำเนินการ workflow ของ n8n ด้วยพารามิเตอร์ที่ให้มา',
            inputSchema: {
              type: 'object',
              properties: {
                workflow_id: {
                  type: 'string',
                  description: 'ID ของ workflow n8n ที่จะดำเนินการ'
                },
                parameters: {
                  type: 'object',
                  description: 'พารามิเตอร์ที่จะส่งไปยัง workflow'
                }
              },
              required: ['workflow_id', 'parameters']
            }
          },
          {
            name: 'query_workflow_executions',
            description: 'สืบค้นการดำเนินการ workflow ในอดีต',
            inputSchema: {
              type: 'object',
              properties: {
                workflow_id: {
                  type: 'string',
                  description: 'กรองตาม workflow ID'
                },
                status: {
                  type: 'string',
                  enum: ['success', 'error', 'waiting'],
                  description: 'กรองตามสถานะการดำเนินการ'
                },
                limit: {
                  type: 'number',
                  default: 10,
                  description: 'จำนวนผลลัพธ์สูงสุด'
                }
              }
            }
          }
        ]
      };
    });

    // จัดการการดำเนินการเครื่องมือ
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;
      
      if (name === 'execute_n8n_workflow') {
        return await this.executeWorkflow(args.workflow_id, args.parameters);
      } else if (name === 'query_workflow_executions') {
        return await this.queryExecutions(args);
      }
      
      throw new Error(`เครื่องมือที่ไม่รู้จัก: ${name}`);
    });

    // แสดงรายการทรัพยากร (แหล่งข้อมูลที่เปิดเผย)
    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
      return {
        resources: [
          {
            uri: 'n8n://workflows',
            name: 'Workflows ที่มีอยู่',
            description: 'รายการ workflows ของ n8n ที่มีอยู่ทั้งหมด',
            mimeType: 'application/json'
          },
          {
            uri: 'n8n://executions/recent',
            name: 'การดำเนินการล่าสุด',
            description: 'การดำเนินการ workflow ล่าสุด',
            mimeType: 'application/json'
          }
        ]
      };
    });

    // อ่านเนื้อหาทรัพยากร
    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
      const { uri } = request.params;
      
      if (uri === 'n8n://workflows') {
        const workflows = await this.fetchWorkflows();
        return {
          contents: [{
            uri,
            mimeType: 'application/json',
            text: JSON.stringify(workflows, null, 2)
          }]
        };
      }
      
      throw new Error(`ทรัพยากรที่ไม่รู้จัก: ${uri}`);
    });
  }

  async executeWorkflow(workflowId, parameters) {
    const axios = require('axios');
    
    try {
      const response = await axios.post(
        `${this.n8nConfig.baseUrl}/api/v1/workflows/${workflowId}/execute`,
        { data: parameters },
        {
          headers: {
            'X-N8N-API-KEY': this.n8nConfig.apiKey
          }
        }
      );
      
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(response.data, null, 2)
          }
        ]
      };
    } catch (error) {
      throw new Error(`การดำเนินการ workflow ล้มเหลว: ${error.message}`);
    }
  }
}

// เริ่มเซิร์ฟเวอร์
const server = new N8nMCPServer({
  baseUrl: process.env.N8N_URL || 'http://localhost:5678',
  apiKey: process.env.N8N_API_KEY
});

server.start().catch(console.error);

// n8n workflow: AI Database Agent กับ MCP
{
  "name": "MCP Database AI Agent",
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "คำขอของผู้ใช้",
      "parameters": {
        "httpMethod": "POST",
        "path": "db-agent"
      }
    },
    {
      "type": "n8n-nodes-base.agent",
      "name": "ตัวแทนเข้าใจคำขอ",
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นผู้เชี่ยวชาญในการสืบค้นฐานข้อมูล วิเคราะห์คำขอเป็นธรรมชาติของผู้ใช้และกำหนดว่าต้องการการดำเนินการฐานข้อมูลใด\\n\\nเครื่องมือที่มีผ่าน MCP:\\n- postgres_query: ดำเนินการสืบค้น PostgreSQL\\n- postgres_explain: รับแผนการดำเนินการสืบค้น\\n- postgres_schema: ดู schemas ของตาราง\\n\\nกระบวนการ:\\n1. เข้าใจเจตนาของผู้ใช้\\n2. กำหนดตารางที่เกี่ยวข้อง\\n3. สร้าง SQL ที่เหมาะสม\\n4. พิจารณาความปลอดภัย (ไม่มี DROP, DELETE โดยไม่มี WHERE)\\n\\nส่งออก JSON ด้วย: intent, tables_involved, suggested_query, needs_human_approval"
        }
      }
    }
  ]
}

# การกำหนดค่า n8n workflow: Multi-System MCP Integration
workflow:
  name: Enterprise MCP Integration Hub
  description: ศูนย์กลางหลักสำหรับการผสานรวมระบบแบบ MCP
  
  mcp_servers:
    - name: salesforce
      command: npx
      args: [-y, '@modelcontextprotocol/server-salesforce']
      env:
        SF_USERNAME: ${SF_USERNAME}
        SF_TOKEN: ${SF_TOKEN}
        
    - name: hubspot
      command: npx
      args: [-y, '@modelcontextprotocol/server-hubspot']
      env:
        HUBSPOT_API_KEY: ${HUBSPOT_API_KEY}
        
    - name: stripe
      command: npx
      args: [-y, '@modelcontextprotocol/server-stripe']
      env:
        STRIPE_API_KEY: ${STRIPE_SECRET_KEY}
        
    - name: slack
      command: npx
      args: [-y, '@modelcontextprotocol/server-slack']
      env:
        SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
        
    - name: notion
      command: npx
      args: [-y, '@modelcontextprotocol/server-notion']
      env:
        NOTION_API_KEY: ${NOTION_API_KEY}

  integrations:
    - name: customer_360_sync
      trigger: webhook
      description: ซิงค์ข้อมูลลูกค้าในทุกระบบ
      steps:
        - action: mcp.call_tool
          server: salesforce
          tool: get_contact
          params:
            email: "{{ $input.email }}"
            
        - action: mcp.call_tool
          server: hubspot
          tool: get_contact
          params:
            email: "{{ $input.email }}"
            
        - action: n8n.transform
          description: รวมข้อมูลจากหลายแหล่ง
          code: |
            const merged = mergeCustomerData([
              $steps[0].result,
              $steps[1].result
            ]);
            return merged;
            
        - action: mcp.call_tool
          server: notion
          tool: update_page
          params:
            database_id: "customer-360"
            properties: "{{ $steps[2].result }}"
            
        - action: mcp.call_tool
          server: slack
          tool: send_message
          params:
            channel: "#customer-updates"
            text: "อัปเดตโปรไฟล์ลูกค้า 360° สำหรับ {{ $input.email }}"

// MCP Security Middleware
class MCPSecurityGovernor {
  constructor(config) {
    this.config = {
      allowedServers: config.allowedServers || [],
      blockedTools: config.blockedTools || [],
      requireApproval: config.requireApproval || [],
      rateLimits: config.rateLimits || {},
      ...config
    };
    this.auditLog = [];
  }

  async validateServer(serverUrl) {
    // ตรวจสอบกับ allowlist
    const allowed = this.config.allowedServers.some(allowed => 
      serverUrl.startsWith(allowed)
    );
    
    if (!allowed) {
      throw new Error(`เซิร์ฟเวอร์ MCP ไม่ได้รับอนุญาต: ${serverUrl}`);
    }
    
    return { authorized: true };
  }

  async validateToolCall(serverName, toolName, parameters) {
    // ตรวจสอบว่าเครื่องมือถูกบล็อกหรือไม่
    if (this.config.blockedTools.includes(toolName)) {
      await this.logSecurityEvent('BLOCKED_TOOL_ATTEMPT', {
        server: serverName,
        tool: toolName
      });
      throw new Error(`เครื่องมือ '${toolName}' ถูกบล็อก`);
    }
    
    // ตรวจสอบว่าต้องการการอนุมัติหรือไม่
    if (this.config.requireApproval.includes(toolName)) {
      const approval = await this.requestHumanApproval({
        server: serverName,
        tool: toolName,
        parameters
      });
      
      if (!approval.granted) {
        throw new Error('การดำเนินการเครื่องมือต้องการการอนุมัติ');
      }
    }
    
    return { approved: true };
  }
}

# การกำหนดค่าการป้องกันข้อมูล MCP
datenschutz:
  pii_erkennung:
    aktiviert: true
    muster:
      - typ: email
        regex: \\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b
        aktion: maskieren
      - typ: telefon
        regex: \\b\\+?[\\d\\s-]{10,20}\\b
        aktion: maskieren
        
  gdpr:
    recht_auf_vergessenwerden: true
    datenportabilitaet: true
    einwilligung_verfolgung: true
    
  audit:
    alle_aufrufe_loggen: true
    aufbewahrung_tage: 90

// การผสานรวม MCP Observability
class MCPObservability {
  constructor(langfuseConfig) {
    this.langfuse = new Langfuse(langfuseConfig);
  }

  async traceMCPSession(sessionConfig) {
    const trace = this.langfuse.trace({
      name: `mcp-session-${sessionConfig.server}`,
      userId: sessionConfig.userId,
      metadata: {
        server: sessionConfig.server,
        tools: sessionConfig.tools,
        startTime: new Date().toISOString()
      }
    });

    return {
      trace,
      
      async logToolCall(toolName, parameters, result, duration) {
        const generation = trace.generation({
          name: `mcp-tool-${toolName}`,
          model: `mcp-server:${sessionConfig.server}`,
          input: this.sanitize(parameters),
          output: this.sanitize(result),
          usage: {
            duration_ms: duration
          }
        });

        await this.sendMetrics({
          server: sessionConfig.server,
          tool: toolName,
          duration,
          success: !result.error,
          timestamp: new Date().toISOString()
        });
      }
    };
  }
}