// Vor MCP: Hardcodierte Integrationen
const integrations = {
  slack: require('./integrations/slack'),
  github: require('./integrations/github'),
  notion: require('./integrations/notion'),
  // ... 44 weitere benutzerdefinierte Adapter
};

// Jede Integration erforderte benutzerdefinierte Authentifizierung, Fehlerbehandlung, Ratenlimitierung
// Insgesamt: 47 verschiedene Integrationsmuster zu pflegen

// Nach MCP: Standardisiertes Protokoll
const { Client } = require('@anthropic/mcp-client');

const client = new Client();
await client.connect('https://mcp-server.slack.com/sse');
await client.connect('https://mcp-server.github.com/sse');
await client.connect('https://mcp-server.notion.com/sse');

// Alle Server stellen Tools über standardisierte Schnittstelle bereit
const tools = await client.listTools();
// Tools sind selbstbeschreibend mit Schemas

// A2A Agent Karte - Wirbt mit Agentenfähigkeiten
{
  "name": "content-creation-agent",
  "description": "Erstellt Blogbeiträge und Social-Media-Inhalte",
  "capabilities": [
    {
      "name": "writeBlogPost",
      "description": "Schreibt SEO-optimierte Blogbeiträge",
      "parameters": {
        "topic": "string",
        "tone": "enum:professional|casual|technical",
        "length": "enum:short|medium|long"
      }
    },
    {
      "name": "generateSocialPosts",
      "description": "Erstellt Social-Media-Inhalte aus Blogbeiträgen",
      "parameters": {
        "sourceContent": "string",
        "platforms": "array:twitter|linkedin|facebook"
      }
    }
  ],
  "authentication": {
    "type": "oauth2",
    "scopes": ["content:read", "content:write"]
  }
}

┌─────────────────────────────────────────────────────────────────┐
│                    Kundenservice Plattform                        │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────────┐    A2A     ┌─────────────────┐           │
│  │  Triage Agent   │◄───────────►│ Research Agent  │           │
│  │   (A2A Client)  │             │   (A2A Server)  │           │
│  └────────┬────────┘             └────────┬────────┘           │
│           │                               │                     │
│           │ A2A                           │ MCP                  │
│           ▼                               ▼                     │
│  ┌─────────────────┐             ┌─────────────────┐           │
│  │ Resolution Agent│             │  CRM MCP Server │           │
│  │   (A2A Server)  │             │                 │           │
│  └────────┬────────┘             └─────────────────┘           │
│           │                                                     │
│           │ MCP                                                 │
│           ▼                                                     │
│  ┌─────────────────┐    ┌─────────────────┐                   │
│  │ Slack MCP Server│    │ Email MCP Server│                   │
│  └─────────────────┘    └─────────────────┘                   │
└─────────────────────────────────────────────────────────────────┘

# Beliebte MCP Server Kategorien (Mai 2026)

developer_tools:
  - github: github.com/github/mcp-server
  - gitlab: gitlab.com/gitlab-org/mcp-server
  - vscode: code.visualstudio.com/mcp
  - docker: hub.docker.com/mcp-server
  - kubernetes: github.com/k8s-mcp/server

business_applications:
  - salesforce: developer.salesforce.com/mcp
  - hubspot: developers.hubspot.com/mcp
  - zendesk: developer.zendesk.com/mcp
  - intercom: developers.intercom.com/mcp
  - stripe: stripe.com/docs/mcp

productivity:
  - notion: developers.notion.com/mcp
  - asana: developers.asana.com/mcp
  - trello: developer.atlassian.com/trello/mcp
  - slack: api.slack.com/mcp
  - microsoft_teams: docs.microsoft.com/mcp/teams

data_storage:
  - postgresql: github.com/modelcontextprotocol/postgres-server
  - mongodb: github.com/modelcontextprotocol/mongodb-server
  - redis: github.com/modelcontextprotocol/redis-server
  - snowflake: docs.snowflake.com/mcp
  - bigquery: cloud.google.com/bigquery/mcp

communication:
  - gmail: developers.google.com/gmail/mcp
  - outlook: docs.microsoft.com/outlook/mcp
  - twilio: twilio.com/docs/mcp
  - sendgrid: sendgrid.com/docs/mcp
  - mailgun: documentation.mailgun.com/mcp

// n8n Code Node: MCP Client Setup
const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
const { SSEClientTransport } = require('@modelcontextprotocol/sdk/client/sse.js');

// MCP Client initialisieren
const client = new Client(
  { name: 'n8n-mcp-client', version: '1.0.0' },
  { capabilities: { tools: {}, resources: {} } }
);

