Slack MCP Client

MCP开发工具

提供方 tuannvm

开发工具 未标注 无需鉴权 社区 / 第三方

A Slack bot and MCP client acts as a bridge between Slack and Model Context Protocol (MCP) servers. Using Slack as the interface, it enables large language models (LLMs) to connect and interact with various MCP servers through standardized MCP tools.

一句话选型结论

按资料字段整理

Slack MCP Client 属于开发工具类 MCP 服务器,传输方式未标注,无需鉴权,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式未标注 鉴权无需鉴权 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

适用场景

developer-toolsslackmcpmcp-client

安装与配置

未标注 无需鉴权
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 资料标注无需鉴权,装好就能连。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Slack MCP Client当前 未标注 未标注 未标注 无 2026-05-18
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方tuannvm上游标注的维护方 tuannvm
分类开发工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式无需鉴权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-05-18上游最后核验时间

详细介绍

37.9 KB
来自项目仓库与上游目录的原文,未做删改

Slack MCP Client

A production-ready bridge between Slack and AI models with full MCP compatibility.

This client enables AI models (OpenAI GPT-4.1, Anthropic Claude 4.5, Ollama local models) to interact with real tools and systems through Slack conversations. Built on the industry-standard Model Context Protocol (MCP), it provides secure access to filesystems, databases, Kubernetes clusters, Git repositories, and custom tools.

> Compatible with MCP Specification 2025-06-18 - Compliant with the latest Model Context Protocol standards

Recent Updates

Oct 2025: langchaingo v0.1.14 with streaming fixes, enhanced agent parsing, and API key sanitization.

Key Features

  • Universal MCP Compatibility - Supports all transport methods (HTTP, SSE, stdio)
  • Multi-Provider LLM Support - OpenAI GPT-4.1/4o, Anthropic Claude 4.5, Ollama (Llama 3.3, Qwen, Mistral, DeepSeek)
  • Agent Mode - Multi-step reasoning with LangChain for complex workflows
  • RAG Integration - Knowledge base with semantic search capabilities
  • Thread-Aware Context - Maintains separate conversation history per Slack thread
  • User Context Integration - Personalized responses with cached user information
  • Unique Tool Naming - Server-prefixed tool names prevent conflicts across MCP servers
  • Production Ready - Comprehensive configuration, monitoring, and security

Use Cases

  • DevOps Teams - Infrastructure automation and monitoring through Slack
  • Development Teams - Code review, Git operations, and file management
  • Support Teams - Database queries, system status checks, and troubleshooting
  • General Use - AI assistance with actual tools and system integration

MCP Compatibility

Compliant with the official Model Context Protocol (2025-06-18 specification):

  • All Transport Methods - HTTP, SSE, and stdio protocols
  • JSON-RPC 2.0 - Standard communication protocol
  • Official MCP Servers - Compatible with all modelcontextprotocol/servers
  • Custom MCP Servers - Works with any MCP-compliant server
  • Security Standards - Implements user consent, data privacy, and tool safety requirements

Authenticating to SSE MCP Servers

Authentication with Server-Sent Events (SSE) MCP servers can be achieved using the following setup:

