Einleitung: Warum MCP die Zukunft der Chatbot-Integration ist

Das Model Context Protocol (MCP) hat die Art und Weise revolutioniert, wie wir AI-Assistenten mit Messaging-Plattformen verbinden. In diesem praxisorientierten Tutorial zeige ich Ihnen, wie Sie MCP mit Slack und Discord integrieren, um leistungsstarke Chatbot-Lösungen zu erstellen, die nahtlos mit verschiedenen AI-Modellen kommunizieren.

Als langjähriger Entwickler bei HolySheep AI habe ich unzählige Integrationen realisiert und kenne die Stolperfallen aus erster Hand. Mit unserer API-Plattform können Sie dabei bis zu 85% der Kosten sparen.

Was ist MCP und warum sollten Sie es nutzen?

Das Model Context Protocol ist ein offener Standard, der die Kommunikation zwischen AI-Modellen und externen Tools vereinheitlicht. Anders als traditionelle API-Integrationen bietet MCP:

2026 Preisdaten: Kostenvergleich der führenden AI-Modelle

Bevor wir in die technische Umsetzung einsteigen, analysieren wir die aktuellen Kosten für AI-APIs. Die folgenden Preise sind für Output-Token (Antworten des Modells) pro Million Token:

ModellPreis/1M TokenKosten für 10M/MonatLatenz
DeepSeek V3.2$0,42$4,20<50ms
Gemini 2.5 Flash$2,50$25,00<80ms
GPT-4.1$8,00$80,00<120ms
Claude Sonnet 4.5$15,00$150,00<100ms

Einsparpotenzial mit HolySheep AI: Durch unseren Wechselkurs von ¥1=$1 und optimierte Infrastruktur bieten wir über 85% Ersparnis gegenüber offiziellen Preisen. Zusätzlich erhalten Sie kostenlose Credits bei der Registrierung und Zahlung per WeChat oder Alipay.

MCP-Server für Slack: Vollständige Implementierung

Voraussetzungen und Installation

Für die Slack-Integration benötigen Sie:

# Installation der benötigten Pakete
pip install mcp slack-sdk python-dotenv requests aiohttp


Projektstruktur erstellen

mkdir mcp-slack-bot && cd mcp-slack-bot
touch app.py mcp_server.py requirements.txt .env

MCP-Server Konfiguration

# mcp_server.py
import json
import requests
from typing import Any, Optional
from mcp.server import Server
from mcp.types import Tool, CallToolResult


HolySheep AI Konfiguration

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Aus .env laden

class HolySheepMCPClient:
    """MCP-Client für HolySheep AI mit Slack-Tool-Integration"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = HOLYSHEEP_BASE_URL
        self.model = "deepseek-v3.2"  # Kostenoptimiertes Modell
        
    def chat_completion(
        self, 
        messages: list[dict], 
        tools: Optional[list] = None,
        temperature: float = 0.7
    ) -> dict:
        """AI-Chat mit HolySheep API - unterstützt MCP-Tools"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": 4000
        }
        
        if tools:
            payload["tools"] = tools
            
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code != 200:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
            
        return response.json()
    
    def search_messages(self, query: str, channel_id: str = None) -> list[dict]:
        """Slack-Nachrichten durchsuchen (via MCP-Tool)"""
        # Dies wird als MCP-Tool暴露iert
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.model,
            "messages": [
                {"role": "system", "content": "Du bist ein Slack-Suchassistent."},
                {"role": "user", "content": f"Suche nach: {query} in Channel: {channel_id or 'allen'}"}
            ]
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload
        )
        
        return response.json().get("choices", [{}])[0].get("message", {})


MCP-Server initialisieren

mcp_server = Server("slack-holysheep-integration")


Tool-Definitionen für MCP

