┌─────────────────────────────────────────────────────────────────┐
│                    MCP-Architekturübersicht                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌──────────────┐         JSON-RPC 2.0          ┌──────────────┐│
│   │   MCP Client │  ◄──────────────────────────► │   MCP Server  ││
│   │  (ChatGPT,   │     (stdio, HTTP/SSE)        │  (Ihre APIs,  ││
│   │   Cursor,    │                               │  Datenbank,   ││
│   │   n8n,       │                               │  Dateien usw.)││
│   │   OpenClaw)  │                               │              ││
│   └──────────────┘                               └──────────────┘│
│          │                                               │       │
│          │           Austausch von Fähigkeiten         │       │
│          │  ───────────────────────────────────────────► │       │
│          │  ◄─────────────────────────────────────────── │       │
│          │                                               │       │
│          │           Tool-Aufrufe / Ressourcen-Anfragen │       │
│          │  ───────────────────────────────────────────► │       │
│          │  ◄─────────────────────────────────────────── │       │
│          │                                               │       │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              MCP Enterprise-Autorisierungsfluss                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Schritt 1: Client-Entdeckung                                    │
│  ────────────────────────────                                    │
│  Client fordert Serverfähigkeiten an                             │
│                                                                  │
│  GET /.well-known/mcp                                            │
│  Antwort enthält:                                                │
│    - Verfügbare Fähigkeiten                                      │
│    - Authentifizierungsanforderungen                             │
│    - Autorisierungsendpunkte                                     │
│                                                                  │
│  Schritt 2: Authentifizierung                                    │
│  ─────────────────────────────                                   │
│  Client authentifiziert mit konfigurierter Methode:              │
│                                                                  │
│  Unterstützte Methoden:                                          │
│    - OAuth 2.0 (Authorization Code + PKCE)                       │
│    - OAuth 2.0 (Client Credentials)                              │
│    - mTLS (Mutual TLS)                                           │
│    - JWT Bearer Tokens                                           │
│    - API Key (mit Rotationsunterstützung)                        │
│                                                                  │
│  Schritt 3: Token-Austausch                                      │
│  ──────────────────────────                                      │
│  Authentifizierter Client erhält MCP-Zugriffstoken:            │
│                                                                  │
│  {                                                               │
│    "access_token": "mcp_at_...",                                 │
│    "token_type": "Bearer",                                       │
│    "expires_in": 3600,                                           │
│    "scope": "tools:read tools:execute resources:read",         │
│    "server_metadata": {                                          │
│      "instance_id": "srv_abc123",                              │
│      "region": "us-west-2",                                      │
│      "capabilities": [...]                                         │
│    }                                                             │
│  }                                                               │
│                                                                  │
│  Schritt 4: Autorisierte Anfragen                                │
│  ────────────────────────────────                                │
│  Client fügt Token in alle Anfragen ein:                         │
│                                                                  │
│  Authorization: Bearer mcp_at_...                                │
│  X-MCP-Client-Version: 2026-07-28                                │
│                                                                  │
│  Server validiert Token, prüft Scopes, verarbeitet Anfrage       │
│                                                                  │
│  Schritt 5: Token-Aktualisierung                                 │
│  ───────────────────────────────                                 │
│  Tokens aktualisieren sich automatisch vor Ablauf                │
│  Refresh-Tokens ermöglichen langlebige Sitzungen                 │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

tools:read          - Tools auflisten
tools:execute       - Tools aufrufen
resources:read      - Auf Ressourcen zugreifen
resources:write     - Ressourcen ändern
prompts:read        - Server-Prompts abrufen
sampling:request    - Client-seitiges Sampling anfordern
admin:configure     - Serverkonfiguration (nur Admin)

// Client-seitiger Sitzungszustand
const mcpSession = {
  // Server-Verbindungsinfo (kann jede Instanz sein)
  serverEndpoint: "https://mcp-api.company.com/v1",
  
  // Authentifizierung
  accessToken: "mcp_at_...",
  tokenExpiry: 1719234567000,
  
  // Gesprächskontext (vom Client verwaltet)
  context: {
    conversationId: "conv_xyz789",
    toolResults: [...],      // Vorherige Tool-Aufruf-Ergebnisse
    resourceCache: {...},    // Zwischengespeicherte Ressourcendaten
    preferences: {...}       // Benutzereinstellungen
  },
  
  // Fähigkeiten-Cache
  serverCapabilities: {...}
};