Example:```json
{
"httpHeaders": {
"Authorization": "Bearer YOUR_TOKEN_HERE"
}
}


Make sure to replace `YOUR_TOKEN_HERE` with your actual token for authentication.

## How It Works```mermaid
flowchart LR
    User([👤 User]) --> Slack{🔗 Slack Interface}

    subgraph Infrastructure[Observability]
        Config[📋 Unified Config<br/>JSON Schema]
        Monitoring[📊 Monitoring<br/>Prometheus Metrics]
        Tracing[🔍 OpenTelemetry Tracing<br/>Langfuse & OTLP]
        Logging[📝 Structured Logging<br/>Debug & Analytics]
    end

    subgraph Core[Features]
        Slack --> Bridge[🌉 LLM-MCP Bridge<br/>Orchestration Layer]

        subgraph LLM[🤖 AI Processing]
            Bridge --> LLMRegistry[LLM Provider Registry]
            LLMRegistry --> OpenAI[OpenAI<br/>GPT-4o]
            LLMRegistry --> Anthropic[Anthropic<br/>Claude]
            LLMRegistry --> Ollama[Ollama<br/>Local Models]

            Bridge --> Agent{🎯 Agent Mode?}
            Agent -->|Yes| LangChain[🔄 LangChain Agent<br/>Multi-step Reasoning]
            Agent -->|No| Standard[⚡ Standard Mode<br/>Single Response]
        end

        subgraph Knowledge[📚 Knowledge & Memory]
            Bridge --> RAG[🧠 RAG System]
            RAG --> SimpleRAG[📄 JSON Store<br/>Simple Documents]
            RAG --> VectorRAG[🔍 OpenAI Vector Store<br/>Semantic Search]
        end

        subgraph Tools[🛠️ MCP Mode]
            Bridge --> MCPManager[MCP Client]
            MCPManager --> FileSystem[📁 Filesystem MCP Server<br/>Read/Write Files]
            MCPManager --> Git[🌿 Git MCP Server <br/>Repository Tools]
            MCPManager --> Kubernetes[☸️ Kubernetes MCP Server<br/>Cluster Management]
        end
    end

    Config -.-> Core
    Core -.-> Monitoring
    Core -.-> Tracing
    Core -.-> Logging

    style Core fill:#F8F9FA,stroke:#6C757D,stroke-width:3px
    style LLM fill:#E3F2FD,stroke:#1976D2,stroke-width:2px
    style Knowledge fill:#E8F5E8,stroke:#388E3C,stroke-width:2px
    style Tools fill:#FFF3E0,stroke:#F57C00,stroke-width:2px
    style Infrastructure fill:#F3E5F5,stroke:#7B1FA2,stroke-width:2px

    style User fill:#4CAF50,stroke:#2E7D32,stroke-width:2px,color:#fff
    style Slack fill:#4A90E2,stroke:#1565C0,stroke-width:2px,color:#fff
    style Bridge fill:#FF9800,stroke:#E65100,stroke-width:2px,color:#fff
    style LangChain fill:#9C27B0,stroke:#4A148C,stroke-width:2px,color:#fff
    style RAG fill:#2196F3,stroke:#0D47A1,stroke-width:2px,color:#fff
  1. User interacts through Slack, sending messages that trigger intelligent AI workflows
  2. LLM-MCP Bridge serves as the intelligent orchestration layer that:
    - Routes requests to appropriate LLM providers (OpenAI, Anthropic, Ollama)
    - Chooses between Agent Mode (multi-step reasoning) or Standard Mode (single response)
    - Integrates RAG system for knowledge retrieval and context enhancement
    - Manages tool discovery and execution across multiple MCP servers
  3. Knowledge & Memory system provides contextual intelligence:
    - Simple JSON store for lightweight document storage
    - OpenAI Vector Store for semantic search and enterprise-grade RAG
  4. Tool Ecosystem connects to diverse external systems:
    - Filesystem operations for file management
    - Git integration for repository interactions
    - Kubernetes cluster management and monitoring
    - Custom tools via HTTP, SSE, or stdio protocols
  5. Infrastructure ensures production-ready deployment:
    - Unified JSON configuration with environment variable support
    - Prometheus metrics for observability and monitoring
    - OpenTelemetry tracing with Langfuse and OTLP providers
    - Structured logging for debugging and analytics

