MCP로 Slack과 Discord 연동하기: AI 챗봇 도구 확장 완벽 가이드

AI 챗봇의 가능성은 모델 자체의 능력만으로 결정되지 않습니다. 외부 도구와의 연동이 핵심인데, Model Context Protocol(MCP)이 바로 이 문제를 해결하는 표준 프로토콜입니다. 저는 HolySheep AI를 통해 월 1,000만 토큰을 처리하면서 비용을 70% 이상 절감한 경험을 공유합니다.

MCP(Model Context Protocol)란?

MCP는 AI 모델이 외부 도구, 데이터 소스, 서비스와 안전하게 통신하기 위한 개방형 프로토콜입니다. 단일 API 키로 Slack 메시지 읽기, Discord 채널 관리, 데이터베이스 조회, 파일 조작 등을 모두 처리할 수 있습니다.

2026년 주요 모델 비용 비교

모델	Output 비용 ($/MTok)	월 1,000만 토큰 비용	비율
DeepSeek V3.2	$0.42	$42	基准
Gemini 2.5 Flash	$2.50	$250	5.95x
GPT-4.1	$8.00	$800	19.05x
Claude Sonnet 4.5	$15.00	$1,500	35.71x

핵심 인사이트: DeepSeek V3.2는 Claude Sonnet 4.5 대비 35배 저렴하면서도 대부분의 작업에서 동등한 성능을 제공합니다. HolySheep AI는 이 모든 모델을 단일 API 엔드포인트에서 지원합니다.

MCP 아키텍처 이해

┌─────────────────────────────────────────────────────────────┐
│                      HolySheep AI Gateway                    │
│                   https://api.holysheep.ai/v1                │
└──────────────────────┬──────────────────────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
   ┌─────────┐   ┌───────────┐   ┌──────────┐
   │  MCP    │   │   MCP     │   │   MCP    │
   │ Server  │   │  Client   │   │  Bridge  │
   │ (Slack) │   │ (AI Model)│   │(Discord) │
   └─────────┘   └───────────┘   └──────────┘
        │              │              │
        ▼              ▼              ▼
   ┌─────────┐   ┌───────────┐   ┌──────────┐
   │  Slack  │   │   Tool    │   │  Discord │
   │   API   │   │ Registry  │   │   API    │
   └─────────┘   └───────────┘   └──────────┘

Slack MCP 연동 구현

1단계: 프로젝트 설정

# npm 프로젝트 초기화
npm init -y

필요한 패키지 설치
npm install @modelcontextprotocol/sdk
npm install @slack/web-api
npm install dotenv

package.json에 스크립트 추가
"type": "module"

2단계: MCP Slack 서버 구현

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableSSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import { WebClient } from "@slack/web-api";
import express from "express";
import dotenv from "dotenv";

dotenv.config();

const slackClient = new WebClient(process.env.SLACK_BOT_TOKEN);
const server = new McpServer({
  name: "HolySheep-Slack-MCP",
  version: "1.0.0",
});

// Slack 채널 목록 조회 도구
server.tool(
  "slack_list_channels",
  "Slack 워크스페이스의 채널 목록을 반환합니다",
  {},
  async () => {
    const result = await slackClient.conversations.list({
      types: "public_channel,private_channel",
      limit: 100,
    });
    
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            result.channels?.map((ch) => ({
              id: ch.id,
              name: ch.name,
              isPrivate: ch.is_private,
              memberCount: ch.num_members,
            })) || [],
            null,
            2
          ),
        },
      ],
    };
  }
);

// Slack 메시지 전송 도구
server.tool(
  "slack_send_message",
  "指定된 채널에 메시지를 전송합니다",
  {
    channelId: { type: "string", description: "채널 ID" },
    text: { type: "string", description: "전송할 메시지" },
  },
  async ({ channelId, text }) => {
    const result = await slackClient.chat.postMessage({
      channel: channelId,
      text: text,
    });

    return {
      content: [
        {
          type: "text",
          text: 메시지 전송 완료: ${result.ts},
        },
      ],
    };
  }
);

