# Tutorial: Building Assistants

After following the basics of setting up an assistant in the [Rasa Tutorial](/content/docs/rasa/user-guide/rasa-tutorial/index.html), we’ll now walk through building a basic FAQ chatbot and then build a bot that can handle contextual conversations.

## Building a simple FAQ assistant

FAQ assistants are the simplest assistants to build and a good place to get started. These assistants allow the user to ask a simple question and get a response. We’re going to build a basic FAQ assistant using features of Rasa designed specifically for this type of assistant.

In this section we’re going to cover the following topics:

- [Responding to simple intents](https://legacy-docs-v1.rasa.com/1.10.2/user-guide/building-assistants/respond-with-memoization-policy) with the MemoizationPolicy
- [Handling FAQs](https://legacy-docs-v1.rasa.com/1.10.2/user-guide/building-assistants/faqs-response-selector) using the ResponseSelector

To prepare for this tutorial, we’re going to create a new directory and start a new Rasa project.

```
mkdir rasa-assistant
rasa init
```

Let’s remove the default content from this bot, so that the `nlu.md`, `stories.md` and `domain.yml` files are empty.

### Memoization Policy

The MemoizationPolicy remembers examples from training stories for up to a `max_history` of turns. The number of “turns” includes messages the user sent, and actions the assistant performed. For the purpose of a simple, context-less FAQ bot, we only need to pay attention to the last message the user sent, and therefore we’ll set that to `1`.

You can do this by editing your `config.yml` file as follows:

```
policies:
- name: MemoizationPolicy
  max_history: 1
- name: MappingPolicy
```

Note

The MappingPolicy is there because it handles the logic of the `/restart` intent, which allows you to clear the conversation history and start fresh.

Now that we’ve defined our policies, we can add some stories for the `goodbye`, `thank` and `greet` intents to the `stories.md` file:

```
## greet
* greet
  - utter_greet

## thank
* thank
  - utter_noworries

## goodbye
* bye
  - utter_bye
```

We’ll also need to add the intents, actions and responses to our `domain.yml` file in the following sections:

```
intents:
  - greet
  - bye
  - thank

responses:
  utter_noworries:
    - text: No worries!
  utter_greet:
    - text: Hi
  utter_bye:
    - text: Bye!
```

Finally, we’ll copy over some NLU data from Sara into our `nlu.md` file:

```
## intent:greet
- Hi
- Hey
- Hi bot
- Hey bot
- Hello
- Good morning

## intent:bye
- goodbye
- goodnight

## intent:thank
- Thanks
- Thank you
```

You can now train a first model and test the bot, by running the following commands:

```
rasa train
rasa shell
```

This bot should now be able to reply to the intents we defined consistently, and in any order.

### Response Selectors

The [ResponseSelector](https://legacy-docs-v1.rasa.com/1.10.2/nlu/components/#response-selector) NLU component is designed to make it easier to handle dialogue elements like [Small Talk](https://legacy-docs-v1.rasa.com/1.10.2/dialogue-elements/small-talk/#small-talk) and FAQ messages in a simple manner. By using the ResponseSelector, you only need one story to handle all FAQs, instead of adding new stories every time you want to increase your bot’s scope.

People often ask Sara different questions surrounding the Rasa products, so let’s start with three intents: `ask_channels`, `ask_languages`, and `ask_rasax`.

## Handling unexpected user input

In this section we’ll go through various forms of “interjections” and how to handle them within Rasa.

The decision to handle these types of user input should always come from reviewing real conversations. You should first build part of your assistant, test it with real users and then add what’s missing.

#### Generic interjections

If you have generic interjections that should always have the same single response no matter the context, you can use the [Mapping Policy](https://legacy-docs-v1.rasa.com/1.10.2/core/policies/#mapping-policy) to handle these.

### Failing gracefully

Even if you design your bot perfectly, users will inevitably say things to your assistant that you did not anticipate. In these cases, your assistant will fail, and it’s important you ensure it does so gracefully.

#### TwoStageFallbackPolicy

One of the most common failures is low NLU confidence, which is handled nicely with the TwoStageFallbackPolicy. You can enable it by adding the following to your configuration file,

```
policies:
  - name: TwoStageFallbackPolicy
    nlu_threshold: 0.8
```

Going one step further, if you observe your users asking for certain things, that you’ll want to turn into a user goal in future, you can handle these as separate intents.