Features

  • ✅ Multi-Mode MCP Client:
  • Server-Sent Events (SSE) for real-time communication with automatic retry
  • HTTP transport for JSON-RPC
  • stdio for local development and testing
  • ✅ Slack Integration:
  • Uses Socket Mode for secure, firewall-friendly communication
  • Works with both channels and direct messages
  • Rich message formatting with Markdown and Block Kit
  • Thread-aware conversation tracking with separate context per thread
  • User context caching for personalized interactions
  • Customizable bot behavior and message history
  • ✅ Multi-Provider LLM Support:
  • OpenAI (GPT-4.1, GPT-4o, o3-pro)
  • Anthropic (Claude Sonnet 4.5, Opus 4.1)
  • Ollama (Llama 3.3, Qwen2.5, Mistral, DeepSeek)
  • Native tool calling and unified LangChain gateway
  • ✅ Agent Mode:
  • Autonomous AI agents powered by LangChain (langchaingo v0.1.14)
  • Enhanced multi-step reasoning and tool orchestration
  • Improved parsing for complex multi-line tool calls
  • Configurable agent iterations and behavior
  • Reliable streaming responses with memory leak fixes
  • Advanced prompt engineering capabilities
  • ✅ RAG (Retrieval-Augmented Generation):
  • Multiple providers: Simple JSON storage, OpenAI Vector Store
  • Reusable vector stores with vectorStoreId support
  • Configurable search parameters and similarity metrics
  • PDF ingestion with intelligent chunking
  • CLI tools for document management
  • ✅ Unified Configuration:
  • Single JSON configuration file with JSON schema validation
  • Comprehensive timeout and retry configuration
  • Environment variable substitution and overrides
  • All underlying package options exposed
  • Smart defaults with full customization capability
  • Server-prefixed tool names to prevent naming conflicts
  • ✅ Production Ready:
  • Docker container support with GHCR publishing
  • Kubernetes Helm charts with OCI registry
  • Comprehensive logging and error handling
  • Test coverage with security scanning
  • ✅ Monitoring & Observability:
  • Prometheus metrics integration
  • Tool invocation tracking with error rates
  • LLM token usage monitoring by model and type
  • OpenTelemetry tracing with Langfuse and simple providers
  • Configurable observability providers with graceful fallbacks
  • Comprehensive span tracking for LLM operations and tool calls
  • Configurable metrics endpoint and logging levels

Installation

From Binary Release

Download the latest binary from the GitHub releases page or install using Go:```bash

Install latest version using Go

go install github.com/tuannvm/slack-mcp-client@latest

Or build from source

git clone https://github.com/tuannvm/slack-mcp-client.git
cd slack-mcp-client
make build

Binary will be in ./bin/slack-mcp-client


### Running Locally with Binary

After installing the binary, you can run it locally with the following steps:

1. Set up environment variables:```bash
# Using environment variables directly
export SLACK_BOT_TOKEN="xoxb-your-bot-token"
export SLACK_APP_TOKEN="xapp-your-app-token"
export OPENAI_API_KEY="sk-your-openai-key"
export OPENAI_MODEL="gpt-4.1"  # or gpt-4o, o3-pro
export LOG_LEVEL="info"

# Or create a .env file and source it
cat > .env << EOL
SLACK_BOT_TOKEN="xoxb-your-bot-token"
SLACK_APP_TOKEN="xapp-your-app-token"
OPENAI_API_KEY="sk-your-openai-key"
OPENAI_MODEL="gpt-4o"
LOG_LEVEL="info"
EOL

source .env
  1. Create a unified configuration file:```bash

Create config.json with the new unified configuration format

cat > config.json << EOL
{
"\$schema": "https://github.com/tuannvm/slack-mcp-client/schema/config-schema.json",
"version": "2.0",
"slack": {
"botToken": "\${SLACK_BOT_TOKEN}",
"appToken": "\${SLACK_APP_TOKEN}"
},
"llm": {
"provider": "openai",
"useNativeTools": true,
"providers": {
"openai": {
"model": "gpt-4o",
"apiKey": "\${OPENAI_API_KEY}",
"temperature": 0.7
}
}
},
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "\$HOME"]
}
},
"monitoring": {
"enabled": true,
"metricsPort": 8080,
"loggingLevel": "info"
},
"observability": {
"enabled": true,
"provider": "simple-otel",
"endpoint": "${OTEL_EXPORTER_OTLP_ENDPOINT}",
"serviceName": "slack-mcp-client",
"serviceVersion": "1.0.0"
}
}
EOL


3. Run the application:```bash
# Run with unified configuration (looks for config.json in current directory)
slack-mcp-client --config config.json

# Enable debug mode with structured logging
slack-mcp-client --config config.json --debug

# Validate configuration before running
slack-mcp-client --config-validate --config config.json

# Configure metrics port via config file or flag
slack-mcp-client --config config.json --metrics-port 9090

Migrating from Legacy Configuration

