Forms

One of the most common conversation patterns is to collect a few pieces of information from a user in order to do something (book a restaurant, call an API, search a database, etc.). This is also called slot filling.

If you need to collect multiple pieces of information in a row, we recommended that you create a FormAction. This is a single action which contains the logic to loop over the required slots and ask the user for this information. There is a full example using forms in the examples/formbot directory of Rasa Core.

When you define a form, you need to add it to your domain file. If your form’s name is restaurant_form, your domain would look like this:

forms:
  - restaurant_form
actions:
  ...

Configuration File

To use forms, you also need to include the FormPolicy in your policy configuration file. For example:

policies:
  - name: "FormPolicy"

Form Basics

Using a FormAction, you can describe all of the happy paths with a single story. By “happy path”, we mean that whenever you ask a user for some information, they respond with the information you asked for.

If we take the example of the restaurant bot, this single story describes all of the happy paths.

## happy path
* request_restaurant
    - restaurant_form
    - form{"name": "restaurant_form"}
    - form{"name": null}

In this story the user intent is request_restaurant, which is followed by the form action restaurant_form. With form{"name": "restaurant_form"} the form is activated and with form{"name": null} the form is deactivated again.

The FormAction will only request slots which haven’t already been set. If a user starts the conversation with I’d like a vegetarian Chinese restaurant for 8 people, then they won’t be asked about the cuisine and num_people slots.

Note that for this story to work, your slots should be unfeaturized. If any of these slots are featurized, your story needs to include slot{} events to show these slots being set. In that case, the easiest way to create valid stories is to use Interactive Learning.

In the story above, restaurant_form is the name of our form action. Here is an example of what it looks like:

You need to define three methods:

• name: the name of this action
• required_slots: a list of slots that need to be filled for the submit method to work.
• submit: what to do at the end of the form, when all the slots have been filled.

def name(self) -> Text:
    """Unique identifier of the form"""
    return "restaurant_form"

@staticmethod
def required_slots(tracker: Tracker) -> List[Text]:
    """A list of required slots that the form has to fill"""
    return ["cuisine", "num_people", "outdoor_seating", "preferences", "feedback"]

def submit(
    self,
    dispatcher: CollectingDispatcher,
    tracker: Tracker,
    domain: Dict[Text, Any],
) -> List[Dict]:
    """Define what the form has to do
        after all required slots are filled"""
    # utter submit template
    dispatcher.utter_message(template="utter_submit")
    return []

Once the form action gets called for the first time, the form gets activated and the FormPolicy jumps in. The FormPolicy is extremely simple and just always predicts the form action.

Custom slot mappings

If you do not define slot mappings, slots will be only filled by entities with the same name as the slot that are picked up from the user input.

Here’s an example for the restaurant bot:

def slot_mappings(self) -> Dict[Text, Union[Dict, List[Dict]]]:
    """A dictionary to map required slots to
        - an extracted entity
        - intent: value pairs
        - a whole message
        or a list of them, where a first match will be picked"""

return {
        "cuisine": self.from_entity(entity="cuisine", not_intent="chitchat"),
        "num_people": [
            self.from_entity(
                entity="number", intent=["inform", "request_restaurant"]
            ),
        ],
        "outdoor_seating": [
            self.from_entity(entity="seating"),
            self.from_intent(intent="affirm", value=True),
            self.from_intent(intent="deny", value=False),
        ],
        "preferences": [
            self.from_intent(intent="deny", value="no additional preferences"),
            self.from_text(not_intent="affirm"),
        ],
        "feedback": [self.from_entity(entity="feedback"), self.from_text()],
    }

Validating user input

After extracting a slot value from user input, the form will try to validate the value of the slot.

Here is an example , validate_cuisine(), which checks if the extracted cuisine slot belongs to a list of supported cuisines.

    @staticmethod
    def cuisine_db() -> List[Text]:
        """Database of supported cuisines"""
        return [
            "caribbean",
            "chinese",
            "french",
            "greek",
            "indian",
            "italian",
            "mexican",
        ]

    def validate_cuisine(
        self,
        value: Text,
        dispatcher: CollectingDispatcher,
        tracker: Tracker,
        domain: Dict[Text, Any],
    ) -> Dict[Text, Any]:
        """Validate cuisine value."""

if value.lower() in self.cuisine_db():
            # validation succeeded, set the value of the "cuisine" slot to value
            return {"cuisine": value}
        else:
            dispatcher.utter_message(template="utter_wrong_cuisine")
            # validation failed, set this slot to None, meaning the
            # user will be asked for the slot again
            return {"cuisine": None}

Handling unhappy paths

Of course your users will not always respond with the information you ask of them. Typically, users will ask questions, make chitchat, change their mind, or otherwise stray from the happy path.

In some situations, users may change their mind in the middle of form action and decide not to go forward with their initial request. In cases like this, the assistant should stop asking for the requested slots.

This can be handled gracefully using a default action action_deactivate_form which will deactivate the form and reset the requested slot. An example story of such conversation could look as follows:

## chitchat
* request_restaurant
    - restaurant_form
    - form{"name": "restaurant_form"}
* stop
    - utter_ask_continue
* deny
    - action_deactivate_form
    - form{"name": null}

The requested_slot slot

The slot requested_slot is automatically added to the domain as an unfeaturized slot. If you want to make it featurized, you need to add it to your domain file as a categorical slot.

Handling conditional slot logic

Many forms require more logic than just requesting a list of fields.

You can achieve this by writing some logic into the required_slots() method.

@staticmethod
def required_slots(tracker) -> List[Text]:
   """A list of required slots that the form has to fill"""
   if tracker.get_slot('cuisine') == 'greek':
     return ["cuisine", "num_people", "outdoor_seating",
             "preferences", "feedback"]
   else:
     return ["cuisine", "num_people",
             "preferences", "feedback"]

Debugging

The first thing to try is to run your bot with the debug flag.

👋 I can help you get started with Rasa and answer your technical questions.