// Mit MCP Server verbinden
const transport = new SSEClientTransport(
  new URL('https://mcp-server.slack.com/sse')
);

await client.connect(transport);

// Verfügbare Tools auflisten
const tools = await client.listTools();

return {
  json: {
    connected: true,
    availableTools: tools.tools.map(t => ({
      name: t.name,
      description: t.description
    }))
  }
};

// MCP unterstützt mehrere Authentifizierungsmuster

// Muster 1: Bearer Token
const authHeaders = {
  'Authorization': `Bearer ${$env.MCP_API_TOKEN}`
};

// Muster 2: OAuth 2.0 (für Benutzerkontext-Operationen)
const oauthConfig = {
  clientId: $env.OAUTH_CLIENT_ID,
  clientSecret: $env.OAUTH_CLIENT_SECRET,
  redirectUri: 'https://your-app.com/oauth/callback',
  scopes: ['slack:read', 'slack:write']
};

// Muster 3: API Key
const apiKeyConfig = {
  headerName: 'X-API-Key',
  apiKey: $env.SERVICE_API_KEY
};

// custom-mcp-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

// Definieren Sie Ihren internen Service-Client
class InternalServiceClient {
  async queryDatabase(query: string, params: any[]) {
    // Ihre Datenbanklogik
  }
  
  async triggerWorkflow(workflowId: string, inputs: any) {
    // Ihre Workflow-Logik
  }
  
  async getCustomerData(customerId: string) {
    // Ihre CRM-Logik
  }
}

const serviceClient = new InternalServiceClient();

const server = new Server(
  {
    name: 'internal-service-mcp',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Verfügbare Tools definieren
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'query_internal_database',
        description: 'Führt Read-Only-Abfragen gegen interne Datenbank aus',
        inputSchema: {
          type: 'object',
          properties: {
            query: {
              type: 'string',
              description: 'Auszuführende SQL-Abfrage'
            },
            parameters: {
              type: 'array',
              description: 'Abfrageparameter'
            }
          },
          required: ['query']
        }
      },
      {
        name: 'trigger_business_workflow',
        description: 'Löst internen Geschäftsprozess-Workflow aus',
        inputSchema: {
          type: 'object',
          properties: {
            workflowId: {
              type: 'string',
              enum: ['customer_onboarding', 'order_processing', 'refund_handling']
            },
            inputs: {
              type: 'object',
              description: 'Workflow-Eingabeparameter'
            }
          },
          required: ['workflowId']
        }
      },
      {
        name: 'get_customer_360_view',
        description: 'Ruft umfassende Kundendaten aus allen Systemen ab',
        inputSchema: {
          type: 'object',
          properties: {
            customerId: {
              type: 'string',
              description: 'Eindeutiger Kundenbezeichner'
            }
          },
          required: ['customerId']
        }
      }
    ]
  };
});

// Tool-Aufrufe behandeln
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    switch (name) {
      case 'query_internal_database':
        const results = await serviceClient.queryDatabase(
          args.query,
          args.parameters || []
        );
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(results, null, 2)
            }
          ]
        };

      case 'trigger_business_workflow':
        const workflowResult = await serviceClient.triggerWorkflow(
          args.workflowId,
          args.inputs
        );
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(workflowResult, null, 2)
            }
          ]
        };

      case 'get_customer_360_view':
        const customerData = await serviceClient.getCustomerData(args.customerId);
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(customerData, null, 2)
            }
          ]
        };

      default:
        throw new Error(`Unbekanntes Tool: ${name}`);
    }
  } catch (error) {
    return {
      content: [
        {
          type: 'text',
          text: `Fehler: ${error.message}`
        }
      ],
      isError: true
    };
  }
});

// Server starten
const transport = new StdioServerTransport();
await server.connect(transport);

# Dockerfile
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .
RUN npm run build

EXPOSE 3000

CMD ["node", "dist/custom-mcp-server.js"]

# docker-compose.yml
version: '3.8'
services:
  mcp-server:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - API_KEY=${API_KEY}
      - LOG_LEVEL=info
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped

