# discord-mcp: a Java MCP server that gives AI assistants a Discord bot's hands

> SaseQ/discord-mcp wraps a JDA bot in a Model Context Protocol server so Claude, Cursor, Codex CLI or n8n can manage channels, post messages and read server information. It ships as a Docker image on port 8085, and the HTTP singleton profile is the mode the README recommends.

**SaseQ/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.

- Repository: https://github.com/SaseQ/discord-mcp
- Stars: 524 · Forks: 106
- Language: Java
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/saseq-discord-mcp

## The gap discord-mcp fills between an AI assistant and a Discord server

An MCP client can read your files and run shell commands, but it has no way to touch Discord unless something exposes Discord's API as MCP tools. That is the whole job of SaseQ/discord-mcp. It is a Model Context Protocol server, written in Java and built on JDA, that turns a Discord bot into a set of tools an MCP-compatible application can call. The README names Claude and ChatGPT as the target assistants and lists channel management, message sending and server information retrieval as the capabilities. The repository topics add claude, discord-bot, n8n and openclaw to that list.

The audience is narrow on purpose. You need a Discord bot application and its token before anything works, and you need an MCP client that speaks either the streamable HTTP transport or the older stdio transport. If you only want a bot that posts on a schedule, a plain JDA or discord.js bot is less machinery. If you want an assistant that can decide to create a channel, announce something, or look up what a server contains, the MCP layer is what makes that decision reachable from the model.

## How the JDA bot and the MCP endpoint fit together

The deployment shape is a single long-running Java process. Spring Boot starts it, JDA opens the bot's gateway connection to Discord, and an MCP endpoint is served over HTTP. The README gives the default endpoint as http://localhost:8085/mcp and a Spring Actuator health endpoint at http://localhost:8085/actuator/health. The Dockerfile confirms the port with EXPOSE 8085 and a HEALTHCHECK that greps the actuator response for "status":"UP".

The mode is selected by the SPRING_PROFILES_ACTIVE variable. Setting it to http gives the singleton HTTP server. The README calls the stdio path legacy, and the difference is operational rather than cosmetic: in stdio mode each MCP client session spawns its own process or container, while the HTTP profile gives every client one shared server. The environment variables are DISCORD_TOKEN and the optional DISCORD_GUILD_ID. When the guild ID is set, the README states that any tool accepting a guildId parameter can omit it, which is a small convenience that also means the server has an implicit default target.

What the README does not document is the tool inventory itself. There is no list of tool names, no parameter schemas, no description of what happens when a tool call fails, and no rate limit guidance. For a project whose entire value is the surface it exposes to a model, that is the thinnest part of the documentation. You can infer the categories from the description (channels, messages, server information), but you cannot plan an integration from the README alone.

## Installing discord-mcp with Docker and connecting Claude Code

The README marks Docker as the recommended path and notes that Docker Desktop must already be installed. First export the three variables. DISCORD_TOKEN is required; DISCORD_GUILD_ID is optional; SPRING_PROFILES_ACTIVE selects the HTTP server.

```bash
export DISCORD_TOKEN="YOUR_DISCORD_BOT_TOKEN"
export DISCORD_GUILD_ID="OPTIONAL_DEFAULT_SERVER_ID"
export SPRING_PROFILES_ACTIVE=http
```

Then start the container, publishing port 8085 and forwarding the variables. The README uses --restart unless-stopped and the -i flag, and the image tag is saseq/discord-mcp:latest.

```bash
docker run -d -i \
  --name discord-mcp \
  --restart unless-stopped \
  -p 8085:8085 \
  -e SPRING_PROFILES_ACTIVE \
  -e DISCORD_TOKEN \
  -e DISCORD_GUILD_ID \
  saseq/discord-mcp:latest
```

If you prefer Compose, the repository ships a docker-compose.yml that builds from the local context, maps 8085:8085, reads the same three variables with defaults, and defines a healthcheck against the actuator endpoint. Clone the repository, write a .env file as the README shows, then bring the service up.

```bash
cat > .env <<EOF
SPRING_PROFILES_ACTIVE=http
DISCORD_TOKEN=<YOUR_DISCORD_BOT_TOKEN>
DISCORD_GUILD_ID=<OPTIONAL_DEFAULT_SERVER_ID>
EOF
docker compose up -d --build
```

Verify with the two commands the README gives: docker ps filtered on the container name, and a curl against the health endpoint. The health check should return a JSON body whose status field is UP. Once that passes, register the server with your client. For Claude Code the README's recommended form uses the HTTP transport.

```bash
claude mcp add discord-mcp --transport http http://localhost:8085/mcp
```

Cursor uses the same URL inside a JSON block pasted into ~/.cursor/mcp.json or a project-level .cursor/mcp.json. Codex CLI has its own subcommand, codex mcp add discord-mcp --url http://localhost:8085/mcp, and the README follows it with codex mcp list to confirm. OpenClaw takes a streamable-http transport entry, either through openclaw mcp set or by editing ~/.openclaw/config.json. The generic client config is a single url key.

```json
{
  "mcpServers": {
    "discord-mcp": {
      "url": "http://localhost:8085/mcp"
    }
  }
}
```

