Discord Mcp
A MCP server for the Discord integration. Enable your AI assistants to seamlessly interact with Discord. Enhance your Discord experience with powerful automation capabilities.
Overview
What is Discord-MCP?
Discord-MCP is a powerful server designed to integrate with Discord, enabling seamless interaction between AI assistants and the Discord platform. This tool enhances the user experience by automating various tasks and providing advanced functionalities that streamline communication and engagement within Discord communities.
Features of Discord-MCP
- AI Integration: Allows AI assistants to interact directly with Discord, providing real-time responses and assistance.
- Automation Capabilities: Automates repetitive tasks, making it easier for users to manage their Discord servers.
- User-Friendly Interface: Designed with simplicity in mind, making it accessible for users of all skill levels.
- Open Source: Being a public repository, users can contribute to its development and customize it to fit their needs.
- Community Support: A growing community of users and developers who share tips, tricks, and support for using Discord-MCP effectively.
How to Use Discord-MCP
- Installation: Clone the repository from GitHub and follow the installation instructions provided in the README file.
- Configuration: Set up your Discord bot and configure the necessary permissions to allow it to interact with your server.
- Integration: Connect your AI assistant to Discord-MCP, enabling it to respond to commands and messages.
- Customization: Modify the code as needed to tailor the functionalities to your specific requirements.
- Engagement: Start using your AI assistant in Discord, enhancing interactions and automating tasks for a smoother experience.
Frequently Asked Questions
Q: Is Discord-MCP free to use?
A: Yes, Discord-MCP is an open-source project and is free to use.
Q: Can I contribute to the project?
A: Absolutely! Contributions are welcome. You can fork the repository, make changes, and submit a pull request.
Q: What programming languages are used in Discord-MCP?
A: Discord-MCP is primarily built using JavaScript and Node.js.
Q: How do I report issues or bugs?
A: You can report issues by creating a new issue in the GitHub repository under the "Issues" tab.
Q: Where can I find documentation for Discord-MCP?
A: Documentation is available in the repository's README file and through community forums and discussions.
By utilizing Discord-MCP, users can significantly enhance their Discord experience, making interactions more efficient and enjoyable.
Details
📖 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.
Server Config
{
"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
```python
import socket
import threading
Server settings
HOST = '127.0.0.1' Localhost
PORT = 12345 Port to listen on
List to keep track of connected clients
clients = []
def handle_client(client_socket, addr):
print(f"Connection from {addr} has been established!")
clients.append(client_socket)
while True:
try:
message = client_socket.recv(1024).decode('utf-8')
if message:
print(f"Received message: {message}")
broadcast(message, client_socket)
else:
break
except:
break
print(f"Connection from {addr} has been closed.")
clients.remove(client_socket)
client_socket.close()
def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
client.send(message.encode('utf-8'))
def start_server():
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen()
print(f"Server is listening on {HOST}:{PORT}")
while True:
client_socket, addr = server_socket.accept()
thread = threading.Thread(target=handle_client, args=(client_socket, addr))
thread.start()
if __name__ == "__main__":
start_server()
```
How to Run
1. Save the code in a file named `unichat_server.py`.
2. Open a terminal and navigate to the directory where the file is saved.
3. Run the server using the command:
```
python unichat_server.py
```
Connecting Clients
You can create a simple client using the following code:
```python
import socket
HOST = '127.0.0.1' Server address
PORT = 12345 Server port
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((HOST, PORT))
while True:
message = input("Enter message: ")
client_socket.send(message.encode('utf-8'))
```
Conclusion
This is a basic implementation of a chat server in Python. You can enhance it by adding features like user authentication, message history, or a graphical user interface.](https://avatars.githubusercontent.com/u/1759588?v=4 "Unichat MCP Server in Python
Overview
Unichat is a simple chat server that allows multiple clients to connect and communicate with each other. This implementation is done using Python's socket programming.
Requirements
- Python 3.x
- Basic knowledge of socket programming
Installation
Make sure you have Python installed on your machine. You can download it from [python.org](https://www.python.org/downloads/).
Code
```python
import socket
import threading
Server settings
HOST = '127.0.0.1' Localhost
PORT = 12345 Port to listen on
List to keep track of connected clients
clients = []
def handle_client(client_socket, addr):
print(f\"Connection from {addr} has been established!\")
clients.append(client_socket)
while True:
try:
message = client_socket.recv(1024).decode('utf-8')
if message:
print(f\"Received message: {message}\")
broadcast(message, client_socket)
else:
break
except:
break
print(f\"Connection from {addr} has been closed.\")
clients.remove(client_socket)
client_socket.close()
def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
client.send(message.encode('utf-8'))
def start_server():
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen()
print(f\"Server is listening on {HOST}:{PORT}\")
while True:
client_socket, addr = server_socket.accept()
thread = threading.Thread(target=handle_client, args=(client_socket, addr))
thread.start()
if __name__ == \"__main__\":
start_server()
```
How to Run
1. Save the code in a file named `unichat_server.py`.
2. Open a terminal and navigate to the directory where the file is saved.
3. Run the server using the command:
```
python unichat_server.py
```
Connecting Clients
You can create a simple client using the following code:
```python
import socket
HOST = '127.0.0.1' Server address
PORT = 12345 Server port
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((HOST, PORT))
while True:
message = input(\"Enter message: \")
client_socket.send(message.encode('utf-8'))
```
Conclusion
This is a basic implementation of a chat server in Python. You can enhance it by adding features like user authentication, message history, or a graphical user interface."){kind=small}