SLACK_TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "search_slack_messages",
            "description": "Durchsucht Slack-Nachrichten nach bestimmten Stichwörtern",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Suchbegriff"},
                    "channel_id": {"type": "string", "description": "Optional: Slack-Channel-ID"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "post_message",
            "description": "Postet eine Nachricht in einen Slack-Channel",
            "parameters": {
                "type": "object",
                "properties": {
                    "channel": {"type": "string", "description": "Channel-ID oder -Name"},
                    "text": {"type": "string", "description": "Nachrichtentext"},
                    "thread_ts": {"type": "string", "description": "Optional: Thread-ID für Antworten"}
                },
                "required": ["channel", "text"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_channel_info",
            "description": "Ruft Informationen über einen Slack-Channel ab",
            "parameters": {
                "type": "object",
                "properties": {
                    "channel_id": {"type": "string", "description": "Channel-ID"}
                },
                "required": ["channel_id"]
            }
        }
    }
]

def handle_tool_call(tool_name: str, arguments: dict, client: HolySheepMCPClient) -> dict:
    """Verarbeitet MCP-Tool-Aufrufe"""
    if tool_name == "search_slack_messages":
        return client.search_messages(
            query=arguments.get("query"),
            channel_id=arguments.get("channel_id")
        )
    elif tool_name == "post_message":
        # Slack API Aufruf hier implementieren
        return {"success": True, "posted_to": arguments.get("channel")}
    elif tool_name == "get_channel_info":
        # Slack API Aufruf hier implementieren
        return {"channel_id": arguments.get("channel_id"), "exists": True}
    
    return {"error": f"Unbekanntes Tool: {tool_name}"}

Slack-Bot Hauptanwendung

# app.py - Slack MCP Bot Hauptdatei
import os
import json
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from dotenv import load_dotenv
from mcp_server import HolySheepMCPClient, SLACK_TOOLS, handle_tool_call

load_dotenv()


Slack App initialisieren

app = App(
    token=os.environ["SLACK_BOT_TOKEN"],
    socket_mode_enabled=True
)


HolySheep AI Client initialisieren

holysheep_client = HolySheepMCPClient(api_key=os.environ["HOLYSHEEP_API_KEY"])


Konversationsverlauf speichern

conversation_history: dict[str, list[dict]] = {}

@app.event("app_mention")
def handle_mention(event, say, client):
    """Behandelt Erwähnungen des Bots in Slack"""
    user_id = event["user"]
    channel_id = event["channel"]
    thread_ts = event.get("thread_ts")
    
    # Nachricht extrahieren (ohne Bot-Erwähnung)
    text = event["text"].replace(f"<@{os.environ['SLACK_BOT_USER_ID']}>", "").strip()
    
    # Konversation initialisieren oder fortsetzen
    conv_id = f"{channel_id}-{thread_ts or event['ts']}"
    if conv_id not in conversation_history:
        conversation_history[conv_id] = [
            {"role": "system", "content": (
                "Du bist ein hilfreicher AI-Assistent in Slack. "
                "Du kannst Slack-Tools verwenden, um Nachrichten zu suchen, "
                "zu posten und Channel-Informationen abzurufen. "
                "Antworte präzise und freundlich auf Deutsch."
            )}
        ]
    
    # Nachricht zur Konversation hinzufügen
    conversation_history[conv_id].append({"role": "user", "content": text})
    
    try:
        # Anfrage an HolySheep AI senden mit MCP-Tools
        response = holysheep_client.chat_completion(
            messages=conversation_history[conv_id],
            tools=SLACK_TOOLS,
            temperature=0.7
        )
        
        assistant_message = response["choices"][0]["message"]
        
        # Tool-Aufrufe verarbeiten falls vorhanden
        if "tool_calls" in assistant_message:
            for tool_call in assistant_message["tool_calls"]:
                tool_name = tool_call["function"]["name"]
                arguments = json.loads(tool_call["function"]["arguments"])
                
                # MCP-Tool ausführen
                tool_result = handle_tool_call(tool_name, arguments, holysheep_client)
                
                # Tool-Ergebnis zur Konversation hinzufügen
                conversation_history[conv_id].append({
                    "role": "tool",
                    "tool_call_id": tool_call["id"],
                    "content": json.dumps(tool_result)
                })
            
            # Finale Antwort mit Tool-Ergebnissen generieren
            response = holysheep_client.chat_completion(
                messages=conversation_history[conv_id],
                temperature=0.7
            )
            assistant_message = response["choices"][0]["message"]
        
        # Antwort in Slack posten
        say(
            text=assistant_message["content"],
            channel=channel_id,
            thread_ts=thread_ts
        )
        
        # Zur Konversation hinzufügen
        conversation_history[conv_id].append({
            "role": "assistant", 
            "content": assistant_message["content"]
        })
        
    except Exception as e:
        say(
            text=f"❌ Ein Fehler ist aufgetreten: {str(e)}",
            channel=channel_id,
            thread_ts=thread_ts
        )

