TinyMCE AI on-premises: advanced scenarios

// knowledge-mcp-server.js
const express = require('express');
const app = express();
app.use(express.json());

const KNOWLEDGE_BASE = {
  'api-guidelines': 'All REST APIs must use JSON, include pagination through Link headers, and return 4xx for client errors with a machine-readable error code.',
  'deployment-process': 'Deployments require: 1) PR approval, 2) passing CI, 3) staging verification, 4) production canary (5% traffic for 30min), 5) full rollout.',
  'security-policy': 'All user data must be encrypted at rest (AES-256) and in transit (TLS 1.3). PII requires additional field-level encryption.',
};

app.post('/mcp', (req, res) => {
  const { method, id, params } = req.body;

  if (method === 'initialize') {
    return res.json({
      jsonrpc: '2.0', id,
      result: {
        protocolVersion: '2024-11-05',
        capabilities: { tools: {} },
        serverInfo: { name: 'knowledge-hub', version: '1.0.0' }
      }
    });
  }

  if (method === 'tools/list') {
    return res.json({
      jsonrpc: '2.0', id,
      result: {
        tools: [{
          name: 'search_knowledge_base',
          description: 'Search the company knowledge base for policies, guidelines, and procedures',
          inputSchema: {
            type: 'object',
            properties: {
              query: { type: 'string', description: 'Search query' }
            },
            required: ['query']
          }
        }, {
          name: 'get_api_spec',
          description: 'Get the OpenAPI spec for an internal service',
          inputSchema: {
            type: 'object',
            properties: {
              service: { type: 'string', description: 'Service name (for example user-service, billing-api)' }
            },
            required: ['service']
          }
        }]
      }
    });
  }

  if (method === 'tools/call') {
    const { name, arguments: args } = params;
    if (name === 'search_knowledge_base') {
      const query = (args?.query || '').toLowerCase();
      const results = Object.entries(KNOWLEDGE_BASE)
        .filter(([key]) => key.includes(query) || query.includes(key.split('-')[0]))
        .map(([key, value]) => `##${key}\n${value}`)
        .join('\n\n');
      return res.json({
        jsonrpc: '2.0', id,
        result: { content: [{ type: 'text', text: results || 'No results found.' }] }
      });
    }
    return res.json({
      jsonrpc: '2.0', id,
      result: { content: [{ type: 'text', text: 'Spec not found for: ' + args?.service }] }
    });
  }

  res.json({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Unknown method' } });
});

app.listen(3001, () => console.log('Knowledge MCP server on http://localhost:3001/mcp'));

app.post('/api/ai-token', requireAuth, (req, res) => {
  const customer = getCustomerConfig(req.user.organizationId);

  const token = jwt.sign({
    aud: customer.envId,
    sub: req.user.id,
    user: { name: req.user.name, email: req.user.email },
    auth: {
      ai: {
        permissions: getPermissionsForPlan(customer.plan)
      }
    }
  }, customer.apiSecret, { algorithm: 'HS256', expiresIn: '1h' });

  res.json({ token });
});

function getPermissionsForPlan(plan) {
  switch (plan) {
    case 'enterprise':
      return ['ai:conversations:*', 'ai:models:agent', 'ai:actions:system:*', 'ai:reviews:system:*'];
    case 'pro':
      return ['ai:conversations:*', 'ai:actions:system:*'];
    case 'basic':
      return ['ai:actions:system:*'];
  }
}

function envFor(tenantId) {
  return {
    envId:     process.env[`AI_ENV_ID_${tenantId}`],
    apiSecret: process.env[`AI_API_SECRET_${tenantId}`]
  };
}