Compatibilidade com vários idiomas com o Google Tradutor

Com as localidades do recurso Business Messages e a tecnologia inteligente e automatizada do Google Tradutor é possível expandir o alcance do seu agente comunicando-se com os usuários o idioma de preferência. Neste tutorial, explicamos uma prova de conceito integração do Google Tradutor com um webhook do Business Messages.

O que é necessário

Para começar, você precisará dos itens a seguir preparados:

Acessar o código

Este tutorial mostra um exemplo de código de webhook que se integra ao Google Traduzir. Para conseguir o código, clone o repositório do GitHub:

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

Navegue até o diretório clonado e coloque a chave da sua conta de serviço no diretório de recursos:

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

DICA: se precisar de ajuda para configurar ou fazer o download da sua chave de serviço, consulte Guia do Google Cloud para gerenciar contas de serviço.

Depois de fazer isso, você pode implantar o código:

gcloud app deploy

Em um dispositivo móvel, envie algumas mensagens para o agente. Tente enviar mensagens em idiomas diferentes e ver o que acontece.

Configurar a API Translate

O exemplo de código já vem com o pacote Node para a API Translate instalado. Se você tiver interesse em como instalar o pacote Node ou em como instalar a API do Google Tradutor em outra linguagem de programação, consulte o Documentos da API Cloud Translate.

Para usar a API Translate, é necessário importar a biblioteca e criar uma cliente da API. Abra o arquivo routes/index.js. As linhas relevantes são:

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

A partir de agora, você pode acessar os métodos da API do Google Tradutor no objeto de tradução.

Observe as variáveis criadas na parte superior do arquivo:

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

O exemplo de código armazena a linguagem do servidor como uma constante porque ela é relativamente corrigidos. No entanto, o idioma atual da conversa pode mudar, por isso é rastreado na variável currentLanguage.

Como detectar o idioma de entrada

O exemplo de código detecta se o idioma de entrada foi alterado e, em caso afirmativo, solicita que o usuário escolha o idioma que gostaria de usar na conversa. Teste esse recurso no seu dispositivo móvel digitando uma mensagem para o agente em um além do inglês. Se você não souber nenhum outro idioma, tente digitar "Olá" (a palavra em espanhol significa "Olá"!).

O agente responde com um prompt perguntando se o usuário quer trocar de aparelho. idiomas. O comando inclui respostas sugeridas que o usuário pode clicar para mudar para esse idioma.

Primeiro, vamos dar uma olhada no recurso de detecção de idioma.