If you have an existing mcp-servers.json file from a previous version, you can migrate to the new unified configuration format:```bash

Automatic migration (recommended)

slack-mcp-client --migrate-config --config legacy-mcp-servers.json --output config.json

Manual migration: Use examples as templates

cp examples/minimal.json config.json

Edit config.json with your specific settings

Validate the new configuration

slack-mcp-client --config-validate --config config.json


The new configuration format provides:
- **Single File**: All settings in one `config.json` file
- **JSON Schema**: IDE support with autocomplete and validation
- **Environment Variables**: Use `${VAR_NAME}` syntax for secrets
- **Smart Defaults**: Minimal configuration required for basic usage
- **Comprehensive Options**: All underlying package settings exposed

The application will connect to Slack and start listening for messages. You can check the logs for any errors or connection issues.

### RAG Setup and Usage

The client includes an improved RAG (Retrieval-Augmented Generation) system that&#x27;s compatible with LangChain Go and provides professional-grade performance:

#### Quick Start with RAG

1. **Enable RAG in your configuration:**```json
{
  &quot;$schema&quot;: &quot;https://github.com/tuannvm/slack-mcp-client/schema/config-schema.json&quot;,
  &quot;version&quot;: &quot;2.0&quot;,
  &quot;slack&quot;: {
    &quot;botToken&quot;: &quot;${SLACK_BOT_TOKEN}&quot;,
    &quot;appToken&quot;: &quot;${SLACK_APP_TOKEN}&quot;
  },
  &quot;llm&quot;: {
    &quot;provider&quot;: &quot;openai&quot;,
    &quot;useNativeTools&quot;: true,
    &quot;providers&quot;: {
      &quot;openai&quot;: {
        &quot;model&quot;: &quot;gpt-4o&quot;,
        &quot;apiKey&quot;: &quot;${OPENAI_API_KEY}&quot;
      }
    }
  },
  &quot;rag&quot;: {
    &quot;enabled&quot;: true,
    &quot;provider&quot;: &quot;simple&quot;,
    &quot;chunkSize&quot;: 1000,
    &quot;providers&quot;: {
      &quot;simple&quot;: {
        &quot;databasePath&quot;: &quot;./knowledge.json&quot;
      },
      &quot;openai&quot;: {
        &quot;indexName&quot;: &quot;my-knowledge-base&quot;,
        &quot;vectorStoreId&quot;: &quot;vs_existing_store_id&quot;,
        &quot;dimensions&quot;: 1536,
        &quot;maxResults&quot;: 10
      }
    }
  }
}
  1. Ingest documents using CLI:```bash

Ingest PDF files from a directory

slack-mcp-client --rag-ingest ./company-docs --rag-db ./knowledge.json

Test search functionality

slack-mcp-client --rag-search "vacation policy" --rag-db ./knowledge.json

Get database statistics

slack-mcp-client --rag-stats --rag-db ./knowledge.json


3. **Use in Slack:**

Once configured, the LLM can automatically search your knowledge base:

**User**: &quot;What&#x27;s our vacation policy?&quot;

**AI**: &quot;Let me search our knowledge base for vacation policy information...&quot;
*(Automatically searches RAG database)*

**AI**: &quot;Based on our company policy documents, you get 15 days of vacation...&quot;

#### RAG Features

- **🎯 Smart Search**: Advanced relevance scoring with word frequency, filename boosting, and phrase matching
- **🔗 LangChain Compatible**: Drop-in replacement for standard vector stores
- **📈 Extensible**: Easy to add vector embeddings and other backends

### Custom Prompts and Assistants

The client supports advanced prompt engineering capabilities for creating specialized AI assistants:

#### System Prompts

Create custom AI personalities and behaviors:```bash
# Create a custom system prompt file
cat &gt; sales-assistant.txt &lt;&lt; EOL
You are SalesGPT, a helpful sales assistant specializing in B2B software sales.

Your expertise includes:
- Lead qualification and discovery
- Solution positioning and value propositions
- Objection handling and negotiation
- CRM best practices and sales processes

Always:
- Ask qualifying questions to understand prospect needs
- Provide specific, actionable sales advice
- Reference industry best practices
- Maintain a professional yet friendly tone

When discussing pricing, always emphasize value over cost.
EOL

# Use the custom prompt
slack-mcp-client --system-prompt ./sales-assistant.txt

Configuration-Based Prompts

