Guide for working with a Go-based Slack Model Context Protocol server implementing OODA loop pattern for intelligent workspace interaction with stdio/SSE transport support
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.
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.
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
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.
The API provider uses an intelligent caching strategy:
```bash
make build
make build-all-platforms
make test
make format
make tidy
make clean
```
```bash
go run cmd/slack-mcp-server/main.go --transport stdio
go run cmd/slack-mcp-server/main.go --transport sse
```
```bash
make npm-publish NPM_TOKEN=your-token NPM_VERSION=x.y.z
make npm-copy-binaries
make release TAG=v1.2.3
```
The `check-unreads` tool implements intelligent windowing based on message count:
This ensures reading correlates with actual content consumption.
The `write-message` tool supports:
Required environment variables:
Optional configuration:
The project includes comprehensive Docker configurations:
Published images are available at `ghcr.io/korotovsky/slack-mcp-server`.
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`
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
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/slack-mcp-server-development/raw