/**
 * 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);
      });
  });
}

Esse método usa o método de detecção no cliente do Tradutor. Como a API Translate pode detectar vários idiomas com diferentes níveis de confiança (e também porque apoia vários entradas), esse método retorna uma matriz de resultados. A amostra usa a primeira resultado, que é o resultado com maior confiança.

Como usar a localidade resolvida

Às vezes, a API Translate não consegue determinar o idioma da mensagem com erros confiança. Por exemplo, se o gato passar pelo teclado e inserir uma sem sentido, a API do Google Tradutor ainda tenta detectar o idioma, mas o idioma detectado provavelmente está incorreto. Afinal, o Google Tradutor ainda não oferece suporte a idiomas com felinos) A API Translate indica isso ao definindo um nível de confiança baixo no resultado de translate.detect.

Neste cenário, o exemplo de código volta para a linguagem Localidade resolvida do Business Messages, que é o melhor palpite da API Business Messages para o idioma com base na o contexto da mensagem. Como a localidade resolvida está no formato BCP-47, você pode usar pacote Node.js correspondente para analisar o código do idioma da localidade.

É possível testar esse comportamento digitando uma longa string de conteúdo sem sentido no agente. Em na maioria dos casos, não será exibido um prompt para alterar o idioma (a menos que o a localidade resolvida é diferente do idioma atual). O agente apenas diz ele não entender sua solicitação.

Solicitação para mudar o idioma

Depois de detectar que o idioma mudou, o agente retorna um prompt para alterar o idioma.

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))
          );
        });
      }

O código cria um comando e o traduz para o idioma atual (mais sobre isso na seção "Tradução de mensagens de saída") e envia uma resposta com respostas sugeridas. O usuário pode querer conversar idiomas:

  • O idioma de entrada detectado.
  • O idioma atual da conversa.
  • A linguagem integrada do servidor.

Como esses três idiomas podem se sobrepor (por exemplo, se o idioma já é o idioma do servidor), o servidor usa um objeto definido para remover duplicatas. Em seguida, ele cria uma resposta sugerida para cada idioma:

/**
 * 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,
    },
  };
}

A resposta sugerida mostra o nome do idioma no próprio idioma. Por exemplo: O espanhol aparece como "Español". Para conseguir informações sobre um idioma a partir dos código de idioma de dois dígitos, use a biblioteca ISO-639-1 para Node.js.

Observe os dados de postback, que são enviados ao servidor quando o usuário clica a essa sugestão. Os dados de postback informam ao servidor como responder e fornecem contexto sobre a sugestão.

O método sendResponse anexa essas objetos de sugestão à resposta:

let messageObject = {
    …
    suggestions: suggestedReplies,
  };

Alterar o idioma da conversa

Agora, volte para seu dispositivo móvel e clique em uma nova opção de idioma na do prompt de comando de antes. Por exemplo, se você digitar "Olá", clique em "Español" no as respostas sugeridas.

O agente responde no novo idioma. Vamos abordar como traduzir mensagens em uma etapa posterior. Por enquanto, analise o código que recebe e processa a resposta sugerida em que você clicou.

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, []);
      });
    }
  }

Se a solicitação contiver uma resposta a uma sugestão, o servidor usará o postback dados para determinar o que fazer. Neste caso simples, o servidor suporta apenas um tipo de dado de postback, o SWITCH_LANGUAGE_POSTBACK, que significa que o conversa deve mudar para o idioma imediatamente seguinte o código-fonte. Após analisar esse código de idioma, o servidor envia uma mensagem para notificar o de que o idioma foi alterado.

Tradução de mensagens recebidas

Com o idioma alterado, é possível enviar uma solicitação ao agente idioma do seu dispositivo móvel. Tente usar a palavra "ajuda" na nova idioma de destino. Se você mudou o idioma para espanhol, digite "ayuda". e envie o mensagem.

O servidor entende seu pedido de ajuda e responde com o menu de . Tente qualquer um destes para ver uma resposta de exemplo codificada.

O exemplo de código usa o método translateText para traduzir os valores de entrada e mensagens enviadas. Confira agora:

/**
 * 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);
      });
  });
}

Se o idioma de origem for o mesmo do idioma de destino, não haverá nada para fazer. Caso contrário, o servidor chamará a função método translate no cliente da API Translate. Assim como o método de detecção, o método de tradução recebem várias entradas. Como o servidor fornece apenas uma entrada, ele toma primeiro resultado da API Translate.

Observe a seção do método de retorno de chamada que responde às mensagens recebidas em o idioma atual:

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

O servidor usa a saída de translateText para escolher uma mensagem de resposta. A próxima seção detalha o processo de escolha da mensagem de resposta e e traduzi-lo.

Tradução de mensagens enviadas

Depois que o servidor traduzir a mensagem recebida para seu inglês nativo, ele terá para escolher, traduzir e enviar uma resposta apropriada à solicitação do usuário. O exemplo de código usa um esquema muito simples que mapeia palavras-chave para respostas. confira o método 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.";
}

Esse esquema só é compatível com inglês no servidor, o que significa que o servidor deve traduzir todas as mensagens recebidas e enviadas. Um sistema mais sofisticado pode oferecem suporte a várias linguagens e respondem nativamente a solicitações em outros idiomas. Por exemplo, se o agente aceita espanhol, talvez ele já tenha uma chave para "ayuda" no mapa de respostas. Sistemas mais sofisticados também podem depender de outros metodologias para escolher uma resposta apropriada, como ML ou pontuação algoritmos. Uma forma de criar respostas mais inteligentes com o recurso Business Messages é fazer a integração com o Dialogflow.

Agora observe o código que envia a mensagem escolhida de volta ao usuário.

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

O exemplo de código reutiliza o método translateText para traduzir a para o idioma atual da conversa. Em seguida, o método sendResponse toma cuidado de criar o novo objeto Message e enviá-lo ao usuário.

Resumo

Neste tutorial, você aprendeu a criar uma integração simples com a API Cloud Translate e use os recursos de localidade do Business Messages para alcançar mais usuários. Se você Você pode usar o exemplo de código deste tutorial como um ponto de partida para própria integração ou pode tentar algo novo! Veja algumas ideias:

  • Envie mensagens bilíngues com o conteúdo da mensagem original e o conteúdo traduzido automaticamente.
  • apresente ao usuário um menu completo de idiomas compatíveis quando ele iniciar uma conversa.
  • Usar os recursos avançados da API Translate como glossários, para traduzir de forma confiável palavras específicas para sua empresa.

Ao fazer a integração com as APIs do Google Tradutor, você aproveita o desempenho para se comunicar com mais usuários no idioma mais confortável deles. Seu agente pode ter conversas mais produtivas e eficientes, aumentando satisfação do cliente e conclusão de tarefas.