{
  "$schema": "https://google.github.io/A2A/schemas/agent-card.json",
  "name": "marketing-content-agent",
  "description": "Erstellt und optimiert Marketing-Inhalte über Kanäle hinweg",
  "version": "2.1.0",
  "url": "https://agents.company.com/marketing-content",
  "provider": {
    "name": "Acme Marketing",
    "url": "https://acme.com"
  },
  "capabilities": {
    "streaming": true,
    "pushNotifications": true,
    "stateTransitionHistory": true
  },
  "skills": [
    {
      "id": "blog-generation",
      "name": "Blog Post Generierung",
      "description": "Generiert SEO-optimierte Blogbeiträge mit Recherche",
      "inputModes": ["text", "file"],
      "outputModes": ["text", "file"],
      "examples": [
        {
          "input": {
            "topic": "KI Automatisierungstrends 2026",
            "tone": "professional",
            "length": 2000
          },
          "output": {
            "content": "...",
            "metadata": {
              "wordCount": 2150,
              "readabilityScore": 72,
              "seoScore": 89
            }
          }
        }
      ]
    },
    {
      "id": "social-optimization",
      "name": "Social Media Optimierung",
      "description": "Transformiert Inhalte für verschiedene Social Plattformen",
      "inputModes": ["text"],
      "outputModes": ["text"]
    }
  ],
  "authentication": {
    "type": "oauth2",
    "authorizationUrl": "https://auth.acme.com/oauth/authorize",
    "tokenUrl": "https://auth.acme.com/oauth/token",
    "scopes": ["content:read", "content:write", "analytics:read"]
  }
}

// n8n Code Node: Agenten entdecken und verbinden

const AGENT_REGISTRY_URL = 'https://registry.a2a.agents.com/v1/agents';

// Nach Agenten nach Fähigkeit suchen
async function discoverAgents(capability) {
  const response = await fetch(
    `${AGENT_REGISTRY_URL}?capability=${encodeURIComponent(capability)}`,
    {
      headers: {
        'Authorization': `Bearer ${$env.A2A_REGISTRY_TOKEN}`
      }
    }
  );
  
  const data = await response.json();
  return data.agents;
}

// Content-Erstellungsagenten finden
const contentAgents = await discoverAgents('content-generation');

// Nach Bewertung und Verfügbarkeit filtern
const qualifiedAgents = contentAgents.filter(agent => 
  agent.rating >= 4.5 && 
  agent.status === 'available' &&
  agent.pricing.model === 'per_task'
);

// Besten Agenten nach Kriterien auswählen
const selectedAgent = qualifiedAgents.sort((a, b) =>
  b.rating - a.rating
)[0];

return {
  json: {
    availableAgents: qualifiedAgents.length,
    selectedAgent: {
      name: selectedAgent.name,
      url: selectedAgent.url,
      rating: selectedAgent.rating,
      costPerTask: selectedAgent.pricing.amount
    }
  }
};

// n8n HTTP Request Node: A2A Aufgabe senden

const a2aTask = {
  id: `task-${Date.now()}`,
  sessionId: $json.sessionId,
  acceptedOutputModes: ['text', 'file'],
  
  message: {
    role: 'user',
    parts: [
      {
        type: 'text',
        text: 'Erstelle einen umfassenden Blogbeitrag über MCP und A2A Protokolle'
      },
      {
        type: 'file',
        file: {
          name: 'research-notes.pdf',
          mimeType: 'application/pdf',
          uri: 'https://storage.company.com/research/notes.pdf'
        }
      }
    ]
  },
  
  // Kontext aus vorherigen Interaktionen
  context: {
    previousTasks: [
      {
        taskId: 'task-12345',
        summary: 'Initiale Recherche abgeschlossen',
        artifacts: ['outline.json', 'sources.bib']
      }
    ],
    // Gemeinsamer Zustand über Agenten hinweg
    sharedState: {
      brandVoice: 'professional_technical',
      targetAudience: 'enterprise_developers',
      seoKeywords: ['MCP', 'A2A', 'multi-agent', 'automation']
    }
  },
  
  // Aufgabenanforderungen
  requirements: {
    maxTokens: 4000,
    temperature: 0.7,
    timeout: 300000, // 5 Minuten
    priority: 'high'
  }
};

// An A2A Agenten senden
const response = await fetch($json.selectedAgent.url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${$env.A2A_AGENT_TOKEN}`,
    'X-A2A-Protocol-Version': '1.0'
  },
  body: JSON.stringify(a2aTask)
});

const result = await response.json();

return {
  json: {
    taskId: result.id,
    status: result.status,
    artifacts: result.artifacts,
    agent: result.agent.name
  }
};

// n8n Code Node: A2A Streaming behandeln

const fetch = require('node-fetch');

async function streamA2ATask(agentUrl, task) {
  const response = await fetch(`${agentUrl}/tasks/sendSubscribe`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${$env.A2A_TOKEN}`,
      'Content-Type': 'application/json',
      'Accept': 'text/event-stream'
    },
    body: JSON.stringify(task)
  });

  const updates = [];
  
  // SSE Stream verarbeiten
  for await (const chunk of response.body) {
    const lines = chunk.toString().split('\n');
    
    for (const line of lines) {
      if (line.startsWith('data: ')) {
        const data = JSON.parse(line.slice(6));
        updates.push({
          timestamp: new Date(),
          status: data.status,
          message: data.message,
          progress: data.progress
        });
        
        // Fortschrittsupdates loggen
        if (data.progress) {
          console.log(`Fortschritt: ${data.progress.percent}% - ${data.progress.stage}`);
        }
      }
    }
  }

  return updates;
}