Define prompts in your configuration:```json
{
"$schema": "https://github.com/tuannvm/slack-mcp-client/schema/config-schema.json",
"version": "2.0",
"slack": {
"botToken": "${SLACK_BOT_TOKEN}",
"appToken": "${SLACK_APP_TOKEN}"
},
"llm": {
"provider": "openai",
"useNativeTools": true,
"customPrompt": "You are a helpful DevOps assistant specializing in Kubernetes and cloud infrastructure.",
"providers": {
"openai": {
"model": "gpt-4.1",
"apiKey": "${OPENAI_API_KEY}",
"temperature": 0.7
}
}
}
}


#### Assistant Roles

Create specialized assistants for different use cases:

- **DevOps Assistant**: Kubernetes, Docker, CI/CD expertise
- **Sales Assistant**: Lead qualification, objection handling
- **HR Assistant**: Policy questions, onboarding guidance
- **Support Assistant**: Customer issue resolution
- **Code Review Assistant**: Security, performance, best practices

### Agent Mode

Agent Mode enables more interactive and context-aware conversations using LangChain&#x27;s agent framework. Instead of single-prompt interactions, agents can engage in multi-step reasoning, use tools more strategically, and maintain better context throughout conversations.

#### How Agent Mode Works

Agent Mode uses LangChain&#x27;s conversational agent framework to provide:

1. **Interactive Conversations**: Maintains context across multiple exchanges
2. **Strategic Tool Usage**: Agents decide when and how to use available tools
3. **Multi-Step Reasoning**: Can break down complex problems into manageable steps
4. **Streaming Responses**: Provides real-time updates during processing
5. **User Context Integration**: Incorporates cached user information for personalized responses
6. **Thread Context Awareness**: Maintains separate conversation history per Slack thread

#### Agent Mode Configuration

Enable Agent Mode in your configuration file:```json
{
  &quot;$schema&quot;: &quot;https://github.com/tuannvm/slack-mcp-client/schema/config-schema.json&quot;,
  &quot;version&quot;: &quot;2.0&quot;,
  &quot;slack&quot;: {
    &quot;botToken&quot;: &quot;${SLACK_BOT_TOKEN}&quot;,
    &quot;appToken&quot;: &quot;${SLACK_APP_TOKEN}&quot;
  },
  &quot;llm&quot;: {
    &quot;provider&quot;: &quot;openai&quot;,
    &quot;useNativeTools&quot;: true,
    &quot;useAgent&quot;: true,
    &quot;customPrompt&quot;: &quot;You are a DevOps expert specializing in Kubernetes and cloud infrastructure. Always think through problems step by step.&quot;,
    &quot;maxAgentIterations&quot;: 20,
    &quot;providers&quot;: {
      &quot;openai&quot;: {
        &quot;model&quot;: &quot;gpt-4.1&quot;,
        &quot;apiKey&quot;: &quot;${OPENAI_API_KEY}&quot;,
        &quot;temperature&quot;: 0.7
      }
    }
  },
  &quot;mcpServers&quot;: {
    &quot;filesystem&quot;: {
      &quot;command&quot;: &quot;npx&quot;,
      &quot;args&quot;: [&quot;-y&quot;, &quot;@modelcontextprotocol/server-filesystem&quot;, &quot;/path/to/project&quot;]
    },
    &quot;github&quot;: {
      &quot;command&quot;: &quot;github-mcp-server&quot;,
      &quot;args&quot;: [&quot;stdio&quot;],
      &quot;env&quot;: {
        &quot;GITHUB_PERSONAL_ACCESS_TOKEN&quot;: &quot;${GITHUB_TOKEN}&quot;
      }
    }
  }
}

Configuration Options

  • llm.useAgent: Enable agent mode (default: false)
  • llm.useNativeTools: Use native LangChain tools vs system prompt-based tools (default: false)
  • llm.customPrompt: System prompt for agent behavior
  • llm.maxAgentIterations: Maximum agent reasoning steps (default: 20)

Agent vs Standard Mode

Standard Mode:
- Single-prompt interactions
- Tools described in system prompt as JSON schemas
- Direct tool call parsing and execution
- More predictable token usage
- Simpler conversation flow

