DialogFlow and Filter Instructions

Make sure your naming is precisely the same for intents and entities as the ones given or you will run into issues later on! 

Greeting Intent

Make an intent called ‘greeting’. Under ‘Training Phrases’ add a number of expressions (at least 10) by which a user may greet - try and be thorough. Under ‘Action and parameters’ make sure the box above the table is filled in with the name of your intent as shown in the image below.

Appreciation, Confirmation, Disconfirmation, Farewell Intents

Add the following intents, following the same procedure as you did for the ‘greeting’ intent and using the same intent names as specified:

1. appreciation

   1. If a user expresses appreciation or gratitude (for example: ‘thanks’).

2. confirmation

   1. If a user wants to agree or say ‘yes’.

3. disconfirmation

   1. If a user wants to disagree or say ‘no’.

4. farewell

   1. If a user wants to say 'goodbye'.

5. checkCapability

   1. the intent that represents a user querying what your agent can do. An example would be “What can you do?”.

Fallback Intent

The Default fallback intent is one of the more important intents and it is already present when creating your Dialogflow agent. Fallback intents are triggered if a user's input is not matched by any of the other intents known by the agent, or if it matches the training phrases you input.

It is unnecessary to input phrases that are completely unrelated to the topic, as that would definitely come back as an unknown intent. Thus, what you should do is think of related phrases that would be close to an intent but should not match it. For example, one could argue “I do not like mushrooms” is food related and has an ingredient entity inside. Yet, it should not be matched to any other intent, because likes and dislikes are not directly discussed with your bot. Of course, one could argue you could include ‘I like’ and ‘I dislike’ as training phrases for filtering by something - that is a design decision for you to make. This fallback intent should be updated as you add more intents throughout the project. 

Entities

Before you can continue creating intents, you have to create the entities you need, since these will be part of the intent specification for certain entities (e.g.: the presence of an entity type is used as a feature by the Dialogflow classifier model to recognize certain intents by). Some of these entities are already given to you. For information on how to upload and create entities, you should have read this page: DialogFlow: Create an Agent, Intents and Entities

Some entities were not provided by us, and you have to add them yourself (see the list below). We provide an example for most to make sure you have at least a few entries for each entity. They may not be that intuitive at first, so make sure to extend the entity specification with more synonyms as your agent evolves. If the word you enter has synonyms, use the synonym option rather than entering them as multiple entity inputs.

1. removekeyword - words to remove filters (for example ‘remove’)

2. timeKeyWord - words that refer to measurements of time(hour, minutes, etc.)

3. shortTimeKeyWord - for example ‘fast’, ‘quick’ etc.

4. negationKeyword - to specify that something needs to be omitted (for example ‘without’ or ‘don’t’)

5. easyKeyWord - to specify recipes that are not hard to make (for example ‘simple’)

When you are done your entities page should look as follows:

Add Filter Intent

Add filter intent is one of the most important intents. It is used to filter recipes for the user based on a variety of criteria. This is the first intent that employs all the entities we have created. In the user expressions, where the user is asking to filter, all different entities need to occur and be tagged in the set of examples. For example, for a training phrase like “I want a Chinese recipe”, ‘Chinese' needs to be tagged as ‘cuisine’, so this phrase can be parsed by Dialogflow in order to apply the filter Chinese to the recipes in our database. The addFilter intent can be found in the folder provided to you, and should be uploaded in Dialogflow by you.

Recipe Filtering Functions Helper Functions

To filter the recipes for the user in the way they intend, we parse their utterances with the intents and entities we made in Dialogflow. This then returns the identified intent (for example ‘addFilter’) and entity information (cuisine - ‘Chinese’). We must now take this information and create Prolog rules to access and gather the filtered recipes. This is done via the following functions. The heads of all rules can be seen in recipe_selection.pl and that is where the bodies should be added. We need a few helper functions before we can start filtering these, which are described below.

nrOfIngredients 

We will start off easy. 

nrOfIngredients(RecipeID, N) :-

Create a rule to return N, the length of the list of ingredients for a certain RecipeID. HINT: your Visual  Support groupmates should have made an ingredients function that could help. 

nrSteps 

nrSteps(RecipeID, N) :-

Create a rule to return N, the number of steps for a certain RecipeID. HINT: your groupmates should have made a recipeSteps function that could help. 

diet

diet(RecipeID, DietaryRestriction) :-

In the diet rule, we need to find all the ingredients that a certain recipe has and then input them into a new function we shall create below diet, called ‘ingredientsMeetDiet’. This function should return a list of ingredients that fit the dietary restriction. This list should be returned with the name DietaryRestriction.

ingredientsMeetDiet([ Ingredient | Rest ], DietaryRestriction) :-

The ingredientsMeetDiet predicate is our stop clause, which will recursively check each ingredient and return ‘false’ when an ingredient does not meet the given dietary restriction. The predicate ‘typeIngredient’ can be used to check if an ingredient meets a dietary restriction. Fill in the body of the rule for ingredientsMeetDiet. 

easyRecipe

easyRecipe(RecipeID) :-

Make a rule that can return all easy recipes. 

 A recipe is easy when:

• it can be made within 45 minutes, 

• it has less than 18 steps, and

• it has less than 15 ingredients

Recipe Filtering Functions

These functions filter our recipes and return a list of filtered recipes in the form of their RecipeIDs. The heads of the rules are in the recipe_selection.pl file. 

There are different variants that you need to implement of the ‘applyFilter’ rule, depending on the filter that needs to be applied - filtering for cuisine asks for a different function than filtering for duration. These variants are specified in the table below.

applyFilter

applyFilter(+ParamName, +Value, +RecipeIDs, -FilteredRecipes)

Filters the recipes provided as input using the (Key) feature with associated value and returns the recipes that satisfy the feature as output.

• ParamName: A parameter name referring to a feature that the recipes should have (for example: ’cuisine’).

• Value: The associated value of the recipe feature (for example: ‘Chinese’).

• RecipeIDs: The recipes that need to be filtered.

• FilteredRecipes: The recipes that have the required feature.

Thus, you must find all recipes that fit the filter criteria and return a list of the filtered recipes. Make sure to use the naming conventions for the variables that we provided. For the first two functions, we shall provide some hints. These hints could apply to more than one ‘applyFilter’ rule. The heads can be found in recipe_selection.pl.

A list of all your ‘applyFilter’ functions and some notes on how to create them:

Further Necessary Intents

deleteFilterValue 

‘deleteFilterValue’ is useful to deal with a scenario where the user requests to remove a filter that they have already put on specifically. For example, “I wish to remove the onion filter”, “Forget about excluding broccoli”, and “Can you delete the Chinese cuisine”. 

It is thus important that in your training phrases you include a variety of entities and that these entities are also given specific values and parameter names in the Action and Parameters tables. Your entity table under Action and Parameters should look like this when you are done. 

deleteParameter 

The ‘deleteParameter’ intent is identified when the user requests to remove a kind of constraint. For example, “I wish to remove the ingredient constraint”, and “Please drop the step constraint”. This intent requires the use of a certain entity. Make sure to include it in your action and parameters section. 

noMoreFilters 

The ‘noMoreFilters’ intent is used when the user does not want to add any more filters to their recipes list and wishes to see the available recipes. 

recipeRequest

‘recipeRequest’ is used to confirm the user's choice of recipes (“I want this specific recipe name here”). Under Entities, you can find an entity for the recipe names in our database.

In the end, your Intent page should look like this:

This marks the end of the basic implementation of the Natural Language Understanding of your agent. Make sure to properly test each intent, entity and rule that you have implemented (further detailed in the System testing section).