// Verwendung
const streamingResult = await streamA2ATask(
  $json.agentUrl,
  $json.task
);

return {
  json: {
    updateCount: streamingResult.length,
    finalStatus: streamingResult[streamingResult.length - 1]?.status,
    processingTime: streamingResult[streamingResult.length - 1]?.timestamp - 
                   streamingResult[0]?.timestamp
  }
};

// n8n Workflow: MCP-gestützter Kundensupport

// Schritt 1: Kundenanfrage empfangen (Webhook Node)
// Auslöser: Neues Support-Ticket erstellt

// Schritt 2: CRM via MCP abfragen
const crmQuery = {
  tool: 'get_customer_360_view',
  parameters: {
    customerId: $json.ticket.customerId
  }
};

// Mit CRM MCP Server verbinden
const crmResponse = await fetch('https://mcp-crm.company.com/tools/call', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${$env.CRM_MCP_TOKEN}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(crmQuery)
});

const customerData = await crmResponse.json();

// Schritt 3: Wissensdatenbank via MCP prüfen
const kbQuery = {
  tool: 'search_articles',
  parameters: {
    query: $json.ticket.subject,
    limit: 5,
    customerTier: customerData.tier
  }
};

const kbResponse = await fetch('https://mcp-kb.company.com/tools/call', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${$env.KB_MCP_TOKEN}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(kbQuery)
});

const kbArticles = await kbResponse.json();

// Schritt 4: Basierend auf Komplexität an geeigneten Agenten routen
let routing;
if (customerData.tier === 'enterprise' && $json.ticket.priority === 'urgent') {
  routing = {
    agent: 'senior_support',
    sla: '15_minutes',
    notify: ['support_manager', 'customer_success']
  };
} else if (kbArticles.length > 0 && kbArticles[0].confidence > 0.9) {
  // Mit vorgeschlagener Antwort automatisch lösen
  routing = {
    action: 'auto_respond',
    articleId: kbArticles[0].id,
    draftResponse: await generateDraftResponse(kbArticles[0], $json.ticket)
  };
} else {
  // Für menschlichen Agenten in Warteschlange stellen
  routing = {
    agent: 'general_support',
    sla: '4_hours'
  };
}

// Schritt 5: Via Slack MCP benachrichtigen
await fetch('https://mcp-slack.company.com/tools/call', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${$env.SLACK_MCP_TOKEN}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    tool: 'send_channel_message',
    parameters: {
      channel: routing.agent === 'senior_support' ? '#enterprise-urgent' : '#support-queue',
      message: {
        text: `Neues ${$json.ticket.priority} Ticket von ${customerData.company}`,
        blocks: [
          {
            type: 'section',
            text: {
              type: 'mrkdwn',
              text: `*${$json.ticket.subject}*\nVon: ${customerData.name} (${customerData.tier})\nSLA: ${routing.sla}`
            }
          }
        ]
      }
    }
  })
});

return {
  json: {
    ticketId: $json.ticket.id,
    routing: routing,
    customerTier: customerData.tier,
    kbMatches: kbArticles.length
  }
};

// n8n Workflow: Multi-Agent Content Pipeline

// Verfügbare Agenten via A2A:
// 1. Recherche Agent - Sammelt Informationen und Quellen
// 2. Schreib Agent - Erstellt Content-Entwürfe
// 3. SEO Agent - Optimiert für Suche
// 4. Review Agent - Qualitätssicherung

const pipeline = {
  topic: $json.contentRequest.topic,
  contentType: $json.contentRequest.type,
  deadline: $json.contentRequest.deadline
};

// Schritt 1: An Recherche Agenten delegieren
const researchTask = {
  id: `research-${Date.now()}`,
  skill: 'comprehensive-research',
  input: {
    topic: pipeline.topic,
    depth: 'detailed',
    sources: ['industry_reports', 'competitor_analysis', 'trend_data']
  },
  context: {
    industry: $json.contentRequest.industry,
    targetAudience: $json.contentRequest.audience
  }
};

