Skip to main content

​
Overview

Corvus supports 15+ messaging platforms through a unified channel system. Each channel can be independently configured with authentication, allowlists, and platform-specific settings.

​
Supported Channels

Telegram

Bot API with streaming support

Discord

WebSocket gateway integration

Slack

Socket Mode and webhook support

WhatsApp

Meta Business Cloud API

Matrix

Decentralized messaging

Signal

signal-cli HTTP integration

iMessage

macOS AppleScript integration

IRC

Classic IRC with TLS

Email

IMAP/SMTP support

Lark/Feishu

WebSocket & webhook modes

DingTalk

Stream Mode integration

QQ

Official Bot SDK

Mattermost

Self-hosted Slack alternative

Webhook

HTTP webhook endpoint

CLI

Command-line interface

​
Channel Security Model

Empty allowlists deny all inbound messages by default. This prevents accidental exposure.
Allowlist behavior:
  • Empty array []: Deny all inbound messages (secure by default)
  • Wildcard ["*"]: Allow all senders (explicit opt-in)
  • Specific IDs: Exact-match allowlist (recommended)

​
Finding Your Identity

If you’re unsure which identity to allowlist:
  1. Start the channel with an empty allowlist
  2. Send a test message to your bot
  3. Check the logs for the unauthorized sender identity
  4. Add that value to allowed_users and rerun channel setup
corvus onboard --channels-only

​
Telegram Configuration

1

Create a Bot

Message @BotFather on Telegram and create a new bot with /newbot.
2

Get Bot Token

Copy the bot token provided by BotFather.
3

Configure Corvus

Add to config.toml:
[channels_config.telegram]
bot_token = "123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
allowed_users = ["your_username"]  # Without @ symbol
stream_mode = "partial"  # or "off"
draft_update_interval_ms = 1000

​
Configuration Fields

​
channels_config.telegram.bot_token
string
required
Bot token from @BotFather.
​
channels_config.telegram.allowed_users
string[]
required
List of allowed Telegram usernames (without @) or user IDs.Examples:
  • Username: ["alice", "bob"]
  • User ID: ["123456789"]
  • Allow all: ["*"]
​
channels_config.telegram.stream_mode
string
default:"off"
Streaming mode for progressive response updates:
  • off: Send complete response as single message (default)
  • partial: Update draft message during generation
​
channels_config.telegram.draft_update_interval_ms
number
default:1000
Minimum interval between draft message edits (to avoid rate limits).

​
Discord Configuration

1

Create Application

Go to Discord Developer Portal and create a new application.
2

Create Bot

Under “Bot”, click “Add Bot” and enable:
  • Message Content Intent
  • Server Members Intent (optional)
3

Get Bot Token

Copy the bot token from the Bot settings page.
4

Invite Bot

Under “OAuth2” → “URL Generator”, select:
  • Scopes: bot
  • Permissions: Send Messages, Read Message History
Open the generated URL to invite the bot to your server.
5

Configure Corvus

[channels_config.discord]
bot_token = "MTk4NjIyNDgzNDcxOTI1MjQ4.XXXXXX.XXXXXX"
guild_id = "123456789012345678"  # Optional: server ID
allowed_users = ["987654321098765432"]  # Discord user IDs
listen_to_bots = false  # Ignore other bots
mention_only = false  # Respond to all messages or @mentions only

​
Configuration Fields

​
channels_config.discord.bot_token
string
required
Bot token from Discord Developer Portal.
​
channels_config.discord.guild_id
string
Server (guild) ID to restrict bot to. Leave empty for all servers.
​
channels_config.discord.allowed_users
string[]
required
List of allowed Discord user IDs (numeric).
​
channels_config.discord.listen_to_bots
boolean
default:false
Process messages from other bots (always ignores own messages).
​
channels_config.discord.mention_only
boolean
default:false
Only respond to messages that @mention the bot.

​
Slack Configuration

1

Create Slack App

Go to Slack API and create a new app.
2

Enable Socket Mode

Under “Socket Mode”, enable Socket Mode and generate an app-level token.
3

Add Bot Scopes

Under “OAuth & Permissions”, add bot token scopes:
  • chat:write
  • channels:history
  • groups:history
  • im:history
4

Install to Workspace

Install the app to your workspace and copy the Bot User OAuth Token.
5

Configure Corvus

[channels_config.slack]
bot_token = "xoxb-..."
app_token = "xapp-..."  # For Socket Mode
channel_id = "C01234567"  # Optional: specific channel
allowed_users = ["U01234567"]  # Slack member IDs

​
Configuration Fields

​
channels_config.slack.bot_token
string
required
Bot User OAuth Token (starts with xoxb-).
​
channels_config.slack.app_token
string
App-level token for Socket Mode (starts with xapp-).
​
channels_config.slack.channel_id
string
Specific channel ID to monitor. Leave empty for all channels.
​
channels_config.slack.allowed_users
string[]
required
List of allowed Slack member IDs (starts with U).

​
WhatsApp Configuration

WhatsApp requires HTTPS webhook endpoint. Use a tunnel (ngrok, Cloudflare, Tailscale) for local development.
1

Create Meta Business App

Go to Meta for Developers and create a Business app.
2

Add WhatsApp Product