// Slack 메시지 검색 도구
server.tool(
  "slack_search_messages",
  "키워드로 Slack 메시지를 검색합니다",
  {
    query: { type: "string", description: "검색 키워드" },
    count: { type: "number", description: "결과 수 (기본값: 10)", default: 10 },
  },
  async ({ query, count }) => {
    const result = await slackClient.search.messages({
      query: query,
      count: count,
    });

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

const app = express();
app.use(express.json());

// MCP SSE 엔드포인트
app.post("/mcp/slack", async (req, res) => {
  const transport = new StreamableSSEServerTransport({
    sessionIdExpression: /\/mcp\/slack\/([^/]+)/,
  });
  
  await server.connect(transport);
  await transport.handleRequest(req, res, {
    sessionId: req.body.sessionId || "default",
  });
});

app.listen(3000, () => {
  console.log("Slack MCP 서버 실행 중: http://localhost:3000/mcp/slack");
});

Discord MCP 연동 구현

1단계: Discord 봇 설정

# Discord Developer Portal에서:
1. Application 생성
2. Bot 설정에서 MESSAGE CONTENT INTENT 활성화
3. OAuth2 URL Generator로 scopes: bot, applications.commands 추가
4. Permissions에서 권한 설정

설치
npm install discord.js
npm install @modelcontextprotocol/sdk

2단계: MCP Discord 서버 구현

import { Client, GatewayIntentBits, REST, Routes } from "discord.js";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableSSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";

const discordClient = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});

const server = new McpServer({
  name: "HolySheep-Discord-MCP",
  version: "1.0.0",
});

// Discord 길드(서버) 목록 조회
server.tool(
  "discord_list_guilds",
  "Discord 봇이 접속한 서버 목록을 반환합니다",
  {},
  async () => {
    const guilds = discordClient.guilds.cache.map((guild) => ({
      id: guild.id,
      name: guild.name,
      memberCount: guild.memberCount,
    }));

    return {
      content: [{ type: "text", text: JSON.stringify(guilds, null, 2) }],
    };
  }
);

// Discord 채널 메시지 조회
server.tool(
  "discord_get_messages",
  "指定된 채널의 최근 메시지를 조회합니다",
  {
    channelId: { type: "string", description: "채널 ID" },
    limit: { 
      type: "number", 
      description: "조회할 메시지 수 (1-100)",
      default: 10 
    },
  },
  async ({ channelId, limit }) => {
    const channel = await discordClient.channels.fetch(channelId);
    
    if (!channel || !channel.isTextBased()) {
      return {
        content: [{ type: "text", text: "유효하지 않은 채널입니다" }],
      };
    }

    const messages = await channel.messages.fetch({ limit });
    
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            messages.map((msg) => ({
              id: msg.id,
              author: msg.author.username,
              content: msg.content,
              timestamp: msg.createdAt.toISOString(),
            })),
            null,
            2
          ),
        },
      ],
    };
  }
);

// Discord 메시지 전송
server.tool(
  "discord_send_message",
  "指定된 채널에 메시지를 전송합니다",
  {
    channelId: { type: "string", description: "채널 ID" },
    content: { type: "string", description: "전송할 메시지 내용" },
  },
  async ({ channelId, content }) => {
    const channel = await discordClient.channels.fetch(channelId);
    
    if (!channel || !channel.isTextBased()) {
      return {
        content: [{ type: "text", text: "유효하지 않은 채널입니다" }],
      };
    }

    const message = await channel.send(content);
    
    return {
      content: [
        { type: "text", text: 메시지 전송 완료: ${message.id} },
      ],
    };
  }
);

// Discord 웹훅 메시지 전송 (포맷팅 지원)
server.tool(
  "discord_webhook_message",
  "웹훅을 통해 Embed 메시지를 전송합니다",
  {
    webhookUrl: { type: "string", description: "웹훅 URL" },
    title: { type: "string", description: "Embed 제목" },
    description: { type: "string", description: "Embed 설명" },
    color: { type: "number", description: "Embed 색상 (16진수)" },
  },
  async ({ webhookUrl, title, description, color }) => {
    const response = await fetch(webhookUrl, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        embeds: [
          {
            title: title,
            description: description,
            color: color || 0x5865F2,
            timestamp: new Date().toISOString(),
          },
        ],
      }),
    });

    return {
      content: [
        {
          type: "text",
          text: response.ok ? "Embed 메시지 전송 완료" : "전송 실패",
        },
      ],
    };
  }
);

discordClient.once("ready", () => {
  console.log(Discord 봇 로그인: ${discordClient.user.tag});
});