// Jede Anfrage enthält Kontext
const request = {
  jsonrpc: "2.0",
  id: 123,
  method: "tools/call",
  params: {
    name: "search_database",
    arguments: {...},
    // Sitzungskontext mit jeder Anfrage übergeben
    context: mcpSession.context
  }
};

// Gute Tool-Definition
{
  name: "search_customer_database",
  description: "Suche nach Kunden in der CRM-Datenbank. Verwenden Sie dies, wenn Benutzer nach spezifischen Kunden, Konten oder Kontaktinformationen fragen. Gibt Kundendatensätze mit Name, E-Mail, Telefon und Kontostatus zurück.",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Suchabfrage-String. Kann Teil eines Namens, E-Mail oder Telefonnummer sein."
      },
      limit: {
        type: "integer",
        description: "Maximale Anzahl der zurückzugebenden Ergebnisse (1-100)",
        default: 10,
        minimum: 1,
        maximum: 100
      }
    },
    required: ["query"]
  }
}

// Grundlegende Verwendung – nur das Wesentliche
{
  name: "send_email",
  description: "Senden Sie eine E-Mail an einen Empfänger",
  inputSchema: {
    type: "object",
    properties: {
      to: { type: "string", format: "email" },
      subject: { type: "string" },
      body: { type: "string" }
    },
    required: ["to", "subject", "body"]
  }
}

// Erweiterte Verwendung – zusätzliche Optionen für anspruchsvolle Clients
{
  name: "send_email_advanced",
  description: "Senden Sie eine E-Mail mit erweiterten Optionen einschließlich Anhängen, CC/BCC, Planung und Tracking",
  inputSchema: {
    // Erweitertes Schema mit allen Optionen
  }
}

interface ToolResponse<T> {
  // Erfolgsindikator
  success: boolean;
  
  // Ergebnisdaten (bei Erfolg)
  data?: T;
  
  // Fehlerdetails (bei Fehlschlag)
  error?: {
    code: string;
    message: string;
    details?: unknown;
  };
  
  // Metadaten
  meta: {
    executionTime: number;
    requestId: string;
    cached: boolean;
  };
}

# Standard-Ressourcen-URI-Muster
database://table/records/{id}
file://documents/contracts/{filename}
api://service/endpoint/resource
config://settings/environment

// Ressourcen-Definition
{
  uri: "database://customers/active",
  name: "Aktive Kunden",
  description: "Liste derzeit aktiver Kunden",
  mimeType: "application/json",
  size: 15420,
  
  // Fähigkeiten
  capabilities: {
    // Unterstützung für Abonnements (Live-Updates)
    subscribe: true,
    
    // Paginierungsunterstützung
    pagination: {
      supported: true,
      defaultLimit: 100,
      maxLimit: 1000
    },
    
    // Such-/Filter-Unterstützung
    filtering: {
      supported: true,
      operators: ["eq", "neq", "gt", "lt", "contains", "startsWith"]
    },
    
    // Sortierungsunterstützung
    sorting: {
      supported: true,
      defaultField: "createdAt",
      defaultDirection: "desc"
    }
  }
}

// Client abonniert Ressourcen-Updates
const subscription = await client.subscribeResource({
  uri: "database://orders/pending",
  
  // Optional: Abonnement filtern
  filter: {
    region: "europe",
    priority: "high"
  },
  
  // Handler für Updates
  onUpdate: (update) => {
    console.log(`Neue Bestellung: ${update.data.orderId}`);
  },
  
  onError: (error) => {
    console.error(`Abonnementfehler: ${error.message}`);
  }
});

// Abonnement beenden
await subscription.unsubscribe();

interface SamplingRequest {
  // Nachrichten für die KI (ähnlich wie Chat-Completions-API)
  messages: Array<{
    role: "user" | "assistant" | "system";
    content: string;
  }>;
  
