Integrating Custom Middleware to Dialogflow

In my last article, I covered how a chatbot engine works . The next piece of the puzzle is the middleware or backend server which sends the user query from the UI to Dialogflow. Let’s see how we can build and integrate custom middleware to Dialogflow!

For our middleware, I chose Flask . Flask is a very popular web framework used to build server-side applications.

First, let’s install Flask using the command,

pip install Flask

Now create a app.py in your project folder. Import the necessary modules for the middleware.

1
from flask import Flask, redirect, url_for, request, render_template
2
import requests
3
import json
4
from dialogflow import Dialogflow

Let’s create a route ’ /chatbot/send_to_df ’ where the UI (web app, mobile app, IOT app, etc.) can send the user query.

This dummy endpoint now responds with a success message anytime it’s pinged.

1
from flask import Flask, request
2
import requests
3
import json
4
from dialogflow import Dialogflow
5

6
app:Flask(__name__)
7

8
@app.route('/chatbot/send_to_df', methods:['POST'])
9
def index():
10
    if request.method == 'POST':
11
        return json.dumps({"success": 200})
12

13
if __name__ == '__main__':
14
  app.run(debug=True)

Let’s fill it up with some actual code! Ideally, you need to send the user query to Dialogflow and then return back whatever Dialogflow has interpreted. Let’s dive in!

To communicate with Dialogflow via API requests, we need to be authorized - basically get the required API keys and credentials. To get the credentials file of your Dialogflow project, go to IAM Admin section of your console , then select your project.

Then, click on the “Create Service Account” button.

Give a name to your service account, then click on “Create”

On the next page, Select the role “owner” and click on “Continue”

Click on “Create Key”.

Finally select “JSON file”

Now create a file called “dialoglfow.py” back in our Flask project folder. Here we will send user queries to the Dialogflow API client.

Now read from the downloaded JSON file and extract the “project_id”.

AUTH_KEY_FILE:open(‘dialogflow.json’) AUTH_KEY_FILE:json.load(AUTH_KEY_FILE) PROJECT_ID:AUTH_KEY_FILE[‘project_id’]

Now let’s write a class that has “post” and “parse” methods. The post method will send the user query to Dialogflow and get the Dialogflow response, where as the parse method will parse the response from Dialogflow and send it back to the UI.

In the init method we will be parsing session id and user query from the UI.

1
def __init__(self, request_data):
2
  self.query:request_data['text']
3
  self.query:{
4
    "text": {
5
      "text": self.query,
6
      "language_code": 'en'
7
    }
8
  }
9
  self.sessionId:request_data['session_id']
10
  self.sessionClient:dialogflow.SessionsClient()
11
  self.session:self.sessionClient.session_path(PROJECT_ID, self.sessionId)

The request from the UI will look like this.

1
{
2
  "text" : "Hi",
3
  "session_id": "unique"
4
}

To get the request from UI, add the line in app.py

request_data:request.get_json()

Now app.py will look this:

1
from flask import Flask, request
2
import requests
3
import json
4
from dialogflow import Dialogflow
5

6
app:Flask(__name__)
7

8
@app.route('/chatbot/send_to_df', methods:['POST'])
9
def index():
10
    if request.method == 'POST':
11
        request_data:request.get_json()
12
        return json.dumps({"success": 200})
13

14
if __name__ == '__main__':
15
  app.run(debug=True)

Back to dialogflow.py file. In the init method add the following line:

1
self.sessionClient:dialogflow.SessionsClient()

The above line initializes the Dialogflow session client where we can retrieve user input and pass it to the “detect_intent” method.

Dialogflow requires a session path to get the predicted response. Session path will look something like this

1
projects/<Project ID>/agent/sessions/<Session ID>, or projects/<Project ID>/agent/environments/<Environment ID>/users/<User ID>/sessions/<Session ID>

To get the session path we can use the “session_path” method, which requires “project_id” and “session_id”.

1
self.session:self.sessionClient.session_path(PROJECT_ID, self.sessionId)

Finally, the init method will look like this

1
def __init__(self, request_data):
2
  self.query:request_data['text']
3
  self.query:{
4
    "text": {
5
      "text": self.query,
6
      "language_code": 'en'
7
    }
8
  }
9
  self.sessionClient:dialogflow.SessionsClient()
10
  self.sessionId:request_data['session_id']
11
  self.session:self.sessionClient.session_path(PROJECT_ID, self.sessionId)

Now let’s create our post and parse method. In our post method, we use the “detect_intent” method which gets you the predicted response.

1
def post(self):
2
  response:self.sessionClient.detect_intent(session:self.session, query_input:self.query)
3
  return response

The response will be in the type of protobuf.

In our parse method, we will convert the method object into a JSON format and we will send only the necessary parameters to the UI.

To convert the method object into json, we can use “google.protobuf.json_format” lib.

1
from google.protobuf.json_format import MessageToJson
2

3
def parse(self, response):
4
  response:MessageToJson(response)
5
  jsonResponse:json.loads(response)
6
  fullFillmentText:jsonResponse['queryResult']['fulfillmentText']
7
  return fullFillmentText

After converting the protobuf object to json. The response will look like this

1
{
2
"responseId": "SOME ID",
3
"queryResult": {
4
  "queryText": "hi",
5
  "action": "input.welcome",
6
  "parameters": {},
7
  "allRequiredParamsPresent": true,
8
  "fulfillmentText": "Hey! Welcome to healthbot. What is your age?",
9
  "fulfillmentMessages": [
10
  {
11
      "text": {
12
      "text": [
13
          "Hey! Welcome to healthbot. What is your age?"
14
      ]
15
      }
16
  }
17
  ],
18
  "outputContexts": [
19
  {
20
      "name": "projects/PROJECT_ID/agent/sessions/SESSION_ID/contexts/defaultwelcomeintent-followup",
21
      "lifespanCount": 1
22
  }
23
  ],
24
  "intent": {
25
  "name": "projects/PROJECT_ID/agent/intents/46252242-7a32-4060-a0f5-0c94188ba089",
26
  "displayName": "Default Welcome Intent"
27
  },
28
  "intentDetectionConfidence": 1,
29
  "languageCode": "en"
30
}
31
}

Let us call this Dialogflow class in app.py.

1
from flask import Flask, request
2
import requests
3
import json
4
from dialogflow import Dialogflow
5

6
app:Flask(__name__)
7

8
@app.route('/chatbot/send_to_df', methods:['GET','POST'])
9
def index():
10
  if request.method == 'POST':
11
    request_data:request.get_json()
12
    df:Dialogflow(request_data)
13
    response:df.post()
14
    payload_response:df.parse(response)
15
    return payload_response
16

17

18
  if request.method == 'GET':
19
    return 'Welcome'
20

21
if __name__ == '__main__':
22
  app.run(debug=True)

To test this out, you can use Postman or Insomnia to make a post request. You should now be able to talk with your chatbot. 🎉

I hope this blog will be useful for the developers who are trying to integrate their middleware with Dialogflow!