Prolog and Patterns

Greeting pattern without self-identification

We shall start by considering what a typical greeting pattern looks like. When the agent does not introduce itself, a very common greeting pattern could like look this:

Example:

In this example conversation, we see that agent A greets the user, and user U greets the agent in return. We will now try to capture this pattern using the intent we just defined in Dialogflow.

To capture the example pattern, we will use the Prolog predicate pattern([PatternID | Sequence]). Note that this predicate only takes a single list argument, but this list should always have the same structure: the first item in the list should be a PatternID or name of the pattern, followed by a sequence of dialog moves or actor-intent pairs (more on this below).

The first thing we thus always need to come up with when defining a pattern/1 fact is to specify a pattern identification code (ID). For this purpose, we use a systematic taxonomy of patterns with codes for patterns as specified in the book Conversational UX Design: A Practitioner’s Guide to the Natural by Robert J. Moore and Raphael Arar. Greetings are classified as opening patterns by Moore and Arar. A minimal greeting such as in our example is classified as C1.0 in their taxonomy. In our code, we like to avoid the use of capitals and dots too, and we will simply write c10 in our code to refer to this greeting pattern.

The second part of the list we need to add as an argument when creating a pattern/1 fact consists of the sequence of dialog moves the pattern itself consists of. A dialog move has two parts: first, we need to specify who makes the move (in our case, the agent or the user); second, we need to specify the type of move made by either actor. As we will classify what agents and users say as intents, we will use intent labels for representing dialog move types. A dialog move then can be represented as a two-element list [Actor, Intent], where the first element Actor is the dialog actor doing the talking (either the user or the agent) and the second element Intent is the intent representing the dialog move type. The first move in our greeting pattern example above thus can be represented by [agent, greeting] and the second move by [user, greeting]. Combining this with the pattern ID c10, the simple and most basic greeting pattern of our example can be represented by the following fact:

As mentioned above, this greeting pattern should be used if the agent does not introduce itself by its name. If the agent has a name, we would like the agent to introduce itself. To differentiate between these two cases, we will add a condition to our c10 pattern fact which indicates that it should only be used when the agent has no name (which we will identify with the basic fact agentName(''), i.e. when the empty string is associated with the agent’s name). We then obtain the following complete rule for our basic non-self-identifying greeting pattern:

You should add this Prolog rule to the patterns.pl file.

Specifying the agent’s greeting

In the Prolog file responses.pl, we determine what exactly the agent will say to initiate a move in the conversation or how it will respond to something a user said. The basic idea is to add natural language phrases, sentences, or text for each type of move the agent can make. In other words, we need to specify phrases for all the intent labels that occur in dialog moves in all patterns that are made by the agent. If there is no phrase specified at all for one of the agent’s possible dialog moves, the agent will not be able to perform that move…!

We will use the predicate text(Intent, Text) to specify how the agent will greet a user. The first argument Intent of the text/2 predicate should be instantiated with an intent label in a dialog move of the agent, and the second argument Text should be a string with the text you want your agent to say. For the greeting intent we thus need to specify at least one phrase by adding a text(greeting, "YOUR PHRASE HERE") fact to the responses.pl file. Now add such a text/2 fact for the intent label greeting under the % Intent: greeting comment.

Hear your agent say its first words

Greeting with self-identification

You and your team should think of a name for your agent. Feel free to be creative. We need to tell our agent its name somewhere. In dialog_init.mod2g, on line 40 you can add the name you came up with for your agent. Change the empty string in insert(agentName(''), for example, to insert(agentName('Bellabot'). Now your agent has a name, we would also like the agent to self-identify and be able to use the following greeting pattern:

Pattern C1.1: Opening Self-Identification (Agent)

Example:

* insert your agent’s name here

This pattern is quite similar to the C1.0 pattern above but consists of one more dialog move made by the agent. The second dialog move that is new in the C1.1 pattern we call a self-identification move. We suggest that you use the intent label ​​selfIdentification for this agent move. Although Moore’s classification has it that this pattern is a c11, the difference with the c10 pattern is small and can be handled easier by our dialog manager agent if we use the same c10 label again for this only slightly different pattern. You should now be able to add another c10 pattern to the patterns.pl file which adds the self-identification move of the agent as an additional actor-intent pair. Of course, for this pattern to be selected, we should add the condition (as we did before above but now) that the agent has a name: not(agentName('')).

Specifying the agent’s self-identification

We still need to specify at least one phrase for the agent’s selfIdentification intent. We can do this by simply copying the agent’s name we inserted in dialog_init.mod2g but a more generic approach is to use the agentName(Name) query to retrieve this name from the agent’s database. This approach will also show you how you can use facts stored in the agent’s database to create text responses for an intent. The basic idea is to introduce a rule text(selfIdentification, Txt) instead of a simple text(selfIdentification, "SOME PHRASE") fact. For the body of this Prolog rule, you need to specify a query that concatenates two strings: A string such as “My name is” and a string of the agent’s name. To specify this query, the string_concat/3 predicate will be useful. Add the rule under the comment % Intent: self-identification in the responses.pl file.

Visuals

Welcoming page

When a user has visited the Start page and clicked on the Start button, your agent should start by greeting its user. But we would also like to show a webpage that welcomes the user and is shown while the greeting pattern c10 is active and ongoing. Additionally, the new page provides the user with the ability to start talking by clicking on the microphone icon.

Whether you followed our suggestions above or not, make sure your welcoming page looks inviting!

See Visuals and Visual Requirements for more information.

Run It!

Make sure you have added the c10 pattern to the agent’s agenda in the dialog_init.mod2g file.

Test: Greet your agent

Test your agent by launching your MARBEL agent in Debug mode. When you run your conversational agent, you should:

• hit your Start page,

• be able to press the Start button,

• and after you do so, your agent should introduce itself;

• then you should be able to unmute yourself by clicking the microphone icon in the top left corner,

• give Google Chrome permission to use your microphone (only needed once every time you restart the browser when you launch the SIC server), and

• return the greeting, by saying hello or anything else you come up with that sounds like a greeting.

Check whether your Dialogflow agent understood what you said and classified what you said as a greeting intent by inspecting the terminal in which you ran run-dialogflow.

Open

Also, pause the MARBEL agent and inspect the session/1 fact. You see that the greeting pattern has been completed and a new empty sequence has been added at the head of the session history (list).

Test: Respond with something different than a greeting

Terminate the MARBEL agent and restart it in Debug mode again. Repeat the interaction but this time, when it is your turn to speak, say something that is not remotely close to a greeting instead. Check out the terminal again to see how Dialogflow classified what you said. Pause the MARBEL agent and again inspect the session/1 fact. What is different, and what is the same? To understand what happened, check out the Session updating part at the top of the dialog_update.mod2g file.