Compatibilité avec plusieurs langues avec Google Traduction

Grâce aux paramètres régionaux de Business Messages et à la fonctionnalité intelligente et automatisée de Google Traduction, vous pouvez étendre la portée de votre agent en communiquant avec les utilisateurs dans la langue qu'ils préfèrent. Ce tutoriel présente une démonstration de faisabilité l'intégration de Google Traduction à un webhook Business Messages.

Prérequis

Pour commencer, vous devez préparer les éléments suivants:

Obtenir le code

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

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

Accédez au répertoire cloné et placez la clé de votre compte de service dans le répertoire "resources" :

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 la Guide Google Cloud sur la gestion des comptes de service

Une fois cette opération effectuée, vous pouvez déployer le code:

gcloud app deploy

À l'aide de votre appareil mobile, envoyez des messages à l'agent. Essayez d'envoyer votre messages dans différentes langues et voyez ce qui se passe.

Configurer l'API Translate

L'exemple de code est fourni avec le package Node pour l'API Translate installés. Si vous souhaitez savoir comment installer le package Node ou comment installer l'API Translate dans un autre langage de programmation, consultez la Documentation sur l'API Cloud Translate

Pour utiliser l'API Translate, vous devez importer la bibliothèque et créer un service Translate client API. Ouvrez le fichier routes/index.js. Les lignes concernées 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();

À partir de maintenant, vous pouvez accéder aux méthodes de l'API Translate au niveau de l'objet Translate.

Examinez les variables créées vers le 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 ou corriger un problème. Cependant, la langue actuelle de la conversation peut changer. Elle fait donc l'objet d'un suivi. 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. Essayez cette fonctionnalité sur votre appareil mobile en saisissant un message à l'intention de l'agent dans une autre langue que l'anglais. Si vous ne connaissez pas d'autres langues, essayez de saisir du texte "Bonjour" (c'est-à-dire "Hello" en espagnol !).

L'agent répond par une invite demandant à l'utilisateur s'il souhaite changer de mode. langues. L'invite inclut des suggestions de réponses sur lesquelles l'utilisateur peut cliquer je passe dans cette langue.

Commençons par étudier 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. sur le client de traduction. Comme l'API Translate peut détecter plusieurs langues avec différents niveaux de confiance (et parce qu'il accepte plusieurs entrées), cette méthode renvoie un tableau de résultats. L'échantillon prend la première résultat, qui est le résultat avec le niveau de confiance le plus élevé.

Utilisation de paramètres régionaux résolus

Il arrive parfois que l'API Translate ne puisse pas déterminer la langue du message avec des réponses la confiance en soi. Par exemple, si votre chat court sur votre clavier et saisit un une chaîne vide de sens, l'API Translate tente toujours de détecter la langue, mais la langue détectée est probablement incorrecte. Après tout, Google Traduction mais pas encore !) Pour cela, l'API Translate Définition d'une faible confiance dans le résultat de translate.detect.

Dans ce scénario, l'exemple de code s'appuie sur le langage de la Paramètres régionaux Business Messages résolus, qui est la meilleure estimation de l'API Business Messages pour le langage, en fonction le contexte du message. Étant donné que les paramètres régionaux résolus sont au format BCP-47, vous pouvez utiliser le package Node.js correspondant pour analyser le code de langue à partir des paramètres régionaux.

Vous pouvez tester ce comportement en saisissant une longue chaîne de contenu vide de sens à l'intention de l'agent. Dans la plupart des cas, vous ne devriez pas voir de message vous invitant à changer de langue (sauf si les paramètres régionaux résolus sont différents de la langue actuelle). L'agent dit simplement il ne comprend pas votre demande.

Invitation à changer de langue

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

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 requête et la traduit dans la langue actuelle (pour en savoir plus, dans la section Traduction des messages sortants), puis envoie une réponse indiquant réponses suggérées. L'utilisateur peut vouloir parler de l'un des éléments suivants langues:

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

Comme il est possible que ces trois langues se chevauchent (par exemple, si la version actuelle est déjà la langue du serveur), le serveur utilise un objet défini pour supprimer en double. Une réponse suggérée est ensuite créée 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 réponse suggérée affiche le nom de la langue dans sa propre langue. Par exemple : L'espagnol apparaît sous la forme "Español". Pour obtenir des informations sur une langue 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 le contexte de 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

Retournez maintenant sur votre appareil mobile et essayez de cliquer sur une nouvelle option de langue dans de la requête précédente. Par exemple, si vous avez tapé « Hola », cliquez sur "Español" dans les réponses suggérées.

L'agent répond dans la nouvelle langue. Nous verrons comment traduire des réponses lors d'une prochaine étape. Pour l'instant, examinons 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 le postback. des données pour déterminer quoi faire. Dans ce cas simple, le serveur n'accepte type de données de postback, SWITCH_LANGUAGE_POSTBACK, qui signifie que la conversation doit s'afficher dans la langue qui suit immédiatement du code source. Après avoir analysé ce code de langue, le serveur envoie un message pour avertir le que la langue a changé.

Traduction des messages entrants

La langue ayant été modifiée, vous pouvez envoyer une requête à l'agent dans ce sur votre appareil mobile. Essayez d'envoyer le mot "aide" dans le nouveau langue. Si vous avez remplacé la langue par l'espagnol, saisissez "ayuda". et envoyez le .

Le serveur comprend votre demande d'aide et vous répond avec le menu des options. Essayez l'une de ces méthodes pour obtenir un exemple de réponse codée en dur.

L'exemple de code utilise la méthode translateText pour traduire les requêtes entrantes et les messages sortants. Jetons-y un coup d’œil:

/**
 * 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, rien ne peut faire. Sinon, le serveur appelle la méthode méthode "translate" sur le client de l'API Translate. Tout comme la méthode de détection, la méthode translate acceptent plusieurs entrées. Comme le serveur ne fournit qu'une seule entrée, il prend le 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 explore le processus de choix du message de réponse et de le traduire.

Traduction des messages sortants

Une fois que le serveur a traduit votre message entrant dans sa langue maternelle, il dispose 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 mappe les mots clés aux réponses. Vous avez examinons 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 pour traduire tous les messages entrants et sortants. Un système plus sophistiqué pourrait sont compatibles avec plusieurs langues et répondent de manière native aux requêtes dans d'autres langues. Par exemple, si votre agent prend en charge l'espagnol, il dispose peut-être déjà d'une clé pour "ayuda" dans le mappage de réponses. Des systèmes plus sophistiqués peuvent également s’appuyer sur d’autres les méthodologies permettant de choisir une réponse appropriée, comme le ML ou l'attribution de scores ; algorithmes. Une façon de créer des réponses plus intelligentes avec Business Messages consiste à l'intégrer à Dialogflow.

Examinez maintenant 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 les valeurs dans la langue de conversation actuelle. La méthode sendResponse, ensuite se charge de créer le nouvel objet Message et de l'envoyer à l'utilisateur.

Résumé

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

  • Envoyez des messages bilingues contenant à la fois le contenu d'origine et le des contenus traduits automatiquement.
  • Présenter à l'utilisateur un menu complet des langues disponibles lorsqu'il commence une conversationnelle.
  • utiliser les fonctionnalités avancées de l'API Translate. comme des glossaires pour traduire de façon fiable des mots spécifiques à votre entreprise.

Grâce à l'intégration aux API Translate, vous pouvez exploiter des machines de haute qualité pour communiquer avec davantage d'utilisateurs dans la langue la plus adaptée. Votre agent peut avoir des conversations plus productives et efficaces, ce qui augmente la satisfaction des clients et l’achèvement des tâches.