How to Put LLMs into Discord | The Complete 2026 Guide

llmcord — The Easiest No-Boilerplate Option

If you want to skip writing most of the bot infrastructure yourself, llmcord (github.com/jakobdylanc/llmcord) is the most popular ready-to-run solution available. It supports any OpenAI-compatible API including Ollama, xAI, Gemini, and OpenRouter.

What Makes llmcord Special

• Hot reloading of config — change settings without restarting
• Caches message data in a size-managed global dictionary to minimize Discord API calls
• Reply-chain conversations that build context naturally
• Per-user, per-role, and per-channel permission controls
• Supports vision models (image attachments) and text file attachments

Setup in 5 Steps

1. Create a Discord Bot at discord.com/developers/applications → Bot tab → generate token → enable Message Content Intent
2. Clone the repo: git clone https://github.com/jakobdylanc/llmcord.git
3. Install dependencies: pip install -r requirements.txt
4. Configure your provider — add base_url and optional api_key. OpenAI, OpenRouter, and Ollama are pre-configured. First model in your list is the default.
5. Run the bot — the invite URL prints to your console automatically.

Conversation Experience

@ the bot to start a conversation and reply to continue. You can branch conversations into threads — just create a thread from any message and @ the bot inside. Back-to-back messages from the same user are automatically chained. In DMs, conversations continue without needing to reply each time.

Pro TipInclude something like "User messages are prefixed with their Discord ID as <@ID>" in your system prompt to help the model understand the user format and mention users back properly.

How to Put LLMs into Discord

Python + Ollama (Local LLM)

If you want full control and zero API costs, running Ollama locally is your move. Ollama lets you run LLMs like Llama 3, Mistral, and Gemma entirely offline — your data never leaves your machine.

Cloud vs. Local: At a Glance

Step-by-Step Setup

Step 1 — Install Ollama and pull a model

ollama pull llama3
ollama run llama3   # verify it works
# Keep this terminal open — your bot needs it running

Step 2 — Set up your Python environment

mkdir discord-llm-bot && cd discord-llm-bot
python -m venv venv
source venv/bin/activate   # Windows: venv\Scripts\activate
pip install discord.py python-dotenv requests

Step 3 — Create your .env file

DISCORD_TOKEN=your_bot_token_here
OLLAMA_MODEL=llama3

Step 4 — Write bot.py

import discord
import requests
import os
from dotenv import load_dotenv

load_dotenv()

TOKEN = os.getenv("DISCORD_TOKEN")
OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "llama3")
OLLAMA_URL = "http://localhost:11434/api/generate"

intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)

def ask_ollama(prompt, temperature=0.7):
    payload = {
        "model": OLLAMA_MODEL,
        "prompt": prompt,
        "stream": False,
        "options": {"temperature": temperature, "num_predict": 500}
    }
    try:
        response = requests.post(OLLAMA_URL, json=payload, timeout=60)
        if response.status_code == 200:
            return response.json().get("response", "").strip()
        return "Something went wrong with the model."
    except requests.exceptions.ConnectionError:
        return "Error: Ollama is not running! Start it with `ollama serve`."

@client.event
async def on_ready():
    print(f"Logged in as {client.user}")

@client.event
async def on_message(message):
    if message.author == client.user:
        return
    if client.user.mentioned_in(message):
        user_input = message.content.replace(f"<@{client.user.id}>", "").strip()
        async with message.channel.typing():
            reply = ask_ollama(user_input)
        await message.reply(reply)

client.run(TOKEN)

Step 5 — Run it: python bot.py — look for Logged in as YourBot#1234 in the console, then @ the bot in your server.

Python + OpenAI API (Cloud LLM)

For the highest-quality responses and zero hardware management, connecting your Discord bot to OpenAI’s API (or any OpenAI-compatible provider like Anthropic or Gemini) is the cleanest cloud option.

pip install discord.py openai python-dotenv

import discord
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client_ai = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
conversation_history = {}  # Per-user memory

intents = discord.Intents.default()
intents.message_content = True
bot = discord.Client(intents=intents)

@bot.event
async def on_message(message):
    if message.author == bot.user:
        return
    if bot.user.mentioned_in(message):
        user_id = str(message.author.id)
        user_input = message.content.replace(f"<@{bot.user.id}>", "").strip()

        if user_id not in conversation_history:
            conversation_history[user_id] = []

        conversation_history[user_id].append({"role": "user", "content": user_input})

        async with message.channel.typing():
            response = client_ai.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": "You are a helpful assistant in a Discord server."},
                    *conversation_history[user_id]
                ],
                max_tokens=800
            )

        reply = response.choices[0].message.content
        conversation_history[user_id].append({"role": "assistant", "content": reply})
        await message.reply(reply)

bot.run(os.getenv("DISCORD_TOKEN"))

LM Studio + Node.js

If you prefer JavaScript, LM Studio gives you a polished desktop GUI for managing and running local LLMs, and its JavaScript SDK makes integrating with a Discord bot clean and straightforward.

npm install discord.js @lmstudio/sdk dotenv

import { LMStudioClient } from '@lmstudio/sdk';
import { Client, GatewayIntentBits } from 'discord.js';
import 'dotenv/config';

const lms = new LMStudioClient();
const discord = new Client({
  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
});

discord.on('ready', () => console.log(`Ready: ${discord.user.tag}`));

discord.on('messageCreate', async (message) => {
  if (message.author.bot) return;
  if (!message.mentions.has(discord.user)) return;

  const prompt = message.content.replace(`<@${discord.user.id}>`, '').trim();
  const model = await lms.llm.get({ path: 'lmstudio-community/gemma-2-2b-it-GGUF' });

  await message.channel.sendTyping();
  const response = await model.respond([{ role: 'user', content: prompt }]);
  await message.reply(response.content);
});

discord.login(process.env.DISCORD_TOKEN);

In LM Studio, navigate to the server section, select your model from the dropdown, and start the local API server before running this script. Models like Gemma 2 2B work well on most consumer hardware.