7 LangChain Integrations: Slack, Discord, WhatsApp Bots

pip install slack-bolt langchain langchain-openai

# slack_bot.py
import os
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

app = App(token=os.environ["SLACK_BOT_TOKEN"])

# Per-channel memory store
memory_store: dict = {}
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

def get_chain(channel_id: str) -> ConversationChain:
    if channel_id not in memory_store:
        memory_store[channel_id] = ConversationBufferMemory()
    return ConversationChain(
        llm=llm,
        memory=memory_store[channel_id],
        verbose=False
    )

@app.event("app_mention")
def handle_mention(event, say):
    channel = event["channel"]
    user_text = event["text"].split(">", 1)[-1].strip()  # Remove @mention

    chain = get_chain(channel)
    response = chain.run(user_text)
    say(response)

if __name__ == "__main__":
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    handler.start()

from langchain.agents import initialize_agent, AgentType
from langchain.tools import DuckDuckGoSearchRun, WikipediaQueryRun

search = DuckDuckGoSearchRun()
tools = [search]

def get_agent(channel_id: str):
    if channel_id not in memory_store:
        memory_store[channel_id] = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )
    return initialize_agent(
        tools=tools,
        llm=llm,
        agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
        memory=memory_store[channel_id],
        verbose=False
    )

@app.event("app_mention")
def handle_mention(event, say):
    channel = event["channel"]
    user_text = event["text"].split(">", 1)[-1].strip()
    agent = get_agent(channel)
    response = agent.run(user_text)
    say(response)

@app.event("app_mention")
def handle_mention(event, say, ack):
    ack()  # Immediately acknowledge
    # Now process (can take longer than 3s)
    channel = event["channel"]
    user_text = event["text"].split(">", 1)[-1].strip()
    response = get_chain(channel).run(user_text)
    say(response)

pip install discord.py langchain langchain-openai

# discord_bot.py
import os
import discord
from discord.ext import commands
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain

intents = discord.Intents.default()
intents.message_content = True
bot = commands.Bot(command_prefix="!", intents=intents)

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
memory_store: dict = {}

def get_chain(user_id: int) -> ConversationChain:
    if user_id not in memory_store:
        # Window memory keeps last 10 exchanges — prevents context overflow
        memory_store[user_id] = ConversationBufferWindowMemory(k=10)
    return ConversationChain(llm=llm, memory=memory_store[user_id])

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

@bot.command(name="ask")
async def ask(ctx, *, question: str):
    """Ask the AI a question: !ask <your question>"""
    async with ctx.typing():  # Shows "Bot is typing..."
        chain = get_chain(ctx.author.id)
        response = await chain.arun(question)
    await ctx.reply(response)

@bot.command(name="reset")
async def reset(ctx):
    """Reset conversation memory"""
    memory_store.pop(ctx.author.id, None)
    await ctx.reply("Memory cleared.")

bot.run(os.environ["DISCORD_TOKEN"])

@bot.tree.command(name="chat", description="Chat with the AI")
async def chat_command(interaction: discord.Interaction, message: str):
    await interaction.response.defer()  # Acknowledge within 3 seconds
    chain = get_chain(interaction.user.id)
    response = await chain.arun(message)
    await interaction.followup.send(response)

# Sync commands on startup
@bot.event
async def on_ready():
    await bot.tree.sync()
    print(f"Synced slash commands. Logged in as {bot.user}")

pip install twilio flask langchain langchain-openai

# whatsapp_bot.py
from flask import Flask, request
from twilio.twiml.messaging_response import MessagingResponse
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

app = Flask(__name__)
llm = ChatOpenAI(model="gpt-4o-mini")
memory_store: dict = {}

def get_chain(phone_number: str) -> ConversationChain:
    if phone_number not in memory_store:
        memory_store[phone_number] = ConversationBufferMemory()
    return ConversationChain(llm=llm, memory=memory_store[phone_number])

@app.route("/whatsapp", methods=["POST"])
def whatsapp_webhook():
    incoming_msg = request.values.get("Body", "").strip()
    sender = request.values.get("From", "")  # e.g., "whatsapp:+1234567890"

    chain = get_chain(sender)
    response_text = chain.run(incoming_msg)

    resp = MessagingResponse()
    resp.message(response_text)
    return str(resp)

if __name__ == "__main__":
    app.run(port=5000)

pip install python-telegram-bot langchain langchain-openai

# telegram_bot.py
import os
from telegram import Update
from telegram.ext import Application, MessageHandler, filters, ContextTypes
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

llm = ChatOpenAI(model="gpt-4o-mini")
memory_store: dict = {}

def get_chain(chat_id: int) -> ConversationChain:
    if chat_id not in memory_store:
        memory_store[chat_id] = ConversationBufferMemory()
    return ConversationChain(llm=llm, memory=memory_store[chat_id])

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    chat_id = update.effective_chat.id
    user_text = update.message.text

    await context.bot.send_chat_action(chat_id=chat_id, action="typing")

    chain = get_chain(chat_id)
    response = await chain.arun(user_text)
    await update.message.reply_text(response)

def main():
    app = Application.builder().token(os.environ["TELEGRAM_TOKEN"]).build()
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    app.run_polling()

if __name__ == "__main__":
    main()

pip install botbuilder-core botbuilder-integration-aiohttp langchain langchain-openai

from botbuilder.core import ActivityHandler, TurnContext, MessageFactory

class TeamsLangChainBot(ActivityHandler):
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4o-mini")
        self.chains = {}

    async def on_message_activity(self, turn_context: TurnContext):
        user_id = turn_context.activity.from_property.id
        chain = self.get_chain(user_id)
        response = await chain.arun(turn_context.activity.text)
        await turn_context.send_activity(MessageFactory.text(response))

from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain.memory import ConversationBufferMemory

def get_persistent_memory(session_id: str) -> ConversationBufferMemory:
    history = RedisChatMessageHistory(
        session_id=session_id,
        url=os.environ["REDIS_URL"],
        ttl=86400  # 24 hour expiry
    )
    return ConversationBufferMemory(
        chat_memory=history,
        return_messages=True
    )

import time
from collections import defaultdict

rate_limits: dict = defaultdict(list)
MAX_MESSAGES = 10
WINDOW_SECONDS = 60

def is_rate_limited(user_id: str) -> bool:
    now = time.time()
    # Remove old timestamps outside the window
    rate_limits[user_id] = [t for t in rate_limits[user_id] if now - t < WINDOW_SECONDS]
    if len(rate_limits[user_id]) >= MAX_MESSAGES:
        return True
    rate_limits[user_id].append(now)
    return False

# In your message handler:
if is_rate_limited(str(user_id)):
    await send_reply("You're sending messages too fast. Please wait a moment.")
    return

Simple hobby project → In-memory dict + synchronous LangChain
Team/production use → Redis memory + async LangChain + rate limiting
Multi-workspace → Database-backed sessions + tenant isolation
Enterprise → Azure Bot Framework + managed identity + audit logging