बिल्ड फ़ुलफ़िलमेंट (Dialogflow)

फ़ुलफ़िलमेंट, आपके Actions प्रोजेक्ट के लिए बातचीत वाला इंटरफ़ेस तय करता है. इससे उपयोगकर्ता का इनपुट मिलता है. साथ ही, इनपुट को प्रोसेस करने और कार्रवाई को पूरा करने के लिए लॉजिक भी तय होता है.

खास जानकारी

आपके ऑर्डर को पूरा करने के लिए, Assistant के अनुरोध मिलते हैं, वह अनुरोध को प्रोसेस करता है, और उसका जवाब देता है. लगातार अनुरोध करने और जवाब देने की यह प्रक्रिया बातचीत को तब तक आगे बढ़ाने में मदद करती है, जब तक आप उपयोगकर्ताओं के शुरुआती अनुरोध को पूरा नहीं कर लेते.

इस तरीके में बताया गया है कि Node.js या Java/Kotlin क्लाइंट लाइब्रेरी के साथ कार्रवाई SDK टूल का इस्तेमाल करके, फ़ुलफ़िलमेंट कैसे तैयार किया जा सकता है:

  1. ActionsSdkApp ऑब्जेक्ट शुरू करें.
  2. ऑर्डर पूरा करने के लिए इस्तेमाल किए जाने वाले लॉजिक में, अनुरोधों को मैनेज करने के लिए फ़ंक्शन बनाएं.

डायलॉग बनाना

ActionsSdkApp ऑब्जेक्ट को शुरू करें

यह कोड इंस्टैंशिएट करता है ActionsSdkApp साथ ही, Google Cloud Functions के लिए कुछ बॉयलरप्लेट Node.js सेट अप करता है:

ऐक्शन SDK (Node.js)
'use strict';

const {actionssdk} = require('actions-on-google');
const functions = require('firebase-functions');

const app = actionssdk({debug: true});

app.intent('actions.intent.MAIN', (conv) => {
  conv.ask('Hi!');
});

// More intent handling if needed
exports.myFunction = functions.https.onRequest(app);
ऐक्शन SDK टूल (Java)
ResponseBuilder responseBuilder = getResponseBuilder(request).add("Hi!");
return responseBuilder.build();
JSON
{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "inputPrompt": {
        "richInitialPrompt": {
          "items": [
            {
              "simpleResponse": {
                "textToSpeech": "Hi!"
              }
            }
          ]
        }
      },
      "possibleIntents": [
        {
          "intent": "actions.intent.TEXT"
        }
      ]
    }
  ],
  "conversationToken": "{\"data\":{}}",
  "userStorage": "{\"data\":{}}"
}

अनुरोधों को मैनेज करने के लिए फ़ंक्शन बनाना

जब उपयोगकर्ता कोई वाक्यांश बोलते हैं, तो आपको Google Assistant से एक अनुरोध मिलता है. अनुरोधों में आने वाले इंटेंट को पूरा करने के लिए, ट्रिगर किए गए इंटेंट को मैनेज करने वाले फ़ंक्शन बनाएं.

अनुरोधों को मैनेज करने के लिए:

  1. उपयोगकर्ता के इनपुट को प्रोसेस करने के लिए ज़रूरी सभी लॉजिक का इस्तेमाल करें.

  2. उस जवाब को पास करने वाले conv.ask() फ़ंक्शन को कॉल करें जिसे आप तर्क के रूप में दिखाना चाहते हैं.

यहां दिए गए कोड से, आसान जवाब तैयार करने का तरीका पता चलता है:

ऐक्शन SDK (Node.js)
conv.ask(`Hi! Say something, and I'll repeat it.`);
ऐक्शन SDK टूल (Java)
ResponseBuilder responseBuilder =
    getResponseBuilder(request).add("Hi! Say something, and I'll repeat it.");