if __name__ == "__main__":
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    handler.start()

MCP-Server für Discord: Vollständige Implementierung

Discord Bot Setup

# discord_bot.py - Discord MCP Integration
import os
import discord
from discord.ext import commands
import json
import requests
from mcp_server import HolySheepMCPClient, SLACK_TOOLS  # Tools wiederverwenden


HolySheep AI Client

holysheep_client = HolySheepMCPClient(api_key=os.environ["HOLYSHEEP_API_KEY"])


Discord Intents konfigurieren

intents = discord.Intents.default()
intents.message_content = True
intents.guild_messages = True

bot = commands.Bot(command_prefix="!", intents=intents)


Konversationsverwaltung pro Server/Channel

conversation_cache: dict[str, list[dict]] = {}

@bot.event
async def on_ready():
    """Bot-Start-Ereignis"""
    print(f"✅ Discord Bot gestartet: {bot.user}")
    print(f"📊 MCP-Server verbunden mit HolySheep AI")
    print(f"💰 Aktuelles Modell: {holysheep_client.model}")

@bot.event
async def on_message(message):
    """Nachrichten-Ereignis mit MCP-Integration"""
    # Eigene Nachrichten ignorieren
    if message.author == bot.user:
        return
    
    # Nur auf Erwähnungen oder !ai Befehle reagieren
    if not (bot.user in message.mentions or message.content.startswith("!ai")):
        return
    
    # Nachricht bereinigen
    content = message.content
    if bot.user in message.mentions:
        content = content.replace(f"@{bot.user.name}", "").strip()
    if content.startswith("!ai"):
        content = content[3:].strip()
    
    if not content:
        await message.reply("❓ Bitte stellen Sie eine Frage nach dem @-Zeichen.")
        return
    
    # Konversations-ID erstellen
    conv_id = f"{message.guild.id}-{message.channel.id}"
    
    # Konversation initialisieren
    if conv_id not in conversation_cache:
        conversation_cache[conv_id] = [
            {"role": "system", "content": (
                "Du bist ein hilfreicher AI-Assistent in Discord. "
                "Du hilfst Benutzern bei Fragen und Aufgaben. "
                "Antworte klar strukturiert mit Markdown-Formatierung. "
                "Verwende Emojis sparsam für bessere Lesbarkeit."
            )}
        ]
    
    # Nachricht hinzufügen
    conversation_cache[conv_id].append({"role": "user", "content": content})
    
    # Loading-Status senden
    async with message.channel.typing():
        try:
            # Anfrage an HolySheep AI senden
            response = holysheep_client.chat_completion(
                messages=conversation_cache[conv_id],
                tools=SLACK_TOOLS,  # Gleiche Tools wie für Slack
                temperature=0.7
            )
            
            assistant_message = response["choices"][0]["message"]
            
            # Tool-Aufrufe verarbeiten
            if "tool_calls" in assistant_message:
                tool_results = []
                for tool_call in assistant_message["tool_calls"]:
                    tool_name = tool_call["function"]["name"]
                    arguments = json.loads(tool_call["function"]["arguments"])
                    
                    # Tool-Result für Discord (angepasst)
                    tool_result = {
                        "tool": tool_name,
                        "args": arguments,
                        "status": "executed"
                    }
                    tool_results.append(tool_result)
                    
                    # Zur Konversation hinzufügen
                    conversation_cache[conv_id].append({
                        "role": "tool",
                        "tool_call_id": tool_call["id"],
                        "content": json.dumps(tool_result)
                    })
                
                # Finale Antwort generieren
                response = holysheep_client.chat_completion(
                    messages=conversation_cache[conv_id],
                    temperature=0.7
                )
                assistant_message = response["choices"][0]["message"]
            
            # Antwort senden (Discord hat 2000 Zeichen Limit)
            response_text = assistant_message["content"]
            if len(response_text) > 1900:
                # Aufteilen auf mehrere Nachrichten
                for i in range(0, len(response_text), 1900):
                    await message.reply(response_text[i:i+1900] if i == 0 else response_text[i:i+1900])
            else:
                await message.reply(response_text)
            
            # Zur Konversation hinzufügen
            conversation_cache[conv_id].append({
                "role": "assistant",
                "content": response_text
            })
            
            # Konversation auf 20 Nachrichten begrenzen
            if len(conversation_cache[conv_id]) > 20:
                conversation_cache[conv_id] = [
                    conversation_cache[conv_id][0]
                ] + conversation_cache[conv_id][-19:]
                
        except Exception as e:
            await message.reply(f"❌ Fehler: {str(e)}")

