# Which Messaging Platforms Does Maka's Bot System Support? A Complete Guide to the 8 Providers

> Explore the 8 messaging platforms Maka's bot system supports including Telegram, Slack, Discord, and more. Integrate seamlessly with your favorite providers.

- Repository: [The Apache Software Foundation/maka](https://github.com/apache/maka)
- Tags: how-to-guide
- Published: 2026-08-22

---

**Maka's bot system supports eight messaging platforms: Telegram, Feishu (Lark), WeCom, WeChat, Discord, DingTalk, QQ, and Slack.**

Apache Maka defines all supported messaging integrations through a centralized `BotProvider` enum located in the core package. This type-safe architecture allows developers to configure and deploy bots across consumer and enterprise chat platforms using unified bridge implementations that translate native events into Maka's standard `BotEvent` model.

## The BotProvider Enum and Supported Platforms

The canonical list of supported providers is defined in [`packages/core/src/bot-chat-settings.ts`](https://github.com/apache/maka/blob/main/packages/core/src/bot-chat-settings.ts) at lines 20-28. According to the Apache Maka source code, the `BotProvider` type enumerates every messaging service the platform can integrate with.

The eight officially supported platforms are:

- **Telegram** – A consumer-grade messaging app with a rich Bot API, typically used for public bots, group chats, and channel posts.
- **Feishu** (also known as Lark) – ByteDance's enterprise collaboration suite, designed for internal corporate bots and workflow automation.
- **WeCom** (Enterprise WeChat) – Tencent's business-focused chat platform for corporate-level notifications and approvals.
- **WeChat** – The popular consumer chat app in China, used for consumer-facing bots and mini-program integration.
- **Discord** – A community-focused voice and text chat platform popular with gamers and developers, used for community bots, moderation, and event alerts.
- **DingTalk** – Alibaba's enterprise communication platform for workplace bot notifications and OA integration.
- **QQ** – The legacy Chinese instant-messenger platform for simple text notifications to legacy user bases.
- **Slack** – The widely used team collaboration tool for channel alerts, slash-command bots, and SaaS integrations.

These providers form the complete set used throughout Maka's runtime and UI layers.

## Runtime Bridge Architecture

Each messaging platform has a dedicated bridge implementation that translates the platform's native event format into Maka's unified `BotEvent` model.

In `packages/runtime/src/bots/`, you will find platform-specific bridges such as `SlackBotBridge` for Slack and similar adapters for other providers. The `BotRegistry` class in [`packages/runtime/src/bots/bot-registry.ts`](https://github.com/apache/maka/blob/main/packages/runtime/src/bots/bot-registry.ts) instantiates the appropriate bridge based on which providers are enabled in the configuration.

The UI layer maps these providers to display elements in [`packages/ui/src/bot-brand.ts`](https://github.com/apache/maka/blob/main/packages/ui/src/bot-brand.ts), handling colors, icons, and documentation links for each platform.

## Configuring Bot Providers

To enable and configure messaging platforms, use the `createDefaultBotChatSettings` factory function from `@maka/core`. This generates a settings object with all eight providers pre-initialized but disabled by default.

```typescript
import { createDefaultBotChatSettings, BotProvider } from '@maka/core';

// Initialise default chat settings for all providers
const settings = createDefaultBotChatSettings();

// Enable and configure a Slack bot
settings.channels['slack'].enabled = true;
settings.channels['slack'].token = process.env.SLACK_BOT_TOKEN ?? '';
settings.channels['slack'].appSecret = process.env.SLACK_APP_SECRET ?? '';
settings.channels['slack'].readiness = 'scaffolded';

// Enable a Telegram bot
settings.channels['telegram'].enabled = true;
settings.channels['telegram'].token = process.env.TELEGRAM_BOT_TOKEN ?? '';
settings.channels['telegram'].readiness = 'scaffolded';

// The settings object can now be passed to the bot-registry
// which will spin up the appropriate bridge(s) for the enabled providers.

```

The `settings.channels` object uses the `BotProvider` enum values as keys, ensuring type-safe access to each platform's configuration.

## Key Implementation Files

The following files define the supported platforms and provide the runtime adapters:

- **[`packages/core/src/bot-chat-settings.ts`](https://github.com/apache/maka/blob/main/packages/core/src/bot-chat-settings.ts)** – Contains the central `BotProvider` enum and default configuration logic.
- **[`packages/runtime/src/bots/slack-bridge.ts`](https://github.com/apache/maka/blob/main/packages/runtime/src/bots/slack-bridge.ts)** – Implements the Slack-specific bridge.
- **[`packages/runtime/src/bots/telegram-bridge.ts`](https://github.com/apache/maka/blob/main/packages/runtime/src/bots/telegram-bridge.ts)** – Implements the Telegram bridge using the same pattern as Slack.
- **[`packages/runtime/src/bots/bot-registry.ts`](https://github.com/apache/maka/blob/main/packages/runtime/src/bots/bot-registry.ts)** – Registry that instantiates the appropriate bridge based on enabled providers.
- **[`packages/ui/src/bot-brand.ts`](https://github.com/apache/maka/blob/main/packages/ui/src/bot-brand.ts)** – Maps providers to UI display colors, icons, and documentation.

## Summary

- Maka supports **eight messaging platforms**: Telegram, Feishu (Lark), WeCom, WeChat, Discord, DingTalk, QQ, and Slack.
- The `BotProvider` enum in [`packages/core/src/bot-chat-settings.ts`](https://github.com/apache/maka/blob/main/packages/core/src/bot-chat-settings.ts) serves as the single source of truth for available integrations.
- Each platform uses a dedicated **bridge implementation** (e.g., `SlackBotBridge`) to normalize events into Maka's `BotEvent` model.
- Configure providers using `createDefaultBotChatSettings()` from `@maka/core`, enabling specific channels via the `settings.channels` object.
- The architecture supports extending the `BotProvider` enum and adding new bridges to integrate additional messaging services.

## Frequently Asked Questions

### How do I add a new messaging platform to Maka?

Extend the `BotProvider` enum in [`packages/core/src/bot-chat-settings.ts`](https://github.com/apache/maka/blob/main/packages/core/src/bot-chat-settings.ts) with the new platform identifier. Then create a corresponding bridge class in `packages/runtime/src/bots/` that translates the platform's native events into Maka's unified `BotEvent` model. Finally, register the bridge in [`packages/runtime/src/bots/bot-registry.ts`](https://github.com/apache/maka/blob/main/packages/runtime/src/bots/bot-registry.ts) so the runtime can instantiate it when the provider is enabled.

### Is there a difference between Feishu and Lark in Maka's configuration?

No. Maka treats Feishu and Lark as the same provider. The `BotProvider` enum uses a single identifier to represent ByteDance's enterprise collaboration suite, which operates under the name Feishu in China and Lark internationally.

### Can I enable multiple messaging platforms simultaneously?

Yes. The `createDefaultBotChatSettings()` function initializes configurations for all eight providers. You can enable any combination of platforms by setting their respective `enabled` property to `true` and providing valid API tokens. The `BotRegistry` will automatically spin up the appropriate bridges for all enabled providers at runtime.

### Where does Maka store bot tokens and secrets?

Bot tokens and secrets are configured through the `settings.channels` object properties (e.g., `settings.channels['slack'].token` and `settings.channels['slack'].appSecret`). These values should be loaded from environment variables or secure secret management systems rather than hardcoded in source files, as shown in the configuration examples using `process.env`.