Slack MCP OODA Loop Integration

This skill helps you work with the Slack MCP Server codebase, a Go-based Model Context Protocol server that provides intelligent Slack workspace interaction through an OODA Loop (Observe-Orient-Decide-Act) pattern.

Overview

The Slack MCP Server implements semantic tools for comprehensive Slack workspace awareness and response workflows. It supports both stdio and SSE transports and operates without requiring special workspace permissions.

Architecture Understanding

OODA Loop Semantic Workflow

The server is organized around four phases:

1. **Observe (Situational Awareness)**

- Tools: `check-unreads`, `catch-up-on-channel`, `check-my-mentions`, `list-channels`

- Purpose: Gather current workspace state and activity

2. **Orient (Context Analysis)**

- Message prioritization and filtering

- Thread detection and importance scoring

- User relationship mapping

- Smart next-action suggestions with pre-populated parameters

3. **Decide (Action Planning)**

- Tool: `decide-next-action` for basic reflection

- Extensible to specialized reasoning tools

- Context-aware workflow recommendations

4. **Act (Response Execution)**

- Tools: `find-discussion`, `mark-as-read`, `write-message`

- Deep exploration and state management

Key Architectural Patterns

**Two-Phase Channel Caching:**

**Self-Deprecating Tool Recommendations:**

**Count-Based Reading Policy:**

Development Workflow

Building and Running

```bash

Build for current platform

make build

Build for all platforms

make build-all-platforms

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

Run tests

make test

Format code

make format

```

Common Development Tasks

**Adding New Semantic Tools:**

1. Create feature file in `pkg/features/` organized by OODA phase

2. Implement tool using `provider.ResolveChannelID()` for channel resolution

3. Include next-action suggestions in results

4. Register in `pkg/server/semantic_server.go`

**Modifying Cache Behavior:**

**Working with Transport Layer:**

Environment Configuration

**Required:**

**Optional:**

Package Structure

Deployment

Docker Support

```bash

Production deployment

docker-compose up

Development setup

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

With additional tools

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

```

Docker images are published to `ghcr.io/korotovsky/slack-mcp-server`.

NPM Publishing

```bash

Copy binaries and publish to npm

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

Or just copy binaries

make npm-copy-binaries

```

Release Management

```bash

Create new release tag

make release TAG=v1.2.3

```

Security Considerations

Testing and Quality

When making changes:

1. Run `make test` to verify functionality

2. Run `make format` to ensure code style consistency

3. Test both stdio and SSE transports

4. Verify two-phase caching behavior with channel operations

5. Check that next-action suggestions are context-aware

Extension Points

**Adding New OODA Tools:**

**Specialized Reasoning Tools:**