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

# Command Line Interface

## Cheat Sheet
The command line interface (CLI) gives you easy-to-remember commands for common tasks.

| Command | Effect |
| --- | --- |
| `rasa init` | Creates a new project with example training data, actions, and config files. |
| `rasa train` | Trains a model using your NLU data and stories, saves trained model in `./models`. |
| `rasa interactive` | Starts an interactive learning session to create new training data by chatting. |
| `rasa shell` | Loads your trained model and lets you talk to your assistant on the command line. |
| `rasa run` | Starts a Rasa server with your trained model. See the [Configuring the HTTP API](https://legacy-docs-v1.rasa.com/1.10.22/user-guide/configuring-http-api/#configuring-http-api) docs for details. |
| `rasa run actions` | Starts an action server using the Rasa SDK. |
| `rasa visualize` | Visualizes stories. |
| `rasa test` | Tests a trained Rasa model using your test NLU data and stories. |
| `rasa data split nlu` | Performs a split of your NLU data according to the specified percentages. |
| `rasa data convert nlu` | Converts NLU training data between different formats. |
| `rasa export` | Export conversations from a tracker store to an event broker. |
| `rasa x` | Launch Rasa X locally. |
| `rasa -h` | Shows all available commands. |

## Create a new project
A single command sets up a complete project for you with some example training data.

```
rasa init
```

This creates the following files:

```
.
├── __init__.py
├── actions.py
├── config.yml
├── credentials.yml
├── data
│   ├── nlu.md
│   └── stories.md
├── domain.yml
├── endpoints.yml
└── models
    └── <timestamp>.tar.gz
```

The `rasa init` command will ask you if you want to train an initial model using this data.
If you answer no, the `models` directory will be empty.

With this project setup, common commands are very easy to remember.
To train a model, type `rasa train`, to talk to your model on the command line, `rasa shell`, to test your model type `rasa test`.

## Train a Model
The main command is:

```
rasa train
```

This command trains a Rasa model that combines a Rasa NLU and a Rasa Core model.
If you only want to train an NLU or a Core model, you can run `rasa train nlu` or `rasa train core`.
However, Rasa will automatically skip training Core or NLU if the training data and config haven’t changed.

`rasa train` will store the trained model in the directory defined by `--out`. The name of the model
is per default `<timestamp>.tar.gz`. If you want to name your model differently, you can specify the name
using `--fixed-model-name`.

The following arguments can be used to configure the training process:

```
usage: rasa train [-h] [-v] [-vv] [--quiet] [--data DATA [DATA ...]]
                  [-c CONFIG] [-d DOMAIN] [--out OUT]
                  [--augmentation AUGMENTATION] [--debug-plots]
                  [--fixed-model-name FIXED_MODEL_NAME] [--persist-nlu-data]
                  [--force]
                  {core,nlu} ...

positional arguments:
  {core,nlu}
    core                Trains a Rasa Core model using your stories.
    nlu                 Trains a Rasa NLU model using your NLU data.

optional arguments:
  -h, --help            show this help message and exit
  --data DATA [DATA ...]
                        Paths to the Core and NLU data files. (default:
                        ['data'])
  -c CONFIG, --config CONFIG
                        The policy and NLU pipeline configuration of your bot.
                        (default: config.yml)
  -d DOMAIN, --domain DOMAIN
                        Domain specification (yml file). (default: domain.yml)
  --out OUT             Directory where your models should be stored.
                        (default: models)
  --augmentation AUGMENTATION
                        How much data augmentation to use during training.
                        (default: 50)
  --debug-plots         If enabled, will create plots showing checkpoints and
                        their connections between story blocks in a file
                        called `story_blocks_connections.html`. (default:
                        False)
  --fixed-model-name FIXED_MODEL_NAME
                        If set, the name of the model file/directory will be
                        set to the given name. (default: None)
  --persist-nlu-data    Persist the nlu training data in the saved model.
                        (default: False)
  --force               Force a model training even if the data has not
                        changed. (default: False)
```

## Interactive Learning
To start an interactive learning session with your assistant, run

```
rasa interactive
```

If you provide a trained model using the `--model` argument, the interactive learning process
is started with the provided model. If no model is specified, `rasa interactive` will
train a new Rasa model with the data located in `data/` if no other directory was passed to the
`--data` flag. After training the initial model, the interactive learning session starts.
Training will be skipped if the training data and config haven’t changed.

The full list of arguments that can be set for `rasa interactive` is:

```
usage: rasa interactive [-h] [-v] [-vv] [--quiet] [--e2e] [-m MODEL]
                        [--data DATA [DATA ...]] [--skip-visualization]
                        [--conversation-id CONVERSATION_ID]
                        [--endpoints ENDPOINTS] [-c CONFIG] [-d DOMAIN]
                        [--out OUT] [--augmentation AUGMENTATION]
                        [--debug-plots] [--force] [--persist-nlu-data]
                        {core} ... [model-as-positional-argument]

positional arguments:
  {core}
    core                Starts an interactive learning session model to create
                        new training data for a Rasa Core model by chatting.
                        Uses the 'RegexInterpreter', i.e. `/<intent>` input
                        format.

optional arguments:
  -h, --help            show this help message and exit
  --e2e                 Save story files in e2e format. In this format user
                        messages will be included in the stories. (default:
                        False)
  -m MODEL, --model MODEL
                        Path to a trained Rasa model. If a directory is
                        specified, it will use the latest model in this
                        directory. (default: None)
  --data DATA [DATA ...]
                        Paths to the Core and NLU data files. (default:
                        ['data'])
  --skip-visualization  Disable plotting the visualization during interactive
                        learning. (default: False)
  --conversation-id CONVERSATION_ID
                        Specify the id of the conversation the messages are
                        in. Defaults to a UUID that will be randomly
                        generated. (default: 2da7e34b38114c0bbb4532a31dd3aece)
  --endpoints ENDPOINTS
                        Configuration file for the model server and the
                        connectors as a yml file. (default: None)

Python Logging Options:
  -v, --verbose         Be verbose. Sets logging level to INFO. (default:
                        None)
  -vv, --debug          Print lots of debugging statements. Sets logging level
                        to DEBUG. (default: None)
  --quiet               Be quiet! Sets logging level to WARNING. (default:
                        None)
```

## Talk to your Assistant
To start a chat session with your assistant on the command line, run:

```
rasa shell
```

The model that should be used to interact with your bot can be specified by `--model`.
If you start the shell with an NLU-only model, `rasa shell` allows
you to obtain the intent and entities of any text you type on the command line.
If your model includes a trained Core model, you can chat with your bot and see
what the bot predicts as a next action.
If you have trained a combined Rasa model but nevertheless want to see what your model
extracts as intents and entities from text, you can use the command `rasa shell nlu`.

To increase the logging level for debugging, run:

```
rasa shell --debug
```

## Start a Server
To start a server running your Rasa model, run:

```
rasa run
```

## Start an Action Server
To run your action server run

```
rasa run actions
```

## Visualize your Stories
To open a browser tab with a graph showing your stories:

```
rasa visualize
```

## Evaluating a Model on Test Data
To evaluate your model on test data, run:

```
rasa test
```

## Create a Train-Test Split
To create a split of your NLU data, run:

```
rasa data split nlu
```

## Convert Data Between Markdown and JSON
To convert NLU data from LUIS data format, WIT data format, Dialogflow data format, JSON, or Markdown
to JSON or Markdown, run:

```
rasa data convert nlu
```

## Export Conversations to an Event Broker
To export events from a tracker store using an event broker, run:

```
rasa export
```

## Start Rasa X
Rasa X is a toolset that helps you leverage conversations to improve your assistant.
You can start Rasa X locally by executing

```
rasa x
```
