Guides / Use cases

Discord and Slack bots

For bots that live in a busy Discord server or Slack workspace, where hundreds of members talk in the same channels. Recall keeps every member apart, remembers each one across channels and weeks, and keeps what someone told the bot in private out of its public replies.

What memory adds

Without memory, the bot sees the message that mentions it and perhaps the last few lines of the channel. With it, the bot knows who is asking:

Recall is memory, not the bot: your model writes the replies and your bot code talks to Discord or Slack. Recall has no Discord or Slack integration of its own; the bot calls the SDK.

How to model it

Build it

Install the SDK (npm install @recall-memory/sdk or pip install recall-mem) and set RECALL_API_KEY. Create the bot peer and turn off learning from it before its first line is stored, then a session per channel in which the bot observes the others.

import { Recall } from "@recall-memory/sdk";

const recall = new Recall({ workspaceId: "discord-912847561203948572" });

// One workspace per server. Members are peers keyed by their platform user id, never by
// display name, which members change and share.
const member = (userId: string) => recall.peer(`discord-${userId}`);
// The bot learns about members, not from its own lines.
const bot = recall.peer("bot");
await bot.setConfiguration({ observeMe: false });

// A channel (or thread) is a session. In public channels the bot builds its own view of
// every member who speaks; members join the session with their first message.
const general = recall.session("ch-1129384756102938475", {
  peers: { bot: { observeOthers: true } },
});

from recall_memory import Peer, PeerConfig, Recall, SessionPeerConfig

recall = Recall(workspace_id="discord-912847561203948572")

# One workspace per server. Members are peers keyed by their platform user id, never by
# display name, which members change and share.
def member(user_id: str) -> Peer:
    return recall.peer(f"discord-{user_id}")

# The bot learns about members, not from its own lines.
bot = recall.peer("bot")
bot.set_configuration(PeerConfig(observe_me=False))

# A channel (or thread) is a session. In public channels the bot builds its own view of
# every member who speaks; members join the session with their first message.
general = recall.session(
    "ch-1129384756102938475", peers={"bot": SessionPeerConfig(observe_others=True)}
)

Busy channels: batch, and only read when asked. Storing every message as it arrives is a request per message, and a busy server soon meets the rate limit. Buffer what nobody addressed to the bot and store it every few seconds in one request (up to 100 messages; the SDKs split larger batches). When someone mentions the bot, turn stores their message and returns the context for the reply in one request of a fraction of a second.

// Two members talk in #general.
const asker = member("284711093281726464");
const helper = member("391028475610293847");
// Messages not addressed to the bot wait in a buffer, stored in one request every few seconds.
const buffer = [
  asker.message("Anyone stuck on the level 12 boss? I play a frost mage."),
  helper.message("Frost will not work there, it is immune. Bring a fire staff."),
];
await general.addMessages(buffer.splice(0));

// A member mentions the bot: store the message and get context in one request, read through
// the bot's own view, so nothing said in a DM comes up in a public channel.
const mention = asker.message("@bot any tips for that boss with my build?");
const { context } = await general.turn([mention], {
  peerTarget: asker,
  peerPerspective: bot,
  tokens: 1500,
});
const prompt = context.toOpenAI(bot);
// Your model writes the reply from `prompt`; store it so the channel history is complete.
const answer = "As a frost mage, swap to a fire staff for this fight.";
await general.addMessages([bot.message(answer)]);

# Two members talk in #general.
asker = member("284711093281726464")
helper = member("391028475610293847")
# Messages not addressed to the bot wait in a buffer, stored in one request every few seconds.
buffer = [
    asker.message("Anyone stuck on the level 12 boss? I play a frost mage."),
    helper.message("Frost will not work there, it is immune. Bring a fire staff."),
]
general.add_messages(buffer)
buffer.clear()

# A member mentions the bot: store the message and get context in one request, read through
# the bot's own view, so nothing said in a DM comes up in a public channel.
mention = asker.message("@bot any tips for that boss with my build?")
result = general.turn([mention], peer_target=asker, peer_perspective=bot, tokens=1500)
prompt = result.context.to_openai(assistant=bot)
# Your model writes the reply from `prompt`; store it so the channel history is complete.
answer = "As a frost mage, swap to a fire staff for this fight."
general.add_messages([bot.message(answer)])

DMs stay private. In a DM the bot reads the member's own memory, which includes what they said in public. In public it reads only its own view, which was never told what was said in a DM.

// A DM is a session of its own, and the bot does not observe it: what a member says here goes
// only into their own memory, which the bot reads here (no perspective), never in public.
const dm = recall.session("dm-391028475610293847", { peers: [helper, bot] });
const reply = await dm.turn([helper.message("Between us, I may leave the raid team.")], {
  peerTarget: helper,
  tokens: 1500,
});

# A DM is a session of its own, and the bot does not observe it: what a member says here goes
# only into their own memory, which the bot reads here (no perspective), never in public.
dm = recall.session("dm-391028475610293847", peers=[helper, bot])
reply = dm.turn(
    [helper.message("Between us, I may leave the raid team.")], peer_target=helper, tokens=1500
)

