Slack MCP Server Development

This skill provides comprehensive guidance for developing and working with a Slack MCP (Model Context Protocol) server written in Go. The server implements an OODA loop (Observe-Orient-Decide-Act) pattern for intelligent Slack workspace interaction and supports both stdio and SSE transports.

Overview

You are working with a sophisticated Slack integration that provides semantic tools for workspace interaction. The server is designed around an OODA loop pattern that enables comprehensive workspace awareness and intelligent response workflows without requiring Slack admin permissions.

Key Architecture Concepts

OODA Loop Semantic Workflow

The server organizes functionality into four phases:

1. **Observe** (Situational Awareness): Tools for discovering unread messages, channel activity, mentions, and available channels

2. **Orient** (Context Analysis): Message prioritization, thread detection, importance scoring, and relationship mapping

3. **Decide** (Action Planning): Reflection tools and context-aware workflow recommendations

4. **Act** (Response Execution): Thread exploration, read state management, and message sending

Tool Recommendation Pattern

Tools implement **self-deprecating recommendations** where basic tools actively suggest better specialized alternatives. This creates upgrade paths from simple to sophisticated workflows while maintaining a tool hierarchy: specialized > fallback > manual construction.

Two-Phase Channel Caching

The API provider uses an intelligent caching strategy:

Development Commands

Building and Testing

```bash

Build for current platform

make build

Build for all supported platforms (darwin, linux, windows × amd64, arm64)

make build-all-platforms

Run tests

make test

Format code

make format

Tidy dependencies

make tidy

Clean build artifacts

make clean

```

Running the Server

```bash

Run with stdio transport (default)

go run cmd/slack-mcp-server/main.go --transport stdio

Run with SSE transport

go run cmd/slack-mcp-server/main.go --transport sse

```

Publishing and Releases

```bash

Copy binaries to npm packages and publish

make npm-publish NPM_TOKEN=your-token NPM_VERSION=x.y.z

Copy binaries without publishing

make npm-copy-binaries

Create a new release tag

make release TAG=v1.2.3

```

Package Structure

Key Implementation Details

Count-Based Reading Policy

The `check-unreads` tool implements intelligent windowing based on message count:

This ensures reading correlates with actual content consumption.

Smart Message Resolution

The `write-message` tool supports:

Environment Configuration

Required environment variables:

Optional configuration:

Docker Support

The project includes comprehensive Docker configurations:

Published images are available at `ghcr.io/korotovsky/slack-mcp-server`.

OODA Loop Workflow Example

When implementing features or debugging, follow the OODA pattern:

1. **Observe**: Use tools like `check-unreads`, `check-my-mentions` to gather situational awareness

2. **Orient**: Analyze message content, prioritize based on importance scoring

3. **Decide**: Use `decide-next-action` or specialized reasoning tools

4. **Act**: Execute with `find-discussion`, `mark-as-read`, or `write-message`

Important Constraints

When Working on This Codebase

1. Understand which OODA phase your changes affect

2. Use the two-phase caching architecture appropriately

3. Follow the tool recommendation pattern for new features

4. Test with both stdio and SSE transports

5. Ensure Docker builds succeed with `make build-all-platforms`

6. Verify environment variable handling for both required and optional configs

7. Implement count-based windowing when dealing with message lists

8. Use smart resolution patterns for channels and users