Build a Discord Bot with MCP Tools in 5 Minutes

We built a Discord bot that queries a database and creates Jira tickets. No workflow graph. No if/else branches. The LLM read the message, decided what to do, and called the right MCPs. Five minutes on the Aerostack side.

The catch: you need your credentials first. That prep is the real time cost. But once you have them, the Aerostack part is fast.

Prerequisites

Before you touch the dashboard, collect these:

Discord bot credentials — From the Discord Developer Portal. You need three things: a bot_token, an application_id, and the public_key. Enable "Message Content Intent" under your bot's Privileged Gateway Intents. This is the step most people get stuck on — Discord's developer portal has changed layouts three times in two years.

A database MCP — Aerostack doesn't connect to your database directly. You need an MCP server that wraps your database. Either use a published one from the registry (we host a PostgreSQL MCP) or deploy your own. The MCP exposes tools like query and list_tables that the LLM can call.

A Jira MCP — Same idea. A Jira MCP server that exposes tools like create_issue, search_issues, get_issue. We have one in the registry. You'll need your Jira email + API token from account.atlassian.com → Security → Create API token.

That's the real time cost. Collecting credentials and making sure your MCPs are deployed. Once they exist, everything below is fast.

What You're Building

A Discord bot that:

Responds to natural language in your server
Queries your database for error logs, user data, whatever the MCP exposes
Decides on its own whether to create a Jira ticket, summarize findings, or ask for clarification
Does this without a workflow graph — the LLM figures out which tools to call

Here's what it looks like:

User: "What errors happened in the last hour?"

Bot: (calls database MCP → runs query → reads results)

"Found 3 errors in the last hour: connection timeout at 14:32, auth failure at 14:47, null pointer at 15:01. Want me to create a Jira ticket for any of these?"

User: "Create a ticket for the auth failure."

Bot: (calls Jira MCP → creates issue)

"Done. Created PROJ-1247: Auth failure in login service."

The bot offered to create a ticket without anyone programming that branch. The LLM read the context, saw the Jira MCP in its tool list, and decided it was relevant.

Discord bot querying a database and creating Jira tickets from natural language

Step 1: Create a Workspace

A workspace is a container for MCPs. It holds secrets, manages access, and gives you a single gateway URL.

From the dashboard, create a new workspace. Give it a name. You get back a slug and a gateway URL:

https://mcp.aerostack.dev/ws/my-discord-bot

That URL is where all your MCP tools are exposed through. One endpoint, multiple MCPs behind it.

Step 2: Add MCPs to the Workspace

This is the part that replaces per-machine MCP config.

You browse the registry (or search by name), find the PostgreSQL MCP and the Jira MCP, and add them to your workspace.

Then you add secrets. Each MCP needs credentials to talk to the upstream service. In the workspace secrets panel:

Key: POSTGRES_CONNECTION_STRING
Value: postgresql://db_user:****@your-host:5432/production_db

Key: JIRA_EMAIL
Value: your-email@company.com

Key: JIRA_API_TOKEN
Value: ****

Secrets are encrypted before they hit storage. At runtime, when the bot calls an MCP tool, the gateway decrypts the relevant secrets and injects them into the MCP request. The bot never sees raw credentials. The LLM never sees them either — it only sees tool schemas (name, description, parameter types).

You tell each MCP which secrets it needs. The PostgreSQL MCP gets the connection string. The Jira MCP gets the email and API token.

Step 3: Create the Bot

Aerostack has a 6-step bot wizard. For a freestyle bot, the important steps are:

Bot creation wizard — 6 steps from identity to go-live

Identity — name it, write a system prompt:

You are an error detective bot. Users ask about recent errors, crashes, or
system issues in our production database.

When users ask about errors:
1. Query the database MCP for recent error logs.
2. Summarize what you find.
3. Ask if they want a Jira ticket.

When users ask to create a ticket:
1. Call the Jira MCP to create an issue with the error details.
2. Return the ticket key.

Keep responses concise. Explain what queries you ran.

AI Brain — pick a model. The default is Claude Sonnet. You can swap to GPT-4o, Gemini, Groq, or Workers AI. If you bring your own API key (BYOK), you paste it here — it gets encrypted the same way workspace secrets do.

Workspace — link to the workspace you just created. The bot automatically gets access to every MCP in that workspace.

Platform — choose Discord.

Step 4: Connect to Discord

Discord integration needs three fields:

Bot Token:      MTk4NjIyNDgzNDU3Njcw...
Application ID: 1234567890
Public Key:     f1d88f5b1e4a...

All three come from the Discord Developer Portal. The public_key is used to verify that incoming webhooks actually came from Discord (Ed25519 signature verification).

When you hit Go Live, Aerostack registers your bot's webhook endpoint with Discord and sets up /ask and /reset slash commands. Your bot is live.

Step 5: Test It

Go to your Discord server. Type:

@Error Detective what errors happened in the last hour?

Here's what happens behind the scenes:

Behind the scenes — from Discord interaction to LLM tool calls to response

If the user says "yes, create a ticket," the loop runs again. This time the LLM picks the Jira MCP instead. Nobody programmed that branch.

The Real Bottleneck

The five minutes is honest for the Aerostack side. The real time goes into:

Discord Developer Portal (3-5 min): Creating the application, enabling Message Content Intent, copying three separate credential fields. Discord's portal is powerful but not intuitive — if it's your first time, budget extra time to find the right settings page.

Database MCP (varies): If you're using a hosted MCP from our registry, it's quick — add it to workspace, configure the connection string secret. If you're deploying your own MCP server that wraps a custom database, that's a separate task. Either way, create a read-only database user with SELECT permissions on only the tables the bot needs. Don't give it your production admin credentials.

Jira API token (2-3 min): Atlassian account → Security → Create API token. Straightforward.

Total from zero: 15-30 minutes depending on whether your MCPs already exist in the registry. That's not because Aerostack is slow — it's because third-party credential gathering is friction we can't eliminate.

What Could Be Smoother

Copying API tokens from account settings pages is the biggest friction point. We're building OAuth flows for services like Jira and GitHub so authorization happens inline.

We're also building bot templates. Pick "Error Detective," plug in your credentials, and get a pre-configured bot with a tuned system prompt and MCPs already linked.

Extending It

Add more MCPs. Slack, GitHub, Notion — add them to the workspace, and the LLM can call their tools alongside the existing ones. No code changes. The bot sees all tools in its workspace and decides which to use based on context.

Tune the system prompt. Tell the bot to never create high-priority tickets without confirmation. Or always assign to the on-call engineer. Or include a runbook link in every ticket description. The system prompt is your control surface — change it without redeploying.

Add webhooks. Instead of responding to Discord mentions, trigger the bot from monitoring alerts. Datadog detects a spike, sends a webhook to your workspace, the bot queries the database and creates a Jira ticket automatically, then posts the summary to Discord.

Tomorrow: the workflow nodes that power all of this — the building blocks behind bots, webhooks, and agent endpoints.