Slack MCP OODA Loop Server

A Model Context Protocol (MCP) server written in Go that provides semantic tools for intelligent Slack workspace interaction. Implements an OODA loop (Observe-Orient-Decide-Act) pattern for comprehensive workspace awareness and response workflows without requiring admin permissions.

Overview

This server enables AI-driven Slack workspace interaction through a structured semantic workflow. It supports both stdio and SSE transports and uses a two-phase channel caching architecture for fast, secure access to workspace data.

Architecture Principles

OODA Loop Semantic Workflow

The server organizes tools into four phases for intelligent interaction:

**Observe (Situational Awareness)**:

**Orient (Context Analysis)**:

**Decide (Action Planning)**:

**Act (Response Execution)**:

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.

Count-Based Reading Policy

The `check-unreads` tool uses intelligent windowing:

This ensures reading correlates with actual content consumption.

Development Workflow

Initial Setup

```bash

Clone the repository

git clone <repository-url>

cd slack-mcp-server

Tidy dependencies

make tidy

Set required environment variables

export SLACK_MCP_XOXC_TOKEN="xoxc-..."

export SLACK_MCP_XOXD_TOKEN="xoxd-..."

```

Build Commands

```bash

Build for current platform

make build

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

make build-all-platforms

Run tests

make test

Format code

make format

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

```

Docker Development

```bash

Development setup

docker-compose -f docker-compose.dev.yml up

Production deployment

docker-compose up

With toolkit

docker-compose -f docker-compose.toolkit.yml up

```

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

Environment Variables

**Required**:

**Optional**:

Key Implementation Details

Two-Phase Channel Caching

The API provider (`pkg/provider/api.go`) implements fast channel loading:

Channel ID Security

All tools use channel names instead of IDs to prevent exposing internal identifiers to AI systems. The provider handles resolution through cached mappings.

Smart Cache Management

Combines reactive (Slack RetryAfter headers) and proactive (2-second delays) rate limiting. User data persists to `.users_cache.json` with channel mappings.

Write-Message Features

Package Structure

```

cmd/slack-mcp-server/ # Entry point with transport selection

pkg/

├── server/ # MCP server with semantic tool registration

├── provider/ # Slack API client with two-phase caching

├── features/ # Semantic tools organized by OODA phase

├── transport/ # HTTP transport wrapper for auth

└── text/ # Text processing utilities

```

Publishing and Releases

```bash

Copy binaries to npm packages and publish

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

Just copy binaries without publishing

make npm-copy-binaries

Create a new release tag

make release TAG=v1.2.3

```

Example Workflow

**Complete "Anything new from [Person]?" workflow**:

1. **Observe**: Run `check-unreads` to detect unread DMs and mentions

2. **Orient**: Enhanced tool shows actual message content with count-based windowing

3. **Decide**: Use `decide-next-action` to analyze context and suggest response approach

4. **Act**: Execute `write-message` to compose and send appropriate response

The count-based policy ensures you only auto-mark messages as read when they've been fully consumed (1-15 messages), while keeping larger volumes unread for follow-up.

Constraints