korotovsky/slack-mcp-server: A Go MCP Server for Slack with Stealth and OAuth Modes

What the Server Does and the Stealth Mode Distinction

slack-mcp-server connects AI agents to Slack through the Model Context Protocol. Most Slack bots require a bot installation with explicit permission scopes in the workspace, which means getting IT or a Slack workspace admin to approve and install the app. Stealth mode sidesteps this by operating as the authenticated user rather than as a bot, using session tokens extracted from the browser rather than OAuth bot tokens. This gives the server access to any channel or DM the user can see, without a formal app installation.

OAuth mode is the alternative for teams that want a more conventional setup. It uses secure OAuth tokens and does not require refreshing or extracting browser tokens. The README presents both modes without recommending one over the other; the choice depends on whether a bot installation is feasible in the target workspace.

Enterprise Grid workspaces are listed as supported. The server handles DMs, Group DMs, channel threads and both standard Slack and GovSlack environments.

Installing and Running with Docker

The simplest deployment path is Docker. The repository includes a `docker-compose.yml` that runs the server on port 3001:

services:
  mcp-server:
    image: ghcr.io/korotovsky/slack-mcp-server:latest
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - users_cache:/app/mcp-server/.users_cache.json
      - channels_cache:/app/mcp-server/.channels_cache.json
    env_file:
      - .env
    environment:
      SLACK_MCP_HOST: "0.0.0.0"
      SLACK_MCP_PORT: "3001"

The `.env.dist` file in the repository lists all configurable environment variables. Two Docker volumes persist the user and channel caches between restarts, avoiding repeated API calls to fetch workspace member lists.

The Dockerfile builds a production binary from Go 1.25 on an Alpine 3.22 base, exposing port 3001. The default transport in the production image is SSE. To use Stdio or HTTP transports instead, pass a different `--transport` argument to the container entrypoint.

Available Tools and Their Parameters

The server exposes four tools to the MCP client.

`conversations_history` fetches messages from a channel, DM or Group DM by channel ID or name (using `#channel-name` or `@username_dm` notation). The `limit` parameter accepts either a time range in the format `1d`, `7d`, `30d` or `90d`, or a message count such as `50`. The `cursor` field from the last response row enables pagination.

`conversations_replies` fetches a thread by channel ID and `thread_ts`, the message timestamp in the format `1234567890.123456`. The same limit and cursor parameters apply.

`conversations_search_messages` searches across channels, threads and DMs using a free-text query with optional filters for channel, user and date range. This tool is not available when using a bot token (`xoxb-*`); the `search.messages` Slack API endpoint requires a user token.

`conversations_add_message` posts a message to a channel or thread. It is disabled by default for safety. Setting `SLACK_MCP_ADD_MESSAGE_TOOL` to a comma-separated list of channel IDs enables posting only to those channels; setting it to any other truthy value enables posting everywhere.

Smart History, Unread Messages and Caching

The smart history feature allows fetching by date range rather than just by count. The `1d`, `7d`, `1m` and `90d` range formats translate to Slack API pagination calls that return messages within the specified window. The 90-day limit is noted as the default maximum for free Slack tier history.

The unread messages feature retrieves all unread messages across channels with priority sorting: DMs first, then partner channels, then internal channels. An `@mention` filter narrows results to messages where the user was mentioned. The tool also supports marking messages as read.

Channel and user information is cached to local JSON files (`.users_cache.json` and `.channels_cache.json`) to reduce API calls. The Docker volumes mount these files outside the container so they persist across container restarts. The cache entries allow addressing channels and users by name using the `#channel` and `@user` lookup syntax rather than requiring callers to know Slack IDs.

Transport Options and Proxy Support

The server supports three MCP transports: Stdio, SSE and HTTP. Stdio is suitable for local agent setups where the MCP client launches the server as a subprocess. SSE and HTTP are better for network deployments where multiple agents or clients connect to a shared server instance.

Proxy support lets outgoing requests route through a configured proxy, which is relevant for organizations where Slack API calls must pass through a corporate network proxy or where direct internet access is restricted.

The repository also includes an npm wrapper package for distributing the binary through the Node.js ecosystem. The `Makefile` includes cross-compilation targets for darwin, linux and windows on both amd64 and arm64, and a target for building an extension in DXT format. Version metadata (commit hash, version string, build time and binary name) is embedded at link time via `-ldflags`.

Ngrok integration is also listed in the Go module dependencies (`golang.ngrok.com/ngrok/v2`), which suggests support for tunneling the server endpoint for local development.

Limitations and Alternatives

The search tool requires a user token, not a bot token. This is a Slack API restriction: `search.messages` is not available to bot tokens. Any deployment that uses only OAuth bot tokens (`xoxb-*`) will not have search capability. The README documents this constraint in the tool description for `conversations_search_messages`.

Stealth mode depends on session token extraction from the browser. Session tokens expire or get invalidated when the user logs out or Slack rotates them, requiring re-extraction. The README describes this as operating with no permissions or scopes in the workspace, which is a security tradeoff: the token grants full user-level access, not a restricted set of bot scopes. Organizations with audit logging requirements may flag user token access differently than bot token access.

The official Slack MCP server from Slack itself is a conventional OAuth-based bot integration. The difference is that the official server requires workspace admin approval for installation and operates with declared scopes, while korotovsky/slack-mcp-server's stealth mode operates with full user token access without a formal installation record. Teams that need a documented, auditable integration should use the official path. The last push to this repository was 2026-07-16, and the project has had no release since v1.3.0 on 2026-05-14.

Maintenance and Licence

The repository is MIT licensed and written in Go 1.25. The most recent release is v1.3.0, published on 2026-05-14. Before that, v1.2.3 was released on 2026-03-03 and v1.2.2 on 2026-02-25. The last push to the repository was on 2026-07-16, which is more than two months before today's date.

The Go module at `github.com/korotovsky/slack-mcp-server` lists several well-known dependencies including the `mark3labs/mcp-go` MCP implementation, the Slack libraries `rusq/slack`, `rusq/slackauth` and `slack-go/slack`, the `refraction-networking/utls` library for TLS fingerprint spoofing (relevant to stealth mode), and `go.uber.org/zap` for structured logging. The repository includes a SECURITY.md for reporting vulnerabilities.

A `.dxt` extension file is included in the build targets for desktop extension distribution. The `manifest-dxt.json` in the repository root defines the extension metadata. The cross-compilation targets in the Makefile cover darwin, linux and windows on both amd64 and arm64, producing binaries for each combination. This breadth of platform support, combined with the npm wrapper and Docker image, gives teams multiple paths for integrating the server into their existing toolchain.

Editorial conclusion

slack-mcp-server is the right choice for engineers who want to connect an AI coding agent to a Slack workspace without going through a formal bot installation process. Stealth mode is the practical differentiator: it lets the server operate in workspaces where adding a bot app is not possible without IT approval. The last push to the repository was on 2026-07-16, which is more than two months before today's date. The most recent release, v1.3.0, was published on 2026-05-14. Teams evaluating the project should confirm that the version covers their required features before relying on it, and should note that the `conversations_add_message` tool is disabled by default. Enable it only for specific channels via `SLACK_MCP_ADD_MESSAGE_TOOL` if write access is needed.

Frequently asked questions

Official sources

1. Issues
2. korotovsky/slack-mcp-server on GitHub
3. License: MIT
4. README
5. Releases