return responseBuilder.build();
JSON
{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "inputPrompt": {
        "richInitialPrompt": {
          "items": [
            {
              "simpleResponse": {
                "textToSpeech": "Hi! Say something, and I'll repeat it."
              }
            }
          ]
        }
      },
      "possibleIntents": [
        {
          "intent": "actions.intent.TEXT"
        }
      ]
    }
  ],
  "conversationToken": "{\"data\":{}}",
  "userStorage": "{\"data\":{}}"
}

हैंडलिंग के इंटेंट

ट्रिगर किए गए इंटेंट को हैंडल करने के लिए सभी फ़ंक्शन उपलब्ध होने पर, इंटेंट के लिए हैंडलर असाइन करने के लिए app.intent का इस्तेमाल करें.

ऐक्शन SDK (Node.js)
app.intent('actions.intent.TEXT', (conv) => {
  // handle text intent.
});
app.intent('actions.intent.MAIN', (conv) => {
  // handle main intent.
});
ऐक्शन SDK टूल (Java)
@ForIntent("actions.intent.MAIN")
public ActionResponse main(ActionRequest request) {
  // handle main intent
  // ...
}

@ForIntent("actions.intent.TEXT")
public ActionResponse text(ActionRequest request) {
  // handle text intent
  // ...
}

बातचीत खत्म की जा रही है

अगर आपको इसके बदले में किसी उपयोगकर्ता का इनपुट नहीं चाहिए और आप बातचीत को खत्म करना चाहते हैं, तो conv.close() फ़ंक्शन को कॉल करें. इस फ़ंक्शन की मदद से, Google Assistant उपयोगकर्ता को टेक्स्ट पढ़कर सुनाती है और माइक्रोफ़ोन बंद करके बातचीत खत्म करती है.

मुख्य बातचीत के इंटेंट को मैनेज करना

जब उपयोगकर्ता app.intent.action.MAIN इंटेंट को ट्रिगर करते हैं, तो आम तौर पर आपको उपयोगकर्ता के इनपुट को प्रोसेस करने की ज़रूरत नहीं होती. अगर आपके सेट किए गए ऐक्शन पैकेज में कई कार्रवाइयां शामिल हैं और उसमें इस्तेमाल के कई उदाहरण शामिल हैं, तो बेहतर होगा कि आप उपयोगकर्ता को कुछ ऐसी चीज़ें बताएं जो वह कर सकता है.

  1. आपके जवाब को तर्क के तौर पर पास करने वाले conv.ask() फ़ंक्शन को कॉल करें. Google Assistant, उपयोगकर्ता से आपका जवाब देती है और तब तक इंतज़ार करती है, जब तक कि उपयोगकर्ता आपके बताए गए किसी एक इंटेंट को ट्रिगर नहीं करता.

नीचे दिए गए स्निपेट में, आसान वेलकम इंटेंट को मैनेज करने का तरीका बताया गया है:

ऐक्शन SDK (Node.js)
// handle the initialTrigger
function handleMainIntent(conv, input) {
  conv.ask(input);
}
ऐक्शन SDK टूल (Java)
private ActionResponse handleMainIntent(ResponseBuilder rb, String input) {
  return rb.add(input).build();
}

बातचीत की स्थिति

अगर बातचीत का एचटीटीपी/JSON वेबहुक एपीआई इस्तेमाल किया जा रहा है, तो JSON फ़ॉर्मैट वाले ऑब्जेक्ट (conversationToken) से अपनी बातचीत की स्थिति को मैनेज किया जा सकता है. यह ऑब्जेक्ट, Google Assistant और आपके बीच भेजा जाता है. अगर Node.js क्लाइंट लाइब्रेरी का इस्तेमाल किया जा रहा है, तो सीधे conv.data फ़ील्ड में जाकर, डेटा को उसमें मौजूद डेटा से पढ़ा जा सकता है. यह फ़ील्ड अनुरोधों और जवाबों के बीच अपने-आप आगे और पीछे हो जाता है.

ऐक्शन SDK (Node.js)
conv.data = {something: 10};
let value = conv.data.something;
ऐक्शन SDK टूल (Java)
ResponseBuilder rb = getResponseBuilder(request);
rb.getConversationData().put("something", 10);
Object value = rb.getConversationData().get("something");