Agent Mode:
- Multi-turn conversational interactions
- Context-aware tool usage decisions
- Better user context integration
- More natural conversation flow
- Enhanced reasoning capabilities

Agent Mode Examples

Interactive Development Consultation:```
User: "I need help optimizing my React app performance"

Agent Response:
🤖 I'd be happy to help optimize your React app performance! Let me understand your current setup better.

[Agent maintains conversation context and asks relevant follow-up questions]
Agent: "What specific performance issues are you experiencing? Are you seeing slow renders, large bundle sizes, or something else?"

User: "The app takes too long to load initially"

Agent: "Let me check your current bundle setup and suggest optimizations..."
[Agent uses filesystem tools to analyze the project structure and provides targeted advice]


**Contextual Problem Solving**:```
User: &quot;Can you help me with my deployment pipeline?&quot;

Agent Response:
🤖 I&#x27;ll help you with your deployment pipeline. Since I know you&#x27;re working on a React project, let me check your current CI/CD setup.

[Agent leverages previous conversation context and user information to provide personalized assistance]
[Agent strategically uses relevant tools based on the conversation flow]

Agent Mode Best Practices

  1. System Prompts: Design clear, specific system prompts that guide the agent's behavior
  2. Tool Selection: Provide relevant tools for the agent's domain
  3. Context Management: Agents maintain better context across conversations
  4. User Personalization: Leverage user context integration for personalized responses
  5. Tool Strategy: Choose between native tools or system prompt-based tools based on your needs

Limitations and Considerations

  • OpenAI Agent: Native OpenAI agent in langchaingo has known issues, uses conversational agent as workaround
  • LangChain Dependency: Agent mode requires LangChain provider
  • Permissions: May require additional Slack permissions for user information retrieval
  • Performance: Agent mode may have different performance characteristics than standard mode

Kubernetes Deployment with Helm

For deploying to Kubernetes, a Helm chart is available in the helm-chart directory. This chart provides a flexible way to deploy the slack-mcp-client with proper configuration and secret management.

Installing from GitHub Container Registry

The Helm chart is also available directly from GitHub Container Registry, allowing for easier installation without needing to clone the repository:```bash

Add the OCI repository to Helm (only needed once)

helm registry login ghcr.io -u USERNAME -p GITHUB_TOKEN

Pull the Helm chart

helm pull oci://ghcr.io/tuannvm/charts/slack-mcp-client --version 0.1.0

Or install directly

helm install my-slack-bot oci://ghcr.io/tuannvm/charts/slack-mcp-client --version 0.1.0 -f values.yaml


You can check available versions by visiting the GitHub Container Registry in your browser.

#### Prerequisites
- Kubernetes 1.16+
- Helm 3.0+
- Slack Bot and App tokens

#### Basic Installation```bash
# Create a values file with your configuration
cat &gt; values.yaml &lt;&lt; EOL
secret:
  create: true

env:
  SLACK_BOT_TOKEN: &quot;xoxb-your-bot-token&quot;
  SLACK_APP_TOKEN: &quot;xapp-your-app-token&quot;
  OPENAI_API_KEY: &quot;sk-your-openai-key&quot;
  OPENAI_MODEL: &quot;gpt-4o&quot;
  LOG_LEVEL: &quot;info&quot;

# Optional: Configure MCP servers
configMap:
  create: true
EOL

# Install the chart
helm install my-slack-bot ./helm-chart/slack-mcp-client -f values.yaml

Configuration Options

The Helm chart supports various configuration options including:
- Setting resource limits and requests
- Configuring MCP servers via ConfigMap
- Managing sensitive data via Kubernetes secrets
- Customizing deployment parameters

For more details, see the Helm chart README.

Using the Docker Image from GHCR

The Helm chart uses the Docker image from GitHub Container Registry (GHCR) by default. You can specify a particular version or use the latest tag:```yaml

In your values.yaml

image:
repository: ghcr.io/tuannvm/slack-mcp-client
tag: "latest" # Or use a specific version like "1.0.0"
pullPolicy: IfNotPresent


To manually pull the image:```bash
# Pull the latest image
docker pull ghcr.io/tuannvm/slack-mcp-client:latest

