Channels in Rasa

Channels in Rasa are the abstraction that allows you to connect the Rasa Assistant to your desired platform where your users are. If the built-in channels in Rasa do not fit your needs, you can create a custom channel.

A custom channel connector must be implemented as a Python class. When building a custom channel, think of it like a two-way conversation between your desired platform and Rasa. You need:

• InputChannel: Receives messages from users on your platform and forwards them to Rasa for processing.

• OutputChannel: Takes Rasa's responses and sends them back to users on your platform.

The flow is simple: User sends message → InputChannel receives it → Rasa processes → OutputChannel sends response back to user.

This separation lets you customize how messages come in (webhook, WebSocket, etc.) independently from how responses go out (REST API calls, real-time streaming, etc.).

InputChannel

A custom connector class must subclass rasa.core.channels.channel.InputChannel and implement at least blueprint and name methods.

The name method

The name method defines the url prefix for the connector's webhook. It also defines the channel name you should use in any channel specific response variations and the name you should pass to the output_channel query parameter on the trigger intent endpoint.

For example, if your custom channel is named myio, you would define the name method as:

from rasa.core.channels.channel import InputChannel

class MyIO(InputChannel):
    def name() -> Text:
        """Name of your custom channel."""
        return "myio"

You would write a response variation specific to the myio channel as:

domain.yml
responses:
  utter_greet:
    - text: Hi! I'm the default greeting.
    - text: Hi! I'm the custom channel greeting
      channel: myio

The webhook you give to the custom channel to call would be http://<host>:<port>/webhooks/myio/webhook, replacing the host and port with the appropriate values from your running Rasa server.

The blueprint method

The blueprint method must create a Sanic blueprint that can be attached to a sanic server. Your blueprint should have at least the two routes: health on the route /, and receive on the route /webhook (see example custom channel below).

As part of your implementation of the receive endpoint, you will need to tell Rasa to handle the user message. You do this by calling

    on_new_message(
      rasa.core.channels.channel.UserMessage(
        text,
        output_channel,
        sender_id
      )
    )

Calling on_new_message will send the user message to the handle_message method.

Optional InputChannel Methods

You can override these methods for additional functionality:

• from_credentials(credentials) - Class method to create channel instance from credentials configuration.

OutputChannel

The OutputChannel class is responsible for sending Rasa's responses back to users on your platform. There are two main options:

1. Use CollectingOutputChannel - Collects all bot responses in a list that you can return in your webhook response (good for REST-style channels).
2. Create your own OutputChannel subclass - Implement custom logic for sending responses directly to your platform (good for real-time channels like WebSocket, Slack, etc.).

Using CollectingOutputChannel

CollectingOutputChannel only collects sent messages in a list (doesn't send them anywhere). The collected messages can be accessed via the messages property.

Creating a Custom OutputChannel

To create your own OutputChannel, subclass rasa.core.channels.channel.OutputChannel and implement at minimum the send_text_message method:

from rasa.core.channels.channel import OutputChannel
from typing import Text, Any

class MyCustomOutputChannel(OutputChannel):
    def __init__(self, webhook_url: str):
        super().__init__()
        self.webhook_url = webhook_url

async def send_text_message(self, recipient_id: Text, text: Text, **kwargs: Any) -> None:
        """Required method: Send a simple text message."""
        # Your implementation to send text to your platform
        # e.g., make HTTP request, send via WebSocket, etc.
        pass

Common Use Cases

Accessing Conversation State

The tracker_state property contains comprehensive conversation data including slots, active flows, intents, custom actions called, and other state information. This information can be used to enrich the responses of your channel.

Passing Metadata to Rasa

If you need to use extra information from your front end in your custom actions, you can pass this information using the metadata key of your user message. This information will accompany the user message through the Rasa server into the action server when applicable, where you can find it stored in the tracker. Message metadata will not directly affect NLU classification or action prediction.