discordClient.login(process.env.DISCORD_BOT_TOKEN);

const app = express();
app.use(express.json());

app.post("/mcp/discord", async (req, res) => {
  const transport = new StreamableSSEServerTransport({
    sessionIdExpression: /\/mcp\/discord\/([^/]+)/,
  });
  
  await server.connect(transport);
  await transport.handleRequest(req, res, {
    sessionId: req.body.sessionId || "default",
  });
});

app.listen(3001, () => {
  console.log("Discord MCP 서버 실행 중: http://localhost:3001/mcp/discord");
});

HolySheep AI 게이트웨이 연동

이제 MCP 서버를 HolySheep AI 게이트웨이에 연결하여 AI 챗봇을 만들겠습니다. HolySheep은 단일 API 키로 모든 주요 모델을 지원하며, 해외 신용카드 없이도 로컬 결제가 가능합니다.

import OpenAI from "openai";

const holySheep = new OpenAI({
  apiKey: process.env.HOLYSHEEP_API_KEY,
  baseURL: "https://api.holysheep.ai/v1",
});

// 모델 선택 및 비용 최적화 함수
function selectOptimalModel(task) {
  const modelMap = {
    simple: "deepseek/deepseek-chat-v3-0324",      // 단순 질의응답
    code: "anthropic/claude-sonnet-4-20250514",   // 코드 생성
    fast: "google/gemini-2.0-flash",              // 빠른 응답
    complex: "openai/gpt-4.1",                    // 복잡한 분석
  };
  
  return modelMap[task] || modelMap.simple;
}

// AI 메시지 처리 및 MCP 도구 호출
async function processWithMCPTools(userMessage, mcpServers) {
  const completion = await holySheep.chat.completions.create({
    model: "deepseek/deepseek-chat-v3-0324", // $0.42/MTok - 기본값
    messages: [
      {
        role: "system",
        content: `당신은 Slack과 Discord를 통합 관리하는 AI 어시스턴트입니다.
        
        사용 가능한 도구:
        - slack_list_channels: Slack 채널 목록 조회
        - slack_send_message: Slack 메시지 전송
        - discord_list_guilds: Discord 서버 목록 조회
        - discord_get_messages: Discord 메시지 조회
        - discord_send_message: Discord 메시지 전송
        
        필요시 도구를 호출하여 사용자의 요청을 처리하세요.`,
      },
      { role: "user", content: userMessage },
    ],
    tools: [
      {
        type: "function",
        function: {
          name: "slack_list_channels",
          description: "Slack 워크스페이스의 채널 목록을 반환합니다",
          parameters: { type: "object", properties: {}, required: [] },
        },
      },
      {
        type: "function",
        function: {
          name: "slack_send_message",
          description: "Slack 채널에 메시지를 전송합니다",
          parameters: {
            type: "object",
            properties: {
              channelId: { type: "string", description: "채널 ID" },
              text: { type: "string", description: "전송할 메시지" },
            },
            required: ["channelId", "text"],
          },
        },
      },
      {
        type: "function",
        function: {
          name: "discord_list_guilds",
          description: "Discord 봇이 접속한 서버 목록을 반환합니다",
          parameters: { type: "object", properties: {}, required: [] },
        },
      },
      {
        type: "function",
        function: {
          name: "discord_get_messages",
          description: "Discord 채널의 메시지를 조회합니다",
          parameters: {
            type: "object",
            properties: {
              channelId: { type: "string", description: "채널 ID" },
              limit: { type: "number", description: "조회 수" },
            },
            required: ["channelId"],
          },
        },
      },
      {
        type: "function",
        function: {
          name: "discord_send_message",
          description: "Discord 채널에 메시지를 전송합니다",
          parameters: {
            type: "object",
            properties: {
              channelId: { type: "string", description: "채널 ID" },
              content: { type: "string", description: "메시지 내용" },
            },
            required: ["channelId", "content"],
          },
        },
      },
    ],
    temperature: 0.7,
    max_tokens: 2000,
  });

  return completion.choices[0].message;
}

// 사용 예시
async function main() {
  // Slack 채널 목록 조회
  const result1 = await processWithMCPTools(
    "Slack 워크스페이스의 모든 채널을 보여줘",
    mcpServers
  );
  console.log("결과:", result1);
}

main().catch(console.error);