# Or pull a specific version
docker pull ghcr.io/tuannvm/slack-mcp-client:1.0.0

If you're using private images, you can configure image pull secrets in your values:```yaml
imagePullSecrets:
- name: my-ghcr-secret


### Docker Compose for Local Testing

For local testing and development, you can use Docker Compose to easily run the slack-mcp-client along with additional MCP servers.

#### Setup

1. Create a `.env` file with your credentials:```bash
# Create .env file from example
cp .env.example .env
# Edit the file with your credentials
nano .env
  1. Create a mcp-servers.json file (or use the example):```bash

Create mcp-servers.json from example

cp mcp-servers.json.example mcp-servers.json

Edit if needed

nano mcp-servers.json


3. Start the services:```bash
# Start services in detached mode
docker-compose up -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down

Docker Compose Configuration

The included docker-compose.yml provides:

  • Environment variables loaded from .env file
  • Volume mounting for MCP server configuration
  • Examples of connecting to additional MCP servers (commented out)```yaml
    version: '3.8'

services:
slack-mcp-client:
image: ghcr.io/tuannvm/slack-mcp-client:latest
container_name: slack-mcp-client
environment:
- SLACK_BOT_TOKEN=${SLACK_BOT_TOKEN}
- SLACK_APP_TOKEN=${SLACK_APP_TOKEN}
- OPENAI_API_KEY=${OPENAI_API_KEY}
- OPENAI_MODEL=${OPENAI_MODEL:-gpt-4o}
volumes:
- ./mcp-servers.json:/app/mcp-servers.json:ro


You can easily extend this setup to include additional MCP servers in the same network.

## Slack App Setup

1. Create a new Slack app at https://api.slack.com/apps
2. Enable Socket Mode and generate an app-level token
3. Check `Allow users to send Slash commands and messages from the chat tab` in App Home page, to enable direct message to Slack app.

4. Add the following Bot Token Scopes:
   - `app_mentions:read`
   - `chat:write`
   - `im:history`
   - `im:read`
   - `im:write`
   - `users:read`
   - `users.profile:read`
   - `channels:history`
   - `groups:history`
   - `mpim:history`
5. Enable Event Subscriptions and subscribe to:
   - `app_mention`
   - `message.im`
6. Install the app to your workspace

For detailed instructions on Slack app configuration, token setup, required permissions, and troubleshooting common issues, see the Slack Configuration Guide.

## LLM Integration

The client supports multiple LLM providers through a flexible integration system:

### LangChain Gateway

The LangChain gateway enables seamless integration with various LLM providers:

- **OpenAI**: Native support for GPT models (default)
- **Ollama**: Local LLM support for models like Llama, Mistral, etc.
- **Extensible**: Can be extended to support other LangChain-compatible providers

### LLM-MCP Bridge

The custom LLM-MCP bridge layer enables any LLM to use MCP tools without requiring native function-calling capabilities:

- **Universal Compatibility**: Works with any LLM, including those without function-calling
- **Pattern Recognition**: Detects when a user prompt or LLM response should trigger a tool call
- **Natural Language Support**: Understands both structured JSON tool calls and natural language requests

### Configuration

LLM providers can be configured via environment variables or command-line flags:```bash
# Set OpenAI as the provider (default)
export LLM_PROVIDER=&quot;openai&quot;
export OPENAI_MODEL=&quot;gpt-4.1&quot;  # or gpt-4o, o3-pro

# Use Anthropic
export LLM_PROVIDER=&quot;anthropic&quot;
export ANTHROPIC_API_KEY=&quot;your-anthropic-api-key&quot;
export ANTHROPIC_MODEL=&quot;claude-sonnet-4.5&quot;  # or claude-opus-4.1

# Or use Ollama
export LLM_PROVIDER=&quot;ollama&quot;
export LANGCHAIN_OLLAMA_URL=&quot;http://localhost:11434&quot;
export LANGCHAIN_OLLAMA_MODEL=&quot;llama3.3&quot;  # or qwen2.5-coder, mistral-small-3, deepseek-r1

Switching Between Providers

You can easily switch between providers by changing the LLM_PROVIDER environment variable:```bash

Use OpenAI

export LLM_PROVIDER=openai

Use Anthropic

