Compatibilité avec plusieurs langues avec Google Traduction

Les paramètres régionaux de Business Messages et la traduction intelligente et automatisée de Google Traduction vous permettent d'élargir la portée de votre agent en communiquant avec les utilisateurs dans leur langue préférée. Ce tutoriel décrit l'intégration de la démonstration de faisabilité de Google Traduction avec un webhook Business Messages.

Ce dont vous avez besoin

Pour commencer, vous avez besoin des éléments suivants:

Obtenir le code

Ce tutoriel vous présente un exemple de code webhook qui s'intègre à Google Traduction. Pour obtenir le code, clonez le dépôt à partir de GitHub:

git clone https://github.com/google-business-communications/bm-nodejs-translation-tutorial

Accédez au répertoire cloné et placez votre clé de compte de service dans le répertoire des ressources:

cp credentials.json bm-nodejs-translation-sample/resources/bm-agent-service-account-credentials.json

CONSEIL: Si vous avez besoin d'aide pour configurer ou télécharger votre clé de service, consultez le guide Google Cloud pour la gestion des comptes de service.

Une fois cela fait, vous pouvez déployer le code:

gcloud app deploy

Envoyez des messages à l'agent depuis votre appareil mobile. Essayez d'envoyer vos messages dans différentes langues pour voir ce qu'il se passe.

Configurer l'API Translate

L'exemple de code est fourni avec le package Node pour l'API Translate. Si vous souhaitez installer le package Node ou l'API Translate dans un autre langage de programmation, consultez la documentation de l'API Cloud Translate.

Pour utiliser l'API Translate, vous devez importer la bibliothèque et créer un client API Translate. Ouvrez le fichier routes/index.js. Les lignes pertinentes sont les suivantes:

// Import the Translate API library.
const { Translate } = require("@google-cloud/translate").v2;
// Create a new Translate API client.
const translate = new Translate();

Vous pouvez désormais accéder aux méthodes de l'API Translate sur l'objet de traduction.

Examinez les variables créées en haut du fichier:

const SERVER_LANGUAGE = "en";
let currentLanguage = SERVER_LANGUAGE;

L'exemple de code stocke le langage du serveur en tant que constante, car il est relativement fixe. Toutefois, la langue actuelle de la conversation peut changer, c'est pourquoi elle est suivie dans la variable currentLanguage.

Détecter la langue entrante

L'exemple de code détecte si la langue entrante a changé et, le cas échéant, invite l'utilisateur à choisir la langue qu'il souhaite utiliser dans la conversation. Testez cette fonctionnalité sur votre appareil mobile en saisissant un message dans l'agent dans une langue autre que l'anglais. Si vous ne parlez aucune autre langue, essayez de saisir "Hola" (c'est l'espagnol pour le terme "Bonjour").

L'agent répond par une invite demandant si l'utilisateur souhaite changer de langue. L'invite inclut des réponses suggérées sur lesquelles l'utilisateur peut cliquer pour changer de langue.

Commençons par examiner la fonctionnalité de détection de la langue.

/**
 * Detects input text language.
 *
 * @param {string} text The text received from the consumer.
 * @param {Context} context The user message request context.
 * @return A Promise with the detected language code.
 */
async function detectLanguage(text, context) {
  return new Promise(function (resolve, reject) {
    translate
      .detect(text)
      .then((result) => {
        if (result && result.length > 0) {
          if (result[0].confidence > CONFIDENCE_THRESHOLD) {
            resolve(result[0].language);
          }
          resolve(bcp47.parse(context.resolvedLocale).language);
        } else {
          reject("No language detected");
        }
      })
      .catch((err) => {
        console.error("ERROR:", err);
        reject(err);
      });
  });
}

Cette méthode utilise la méthode de détection du client de traduction. Étant donné que l'API Translate peut détecter plusieurs langues avec différents niveaux de confiance (et aussi parce qu'elle accepte plusieurs entrées), cette méthode renvoie un tableau de résultats. L'échantillon prend le premier résultat, celui qui présente le niveau de confiance le plus élevé.

Utilisation des paramètres régionaux résolus

Parfois, l'API Translate ne peut pas déterminer la langue du message avec un niveau de confiance élevé. Par exemple, si votre chat passe sur votre clavier et saisit une chaîne illisible, l'API Translate tente toujours de détecter la langue, mais celle-ci est probablement incorrecte. Après tout, Google Traduction n'est pas encore compatible avec les langues félines. Pour ce faire, l'API Translate définit une valeur de confiance faible dans le résultat de translate.detect.

Dans ce scénario, l'exemple de code utilise la langue des paramètres régionaux de Business Messages, qui correspond à la meilleure estimation de la langue de l'API Business Messages en fonction du contexte du message. Les paramètres régionaux résolus sont au format BCP-47. Vous pouvez donc utiliser le package Node.js correspondant pour analyser le code de langue des paramètres régionaux.