  // Modellpräferenzen
  modelPreferences?: {
    hints?: string[];           // Modell-Hinweise (z.B. ["claude-3-opus", "gpt-4"])
    priority?: "speed" | "quality";  // Optimierungspriorität
  };
  
  // Vervollständigungsparameter
  maxTokens?: number;
  temperature?: number;
  
  // Metadaten für Client-Kontext
  metadata: {
    requestId: string;
    purpose: string;
    clientInfo: {
      name: string;
      version: string;
    };
  };
}

// Server fordert Sampling vom Client an
async function processDocument(document: Document) {
  // Server führt initiale Verarbeitung durch
  const extractedData = await extractData(document);
  
  // Fordert KI-Unterstützung für Zusammenfassung an
  const samplingResult = await client.requestSampling({
    messages: [
      {
        role: "system",
        content: "Sie sind ein Dokumentenanalyse-Assistent. Fassen Sie die wichtigsten Punkte zusammen."
      },
      {
        role: "user",
        content: `Dokumentendaten: ${JSON.stringify(extractedData)}`
      }
    ],
    maxTokens: 500,
    metadata: {
      requestId: generateId(),
      purpose: "document_summary",
      clientInfo: { name: "mcp-server", version: "1.0.0" }
    }
  });
  
  // Kombiniert Server-Verarbeitung mit KI-Zusammenfassung
  return {
    data: extractedData,
    summary: samplingResult.content
  };
}

my-mcp-server/
├── src/
│   ├── index.ts              # Einstiegspunkt
│   ├── server.ts             # MCP-Server-Setup
│   ├── auth/
│   │   ├── oauth.ts          # OAuth-Implementierung
│   │   ├── jwt.ts            # JWT-Validierung
│   │   └── scopes.ts         // Bereichsprüfung
│   ├── tools/
│   │   ├── index.ts          // Tool-Registrierung
│   │   ├── customer-search.ts
│   │   ├── order-management.ts
│   │   └── email-sender.ts
│   ├── resources/
│   │   ├── index.ts          // Ressourcen-Registrierung
│   │   ├── customer-data.ts
│   │   └── order-stream.ts
│   ├── handlers/
│   │   ├── tools.ts          // Tool-Anfrage-Handler
│   │   ├── resources.ts      // Ressourcen-Anfrage-Handler
│   │   └── sampling.ts       // Sampling-Anfrage-Handler
│   └── utils/
│       ├── validation.ts
│       ├── errors.ts
│       └── logging.ts
├── tests/
│   ├── unit/
│   └── integration/
├── config/
│   ├── development.yaml
│   └── production.yaml
├── Dockerfile
├── package.json
└── tsconfig.json

// src/server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListResourcesRequestSchema,
  ListToolsRequestSchema,
  ReadResourceRequestSchema,
  ErrorCode,
  McpError
} from "@modelcontextprotocol/sdk/types.js";

import { authenticateRequest } from "./auth/jwt.js";
import { checkScope } from "./auth/scopes.js";
import { toolHandlers } from "./handlers/tools.js";
import { resourceHandlers } from "./handlers/resources.js";

class MCPServer {
  private server: Server;

  constructor() {
    this.server = new Server(
      {
        name: "enterprise-mcp-server",
        version: "1.0.0"
      },
      {
        capabilities: {
          tools: {},
          resources: {
            subscribe: true
          },
          sampling: {}
        }
      }
    );

    this.setupHandlers();
    this.setupErrorHandling();
  }

