Chatbots with Google Dialogflow

1Let a cloud service do the understanding

Your Python bots match words or similar sentences. A parent who writes "how much does my daughter in senior five pay?" shares few words with any training question, yet clearly wants the S5 fees. Google's Dialogflow uses a machine-learning model trained on huge amounts of language to recognise the intent behind varied wording, and pulls out the details, such as the class, as entities. You design the conversation in a web console; Google runs the understanding; and the finished agent can be placed on a website or a messaging app.

2Anatomy of an intent

The highlighted words in the training phrases are annotated as the entity @class. When a user writes "fees for senior five", the agent matches fees_for_class and fills the parameter class. If the user's message has no class, the required setting makes the agent ask the prompt and wait: this is called slot filling.

3Step by step: create, train and test an agent

1. Create the agent. Sign in to the Dialogflow ES console (dialogflow.cloud.google.com) with a Google account. Click Create agent, name it SchoolBot, choose English and the time zone (Africa/Kigali), and let it create a Google Cloud project. Two intents already exist: Default Welcome Intent and Default Fallback Intent.
2. Create a custom entity. Under Entities, create class with entries S1 to S6, each with synonyms such as "Senior 5", "S.5" and "senior five". Save.
3. Create intents. Under Intents, create fees_for_class. Add at least ten varied training phrases; Dialogflow annotates recognised entities automatically, and you can highlight a word to annotate it yourself. Mark class as required and write its prompt. Add text responses. Create further intents (term_dates, documents, visiting) the same way.
4. Train. Saving an intent starts training the agent automatically; a message shows when it has finished.
5. Test. Type into the Try it now panel on the right. It shows the matched intent, the extracted parameters and the response. Try phrasings that are not in your training phrases, and a message with no class.
6. Tune. When a test message reaches the wrong intent, add it (correctly annotated) to the right intent's training phrases. In the agent's settings, under ML Settings, the classification threshold sets how confident the match must be; below it, the fallback intent answers.

4Fulfillment: real answers from your own code

Fixed text responses are enough for fixed facts. To look something up, for example the exact fee for the class, switch on Enable webhook call for this intent and give Dialogflow the address of your web service under Fulfillment. Dialogflow then sends your service a JSON request containing the matched intent and parameters, and speaks whatever fulfillmentText your service returns. This webhook uses the small web framework Flask:

from flask import Flask, request, jsonify

app = Flask(__name__)
FEES = {"S4": 95000, "S5": 98000, "S6": 98000}     # Frw per term (illustrative)


@app.post("/webhook")
def webhook():
    body = request.get_json(silent=True) or {}
    result = body.get("queryResult", {})
    intent = result.get("intent", {}).get("displayName", "")
    params = result.get("parameters", {})

    if intent == "fees_for_class":
        cls = params.get("class", "")
        fee = FEES.get(cls)
        if fee is None:
            text = f"Sorry, I have no fee for {cls or 'that class'}. Please ask the bursar."
        else:
            text = f"The fee for {cls} is {fee:,} Frw per term."
    else:
        text = "Sorry, I cannot help with that yet."
    return jsonify({"fulfillmentText": text})


if __name__ == "__main__":
    app.run(port=8080)

It was tested with Flask's built-in test client, which sends the same JSON shape that Dialogflow ES sends:

from webhook import app

client = app.test_client()
for cls in ["S5", "S2"]:
    request_body = {"queryResult": {"queryText": f"How much is {cls}?",
                                    "parameters": {"class": cls},
                                    "intent": {"displayName": "fees_for_class"}}}
    print(client.post("/webhook", json=request_body).get_json())

{'fulfillmentText': 'The fee for S5 is 98,000 Frw per term.'}
{'fulfillmentText': 'Sorry, I have no fee for S2. Please ask the bursar.'}

To be used by Dialogflow, the webhook must run on a public HTTPS address, for example on a cloud host; a program on your own laptop is not reachable from Google's servers.

5Deploying the agent

Under Integrations, Dialogflow ES offers ready-made connections. The simplest are a Web Demo page with its own link, and Dialogflow Messenger, a chat window you paste into any web page, such as the WordPress site from unit 2 (in a Custom HTML block):

<script src="https://www.gstatic.com/dialogflow-console/fast/messenger/bootstrap.js?v=1"></script>
<df-messenger
  intent="WELCOME"
  chat-title="SchoolBot"
  agent-id="YOUR-AGENT-ID"
  language-code="en"
></df-messenger>

The console gives you this code with your real agent ID filled in. Other integrations connect the same agent to messaging apps such as Telegram. A Python program can also talk to the agent through the Dialogflow API; this sketch follows Google's client library, but it was not run here, because it needs a Google Cloud project and a service-account key:

# pip install google-cloud-dialogflow   (needs a Google Cloud project and credentials)
from google.cloud import dialogflow

def ask(project_id, session_id, text):
    client = dialogflow.SessionsClient()
    session = client.session_path(project_id, session_id)
    query = dialogflow.QueryInput(text=dialogflow.TextInput(text=text, language_code="en"))
    response = client.detect_intent(request={"session": session, "query_input": query})
    result = response.query_result
    return result.intent.display_name, result.intent_detection_confidence, result.fulfillment_text

6Hands-on: SchoolBot on Dialogflow

1. Create the agent, the class entity and four intents from the school office's list, each with at least ten training phrases and a required parameter where needed.
2. Edit the welcome and fallback responses so they say what the bot can do and how to reach a person.
3. Test 15 messages in Try it now, including 5 you did not train on. Record the matched intent and parameters for each in a table.
4. Fix every mismatch by adding training phrases, and test again.
5. Open the Web Demo or Dialogflow Messenger integration, and test the bot on a phone.
6. (Extension) Run the Flask webhook on a free cloud host with HTTPS, connect it under Fulfillment, and enable it for fees_for_class.

Check: at least 13 of your 15 test messages reach the right intent with the right parameters, and an off-topic question reaches the fallback.