Build a Slack Enterprise MCP Server: Search Messages, Manage Canvases & Automate Workflows in 2026

The Slack + AI Agent Opportunity

Slack's official MCP server launched with basic search and messaging. But enterprise teams need more: channel-specific AI assistants that understand context, automated standup summaries, canvas-based knowledge management, and workflow triggers. This FastMCP server provides those capabilities with enterprise-grade OAuth and permission scoping.

Server Implementation (src/slack-mcp.ts)

// src/slack-mcp.ts
import { FastMCP } from 'fastmcp';
import { z } from 'zod';
import { WebClient } from '@slack/web-api';
import Redis from 'ioredis';

const server = new FastMCP({ name: 'slack-enterprise', version: '1.0.0' });
const slack = new WebClient(process.env.SLACK_BOT_TOKEN);
const redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379');

// Tool 1: Search Messages
server.tool(
  'search_messages',
  'Search Slack messages with full query syntax',
  {
    query: z.string().describe('Search query (supports Slack search syntax)'),
    channel: z.string().optional().describe('Restrict to specific channel'),
    user: z.string().optional().describe('Filter by user ID'),
    limit: z.number().optional().default(20),
  },
  async ({ query, channel, user, limit }) => {
    const searchQuery = [
      query,
      channel ? `in:${channel}` : '',
      user ? `from:${user}` : '',
    ].filter(Boolean).join(' ');

    const result = await slack.search.messages({
      query: searchQuery,
      count: limit,
      sort: 'timestamp',
      sort_dir: 'desc',
    });

    const messages = (result.messages?.matches || []).map((m: any) => ({
      text: m.text,
      user: m.user,
      channel: m.channel?.name,
      timestamp: m.ts,
      permalink: m.permalink,
    }));

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({ messages, total: result.messages?.total || 0 }, null, 2),
      }],
    };
  }
);

// Tool 2: Channel Summary
server.tool(
  'summarize_channel',
  'Generate a summary of recent channel activity',
  {
    channel: z.string().describe('Channel name or ID'),
    hours: z.number().optional().default(24),
  },
  async ({ channel, hours }) => {
    const cutoff = Math.floor(Date.now() / 1000) - (hours * 3600);
    const history = await slack.conversations.history({
      channel,
      oldest: String(cutoff),
      limit: 100,
    });

    const messages = (history.messages || []).map((m: any) => m.text).join('\
');
    const summary = `Channel ${channel}: ${(history.messages || []).length} messages in last ${hours}h. Key topics: ${messages.slice(0, 500)}`;

    return {
      content: [{ type: 'text', text: summary }],
    };
  }
);

// Tool 3: Create Canvas
server.tool(
  'create_canvas',
  'Create a Slack canvas with structured content',
  {
    title: z.string(),
    content: z.string().describe('Markdown content for the canvas'),
    channel: z.string().optional().describe('Share in channel'),
  },
  async ({ title, content, channel }) => {
    const result = await slack.canvasCreate({
      title,
      content: { blocks: [{ type: 'markdown', text: content }] },
    });

    if (channel && result.canvas?.id) {
      await slack.chat.postMessage({
        channel,
        text: `📋 New canvas created: ${title}`,
        blocks: [{ type: 'canvas', canvas_id: result.canvas.id }],
      });
    }

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({ canvas_id: result.canvas?.id, title, shared: !!channel }),
      }],
    };
  }
);

// Tool 4: Send Targeted Notification
server.tool(
  'send_notification',
  'Send a DM or channel notification with context',
  {
    recipient: z.string().describe('User ID or channel ID'),
    message: z.string(),
    context_url: z.string().optional().describe('Link to provide context'),
  },
  async ({ recipient, message, context_url }) => {
    const blocks: any[] = [{ type: 'section', text: { type: 'mrkdwn', text: message } }];
    if (context_url) {
      blocks.push({ type: 'section', text: { type: 'mrkdwn', text: `<${context_url}|View Context>` } });
    }

    await slack.chat.postMessage({
      channel: recipient,
      text: message,
      blocks,
    });

    return { content: [{ type: 'text', text: `Notification sent to ${recipient}` }] };
  }
);

server.start({ transport: 'stdio' });

Performance Benchmarks

Production Reality Check

Rate-limit handling: Slack API allows 50-100 requests per minute per app. Implement per-method rate limiting with Redis. For enterprise workspaces with 10K+ channels, use Slack's paginated APIs. Permission scoping: Use Slack's granular OAuth scopes: search:read, channels:history, chat:write, canvas:write. Request only the scopes your tools need. Failure recovery: Slack API returns 429 for rate limits. Implement exponential backoff with jitter. For 5xx errors, retry once after 5 seconds.

By <a href="https://x.com/deeepakbagada" rel="nofollow noopener noreferrer">Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with FastMCP 3.14, Slack SDK 7.x, Node v22, and Redis 7.4.

Related Architecture & Implementation Resources

• Browse complementary servers and client connectors in the Daily AI World MCP Directory.
• Integrate this tool into multi-agent pipelines with our AI Workflows Blueprints.
• Review frontier LLM capabilities and token metrics on Latest AI News.