export LLM_PROVIDER=anthropic

Use Ollama (local)

export LLM_PROVIDER=ollama


## Configuration

The client uses two main configuration approaches:

### Environment Variables

Configure LLM providers and Slack integration using environment variables:

| Variable              | Description                                  | Default    |
| --------------------- | -------------------------------------------- | ---------- |
| SLACK_BOT_TOKEN       | Bot token for Slack API                      | (required) |
| SLACK_APP_TOKEN       | App-level token for Socket Mode              | (required) |
| OPENAI_API_KEY        | API key for OpenAI authentication            | (required) |
| OPENAI_MODEL          | OpenAI model to use                          | gpt-4.1    |
| ANTHROPIC_API_KEY     | API key for Anthropic authentication         | (required for Anthropic) |
| ANTHROPIC_MODEL       | Anthropic model to use                       | claude-sonnet-4.5 |
| LOG_LEVEL             | Logging level (debug, info, warn, error)     | info       |
| LLM_PROVIDER          | LLM provider to use (openai, anthropic, ollama) | openai     |
| LANGCHAIN_OLLAMA_URL  | URL for Ollama when using LangChain          | http://localhost:11434 |
| LANGCHAIN_OLLAMA_MODEL| Model name for Ollama when using LangChain   | llama3.3   |
| LANGFUSE_ENDPOINT     | Langfuse API endpoint for observability      | (optional) |
| LANGFUSE_PUBLIC_KEY   | Langfuse public key for authentication       | (optional) |
| LANGFUSE_SECRET_KEY   | Langfuse secret key for authentication       | (optional) |
| OTEL_EXPORTER_OTLP_ENDPOINT | OTLP endpoint for simple tracing       | (optional) |

### Monitoring &amp; Observability Configuration

The client includes comprehensive monitoring capabilities with both metrics and distributed tracing:

#### Prometheus Metrics
- **Metrics Endpoint**: Accessible at `/metrics` on the configured port
- **Default Port**: 8080 (configurable via `--metrics-port` flag)
- **Metrics Available**:
  - `slackmcp_tool_invocations_total`: Counter for tool invocations with labels for tool name, server, and error status
  - `slackmcp_llm_tokens`: Histogram for LLM token usage by type and model

#### OpenTelemetry Tracing
- **Supported Providers**:
  - `simple-otel`: Basic OpenTelemetry tracing to OTLP endpoints (requires endpoint configuration)
  - `langfuse-otel`: Advanced LLM observability with Langfuse integration (requires endpoint and auth)
  - `disabled`: No tracing (default when no endpoint configured)
- **Automatic Fallbacks**: Failed providers automatically fall back to disabled state
- **Comprehensive Tracking**: Spans for LLM operations, tool calls, and user interactions with detailed attributes

Example configuration and usage:```bash
# Access metrics endpoint
curl http://localhost:8080/metrics

# Run with custom metrics port
slack-mcp-client --metrics-port 9090

# Enable Langfuse tracing (example)
export LANGFUSE_ENDPOINT=&quot;https://cloud.langfuse.com&quot;
export LANGFUSE_PUBLIC_KEY=&quot;pk-your-public-key&quot;
export LANGFUSE_SECRET_KEY=&quot;sk-your-secret-key&quot;

# Enable simple OTLP tracing (example)
export OTEL_EXPORTER_OTLP_ENDPOINT=&quot;http://localhost:4318&quot;

Unified Configuration Format

All configuration is now managed through a single config.json file with comprehensive options:```json
{

…(正文过长,页面只展示前面部分,完整内容见仓库)
```

常见问题

5 问
答案由本站依据条目字段整理,不引用上游原文
Slack MCP Client 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Slack MCP Client 怎么在客户端里配置?

它的传输方式未标注,在客户端 MCP 配置里按官方文档填写启动命令和参数,保存后重启客户端生效。

Slack MCP Client 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Slack MCP Client 需要 API Key 吗?

资料标注为无需认证,装好就能连;如果实际调用时报鉴权错误,按官方文档补上凭据。

Slack MCP Client 能提供哪些能力?

资料显示能力标签包括 Slack、开发工具、命令行工具。具体工具清单以官方文档为准。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-18。