Vous pouvez tester ce comportement en saisissant une longue chaîne vide de sens dans l'agent. Dans la plupart des cas, vous ne devriez pas être invité à modifier la langue (sauf si les paramètres régionaux résolus sont différents de la langue actuelle). L'agent dit simplement qu'il ne comprend pas votre requête.

Demander à changer de langue

Après avoir détecté que la langue a changé, l'agent renvoie une invite pour en changer.

if (detectedLanguage != currentLanguage) {
        translateText(
          "Which language would you like to use?",
          SERVER_LANGUAGE,
          currentLanguage
        ).then((normalizedTranslationNotice) => {
          sendResponse(
            normalizedTranslationNotice,
            conversationId,
            [
              ...new Set([detectedLanguage, currentLanguage, SERVER_LANGUAGE]),
            ].map((x) => createSuggestedReply(x))
          );
        });
      }

Le code crée une invite, la traduit dans la langue actuelle (voir la section sur la traduction des messages sortants), puis envoie une réponse avec des réponses suggérées. L'utilisateur peut souhaiter parler dans l'une des langues suivantes:

  • Langue entrante détectée.
  • Langue de la conversation actuelle.
  • Langue intégrée du serveur.

Étant donné que ces trois langues peuvent se chevaucher (par exemple, si la langue actuelle est déjà celle du serveur), le serveur utilise un objet défini pour supprimer les doublons. Elle propose ensuite une suggestion de réponse pour chaque langue:

/**
 * Create a suggested reply for a language code.
 * @param {string} languageCode A ISO 6391 language code.
 * @return {Suggestion} The suggestion object for switching to the language.
 */
function createSuggestedReply(languageCode) {
  return {
    reply: {
      text: ISO6391.getNativeName(languageCode),
      postbackData: SWITCH_LANGUAGE_POSTBACK + languageCode,
    },
  };
}

La suggestion de réponse affiche le nom de la langue dans sa propre langue. Par exemple, si vous utilisez l'espagnol "Español"." Pour obtenir des informations sur une langue à partir de son code de langue à deux chiffres, vous pouvez utiliser la bibliothèque ISO-639-1 pour Node.js.

Notez les données de postback, qui sont envoyées au serveur lorsque l'utilisateur clique sur cette suggestion. Les données de postback indiquent au serveur comment répondre et fournissent du contexte sur la suggestion.

La méthode sendResponse associe ces objets de suggestion à la réponse:

let messageObject = {
    …
    suggestions: suggestedReplies,
  };

Modification de la langue de la conversation

Revenez maintenant à votre appareil mobile et essayez de cliquer sur une nouvelle option de langue dans l'invite décrite précédemment. Par exemple, si vous avez saisi "Hola", essayez de cliquer sur "Español" dans les réponses suggérées.

L'agent répond dans la nouvelle langue. Nous verrons comment traduire les réponses sortantes dans une prochaine étape. Pour l'instant, examinez le code qui reçoit et traite la réponse suggérée sur laquelle vous avez cliqué.

if (requestBody.suggestionResponse !== undefined) {
    let postbackData = requestBody.suggestionResponse.postbackData;
    if (postbackData.startsWith(SWITCH_LANGUAGE_POSTBACK)) {
      let languageCode = postbackData.substr(SWITCH_LANGUAGE_POSTBACK.length);
      currentLanguage = languageCode;
      translateText(
        "The language was set to " +
          ISO6391.getName(languageCode) +
          ". Please repeat your request.",
        SERVER_LANGUAGE,
        languageCode
      ).then((translationNotice) => {
        sendResponse(translationNotice, conversationId, []);
      });
    }
  }

Si la requête contient une réponse à une suggestion, le serveur utilise les données de postback pour déterminer la procédure à suivre. Dans ce cas simple, le serveur n'accepte qu'un seul type de données de postback, SWITCH_LANGUAGE_POSTBACK, qui signifie que la conversation doit être remplacée par la langue dans le code de langue suivant. Après avoir analysé ce code de langue, le serveur envoie un message pour avertir l'utilisateur que la langue a changé.

Traduction des messages entrants

Maintenant que la langue a été modifiée, vous pouvez envoyer une requête à l'agent dans cette langue depuis votre appareil mobile. Essayez d'envoyer le mot "aide" dans la nouvelle langue. Si vous êtes passé à l'espagnol, saisissez "ayuda&ay" et envoyez le message.

Le serveur comprend votre demande d'aide et répond via le menu d'options. Essayez l'un de ces exemples pour voir un exemple de réponse codé en dur.

L'exemple de code utilise la méthode translateText pour traduire les messages entrants et sortants. Regardez-le dès maintenant:

/**
 * Translates text to a given target language. No translation if source and
 * target language match.
 *
 * @param {string} text the text to translate
 * @param {string} sourceLanguage The language of the source text.
 * @param {string} targetLanguage The target language.
 * @return A Promise with the translated text.
 */