  private setupHandlers() {
    // Verfügbare Tools auflisten
    this.server.setRequestHandler(ListToolsRequestSchema, async (request) => {
      // Authentifizieren und autorisieren
      const auth = await authenticateRequest(request);
      checkScope(auth, "tools:read");
      
      return {
        tools: [
          {
            name: "search_customers",
            description: "Kundendatenbank durchsuchen",
            inputSchema: {
              type: "object",
              properties: {
                query: { type: "string" },
                limit: { type: "number", default: 10 }
              },
              required: ["query"]
            }
          },
          {
            name: "create_order",
            description: "Neue Bestellung erstellen",
            inputSchema: {
              type: "object",
              properties: {
                customerId: { type: "string" },
                items: { type: "array" },
                shippingAddress: { type: "object" }
              },
              required: ["customerId", "items"]
            }
          }
        ]
      };
    });

    // Tool-Aufrufe ausführen
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const auth = await authenticateRequest(request);
      checkScope(auth, "tools:execute");
      
      const handler = toolHandlers[request.params.name];
      if (!handler) {
        throw new McpError(
          ErrorCode.MethodNotFound,
          `Tool nicht gefunden: ${request.params.name}`
        );
      }
      
      return await handler(request.params.arguments, auth);
    });

    // Verfügbare Ressourcen auflisten
    this.server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
      const auth = await authenticateRequest(request);
      checkScope(auth, "resources:read");
      
      return {
        resources: [
          {
            uri: "database://customers/active",
            name: "Aktive Kunden",
            mimeType: "application/json"
          },
          {
            uri: "database://orders/pending",
            name: "Ausstehende Bestellungen",
            mimeType: "application/json"
          }
        ]
      };
    });

    // Ressourceninhalt lesen
    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
      const auth = await authenticateRequest(request);
      checkScope(auth, "resources:read");
      
      const handler = resourceHandlers[request.params.uri];
      if (!handler) {
        throw new McpError(
          ErrorCode.InvalidRequest,
          `Ressource nicht gefunden: ${request.params.uri}`
        );
      }
      
      return await handler(request.params.uri, auth);
    });
  }

  private setupErrorHandling() {
    this.server.onerror = (error) => {
      console.error("[MCP-Fehler]", error);
    };

    process.on("SIGINT", async () => {
      await this.server.close();
      process.exit(0);
    });
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error("MCP-Server läuft über stdio");
  }
}

const server = new MCPServer();
server.run().catch(console.error);

// src/handlers/tools.ts
import { z } from "zod";

// Eingabevalidierungs-Schemas
const SearchCustomersSchema = z.object({
  query: z.string().min(1),
  limit: z.number().min(1).max(100).default(10)
});

const CreateOrderSchema = z.object({
  customerId: z.string(),
  items: z.array(z.object({
    sku: z.string(),
    quantity: z.number().min(1),
    price: z.number().positive()
  })).min(1),
  shippingAddress: z.object({
    street: z.string(),
    city: z.string(),
    country: z.string()
  }).optional()
});

// Tool-Implementierungen
export const toolHandlers: Record<string, Function> = {
  async search_customers(args: unknown, auth: AuthContext) {
    // Eingabe validieren
    const validated = SearchCustomersSchema.parse(args);
    
    // Zusätzliche Berechtigungen prüfen
    if (!auth.permissions.includes("customer:read")) {
      throw new McpError(
        ErrorCode.InvalidRequest,
        "Unzureichende Berechtigungen zum Durchsuchen von Kunden"
      );
    }
    
    // Suche ausführen
    const customers = await db.customers.search({
      query: validated.query,
      limit: validated.limit,
      tenantId: auth.tenantId  // Multi-Tenant-Isolierung
    });
    
    // Strukturierte Antwort zurückgeben
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            success: true,
            data: customers,
            meta: {
              count: customers.length,
              query: validated.query
            }
          }, null, 2)
        }
      ]
    };
  },

  async create_order(args: unknown, auth: AuthContext) {
    const validated = CreateOrderSchema.parse(args);
    
    // Überprüfen, ob Kunde zum Mandanten gehört
    const customer = await db.customers.findById(validated.customerId);
    if (customer.tenantId !== auth.tenantId) {
      throw new McpError(
        ErrorCode.InvalidRequest,
        "Kunde nicht gefunden"
      );
    }
    
    // Bestellung mit Audit-Trail erstellen
    const order = await db.orders.create({
      ...validated,
      tenantId: auth.tenantId,
      createdBy: auth.userId,
      createdAt: new Date()
    });
    
    // Erfolgsantwort zurückgeben
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            success: true,
            data: {
              orderId: order.id,
              status: "created",
              total: order.items.reduce((sum, item) => sum + item.price * item.quantity, 0)
            },
            meta: {
              executionTime: Date.now() - startTime
            }
          }, null, 2)
        }
      ]
    };
  }
};

