Deploying your Rasa Assistant

These docs are for version 1.x of Rasa Open Source.

Deploying your Rasa Assistant

This page explains when and how to deploy an assistant built with Rasa. It will allow you to make your assistant available to users and set up a production-ready environment.

When to deploy your assistant

The best time to deploy your assistant and make it available to test users is once it can handle the most important happy paths or is what we call a minimum viable assistant.

The recommended deployment methods described below make it easy to share your assistant with test users via the share your assistant feature in Rasa X. Then, when you’re ready to make your assistant available via one or more Messaging and Voice Channels, you can easily add them to your existing deployment setup.

Recommended Deployment Methods

The recommended way to deploy an assistant is using either the Docker Compose or Kubernetes/Openshift options we support. Both deploy Rasa X and your assistant. They are the easiest ways to deploy your assistant, allow you to use Rasa X to view conversations and turn them into training data, and are production-ready.

Kubernetes/Openshift

Kubernetes/Openshift is the best option if you need a scalable architecture. It’s straightforward to deploy if you use the helm charts we provide. However, you can also customize the Helm charts if you have specific requirements.

Default: Read the docs here.

Custom: Read the docs here and customize the open source Helm charts.

Docker Compose

To run your AI assistant in production, configure your required Messaging and Voice Channels in credentials.yml. If this file does not exist, create it using:

touch credentials.yml

Then edit it according to your connected channels. Afterwards, run the trained model with:

docker run \
  -v $(pwd)/models:/app/models \
  rasa/rasa:latest-full \
  run

Rasa-Only Deployment with Docker Compose

It is also possible to deploy a Rasa assistant using Docker Compose without Rasa X.

Using Docker Compose to Run Multiple Services

To run Rasa together with other services, such as a server for custom actions, it is recommended to use Docker Compose. Start by creating a file called docker-compose.yml:

touch docker-compose.yml

Add the following content to the file:

version: '3.0'
services:
  rasa:
    image: rasa/rasa:latest-full
    ports:
      - 5005:5005
    volumes:
      - ./:/app
    command:
      - run

To run the services configured in your docker-compose.yml, execute:

docker-compose up

Adding Custom Actions

To create more sophisticated assistants, you will want to use Custom Actions.

Creating a Custom Action

Start by creating the custom actions in a directory actions:

mkdir actions
# Rasa SDK expects a python module.
# Therefore, make sure that you have this file in the directory.
touch actions/__init__.py
touch actions/actions.py

Then build a custom action using the Rasa SDK, e.g.:

import requests
import json
from rasa_sdk import Action

class ActionJoke(Action):
  def name(self):
    return "action_joke"

def run(self, dispatcher, tracker, domain):
    request = requests.get('http://api.icndb.com/jokes/random').json()  # make an api call
    joke = request['value']['joke']  # extract a joke from returned json response
    dispatcher.utter_message(text=joke)  # send the message back to the user
    return []

Adding the Action Server

The custom actions are run by the action server. To spin it up together with the Rasa instance, add a service action_server to the docker-compose.yml:

version: '3.0'
services:
  rasa:
    image: rasa/rasa:latest-full
    ports:
      - 5005:5005
    volumes:
      - ./:/app
    command:
      - run
  action_server:
    image: rasa/rasa-sdk:latest
    volumes:
      - ./actions:/app/actions

Adding a Custom Tracker Store

By default, all conversations are saved in memory. This means that all conversations are lost as soon as you restart the Rasa server. If you want to persist your conversations, you can use a different Tracker Store.

Using PostgreSQL as Tracker Store

Start by adding PostgreSQL to your docker-compose file:

postgres:
  image: postgres:latest

Then add PostgreSQL to the tracker_store section of your endpoint configuration config/endpoints.yml:

tracker_store:
  type: sql
  dialect: "postgresql"
  url: postgres
  db: rasa

Using MongoDB as Tracker Store

Start by adding MongoDB to your docker-compose file:

mongo:
  image: mongo
  environment:
    MONGO_INITDB_ROOT_USERNAME: rasa
    MONGO_INITDB_ROOT_PASSWORD: example

Using Redis as Tracker Store

Start by adding Redis to your docker-compose file:

redis:
  image: redis:latest

Then add Redis to the tracker_store section of your endpoint configuration endpoints.yml:

  type: redis
  url: redis

Using a Custom Tracker Store Implementation

If you have a custom implementation of a tracker store, you have two options to add this store to Rasa:

Then add the required configuration to your endpoint configuration endpoints.yml as it is described in Tracker Stores.