--- title: "Slack Bot Agent: Building an AI Assistant for Team Communication" description: "Build a production-ready Slack bot agent using the Slack SDK that listens to events, handles slash commands, responds with interactive messages, and integrates LLM-powered reasoning for team support." canonical: https://callsphere.ai/blog/slack-bot-agent-ai-assistant-team-communication category: "Learn Agentic AI" tags: ["Slack Bot", "AI Agents", "Slack SDK", "Workflow Automation", "Python", "ChatOps"] author: "CallSphere Team" published: 2026-03-17T00:00:00.000Z updated: 2026-05-06T20:37:27.410Z --- # Slack Bot Agent: Building an AI Assistant for Team Communication > Build a production-ready Slack bot agent using the Slack SDK that listens to events, handles slash commands, responds with interactive messages, and integrates LLM-powered reasoning for team support. ## Why Slack Is the Perfect Home for AI Agents Slack is where teams coordinate work. When an AI agent lives inside Slack, it eliminates context-switching. Instead of opening a separate tool, team members ask the agent directly in the channel where the conversation is already happening. The agent can answer questions about internal docs, summarize threads, create tickets, and route requests to the right people. In this guide, we will build a Slack bot agent using Python's `slack_bolt` framework. The agent handles events, slash commands, and interactive messages while delegating complex reasoning to an LLM. ## Setting Up the Slack App Before writing code, create a Slack app at api.slack.com/apps. Enable Socket Mode for local development, add the `chat:write`, `app_mentions:read`, `commands`, and `im:history` scopes, and subscribe to the `app_mention` and `message.im` events. ```mermaid flowchart LR INPUT(["User intent"]) PARSE["Parse plus classify"] PLAN["Plan and tool selection"] AGENT["Agent loop LLM plus tools"] GUARD{"Guardrails and policy"} EXEC["Execute and verify result"] OBS[("Trace and metrics")] OUT(["Outcome plus next action"]) INPUT --> PARSE --> PLAN --> AGENT --> GUARD GUARD -->|Pass| EXEC --> OUT GUARD -->|Fail| AGENT AGENT --> OBS style AGENT fill:#4f46e5,stroke:#4338ca,color:#fff style GUARD fill:#f59e0b,stroke:#d97706,color:#1f2937 style OBS fill:#ede9fe,stroke:#7c3aed,color:#1e1b4b style OUT fill:#059669,stroke:#047857,color:#fff ``` Install dependencies: ```python # pip install slack-bolt openai from slack_bolt import App from slack_bolt.adapter.socket_mode import SocketModeHandler import os app = App(token=os.environ["SLACK_BOT_TOKEN"]) ``` ## Handling App Mentions When someone mentions the bot in a channel, the agent processes the message and responds with LLM-generated content: ```python from openai import OpenAI llm = OpenAI() SYSTEM_PROMPT = ( "You are a helpful team assistant in Slack. " "Answer questions concisely. Use bullet points for lists. " "If you do not know the answer, say so clearly." ) def ask_llm(question: str, context: str = "") -> str: """Send a question to the LLM with optional context.""" messages = [{"role": "system", "content": SYSTEM_PROMPT}] if context: messages.append({"role": "user", "content": f"Context:\n{context}"}) messages.append({"role": "user", "content": question}) response = llm.chat.completions.create( model="gpt-4o-mini", messages=messages, temperature=0.3, max_tokens=500, ) return response.choices[0].message.content @app.event("app_mention") def handle_mention(event, say, client): """Respond to @bot mentions in channels.""" user_text = event["text"] thread_ts = event.get("thread_ts", event["ts"]) # Fetch thread context if replying in a thread context = "" if event.get("thread_ts"): result = client.conversations_replies( channel=event["channel"], ts=event["thread_ts"], limit=10, ) context = "\n".join( m["text"] for m in result["messages"][:-1] # Exclude current message ) response = ask_llm(user_text, context) say(text=response, thread_ts=thread_ts) ``` The agent fetches thread history for context when mentioned inside a thread. This gives the LLM the full conversation to work with rather than just the latest message. ## Implementing Slash Commands Slash commands provide structured entry points for specific actions. Here we create a `/ask` command that accepts a question and a `/summarize` command that summarizes the current channel's recent messages: ```python @app.command("/ask") def handle_ask(ack, command, say): """Handle the /ask slash command.""" ack() # Acknowledge within 3 seconds question = command["text"] if not question.strip(): say("Usage: `/ask `", ephemeral=True) return answer = ask_llm(question) say(f"*Q:* {question}\n\n{answer}") @app.command("/summarize") def handle_summarize(ack, command, client, say): """Summarize recent channel messages.""" ack() channel = command["channel_id"] result = client.conversations_history(channel=channel, limit=50) messages = [m["text"] for m in result["messages"] if m.get("text")] combined = "\n".join(messages[:50]) summary = ask_llm( "Summarize the following Slack messages into 3-5 bullet points. " "Focus on decisions, action items, and key topics.", context=combined, ) say(f"*Channel Summary (last 50 messages):*\n\n{summary}") ``` Always call `ack()` immediately when handling slash commands. Slack requires acknowledgment within three seconds or it shows an error to the user. ## Interactive Messages with Buttons Interactive messages let users take actions directly from the bot's response. Here we add approval buttons to a request workflow: ```python @app.command("/request") def handle_request(ack, command, client): """Create an approval request with interactive buttons.""" ack() request_text = command["text"] requester = command["user_id"] client.chat_postMessage( channel=os.environ["APPROVAL_CHANNEL"], text=f"New request from ", blocks=[ { "type": "section", "text": { "type": "mrkdwn", "text": f"*New Request from :*\n{request_text}", }, }, { "type": "actions", "elements": [ { "type": "button", "text": {"type": "plain_text", "text": "Approve"}, "style": "primary", "action_id": "approve_request", "value": f"{requester}|{request_text}", }, { "type": "button", "text": {"type": "plain_text", "text": "Deny"}, "style": "danger", "action_id": "deny_request", "value": f"{requester}|{request_text}", }, ], }, ], ) @app.action("approve_request") def handle_approve(ack, body, client): """Handle approval button click.""" ack() requester, request_text = body["actions"][0]["value"].split("|", 1) approver = body["user"]["id"] client.chat_postMessage( channel=requester, text=f"Your request was *approved* by : {request_text}", ) ``` ## Running the Agent Start the bot with Socket Mode for development: ```python if __name__ == "__main__": handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]) print("Slack bot agent is running...") handler.start() ``` For production, switch to HTTP mode behind a reverse proxy with proper SSL termination. Use a process manager like systemd or deploy as a container. ## FAQ ### How do I handle rate limits from the Slack API? The `slack_bolt` framework includes built-in rate limit handling that automatically retries requests with appropriate backoff. For high-volume bots, use `WebClient` with `retry_handlers` configured and batch operations where possible. ### Can the bot maintain conversation history across messages? Store conversation context in a database or Redis keyed by channel ID and thread timestamp. Before each LLM call, retrieve the last N messages from your store to include as context. This gives the agent memory without relying solely on Slack API calls. ### How do I restrict the bot to certain channels? Check `event["channel"]` against an allowlist of channel IDs in your event handlers. Return early without processing if the channel is not in the list. You can also use Slack's app-level channel restrictions in the app configuration. --- #SlackBot #AIAgents #SlackSDK #WorkflowAutomation #Python #ChatOps #AgenticAI #LearnAI #AIEngineering --- Source: https://callsphere.ai/blog/slack-bot-agent-ai-assistant-team-communication