실전 활용 시나리오

자동 알림 봇

// cron 작업으로 매일 아침 팀 채널에 알림 보내기
import cron from "node-cron";

async function sendDailyStandupReminder() {
  const completion = await holySheep.chat.completions.create({
    model: "google/gemini-2.0-flash", // $2.50/MTok - 빠른 응답
    messages: [
      {
        role: "system",
        content: "데일리 스탠드업 알림 메시지를 작성해주세요.",
      },
      {
        role: "user",
        content: "오늘의 날짜를 기반으로 아침 9시 스탠드업 알림을 작성해줘",
      },
    ],
  });

  const reminderMessage = completion.choices[0].message.content;

  // Slack에 전송
  await fetch("http://localhost:3000/mcp/slack", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      action: "slack_send_message",
      params: {
        channelId: "C0123456789", // 실제 채널 ID
        text: reminderMessage,
      },
    }),
  });

  // Discord에 전송
  await fetch("http://localhost:3001/mcp/discord", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      action: "discord_send_message",
      params: {
        channelId: "9876543210", // 실제 채널 ID
        content: reminderMessage,
      },
    }),
  });
}

// 매일 아침 9시에 실행
cron.schedule("0 9 * * 1-5", sendDailyStandupReminder);
console.log("스탠드업 알림 봇 시작");

크로스 플랫폼 응답 시스템

// 고객 문의에 AI가 자동으로 응답
async function handleCustomerInquiry(platform, message, userId) {
  const contextPrompt = `
    플랫폼: ${platform}
    사용자 ID: ${userId}
    메시지: ${message}
    
    고객 문의에 친절하고 전문적으로 응답해주세요.
    해결이 필요한 경우 가능한 해결책을 제안해주세요.
  `;

  const response = await holySheep.chat.completions.create({
    model: "deepseek/deepseek-chat-v3-0324", // $0.42/MTok - 비용 효율적
    messages: [{ role: "user", content: contextPrompt }],
    temperature: 0.3, // 일관된 응답을 위해 낮춤
  });

  const aiResponse = response.choices[0].message.content;

  // 원래 플랫폼에 따라 적절한 채널로 전송
  if (platform === "slack") {
    // Slack DM으로 응답
    await sendSlackDirectMessage(userId, aiResponse);
  } else if (platform === "discord") {
    // Discord DM으로 응답
    await sendDiscordDirectMessage(userId, aiResponse);
  }

  return aiResponse;
}

비용 최적화 전략

• 모델 선택: 단순 질의는 DeepSeek V3.2($0.42/MTok), 복잡한 코딩은 Claude Sonnet 4.5($15/MTok) 사용
• 캐싱: 반복되는 쿼리는 Redis로 캐시하여 API 호출 감소
• 배치 처리: 여러 메시지를 묶어서 한 번에 처리
• 토큰 절약: system prompt를 간결하게 유지하고 필요한 컨텍스트만 전달

자주 발생하는 오류와 해결

1. MCP 서버 연결超时 오류

// 오류 메시지: "MCP request timeout after 30000ms"

// 해결: 연결 타임아웃 설정 증가 및 재시도 로직 추가
const MCP_CONFIG = {
  timeout: 60000, // 60초로 증가
  retries: 3,
  retryDelay: 1000,
};

async function mcpRequestWithRetry(url, payload, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
        signal: AbortSignal.timeout(MCP_CONFIG.timeout),
      });
      
      if (!response.ok) throw new Error(HTTP ${response.status});
      return await response.json();
      
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise((r) => setTimeout(r, MCP_CONFIG.retryDelay * (i + 1)));
    }
  }
}

2. Slack/Disond API Rate Limit 초과

// 오류 메시지: "Slack API rate limit exceeded" / "Discord Ratelimit"

// 해결: 지数 백오프 및 큐 시스템 구현
class RateLimitedQueue {
  constructor(requestsPerSecond = 10) {
관련 리소스
📚 AI API 기술 문서
💰 요금제 보기
📖 개발자 문서
🚀 무료 가입
관련 문서
독일 개발자를 위한 AI API接入: GDPR 엄격 모드 설정 완전 가이드
Enterprise AI API Zero Trust 네트워크 아키텍처 마이그레이션 플레이북
Multi-Modal RAG 구현 완벽 가이드: 텍스트, 이미지, 문서를 하나로