# Dockerfile
FROM node:20-alpine

WORKDIR /app

# Abhängigkeiten installieren
COPY package*.json ./
RUN npm ci --only=production

# Quelle kopieren
COPY dist/ ./dist/

# Nicht-Root-Benutzer für Sicherheit
USER node

# Health-Check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node -e "console.log('healthcheck')" || exit 1

# Port für HTTP-Transport freigeben
EXPOSE 3000

# Server starten
CMD ["node", "dist/index.js"]

# docker-compose.yml
version: "3.8"

services:
  mcp-server:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - JWT_SECRET=${JWT_SECRET}
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=${REDIS_URL}
    depends_on:
      - redis
      - db
    restart: unless-stopped
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '1'
          memory: 512M
        reservations:
          cpus: '0.5'
          memory: 256M

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - redis-data:/data

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=mcp
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=mcp_data
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  redis-data:
  postgres-data:

# MCP-Knoten ist in n8n 2.0+ enthalten
# Für Self-Hosting, stellen Sie sicher, dass Sie ausführen:
npx n8n --version  # Sollte 2.0.0 oder höher sein

{
  "nodes": [
    {
      "parameters": {
        "operation": "listTools",
        "server": {
          "transport": "stdio",
          "command": "node",
          "args": ["/path/to/server.js"]
        }
      },
      "name": "MCP Server",
      "type": "n8n-nodes-base.mcp",
      "typeVersion": 1,
      "position": [250, 300]
    }
  ]
}

┌─────────────────────────────────────────────────────────────────┐
│         n8n-Workflow: MCP-gestützte Kundenbetreuung             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌───────────────┐                                              │
│  │ Webhook       │  Kunden-Nachricht empfangen                  │
│  │ (Chat-Input)  │                                              │
│  └───────┬───────┘                                              │
│          │                                                       │
│          ▼                                                       │
│  ┌───────────────┐     ┌─────────────────┐                    │
│  │ KI-Agent      │────▶│ MCP-Tool: Suche   │                    │
│  │ (Claude/GPT)  │     │ Kundendatenbank   │                    │
│  │               │◄───│                   │                    │
│  └───────┬───────┘     └─────────────────┘                    │
│          │                                                       │
│          ▼                                                       │
│  ┌───────────────┐     ┌─────────────────┐                    │
│  │ KI-Agent      │────▶│ MCP-Tool: Prüfe │                    │
│  │ (Analyse)     │     │ Bestellstatus     │                    │
│  │               │◄───│                   │                    │
│  └───────┬───────┘     └─────────────────┘                    │
│          │                                                       │
│          ▼                                                       │
│  ┌───────────────┐     ┌─────────────────┐                    │
│  │ KI-Agent      │────▶│ MCP-Tool: Erstelle│                    │
│  │ (Antwort)     │     │ Support-Ticket    │                    │
│  │               │◄───│ (falls nötig)     │                    │
│  └───────┬───────┘     └─────────────────┘                    │
│          │                                                       │
│          ▼                                                       │
│  ┌───────────────┐                                              │
│  │ Antwort senden│  An Kunden zurückgeben                       │
│  │ (Discord/     │                                              │
│  │  Slack/E-Mail)│                                              │
│  └───────────────┘                                              │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// Knoten: MCP-Tool – Kundendatenbank durchsuchen
{
  "parameters": {
    "operation": "callTool",
    "tool": "search_customers",
    "arguments": {
      "query": "={{ $json.customerQuery }}",
      "limit": 5
    },
    "server": {
      "transport": "http",
      "url": "https://mcp-api.company.com",
      "auth": {
        "type": "oauth2",
        "oauth2": {
          "grantType": "clientCredentials",
          "clientId": "={{ $env.MCP_CLIENT_ID }}",
          "clientSecret": "={{ $env.MCP_CLIENT_SECRET }}",
          "tokenEndpoint": "https://auth.company.com/oauth/token"
        }
      }
    }
  }
}

