MCP Server: Weixin, DingTalk, Telegram Push

Overview

MCP Server is a lightweight notification relay that accepts standard MCP-style messages over HTTP and forwards them to multiple messaging and push services. It centralizes delivery logic so you can send one request to the MCP Server and reliably deliver the same content to platforms such as Weixin (WeChat), DingTalk, Telegram, Bark, Lark/Feishu, and Home Assistant.

This is useful when you need consistent, cross-platform alerting for monitoring, CI/CD, home automation, or bot notifications. By keeping provider credentials and mapping logic inside the MCP Server, clients only need one integration point and the server handles retries, formatting, and per-platform delivery details.

Features

• Accepts MCP-like JSON messages over HTTP
• Forward to multiple providers in a single request
• Supports: Weixin (WeChat enterprise), DingTalk, Telegram, Bark (iOS), Lark/Feishu, Home Assistant
• Credential/configuration via YAML or environment variables
• Docker-ready for easy deployment
• Simple request/response API for integrating with scripts, automation, and monitoring systems

Installation / Configuration

Clone and run the server locally or use Docker.

Clone repository:

git clone https://github.com/aahl/mcp-notify.git
cd mcp-notify

Build and run with Docker:

# build
docker build -t mcp-notify .

# run (example)
docker run -d \
  -p 8080:8080 \
  -v $(pwd)/config.yaml:/app/config.yaml:ro \
  --name mcp-notify \
  mcp-notify:latest

Docker Compose example:

version: "3.8"
services:
  mcp-notify:
    image: aahl/mcp-notify:latest
    ports:
      - "8080:8080"
    volumes:
      - ./config.yaml:/app/config.yaml:ro
    restart: unless-stopped

Example config.yaml (credential mapping):

server:
  port: 8080

providers:
  telegram:
    bot_token: "123456:ABC-DEF"
  dingding:
    webhook: "https://oapi.dingtalk.com/robot/send?access_token=..."
  weixin:
    corp_id: "wx12345"
    corp_secret: "SECRET"
  bark:
    server_key: "https://api.day.app/your-key"
  feishu:
    app_id: "cli_xxx"
    app_secret: "xxx"
  homeassistant:
    webhook_base: "https://ha.example.com/api/webhook"

Environment variable alternatives (example):

# override port
MCP_SERVER_PORT=8080

# individual provider tokens
MCP_TELEGRAM_BOT_TOKEN="123456:ABC-DEF"

The server reads providers from a config file and environment variables; provider-specific credentials are used when forwarding messages.

API — basic usage

POST to the MCP Server to deliver a message. The server accepts a compact JSON envelope that specifies recipients or provider targets.

Example request (single provider):

curl -X POST http://localhost:8080/api/v1/push \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "telegram",
    "bot_token": "123456:ABC-DEF",
    "chat_id": 987654321,
    "title": "Deployment",
    "message": "Build #123 succeeded"
  }'

Example request (multiple targets):

curl -X POST http://localhost:8080/api/v1/push \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Alert",
    "message": "Disk usage > 90%",
    "targets": [
      {"provider":"telegram","chat_id":987654321,"bot_token":"..."},
      {"provider":"dingding","webhook":"https://oapi.dingtalk.com/robot/send?access_token=..."},
      {"provider":"bark","url":"https://api.day.app/your-key"}
    ]
  }'

Responses include per-target delivery status and error messages for failed deliveries.

Supported providers and required credentials

Available Tools / Resources

• GitHub repository: https://github.com/aahl/mcp-notify — code, examples and sample configs
• Docker image (repo provides Dockerfile) — deployable in containers
• API endpoint for simple curl/post integration from scripts and automation

Check the repository for extra utility scripts, sample config files, and test clients.

Use Cases

• Monitoring alerts: Send a single alert payload to MCP Server and deliver it to on-call Telegram chat, a DingTalk room, and an iOS Bark push for simultaneous delivery.
• CI/CD notifications: Notify teams on Feishu and maintain a backup Telegram message for critical pipeline failures.
• Home automation: Forward sensor events from Home Assistant to personal Telegram or Bark pushes using a single integration.
• Cross-team broadcasts: One POST can fan out to multiple platforms, ensuring team members on different apps all receive the same message.

If you’re integrating notifications