const researchResult = await delegateToAgent(
  'https://research-agent.company.com/a2a',
  researchTask
);

// Schritt 2: Recherche an Schreib Agenten weitergeben
const writingTask = {
  id: `writing-${Date.now()}`,
  skill: 'long-form-content',
  input: {
    topic: pipeline.topic,
    research: researchResult.artifacts,
    contentType: pipeline.contentType,
    tone: $json.contentRequest.tone
  },
  context: {
    previousTask: researchTask.id,
    researchSummary: researchResult.summary
  }
};

const draftResult = await delegateToAgent(
  'https://writing-agent.company.com/a2a',
  writingTask
);

// Schritt 3: Parallele Verarbeitung - SEO und Review
const [seoResult, reviewResult] = await Promise.all([
  // SEO-Optimierung
  delegateToAgent('https://seo-agent.company.com/a2a', {
    id: `seo-${Date.now()}`,
    skill: 'seo-optimization',
    input: {
      content: draftResult.content,
      keywords: $json.contentRequest.keywords,
      targetScore: 85
    }
  }),
  
  // Qualitätsprüfung
  delegateToAgent('https://review-agent.company.com/a2a', {
    id: `review-${Date.now()}`,
    skill: 'content-review',
    input: {
      content: draftResult.content,
      checks: ['grammar', 'accuracy', 'brand_voice', 'readability']
    }
  })
]);

// Schritt 4: Feedback integrieren
const finalContent = await integrateFeedback({
  draft: draftResult.content,
  seoSuggestions: seoResult.suggestions,
  reviewFeedback: reviewResult.feedback
});