// Knoten: MCP-Tool – Support-Ticket erstellen
{
  "parameters": {
    "operation": "callTool",
    "tool": "create_ticket",
    "arguments": {
      "customerId": "={{ $json.customerId }}",
      "subject": "={{ $json.issueSubject }}",
      "description": "={{ $json.issueDescription }}",
      "priority": "={{ $json.priority || 'normal' }}"
    },
    "server": {
      "transport": "stdio",
      "command": "node",
      "args": ["/app/mcp/servers/zendesk-server.js"]
    }
  }
}

// Funktionsknoten zur Bestimmung, welche Tools aufgerufen werden sollen
const intent = $json.intent;
const entities = $json.entities;

const toolCalls = [];

if (intent === "order_inquiry") {
  toolCalls.push({
    tool: "get_order_status",
    args: { orderId: entities.orderId }
  });
}

if (intent === "refund_request") {
  toolCalls.push(
    { tool: "get_order_status", args: { orderId: entities.orderId } },
    { tool: "check_refund_eligibility", args: { orderId: entities.orderId } }
  );
}

if (intent === "product_question") {
  toolCalls.push({
    tool: "search_products",
    args: { query: entities.productName }
  });
}

return toolCalls.map(call => ({
  json: call
}));

// Split-Knoten für parallele Ausführung
const requests = $json.toolCalls;

return requests.map((req, index) => ({
  json: {
    ...req,
    _parallelIndex: index
  },
  pairedItem: { item: 0 }
}));

// Dann MCP-Knoten in parallelen Zweigen verwenden
// Ergebnisse mit Merge-Knoten aggregieren

// Fehlerbehandlungs-Unter-Workflow
async function handleMCPError(error, context) {
  const errorCode = error.code;
  
  switch(errorCode) {
    case "RATE_LIMIT":
      // Exponentielles Backoff
      const delay = Math.pow(2, context.retryCount) * 1000;
      await sleep(delay);
      return { action: "retry", delay };
      
    case "AUTH_EXPIRED":
      // Token aktualisieren und wiederholen
      await refreshAccessToken();
      return { action: "retry", delay: 0 };
      
    case "TOOL_NOT_FOUND":
      // Auf alternatives Tool zurückgreifen
      return { 
        action: "fallback", 
        alternativeTool: findAlternativeTool(context.tool) 
      };
      
    case "VALIDATION_ERROR":
      // Eingabe korrigieren und wiederholen
      const fixedArgs = await fixInputWithAI(error, context.args);
      return { action: "retry", fixedArgs };
      
    default:
      return { action: "escalate", error };
  }
}

// Vor dem Abrufen der Ressource Cache prüfen
const cacheKey = `mcp-resource-${resourceUri}`;
const cached = await $getWorkflowStaticData("global").get(cacheKey);

if (cached && Date.now() - cached.timestamp < 300000) { // 5 Min Cache
  return { json: cached.data };
}

// Vom MCP-Server abrufen
const resource = await fetchMCPResource(resourceUri);

// Im Cache speichern
await $getWorkflowStaticData("global").set(cacheKey, {
  data: resource,
  timestamp: Date.now()
});

return { json: resource };

// Anmeldeinformationskonfiguration
{
  "name": "MCP Enterprise Server",
  "type": "mcpOAuth2Api",
  "data": {
    "grantType": "clientCredentials",
    "clientId": "mcp-client-123",
    "clientSecret": "...",
    "tokenEndpoint": "https://auth.company.com/oauth/token",
    "scope": "tools:execute resources:read"
  }
}

# docker-compose.n8n.yml
version: "3.8"

services:
  n8n:
    image: n8nio/n8n:2.0
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - WEBHOOK_URL=https://n8n.company.com/
      - MCP_CLIENT_ID=${MCP_CLIENT_ID}
      - MCP_CLIENT_SECRET=${MCP_CLIENT_SECRET}
      - MCP_SERVER_URL=${MCP_SERVER_URL}
    volumes:
      - ~/.n8n:/home/node/.n8n
      - /app/mcp/servers:/app/mcp/servers:ro
    networks:
      - n8n-network

networks:
  n8n-network:
    external: true