Add “WhatsApp” product to your app.
3

Get Credentials

From WhatsApp → API Setup:
  • Copy Access Token
  • Copy Phone Number ID
  • Define a Verify Token (any random string)
4

Configure Corvus

[channels_config.whatsapp]
access_token = "EAABx..."
phone_number_id = "123456789012345"
verify_token = "my-secret-verify-token"
app_secret = "app-secret-from-meta"  # For signature verification
allowed_numbers = ["+1234567890"]  # E.164 format
5

Start Gateway with Tunnel

corvus gateway --port 8080
Set up a tunnel to expose the gateway:
ngrok http 8080
6

Configure Webhook

In Meta Developer Console → WhatsApp → Configuration:
  • Callback URL: https://your-tunnel-url/whatsapp
  • Verify Token: Same as verify_token in config
  • Subscribe to: messages

​
Configuration Fields

​
channels_config.whatsapp.access_token
string
required
Access token from Meta Business Suite.
​
channels_config.whatsapp.phone_number_id
string
required
Phone number ID from WhatsApp API Setup.
​
channels_config.whatsapp.verify_token
string
required
Webhook verification token (you define this).
​
channels_config.whatsapp.app_secret
string
App secret for webhook signature verification. Can also be set via CORVUS_WHATSAPP_APP_SECRET.
​
channels_config.whatsapp.allowed_numbers
string[]
required
Allowed phone numbers in E.164 format (e.g., +1234567890).Use ["*"] to allow all numbers.

​
Signal Configuration

Requires signal-cli running in HTTP daemon mode. 
[channels_config.signal]
http_url = "http://127.0.0.1:8686"
account = "+1234567890"  # Your signal-cli number
group_id = "dm"  # "dm" for DMs only, or specific group ID
allowed_from = ["+9876543210"]
ignore_attachments = false
ignore_stories = true
​
channels_config.signal.http_url
string
required
URL of signal-cli HTTP daemon.
​
channels_config.signal.account
string
required
E.164 phone number of signal-cli account.
​
channels_config.signal.group_id
string
Filter messages by group:
  • Omit: Accept all messages (DMs and groups)
  • "dm": Only accept direct messages
  • Group ID: Only accept messages from specific group
​
channels_config.signal.allowed_from
string[]
required
Allowed sender phone numbers in E.164 format.

​
Lark/Feishu Configuration

Lark (international) and Feishu (China) support two receive modes: 
[channels_config.lark]
app_id = "cli_..."
app_secret = "..."
allowed_users = ["ou_..."]  # User IDs or union IDs
use_feishu = false  # true for Feishu (China)
receive_mode = "websocket"  # or "webhook"

# Only for webhook mode:
port = 8080
encrypt_key = "..."  # Optional
verification_token = "..."  # Optional
​
channels_config.lark.receive_mode
string
default:"websocket"
Event receive mode:
  • websocket: Persistent connection, no public URL required (recommended)
  • webhook: HTTP callback, requires public HTTPS endpoint
​
channels_config.lark.use_feishu
boolean
default:false
Use Feishu (China) endpoint instead of Lark (international).

​
IRC Configuration

[channels_config.irc]
server = "irc.libera.chat"
port = 6697
nickname = "corvus-bot"
channels = ["#rust", "#ai"]
allowed_users = ["alice", "bob"]  # Case-insensitive

# Authentication (choose one)
server_password = "..."  # For bouncers like ZNC
nickserv_password = "..."  # For NickServ IDENTIFY
sasl_password = "..."  # For SASL PLAIN (IRCv3)

verify_tls = true  # Verify TLS certificate

​
Email Configuration

[channels_config.email]
imap_host = "imap.gmail.com"
imap_port = 993
smtp_host = "smtp.gmail.com"
smtp_port = 587
email = "bot@example.com"
password = "app-password"
allowed_from = ["user@example.com"]

​
Webhook Configuration

Generic HTTP webhook endpoint: 
[channels_config.webhook]
port = 3000
secret = "webhook-secret-token"  # Optional HMAC verification
Usage: 
curl -X POST http://localhost:3000/webhook \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <pairing-token>" \
  -d '{"message": "Hello, Corvus!"}'

​
Channel Health Checks

Check the health of configured channels: 
corvus channel doctor
This validates:
  • Authentication credentials
  • Network connectivity
  • API endpoint availability
  • Webhook configuration

​
Quick Reconfiguration

To reconfigure channels without affecting other settings: 
corvus onboard --channels-only
This updates channel configuration and allowlists while preserving provider, memory, and security settings.

​
Complete Example

[channels_config]
cli = true

[channels_config.telegram]
bot_token = "123456789:ABCdef..."
allowed_users = ["alice"]
stream_mode = "partial"

[channels_config.discord]
bot_token = "MTk4NjIy..."
allowed_users = ["123456789012345678"]
mention_only = true

[channels_config.slack]
bot_token = "xoxb-..."
app_token = "xapp-..."
allowed_users = ["U01234567"]

[channels_config.whatsapp]
access_token = "EAABx..."
phone_number_id = "123456789012345"
verify_token = "my-secret"
allowed_numbers = ["+1234567890"]

​
Next Steps

Memory Configuration

Configure memory backends and embedding providers