// Schritt 5: Via MCP veröffentlichen
await fetch('https://mcp-cms.company.com/tools/call', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${$env.CMS_MCP_TOKEN}`
  },
  body: JSON.stringify({
    tool: 'publish_article',
    parameters: {
      title: finalContent.title,
      content: finalContent.body,
      metadata: {
        seoScore: seoResult.score,
        reviewScore: reviewResult.score,
        author: 'AI-Pipeline',
        publishedAt: new Date().toISOString()
      }
    }
  })
});

return {
  json: {
    contentId: finalContent.id,
    seoScore: seoResult.score,
    reviewScore: reviewResult.score,
    processingTime: Date.now() - startTime,
    agentsUsed: ['research', 'writing', 'seo', 'review']
  }
};

// Hilfsfunktion
async function delegateToAgent(agentUrl, task) {
  const response = await fetch(`${agentUrl}/tasks/send`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${$env.A2A_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(task)
  });
  return await response.json();
}

// n8n Workflow: Verteilte Zustandsverwaltung

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

const sessionId = $json.sessionId || `session-${Date.now()}`;

// Zustandsstruktur für Multi-Agent Sitzung
const sessionState = {
  id: sessionId,
  createdAt: new Date().toISOString(),
  agents: {},
  sharedContext: {},
  artifacts: [],
  status: 'active'
};

// Initialisieren wenn neue Sitzung
const existing = await redis.get(`session:${sessionId}`);
if (!existing) {
  await redis.setex(
    `session:${sessionId}`,
    3600, // 1 Stunde TTL
    JSON.stringify(sessionState)
  );
}

// Agentenregistrierung
async function registerAgent(agentId, agentInfo) {
  const state = JSON.parse(await redis.get(`session:${sessionId}`));
  state.agents[agentId] = {
    ...agentInfo,
    registeredAt: new Date().toISOString(),
    lastHeartbeat: new Date().toISOString(),
    status: 'active'
  };
  await redis.setex(`session:${sessionId}`, 3600, JSON.stringify(state));
}

// Kontextupdates
async function updateContext(key, value) {
  const state = JSON.parse(await redis.get(`session:${sessionId}`));
  state.sharedContext[key] = {
    value,
    updatedAt: new Date().toISOString(),
    updatedBy: $json.agentId
  };
  await redis.setex(`session:${sessionId}`, 3600, JSON.stringify(state));
}

// Artefaktspeicherung
async function storeArtifact(artifact) {
  const state = JSON.parse(await redis.get(`session:${sessionId}`));
  state.artifacts.push({
    ...artifact,
    id: `artifact-${Date.now()}`,
    storedAt: new Date().toISOString()
  });
  await redis.setex(`session:${sessionId}`, 3600, JSON.stringify(state));
}

// Verwendung im Workflow
await registerAgent('writing-agent', {
  name: 'Writing Agent',
  capabilities: ['content-creation', 'editing'],
  url: 'https://writing-agent.company.com'
});

await updateContext('brandVoice', {
  tone: 'professional',
  vocabulary: 'technical',
  avoidWords: ['billig', 'einfach', 'leicht']
});

await storeArtifact({
  type: 'draft',
  content: $json.draftContent,
  version: 1
});

return {
  json: {
    sessionId,
    registered: true
  }
};

# ~/.openclaw/mcp-servers.yaml

servers:
  filesystem:
    command: npx
    args: 
      - "-y"
      - "@modelcontextprotocol/server-filesystem"
      - "/home/user/workspace"
    env:
      - name: NODE_ENV
        value: production
  
  sqlite:
    command: uvx
    args:
      - "mcp-server-sqlite"
      - "--db-path"
      - "/home/user/data/app.db"
  
  brave-search:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-brave-search"
    env:
      - name: BRAVE_API_KEY
        value: ${BRAVE_API_KEY}
  
  custom-business-logic:
    command: node
    args:
      - "/opt/openclaw/skills/custom-mcp/dist/server.js"
    env:
      - name: DATABASE_URL
        value: ${DATABASE_URL}
      - name: API_SECRET
        value: ${API_SECRET}

// ~/.openclaw/skills/multi-agent-orchestrator/SKILL.md
# Multi-Agent Orchestrator Skill

## Beschreibung
Orchestriert mehrere KI-Agenten unter Verwendung von MCP und A2A Protokollen für komplexe Aufgaben

## Anforderungen
- OpenClaw >= 2026.4.0
- Node.js >= 20
- Redis (optional, für Zustandsverwaltung)

## Konfiguration
```yaml
agents:
  research:
    type: mcp
    server: brave-search
    model: claude-3-7-sonnet
  
  writer:
    type: a2a
    url: https://writer-agent.internal.com/a2a
    auth: oauth2
  
  reviewer:
    type: mcp
    server: custom-business-logic
    model: claude-3-5-haiku

@orchestrator erstelle Blogbeitrag über KI Automatisierung
  mit Recherchetiefe: umfassend
  und Ton: professionell
  und seo-optimiert: true

// ~/.openclaw/skills/multi-agent-orchestrator/index.ts

import { Skill, Context, Message } from '@openclaw/core';
import { MCPClient } from '@anthropic/mcp-sdk';
import { A2AClient } from '@google/a2a-sdk';

export default class MultiAgentOrchestratorSkill implements Skill {
  name = 'multi-agent-orchestrator';
  mcpClient: MCPClient;
  a2aClient: A2AClient;

  async initialize(config: any) {
    this.mcpClient = new MCPClient();
    this.a2aClient = new A2AClient();
    
    // Mit konfigurierten MCP Servern verbinden
    for (const [name, serverConfig] of Object.entries(config.mcp_servers)) {
      await this.mcpClient.connect(serverConfig);
    }
  }

  @tool()
  async orchestrate_content_pipeline(
    topic: string,
    contentType: 'blog' | 'whitepaper' | 'social',
    requirements: any,
    context: Context
  ): Promise<any> {
    const sessionId = `session-${Date.now()}`;
    
    // Schritt 1: Recherchephase (MCP)
    const researchResult = await this.mcpClient.callTool(
      'brave-search',
      'search',
      {
        query: topic,
        depth: 'comprehensive',
        num_results: 20
      }
    );

    await context.sendProgress('Recherche abgeschlossen', 25);

    // Schritt 2: Schreibphase (A2A)
    const writingTask = await this.a2aClient.sendTask({
      agentUrl: context.config.agents.writer.url,
      skill: 'long_form_content',
      input: {
        topic,
        research: researchResult,
        contentType,
        requirements
      }
    });

    await context.sendProgress('Entwurf erstellt', 50);

    // Schritt 3: Reviewphase (MCP)
    const reviewResult = await this.mcpClient.callTool(
      'custom-business-logic',
      'analyze_content_quality',
      {
        content: writingTask.output.content,
        checks: ['grammar', 'readability', 'seo']
      }
    );

    await context.sendProgress('Review abgeschlossen', 75);

    // Schritt 4: Finalisieren
    const finalContent = await this.applyEdits(
      writingTask.output.content,
      reviewResult.suggestions
    );

    await context.sendProgress('Content finalisiert', 100);

    return {
      sessionId,
      content: finalContent,
      quality: reviewResult.score,
      sources: researchResult.sources
    };
  }

  @tool()
  async delegate_task(
    agentName: string,
    task: any,
    context: Context
  ): Promise<any> {
    const agent = context.config.agents[agentName];
    
    if (agent.type === 'mcp') {
      return await this.mcpClient.callTool(
        agent.server,
        task.tool,
        task.parameters
      );
    } else if (agent.type === 'a2a') {
      return await this.a2aClient.sendTask({
        agentUrl: agent.url,
        skill: task.skill,
        input: task.input
      });
    }
  }
}

// n8n Workflow: Resiliente MCP-Aufrufe

const CircuitBreaker = require('opossum');

// Circuit Breaker Konfiguration
const options = {
  timeout: 10000, // 10 Sekunden
  errorThresholdPercentage: 50,
  resetTimeout: 30000, // 30 Sekunden
  volumeThreshold: 10
};

// MCP-Aufruf mit Circuit Breaker ummanteln
const mcpCallBreaker = new CircuitBreaker(async (server, tool, params) => {
  const response = await fetch(`https://mcp-${server}.company.com/tools/call`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${$env[`${server.toUpperCase()}_MCP_TOKEN`]}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ tool, parameters: params })
  });
  
  if (!response.ok) {
    throw new Error(`MCP Server Fehler: ${response.status}`);
  }
  
  return await response.json();
}, options);