There is also a manual path for people who do not want Docker: clone the repository, run mvn clean package, and start the jar with the same three variables set. The README warns that Maven must be installed, and the resulting artifact lands in the target directory. The Dockerfile shows the build stage using maven:3.9.6-amazoncorretto-17 and the runtime stage using amazoncorretto:17-alpine, so Java 17 is the version the project builds and runs against.

## Where discord-mcp is the wrong tool

The token model is the first constraint. Every deployment needs a Discord bot token, and that token carries the bot's full permissions. There is no per-user authorization flow in the README, no OAuth handshake, and no scoping story beyond whatever you configure on the Discord application side. Anyone who can reach the MCP endpoint is effectively acting as the bot. The README does not describe authentication on the HTTP endpoint itself, so binding it to localhost or putting it behind your own access control is the obvious posture rather than something the project documents.

The second constraint is the stdio mode. The README labels it legacy and explains that it starts a new process or container per client session. That means each client pays the startup cost of a JVM plus a JDA gateway connection, and each instance holds its own bot session. The HTTP singleton profile exists precisely to avoid that, and the README recommends it. If you are still on stdio because an older client only speaks that transport, expect the heavier behavior.

The third is operational visibility. Beyond the actuator health endpoint, the README does not describe logging, metrics, or what a failed tool call returns to the model. There is no documented rollback for a destructive action such as deleting a channel. The repository has a single release, v1.0.0, dated 2026-03-16, and the last push was on 2026-04-25, so this is a young project with a short history. That is not a reason to avoid it, but it is a reason to test destructive tools in a throwaway guild before pointing it at a server you care about.

## How discord-mcp differs from a hand-written Discord bot

The real alternative is not another MCP server. It is a purpose-built bot using JDA directly, or discord.js if you prefer JavaScript. A hand-written bot gives you exact control over every command, its permissions, its logging and its failure behavior. You decide what happens when Discord returns an error, and you decide how the bot authenticates. Nothing is exposed to a language model unless you write that path yourself.

The trade-off is flexibility against determinism. A hand-written bot does exactly what it was coded to do and nothing else. discord-mcp instead exposes a tool surface that a model chooses from at runtime, which is the point: the assistant can decide to create a channel or send a message without you predefining that exact sequence. The cost is that the model's choices are not fully predictable, and the README does not document guardrails around them. For a fixed workflow such as a nightly digest, a hand-written bot is simpler and safer. For an assistant that needs to respond to ad hoc requests about a Discord server, the MCP layer is what makes that possible without writing a command for every case.

## Licence, maintenance and the cost of upgrading

The project is MIT licensed, and the README links to the LICENSE file at the repository root. MIT is permissive: you can use, modify and redistribute the code, including in closed products, provided the copyright notice and permission notice are preserved. That is a description of the licence text, not legal advice, and if you are embedding this in a commercial product you should read the LICENSE file yourself.

Maintenance signals are limited but concrete. The repository is not archived. The last push was on 2026-04-25, which is roughly five months before today, so the project has recent activity but no long track record. There is exactly one release, v1.0.0, published on 2026-03-16. Treat the version as early. The upgrade path the README implies is a Docker image pull, since the recommended install pins saseq/discord-mcp:latest; that tag moves, so a rebuild can change behavior without a version number changing. If you need reproducibility, build from a cloned commit rather than tracking latest, which the Compose file supports because it builds from the local context. The README does not document a migration guide or a changelog, so upgrading means reading the diff.

## Conclusion

Adopt SaseQ/discord-mcp if your team already runs a Discord bot and wants an MCP-capable assistant to manage channels and send messages through it, and you are comfortable running a Java service on port 8085. Do not adopt it if you need per-user OAuth, want the server to run without a separate bot token, or expect the README to tell you how to roll back a tool call. Before wiring it into Claude or Cursor, create the bot, confirm the token and guild ID, start the container, and check that http://localhost:8085/actuator/health reports UP and that the MCP endpoint answers at http://localhost:8085/mcp.

## FAQ

### Is there a Discord MCP server for Claude?

Yes. SaseQ/discord-mcp is an MCP server for the Discord API built on JDA, and the README lists Claude among the MCP-compatible applications it targets. Claude Code connects with claude mcp add discord-mcp --transport http http://localhost:8085/mcp.

### Is there a discord-mcp server I can run myself?

The README gives a Docker command that runs saseq/discord-mcp:latest on port 8085 and a docker-compose.yml in the repository that builds the same service locally. Both require a Discord bot token in DISCORD_TOKEN.

### What does a discord-mcp server do?

According to the README, it lets AI assistants interact with Discord by managing channels, sending messages and retrieving server information, exposing those operations as MCP tools. It uses JDA for the Discord side.

## Sources

- [Issues](https://github.com/SaseQ/discord-mcp/issues)
- [License: MIT](https://github.com/SaseQ/discord-mcp/blob/main/LICENSE)
- [README](https://github.com/SaseQ/discord-mcp/blob/main/README.md)
- [Releases](https://github.com/SaseQ/discord-mcp/releases)
- [SaseQ/discord-mcp on GitHub](https://github.com/SaseQ/discord-mcp)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/saseq-discord-mcp