async function translateText(text, sourceLanguage, targetLanguage) {
  if (sourceLanguage === targetLanguage) {
    return new Promise(function (resolve, reject) {
      resolve(text);
    });
  }
  return new Promise(function (resolve, reject) {
    translate
      .translate(text, targetLanguage)
      .then((result) => {
        if (result && result.length > 0) {
          resolve(result[0]);
        } else {
          reject("Could not translate message");
        }
      })
      .catch((err) => {
        console.error("ERROR:", err);
        reject(err);
      });
  });
}

Si la langue source est identique à la langue cible, vous n'avez rien à faire. Sinon, le serveur appelle la méthode de traduction du client API Translate. Tout comme la méthode de détection, la méthode de traduction peut accepter plusieurs entrées. Étant donné que le serveur ne fournit qu'une seule entrée, il extrait le premier résultat de l'API Translate.

Examinez la section de la méthode de rappel qui répond aux messages entrants dans la langue actuelle:

translateText(incomingMessage, currentLanguage, SERVER_LANGUAGE).then(
          (normalizedMessage) => {
            let serverResponse = chooseResponseMessage(normalizedMessage);
            …
          }
        );

Le serveur utilise la sortie de translateText pour choisir un message de réponse. La section suivante présente le processus de sélection du message de réponse et sa traduction.

Traduction des messages sortants

Une fois que le serveur a traduit votre message entrant en anglais natif, il doit choisir, traduire et envoyer une réponse appropriée à la requête de l'utilisateur. L'exemple de code utilise un schéma très simple qui met en correspondance les mots clés et les réponses. Examinez la méthode chooseResponseMessage.

/**
 * Select a topically appropriate response based on the message
 * content that the user sent to the agent.
 *
 * @param {string} incomingMessage The content of the message that the user typed in.
 * @param {string} conversationId The unique id for this user and agent.
 * @return {string} A response message.
 */
function chooseResponseMessage(incomingMessage) {
  let responseMapping = {
    balance: "Your current balance is $500.",
    deposit: "Please enter your deposit amount.",
    transfer:
      "Please enter the account number where you wish to transfer the funds.",
    withdraw: "Please enter the amount you wish to withdraw.",
    help: "Please choose what you'd like to do: balance, deposit, transfer, or withdraw.",
  };

  for (const [key, value] of Object.entries(responseMapping)) {
    if (incomingMessage.toLowerCase().includes(key)) {
      return value;
    }
  }

  return "I didn't understand your request. Please try again.";
}

Ce schéma n'accepte que l'anglais sur le serveur, ce qui signifie que le serveur doit traduire tous les messages entrants et sortants. Un système plus sophistiqué peut accepter plusieurs langues et répondre de manière native aux requêtes dans d'autres langues. Par exemple, si votre agent est disponible en espagnol, il se peut qu'il contienne déjà une clé pour "ayuda" dans la carte de réponse. Des systèmes plus sophistiqués peuvent également s'appuyer sur d'autres méthodologies pour choisir une réponse appropriée, comme le ML ou des algorithmes d'évaluation. Pour créer des réponses plus intelligentes avec Business Messages, vous pouvez intégrer Dialogflow.

Examinez à présent le code qui renvoie le message choisi à l'utilisateur.

let serverResponse = chooseResponseMessage(normalizedMessage);
            translateText(
              serverResponse,
              SERVER_LANGUAGE,
              currentLanguage
            ).then((normalizedResponse) => {
              sendResponse(normalizedResponse, conversationId, []);
            });

L'exemple de code réutilise la méthode translateText pour traduire la réponse choisie dans le langage courant de la conversation. La méthode sendResponse se charge ensuite de créer l'objet Message et de l'envoyer à l'utilisateur.

Synthèse

Dans ce tutoriel, vous avez appris à créer une intégration simple avec l'API Cloud Translate et à utiliser les fonctionnalités régionales de Business Messages pour toucher plus d'utilisateurs. Si vous le souhaitez, vous pouvez utiliser l'exemple de code de ce tutoriel comme point de départ de votre propre intégration ou essayer quelque chose de nouveau. Voici quelques idées :

  • Envoyez des messages bilingues qui incluent à la fois le contenu du message d'origine et le contenu traduit automatiquement.
  • Présenter à l'utilisateur un menu complet des langues compatibles lorsqu'il démarre une conversation.
  • Utilisez des fonctionnalités avancées de l'API Translate, telles que des glossaires, pour traduire des mots spécifiques à votre activité de manière fiable.

En intégrant les API Translate, vous bénéficiez d'une traduction automatique de haute qualité pour communiquer avec davantage d'utilisateurs dans leur langage de prédilection. Votre agent peut avoir des conversations plus productives et efficaces, ce qui augmente la satisfaction des clients et la réalisation des tâches.