@bot.command(name="clear")
async def clear_conversation(ctx):
    """Konversation für diesen Channel löschen"""
    conv_id = f"{ctx.guild.id}-{ctx.channel.id}"
    if conv_id in conversation_cache:
        del conversation_cache[conv_id]
    await ctx.send("🗑️ Konversation gelöscht.")

@bot.command(name="model")
async def change_model(ctx, model_name: str = None):
    """AI-Modell wechseln"""
    available_models = {
        "deepseek": "deepseek-v3.2",
        "gemini": "gemini-2.5-flash",
        "gpt": "gpt-4.1",
        "claude": "claude-sonnet-4.5"
    }
    
    if not model_name:
        current = holysheep_client.model
        await ctx.send(f"📌 Aktuelles Modell: {current}\nVerfügbare: {', '.join(available_models.keys())}")
        return
    
    if model_name.lower() in available_models:
        holysheep_client.model = available_models[model_name.lower()]
        await ctx.send(f"✅ Modell gewechselt zu: {holysheep_client.model}")
    else:
        await ctx.send("❌ Unbekanntes Modell. Verfügbar: deepseek, gemini, gpt, claude")


Umgebungsvariablen


DISCORD_BOT_TOKEN=your_discord_token


HOLYSHEEP_API_KEY=your_holysheep_key


if __name__ == "__main__":
    bot.run(os.environ["DISCORD_BOT_TOKEN"])

Praxis-Erfahrungsbericht: Meine MCP-Integration bei HolySheep AI

Als technischer Leiter bei HolySheep AI habe ich in den letzten 18 Monaten über 50 MCP-basierte Integrationen für unsere Kunden umgesetzt. Die häufigsten Anwendungsfälle waren:

Der größte Vorteil von MCP zeigt sich bei komplexen Workflows: Ein einziger API-Aufruf kann mehrere Tools gleichzeitig anstoßen. Beispielsweise kann ein Support-Bot parallel Channel-Informationen abrufen, alte Tickets durchsuchen UND eine Antwort generieren — alles in einem Durchgang.

Mit HolySheep AI profitieren Sie von unserer optimierten Infrastruktur mit unter 50ms Latenz und

Verwandte Ressourcen

Verwandte Artikel