// Event-Handler
mcpCallBreaker.on('open', () => {
  console.log(`Circuit Breaker GEÖFFNET für MCP Server`);
  // Betriebsteam alarmieren
});

mcpCallBreaker.on('halfOpen', () => {
  console.log(`Circuit Breaker HALB-GEÖFFNET für MCP Server`);
});

mcpCallBreaker.on('close', () => {
  console.log(`Circuit Breaker GESCHLOSSEN für MCP Server`);
});

// Verwendung mit Fallback
try {
  const result = await mcpCallBreaker.fire(
    'crm',
    'get_customer',
    { customerId: $json.customerId }
  );
  return { json: result };
} catch (error) {
  // Auf Cache zurückgreifen
  const cached = await getFromCache(`customer:${$json.customerId}`);
  if (cached) {
    return {
      json: {
        ...cached,
        _source: 'cache',
        _warning: 'MCP Server nicht verfügbar, verwende zwischengespeicherte Daten'
      }
    };
  }
  throw error;
}

// n8n Workflow: Intelligente Ratenbegrenzung

const Bottleneck = require('bottleneck');

// Ratenbegrenzungen pro MCP Server definieren
const limiters = {
  'openai': new Bottleneck({
    minTime: 200, // 5 Anfragen pro Sekunde
    maxConcurrent: 3
  }),
  'anthropic': new Bottleneck({
    minTime: 100,
    maxConcurrent: 5
  }),
  'brave-search': new Bottleneck({
    minTime: 1000, // 1 Anfrage pro Sekunde
    reservoir: 2000, // Monatliches Kontingent
    reservoirRefreshAmount: 2000,
    reservoirRefreshInterval: 30 * 24 * 60 * 60 * 1000 // 30 Tage
  })
};

// Kostentracking
const costTracker = {
  async track(server, operation, cost) {
    const key = `costs:${new Date().toISOString().slice(0, 7)}`; // Monatlich
    const current = await redis.hget(key, server) || 0;
    await redis.hset(key, server, parseFloat(current) + cost);
  },
  
  async getBudgetStatus(server, budget) {
    const key = `costs:${new Date().toISOString().slice(0, 7)}`;
    const spent = await redis.hget(key, server) || 0;
    return {
      spent: parseFloat(spent),
      remaining: budget - parseFloat(spent),
      percentUsed: (spent / budget) * 100
    };
  }
};

// Verwendung
const server = $json.mcpServer;
const budget = $json.budget || 1000; // $1000 monatlich

const status = await costTracker.getBudgetStatus(server, budget);

if (status.percentUsed > 90) {
  return {
    json: {
      error: 'Budgetschwelle überschritten',
      status: status,
      action: 'use_fallback'
    }
  };
}

const result = await limiters[server].schedule(async () => {
  const start = Date.now();
  const response = await callMCP(server, $json.operation);
  const duration = Date.now() - start;
  
  // Kosten tracken (Beispiel: $0.002 pro Anfrage)
  await costTracker.track(server, $json.operation, 0.002);
  
  return response;
});

return { json: result };

// n8n Workflow: Sicherer MCP/A2A Zugriff

// JWT Validierungs-Middleware
const jwt = require('jsonwebtoken');

async function validateAccess(token, requiredScopes) {
  try {
    const decoded = jwt.verify(token, $env.JWT_PUBLIC_KEY);
    
    // Scopes prüfen
    const hasScopes = requiredScopes.every(scope => 
      decoded.scopes.includes(scope)
    );
    
    if (!hasScopes) {
      throw new Error('Unzureichende Scopes');
    }
    
    return {
      valid: true,
      userId: decoded.sub,
      organizationId: decoded.org_id,
      scopes: decoded.scopes
    };
  } catch (error) {
    return {
      valid: false,
      error: error.message
    };
  }
}

