Discord Mcp
Un serveur MCP pour l'intégration Discord. Permettez à vos assistants IA d'interagir sans effort avec Discord. Améliorez votre expérience Discord avec des capacités d'automatisation puissantes.
Aperçu
Qu'est-ce que Discord-MCP ?
Discord-MCP est un serveur puissant conçu pour s'intégrer à Discord, permettant une interaction fluide entre les assistants AI et la plateforme Discord. Cet outil améliore l'expérience utilisateur en automatisant diverses tâches et en fournissant des fonctionnalités avancées qui rationalisent la communication et l'engagement au sein des communautés Discord.
Fonctionnalités de Discord-MCP
- Intégration AI : Permet aux assistants AI d'interagir directement avec Discord, fournissant des réponses et une assistance en temps réel.
- Capacités d'automatisation : Automatise les tâches répétitives, facilitant la gestion des serveurs Discord pour les utilisateurs.
- Interface conviviale : Conçu avec la simplicité à l'esprit, rendant l'outil accessible aux utilisateurs de tous niveaux de compétence.
- Open Source : Étant un dépôt public, les utilisateurs peuvent contribuer à son développement et le personnaliser selon leurs besoins.
- Support communautaire : Une communauté croissante d'utilisateurs et de développeurs qui partagent des conseils, des astuces et un soutien pour utiliser Discord-MCP efficacement.
Comment utiliser Discord-MCP
- Installation : Clonez le dépôt depuis GitHub et suivez les instructions d'installation fournies dans le fichier README.
- Configuration : Configurez votre bot Discord et définissez les autorisations nécessaires pour lui permettre d'interagir avec votre serveur.
- Intégration : Connectez votre assistant AI à Discord-MCP, lui permettant de répondre aux commandes et aux messages.
- Personnalisation : Modifiez le code si nécessaire pour adapter les fonctionnalités à vos exigences spécifiques.
- Engagement : Commencez à utiliser votre assistant AI dans Discord, améliorant les interactions et automatisant les tâches pour une expérience plus fluide.
Questions Fréquemment Posées
Q : Discord-MCP est-il gratuit à utiliser ?
R : Oui, Discord-MCP est un projet open-source et est gratuit à utiliser.
Q : Puis-je contribuer au projet ?
R : Absolument ! Les contributions sont les bienvenues. Vous pouvez forker le dépôt, apporter des modifications et soumettre une demande de tirage.
Q : Quelles langages de programmation sont utilisés dans Discord-MCP ?
R : Discord-MCP est principalement construit en utilisant JavaScript et Node.js.
Q : Comment signaler des problèmes ou des bugs ?
R : Vous pouvez signaler des problèmes en créant un nouvel issue dans le dépôt GitHub sous l'onglet "Issues".
Q : Où puis-je trouver la documentation pour Discord-MCP ?
R : La documentation est disponible dans le fichier README du dépôt et à travers les forums et discussions communautaires.
En utilisant Discord-MCP, les utilisateurs peuvent considérablement améliorer leur expérience sur Discord, rendant les interactions plus efficaces et agréables.
Détail
📖 Description
A Model Context Protocol (MCP) server for the Discord API (JDA), allowing seamless integration of Discord Bot with MCP-compatible applications like Claude Desktop.
Enable your AI assistants to seamlessly interact with Discord. Manage channels, send messages, and retrieve server information effortlessly. Enhance your Discord experience with powerful automation capabilities.
🔬 Installation
► 🐳 Docker Installation (Recommended)
NOTE: Docker installation is required. Full instructions can be found on docker.com.
{
"mcpServers": {
"mcp-server": {
"command": "docker",
"args": [
"run", "--rm", "-i",
"-e", "DISCORD_TOKEN=<YOUR_DISCORD_BOT_TOKEN>",
"-e", "DISCORD_GUILD_ID=<OPTIONAL_DEFAULT_SERVER_ID>",
"saseq/discord-mcp:latest"
]
}
}
}
Clone the repository
git clone https://github.com/SaseQ/discord-mcp
Build the project
NOTE: Maven installation is required to use the mvn command. Full instructions can be found here.
cd discord-mcp
mvn clean package # The jar file will be available in the /target directory
Configure AI client
Many code editors and other AI clients use a configuration file to manage MCP servers.
The Discord MPC server can be configured by adding the following to your configuration file.
NOTE: You will need to create a Discord Bot token to use this server. Instructions on how to create a Discord Bot token can be found here.
{
"mcpServers": {
"discord-mcp": {
"command": "java",
"args": [
"-jar",
"/absolute/path/to/discord-mcp-0.0.1-SNAPSHOT.jar"
],
"env": {
"DISCORD_TOKEN": "YOUR_DISCORD_BOT_TOKEN",
"DISCORD_GUILD_ID": "OPTIONAL_DEFAULT_SERVER_ID"
}
}
}
}
The DISCORD_GUILD_ID environment variable is optional. When provided, it sets a default Discord server ID so any tool that accepts a guildId parameter can omit it.
Install Discord MCP Server automatically via Smithery:
npx -y @smithery/cli@latest install @SaseQ/discord-mcp --client <CLIENT_NAME> --key <YOUR_SMITHERY_KEY>
Go to: Settings -> Cursor Settings -> MCP -> Add new global MCP server
Pasting the following configuration into your Cursor ~/.cursor/mcp.json file is the recommended approach. You may also install in a specific project by creating .cursor/mcp.json in your project folder. See Cursor MCP docs for more info.
{
"mcpServers": {
"mcp-server": {
"command": "docker",
"args": [
"run", "--rm", "-i",
"-e", "DISCORD_TOKEN=<YOUR_DISCORD_BOT_TOKEN>",
"-e", "DISCORD_GUILD_ID=<OPTIONAL_DEFAULT_SERVER_ID>",
"saseq/discord-mcp:latest"
]
}
}
}
Run this command. See Claude Code MCP docs for more info.
claude mcp add mcp-server -- docker run --rm -i -e DISCORD_TOKEN=<YOUR_DISCORD_BOT_TOKEN> -e DISCORD_GUILD_ID=<OPTIONAL_DEFAULT_SERVER_ID> saseq/discord-mcp:latest
🛠️ Available Tools
Server Information
get_server_info: Get detailed discord server information
User Management
get_user_id_by_name: Get a Discord user's ID by username in a guild for ping usage<@id>send_private_message: Send a private message to a specific useredit_private_message: Edit a private message from a specific userdelete_private_message: Delete a private message from a specific userread_private_messages: Read recent message history from a specific user
Message Management
send_message: Send a message to a specific channeledit_message: Edit a message from a specific channeldelete_message: Delete a message from a specific channelread_messages: Read recent message history from a specific channeladd_reaction: Add a reaction (emoji) to a specific messageremove_reaction: Remove a specified reaction (emoji) from a message
Channel Management
create_text_channel: Create text a channeldelete_channel: Delete a channelfind_channel: Find a channel type and ID using name and server IDlist_channels: List of all channels
Category Management
create_category: Create a new category for channelsdelete_category: Delete a categoryfind_category: Find a category ID using name and server IDlist_channels_in_category: List of channels in a specific category
Webhook Management
create_webhook: Create a new webhook on a specific channeldelete_webhook: Delete a webhooklist_webhooks: List of webhooks on a specific channelsend_webhook_message: Send a message via webhook
<hr>If
DISCORD_GUILD_IDis set, theguildIdparameter becomes optional for all tools above.
A more detailed examples can be found in the Wiki.
Configuration du serveur
{
"mcpServers": {
"discord-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/metorial/mcp-container--saseq--discord-mcp--discord-mcp",
"java -Dserver.port=$PORT $JAVA_OPTS -jar target/*jar"
],
"env": {
"DISCORD_TOKEN": "discord-token"
}
}
}
}
.
Code du serveur
Voici un exemple de code pour un serveur Unichat Mcp en Python :
```python
import socket
import threading
Configuration du serveur
HOST = '127.0.0.1' Adresse IP du serveur
PORT = 12345 Port du serveur
Liste des clients connectés
clients = []
def handle_client(client_socket, client_address):
print(f"[Nouveau client] {client_address} connecté.")
clients.append(client_socket)
while True:
try:
message = client_socket.recv(1024).decode('utf-8')
if message:
print(f"[Message reçu] {message} de {client_address}")
broadcast(message, client_socket)
else:
break
except:
break
print(f"[Client déconnecté] {client_address} déconnecté.")
clients.remove(client_socket)
client_socket.close()
def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
try:
client.send(message.encode('utf-8'))
except:
client.close()
clients.remove(client)
def start_server():
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen()
print(f"[Démarrage du serveur] Écoute sur {HOST}:{PORT}")
while True:
client_socket, client_address = server.accept()
thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
thread.start()
if __name__ == "__main__":
start_server()
```
Exécution du serveur
Pour exécuter le serveur, sauvegardez le code ci-dessus dans un fichier nommé `unichat_server.py` et exécutez-le avec la commande suivante :
```bash
python unichat_server.py
```
Conclusion
Vous avez maintenant un serveur Unichat Mcp fonctionnel en Python. Vous pouvez le modifier et l'étendre selon vos besoins.](https://avatars.githubusercontent.com/u/1759588?v=4 "Serveur Unichat Mcp en Python
Introduction
Unichat est un serveur de chat simple qui utilise le protocole MCP (Multi-Channel Protocol). Ce document explique comment créer un serveur Unichat en Python.
Prérequis
- Python 3.x
- Bibliothèque `socket`
Installation
Assurez-vous d'avoir Python installé sur votre machine. Vous pouvez le télécharger depuis [python.org](https://www.python.org/downloads/).
Code du serveur
Voici un exemple de code pour un serveur Unichat Mcp en Python :
```python
import socket
import threading
Configuration du serveur
HOST = '127.0.0.1' Adresse IP du serveur
PORT = 12345 Port du serveur
Liste des clients connectés
clients = []
def handle_client(client_socket, client_address):
print(f\"[Nouveau client] {client_address} connecté.\")
clients.append(client_socket)
while True:
try:
message = client_socket.recv(1024).decode('utf-8')
if message:
print(f\"[Message reçu] {message} de {client_address}\")
broadcast(message, client_socket)
else:
break
except:
break
print(f\"[Client déconnecté] {client_address} déconnecté.\")
clients.remove(client_socket)
client_socket.close()
def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
try:
client.send(message.encode('utf-8'))
except:
client.close()
clients.remove(client)
def start_server():
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen()
print(f\"[Démarrage du serveur] Écoute sur {HOST}:{PORT}\")
while True:
client_socket, client_address = server.accept()
thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
thread.start()
if __name__ == \"__main__\":
start_server()
```
Exécution du serveur
Pour exécuter le serveur, sauvegardez le code ci-dessus dans un fichier nommé `unichat_server.py` et exécutez-le avec la commande suivante :
```bash
python unichat_server.py
```
Conclusion
Vous avez maintenant un serveur Unichat Mcp fonctionnel en Python. Vous pouvez le modifier et l'étendre selon vos besoins."){kind=small}