Ask about a member. For a /memory command or a moderator tool, ask the bot's view of one member in plain language. That is a model call of a few seconds, so keep it out of the reply path.

// Per-member memory: what has the bot learned about this member in public channels?
// (waitForIdle is for this demo; a bot never blocks on learning.)
await recall.waitForIdle();
const known = await bot.chat("What does this member play, and what do they need help with?", {
  target: asker,
  reasoningLevel: "minimal",
});

# Per-member memory: what has the bot learned about this member in public channels?
# (wait_for_idle is for this demo; a bot never blocks on learning.)
recall.wait_for_idle()
known = bot.chat(
    "What does this member play, and what do they need help with?",
    target=asker,
    reasoning_level="minimal",
)

Forget on request.

// `/forget`, or a member who leaves the server: erase them from this server's memory.
const removed = await asker.delete();

# `/forget`, or a member who leaves the server: erase them from this server's memory.
removed = asker.delete()

Wiring it to discord.js or Slack Bolt

The platform code stays small. A sketch for discord.js, with one Recall client per server and the calls from above; yourModel stands for your own model call:

const clients = new Map(); // guild id -> Recall client for that server's workspace
async function recallFor(guildId) {
  if (!clients.has(guildId)) {
    const recall = new Recall({ workspaceId: `discord-${guildId}` });
    await recall.peer("bot").setConfiguration({ observeMe: false });
    clients.set(guildId, recall);
  }
  return clients.get(guildId);
}
const pending = new Map(); // channel id -> messages not stored yet

client.on("messageCreate", async (msg) => {
  if (msg.author.bot || !msg.guild) return;
  const recall = await recallFor(msg.guild.id);
  const author = recall.peer(`discord-${msg.author.id}`);
  const waiting = pending.get(msg.channelId) ?? [];
  pending.set(msg.channelId, waiting);
  waiting.push(author.message(msg.content, { createdAt: msg.createdAt }));
  if (!msg.mentions.has(client.user)) return; // a timer flushes `waiting` with addMessages

  const channel = recall.session(`ch-${msg.channelId}`, {
    peers: { bot: { observeOthers: true } },
  });
  const { context } = await channel.turn(waiting.splice(0), {
    peerTarget: author,
    peerPerspective: "bot",
    tokens: 1500,
  });
  const reply = await yourModel(context.toOpenAI("bot"));
  await msg.reply(reply);
  await channel.addMessages([recall.peer("bot").message(reply)]);
});

With Slack Bolt the same calls go in app.message (buffer) and app.event("app_mention") (turn); peer ids are slack- plus the user id, and the workspace is named after the Slack team id. Both platforms expect a slash command to be acknowledged within a few seconds, so acknowledge first and then ask.

Settings that matter

Cost and speed

Measured from Europe against the hosted API (Frankfurt), October 2026: a turn or context call took 0.3 to 0.7 seconds, and a question at minimal or low 2 to 4.5 seconds. Learning runs in the background and never holds up a reply. When you go over the rate limit (counted per API key), Recall answers 429 with Retry-After; the SDKs wait that long and retry, but batching is what keeps you under it.

Context, search and storage are included. You pay for learning, $1.75 per million message tokens with every message counting as at least 50, and for questions. Members who only read cost nothing. An active member who posts 200 short messages a month, gets 40 replies from the bot of about 80 tokens, and runs /memory 5 times:

Short chat lines count as 50 tokens each, so a chatty member costs more than their word count suggests. More in Cost and speed.

Privacy and forgetting

Members do not expect a bot to remember them unless they are told. Pin a notice in the channels the bot reads, say it in the bot's profile, and give members two commands: /memory to see what the bot knows about them, and /forget to erase it. When a member asks, or leaves the server if your notice says so, delete erases their messages and every fact about them or from their view; other members' messages and facts about others that merely mention them stay. A member who never spoke answers 404: there is nothing to forget.

Do not store what the bot does not need: skip channels it is not used in, and never record moderators' private channels. Many Discord communities include teenagers; read Privacy, consent and forgetting before you build profiles of them. Recall stores data in Frankfurt; text is processed by AI model providers in the US through OpenRouter, restricted to providers that do not collect it, and never used for training. See the DPA and Forget a person.

Pitfalls

• Display names as ids. Names change and repeat, and memories follow the name to the wrong person. Use the platform's user id.
• One request per message. A busy channel then hits 429. Batch, and call turn only when the bot is addressed.
• Public replies without peerPerspective. The member's own memory includes their DMs, which can then surface in front of everyone.
• One workspace for every server. What a member said in one community follows them into another. Use a workspace per server.
• observeOthers for members. A session allows at most 10, and members do not need their own view. Give it to the bot only.
• Asking on every message. A question takes seconds and costs per call. Replies need context, not questions.

Next: Workplace assistants · Multi-agent systems