// Row-level Security für Datenbank MCP
async function enforceRLS(userId, table, operation) {
  const permissions = await getUserPermissions(userId);
  
  // Abfrage mit RLS aufbauen
  const query = {
    table,
    operation,
    where: {
      // Mandantenisolierung
      tenant_id: permissions.tenantId,
      // Benutzerspezifische Einschränkungen
      ...permissions.rowFilters[table]
    }
  };
  
  return query;
}

// Audit-Logging
async function auditLog(event) {
  await fetch('https://mcp-audit.company.com/tools/call', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${$env.AUDIT_MCP_TOKEN}` },
    body: JSON.stringify({
      tool: 'log_security_event',
      parameters: {
        timestamp: new Date().toISOString(),
        userId: event.userId,
        action: event.action,
        resource: event.resource,
        outcome: event.outcome,
        ipAddress: $json.requestIp,
        userAgent: $json.userAgent
      }
    })
  });
}

// Verwendung
const auth = await validateAccess(
  $json.token,
  ['mcp:read', 'customer:view']
);

if (!auth.valid) {
  await auditLog({
    userId: 'anonymous',
    action: 'access_denied',
    resource: 'mcp_crm',
    outcome: 'failure',
    reason: auth.error
  });
  
  return {
    json: { error: 'Zugriff verweigert', code: 403 }
  };
}

// Mit sicherem Zugriff fortfahren
const secureQuery = await enforceRLS(auth.userId, 'customers', 'select');
const result = await callMCP('crm', 'query', secureQuery);

await auditLog({
  userId: auth.userId,
  action: 'mcp_query',
  resource: 'customers',
  outcome: 'success'
});

return { json: result };

# mcp-server-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-crm-server
  namespace: ai-automation
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-crm-server
  template:
    metadata:
      labels:
        app: mcp-crm-server
    spec:
      containers:
      - name: mcp-server
        image: company/mcp-crm-server:2.1.0
        ports:
        - containerPort: 3000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: database-url
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: api-key
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: mcp-crm-server
  namespace: ai-automation
spec:
  selector:
    app: mcp-crm-server
  ports:
  - port: 80
    targetPort: 3000
  type: ClusterIP
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mcp-crm-ingress
  namespace: ai-automation
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/rate-limit: "100"
spec:
  tls:
  - hosts:
    - mcp-crm.company.com
    secretName: mcp-crm-tls
  rules:
  - host: mcp-crm.company.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: mcp-crm-server
            port:
              number: 80

// n8n Workflow: MCP/A2A Observability

const { MeterProvider } = require('@opentelemetry/sdk-metrics');
const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');

// Metriken einrichten
const exporter = new PrometheusExporter({
  port: 9090
});

const meterProvider = new MeterProvider({
  readers: [exporter]
});

const meter = meterProvider.getMeter('mcp-a2a-metrics');

// Metriken definieren
const mcpRequestCounter = meter.createCounter('mcp_requests_total', {
  description: 'Gesamte MCP Anfragen'
});

const mcpLatencyHistogram = meter.createHistogram('mcp_request_duration_seconds', {
  description: 'MCP Anfragelatenz'
});

const a2aTaskCounter = meter.createCounter('a2a_tasks_total', {
  description: 'Gesamte A2A Aufgaben'
});

// MCP-Aufrufe instrumentieren
async function instrumentedMCPCall(server, tool, params) {
  const startTime = Date.now();
  const labels = { server, tool };
  
  try {
    const result = await callMCP(server, tool, params);
    
    mcpRequestCounter.add(1, { ...labels, status: 'success' });
    mcpLatencyHistogram.record((Date.now() - startTime) / 1000, labels);
    
    return result;
  } catch (error) {
    mcpRequestCounter.add(1, { ...labels, status: 'error', error: error.code });
    throw error;
  }
}

// Health Check Endpunkt
async function healthCheck() {
  const checks = await Promise.all([
    checkMCPConnection('crm'),
    checkMCPConnection('kb'),
    checkA2AConnection('writer-agent')
  ]);
  
  return {
    status: checks.every(c => c.healthy) ? 'healthy' : 'degraded',
    checks: checks,
    timestamp: new Date().toISOString()
  };
}

// Verwendung im Workflow
const result = await instrumentedMCPCall(
  $json.server,
  $json.tool,
  $json.params
);

return { json: result };