Slots

What are slots?

Slots are your bot’s memory. They act as a key-value store which can be used to store information the user provided (e.g their home city) as well as information gathered about the outside world (e.g. the result of a database query).

Most of the time, you want slots to influence how the dialogue progresses. There are different slot types for different behaviors.

For example, if your user has provided their home city, you might have a text slot called home_city. If the user asks for the weather, and you don’t know their home city, you will have to ask them for it. A text slot only tells Rasa Core whether the slot has a value. The specific value of a text slot (e.g. Bangalore or New York) doesn’t make any difference.

If the value itself is important, use a categorical or a bool slot. There are also float, and list slots. If you just want to store some data, but don’t want it to affect the flow of the conversation, use an unfeaturized slot.

How Rasa Uses Slots

The Policy doesn’t have access to the value of your slots. It receives a featurized representation. The policy just sees a 1 or 0 depending on whether it is set.

You should choose your slot types carefully!

How Slots Get Set

You can provide an initial value for a slot in your domain file:

slots:
  name:
    type: text
    initial_value: "human"

You can get the value of a slot using .get_slot() inside actions.py for example:

data = tracker.get_slot("slot-name")

Slots Set from NLU

If your NLU model picks up an entity, and your domain contains a slot with the same name, the slot will be set automatically. For example:

# story_01
* greet{"name": "Ali"}
  - slot{"name": "Ali"}
  - utter_greet

In this case, you don’t have to include the - slot{} part in the story, because it is automatically picked up.

To disable this behavior for a particular slot, you can set the auto_fill attribute to False in the domain file:

slots:
  name:
    type: text
    auto_fill: False

Slots Set By Clicking Buttons

You can use buttons as a shortcut. Rasa Core will send messages starting with a / to the RegexInterpreter, which expects NLU input in the same format as in story files, e.g. /intent{entities}. For example, if you let users choose a color by clicking a button, the button payloads might be /choose{"color": "blue"} and /choose{"color": "red"}. You can specify this in your domain file:

utter_ask_color:
- text: "what color would you like?"
  buttons:
  - title: "blue"
    payload: '/choose{"color": "blue"}'
  - title: "red"
    payload: '/choose{"color": "red"}'

Slots Set by Actions

The second option is to set slots by returning events in custom actions. In this case, your stories need to include the slots. For example:

slots:
   account_type:
      type: categorical
      values:
      - premium
      - basic

from rasa_sdk.actions import Action
from rasa_sdk.events import SlotSet
import requests

class FetchProfileAction(Action):
    def name(self):
        return "fetch_profile"

def run(self, dispatcher, tracker, domain):
        url = "http://myprofileurl.com"
        data = requests.get(url).json()
        return [SlotSet("account_type", data["account_type"])]

# story_01
* greet
  - action_fetch_profile
  - slot{"account_type" : "premium"}
  - utter_welcome_premium

# story_02
* greet
  - action_fetch_profile
  - slot{"account_type" : "basic"}
  - utter_welcome_basic

Slot Types

Text Slot

text Use For: User preferences where you only care whether or not they’ve been specified. Example:

slots:
   cuisine:
      type: text

Description: Results in the feature of the slot being set to 1 if any value is set. Otherwise, the feature will be set to 0 (no value is set).

Boolean Slot

bool Use For: True or False Example:

slots:
   is_authenticated:
      type: bool

Description: Checks if slot is set and if True.

Categorical Slot

categorical Use For: Slots which can take one of N values. Example:

slots:
   risk_level:
      type: categorical
      values:
      - low
      - medium
      - high

Description: Creates a one-hot encoding describing which of the values matched.

Float Slot

float Use For: Continuous values Example:

slots:
   temperature:
      type: float
      min_value: -100.0
      max_value:  100.0

List Slot

list Use For: Lists of values Example:

slots:
   shopping_items:
      type: list

Unfeaturized Slot

unfeaturized Use For: Data you want to store which shouldn’t influence the dialogue flow. Example:

slots:
   internal_user_id:
      type: unfeaturized

Custom Slot Types

Maybe your restaurant booking system can only handle bookings for up to 6 people. In this case, you want the value of the slot to influence the next selected action. You can do this by defining a custom slot class.

from rasa.core.slots import Slot

class NumberOfPeopleSlot(Slot):
    def feature_dimensionality(self):
        return 2

def as_feature(self):
        r = [0.0] * self.feature_dimensionality()
        if self.value:
            if self.value <= 6:
                r[0] = 1.0
            else:
                r[1] = 1.0
        return r

Now we also need some training stories, so that Rasa Core can learn from these how to handle the different situations:

# story1
...
* inform{"people": "3"}
  - action_book_table
...
# story2
* inform{"people": "9"}
  - action_explain_table_limit