Conetores de conhecimentos

Os conetores de conhecimentos complementam as intenções definidas. Analisa documentos de conhecimento (por exemplo, Perguntas frequentes ou artigos) para encontrar respostas automáticas. Para as configurar, define uma ou mais bases de conhecimentos, que são coleções de documentos de conhecimentos.

Pode ativar as bases de conhecimentos para o seu agente, para que todos os pedidos de intenção de deteção possam encontrar respostas automáticas através das suas bases de conhecimentos. Em alternativa, pode especificar uma ou mais bases de conhecimentos nos seus pedidos individuais de deteção de intenção.

É comum um agente que usa conetores de conhecimento também usar intenções definidas. Os conectores de conhecimento oferecem menos precisão e controlo de respostas do que as intenções. Deve definir as suas intenções para processar pedidos complexos dos utilizadores e permitir que os conetores de conhecimentos processem pedidos simples.

Para ver uma lista dos idiomas suportados, consulte a coluna Knowledge Connectors na referência de idiomas.

Limitações

A funcionalidade de conetores de conhecimento só está disponível para a global região.

Ative funcionalidades beta

Certifique-se de que as funcionalidades beta estão ativadas:

  1. Aceda à consola do Dialogflow ES.
  2. Selecione um agente.
  3. Clique no botão de definições junto ao nome do agente.
  4. Desloque a página para baixo no separador Geral e certifique-se de que a opção Funcionalidades beta está ativada.
  5. Se fez alterações, clique em Guardar.

Crie uma base de conhecimentos e um documento

Siga as instruções no guia de instruções das bases de conhecimentos para criar uma base de conhecimentos e um documento.

Definições para conetores de conhecimentos

Pode ativar ou desativar as bases de conhecimentos para o seu agente. As bases de conhecimentos ativadas são consideradas para todos os pedidos de correspondência de intenções que não especifiquem bases de conhecimentos. Para ativar ou desativar as bases de conhecimentos:

  1. Aceda à consola do Dialogflow ES.
  2. Selecione um agente.
  3. Clique em Conhecimento no menu da barra lateral do lado esquerdo.
  4. Selecione uma ou mais bases de conhecimentos da lista.
  5. Clique em Ativar ou Desativar.

Quando uma expressão do utilizador final também corresponde a uma intenção, pode especificar a intensidade com que prefere os resultados de conhecimentos:

  1. Desloque a página para baixo até à secção Ajustar preferência de resultados de conhecimentos.
  2. Ajuste o controlo de deslize de mais fraco (preferência dada à intenção) para mais forte (preferência dada ao conhecimento). Para mais informações, consulte a secção Respostas de deteção de intenções abaixo.

Configure respostas

Por predefinição, uma base de conhecimentos é configurada com uma única resposta de texto predefinida preenchida com a resposta de conhecimento mais adequada. Pode alterar esta resposta e adicionar mensagens de resposta avançadas. As respostas de conhecimento podem conter até três respostas por base de conhecimentos, e pode consultar estas respostas nas suas respostas configuradas. Para adicionar respostas:

  1. Na página Conhecimento, clique no nome da base de conhecimentos.
  2. Desloque a página para baixo até à secção Respostas e adicione respostas conforme pretendido:
    1. Quando definir a primeira resposta, use $Knowledge.Question[1] e $Knowledge.Answer[1] onde quer que a pergunta e a resposta sejam fornecidas.
    2. O índice de $Knowledge.Question e $Knowledge.Answer começa em 1, por isso, aumente este índice quando adicionar mais respostas.
  3. Clique em Guardar quando terminar a edição.

Quando definir respostas, deve ter em atenção os seguintes pontos:

  • Se o número de respostas definidas for superior ao número N de correspondências de respostas do conetor de conhecimentos, apenas são devolvidas N respostas.
  • Uma vez que a precisão pode ser inferior à correspondência de intenções definidas explicitamente, recomendamos que devolva três respostas aos seus utilizadores sempre que possível.

Exemplo:

Captura de ecrã da integração do conetor de conhecimentos

Detete a intenção com a base de conhecimentos

Quando faz um pedido de deteção de intenção, pode especificar uma ou mais bases de conhecimentos para uma possível resposta. O fornecimento explícito de bases de conhecimentos num pedido substitui as definições das bases de conhecimentos ativadas e desativadas.

Os exemplos abaixo mostram como usar a consola do Dialogflow, a API REST (incluindo a linha de comandos) ou as bibliotecas cliente para detetar a intenção. Para usar a API, chame o método detectIntent no tipo Sessions.

IU da Web

Pode interagir com o agente e receber respostas do conetor de conhecimentos através do simulador do Dialogflow:

  1. Siga os passos acima para ativar uma base de conhecimentos.
  2. Siga os passos acima para definir as respostas.
  3. Escreva "Como me posso inscrever?" no simulador.

REST

Chame o método detectIntent no tipo Sessions e especifique a base de conhecimentos no campo queryParams.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • PROJECT_ID: o ID do seu projeto da GCP
  • KNOWLEDGE_BASE_ID: o ID da sua base de conhecimentos

Método HTTP e URL: 

POST https://dialogflow.googleapis.com/v2beta1/projects/PROJECT_ID/agent/sessions/123456789:detectIntent

Corpo JSON do pedido: 

{
 "queryInput": {
   "text": {
     "text": "How do I sign up?",
     "languageCode": "en-US"
   }
 },
 "queryParams": {
   "knowledgeBaseNames": ["projects/PROJECT_ID/knowledgeBases/KNOWLEDGE_BASE_ID"]
 }
}

Para enviar o seu pedido, expanda uma destas opções:

Deve receber uma resposta JSON semelhante à seguinte:

{
  ...
  "queryResult": {
    "queryText": "How do I sign up?",
    "parameters": {},
    "allRequiredParamsPresent": true,
    "fulfillmentText": "Sign up for Cloud Storage by turning on the Cloud Storage service in the Google Cloud Platform Console.",
    "intent": {
      "name": "projects/my-gcp-project/agent/intents/487c7242-a769-408a-a339-47b95e10dac4",
      "displayName": "Knowledge.KnowledgeBase.MzkzNTAyMDE3NDQxNDk3MDg4MA"
    },
    "intentDetectionConfidence": 0.99371547,
    "languageCode": "en-us",
    "knowledgeAnswers": {
      "answers": [
        {
          "answer": "Sign up for Cloud Storage by turning on the Cloud Storage service in the Google Cloud Platform Console.",
          "matchConfidenceLevel": "HIGH",
          "matchConfidence": 0.99371547
        },
        {
          "answer": "Certain types of content are not allowed on this service; please refer to the Terms of Services and Platform Policies for details. If you believe a piece of content is in violation of our policies, report it here (select See more products, then Google Cloud Storage and Cloud Bigtable).",
          "matchConfidenceLevel": "LOW",
          "matchConfidence": 0.0012244871
        },
        {
          "answer": "From the Cloud Storage documentation click \"Send feedback\" near the top right of the page. This will open a feedback form. Your comments will be reviewed by the Cloud Storage team.",
          "matchConfidenceLevel": "LOW",
          "matchConfidence": 0.0011537358
        }
      ]
    }
  }
}

Java

Para se autenticar no Dialogflow, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 


import com.google.api.gax.rpc.ApiException;
import com.google.cloud.dialogflow.v2beta1.DetectIntentRequest;
import com.google.cloud.dialogflow.v2beta1.DetectIntentResponse;
import com.google.cloud.dialogflow.v2beta1.KnowledgeAnswers;
import com.google.cloud.dialogflow.v2beta1.KnowledgeAnswers.Answer;
import com.google.cloud.dialogflow.v2beta1.QueryInput;
import com.google.cloud.dialogflow.v2beta1.QueryParameters;
import com.google.cloud.dialogflow.v2beta1.QueryResult;
import com.google.cloud.dialogflow.v2beta1.SessionName;
import com.google.cloud.dialogflow.v2beta1.SessionsClient;
import com.google.cloud.dialogflow.v2beta1.TextInput;
import com.google.common.collect.Maps;
import java.io.IOException;
import java.util.List;
import java.util.Map;

public class DetectIntentKnowledge {

  // DialogFlow API Detect Intent sample with querying knowledge connector.
  public static Map<String, KnowledgeAnswers> detectIntentKnowledge(
      String projectId,
      String knowledgeBaseName,
      String sessionId,
      String languageCode,
      List<String> texts)
      throws IOException, ApiException {
    // Instantiates a client
    Map<String, KnowledgeAnswers> allKnowledgeAnswers = Maps.newHashMap();
    try (SessionsClient sessionsClient = SessionsClient.create()) {
      // Set the session name using the sessionId (UUID) and projectID (my-project-id)
      SessionName session = SessionName.of(projectId, sessionId);
      System.out.println("Session Path: " + session.toString());

      // Detect intents for each text input
      for (String text : texts) {
        // Set the text and language code (en-US) for the query
        TextInput.Builder textInput =
            TextInput.newBuilder().setText(text).setLanguageCode(languageCode);
        // Build the query with the TextInput
        QueryInput queryInput = QueryInput.newBuilder().setText(textInput).build();

        QueryParameters queryParameters =
            QueryParameters.newBuilder().addKnowledgeBaseNames(knowledgeBaseName).build();

        DetectIntentRequest detectIntentRequest =
            DetectIntentRequest.newBuilder()
                .setSession(session.toString())
                .setQueryInput(queryInput)
                .setQueryParams(queryParameters)
                .build();
        // Performs the detect intent request
        DetectIntentResponse response = sessionsClient.detectIntent(detectIntentRequest);

        // Display the query result
        QueryResult queryResult = response.getQueryResult();

        System.out.format("Knowledge results:\n");
        System.out.format("====================\n");
        System.out.format("Query Text: '%s'\n", queryResult.getQueryText());
        System.out.format(
            "Detected Intent: %s (confidence: %f)\n",
            queryResult.getIntent().getDisplayName(), queryResult.getIntentDetectionConfidence());
        System.out.format(
            "Fulfillment Text: '%s'\n",
            queryResult.getFulfillmentMessagesCount() > 0
                ? queryResult.getFulfillmentMessages(0).getText()
                : "Triggered Default Fallback Intent");
        KnowledgeAnswers knowledgeAnswers = queryResult.getKnowledgeAnswers();
        for (Answer answer : knowledgeAnswers.getAnswersList()) {
          System.out.format(" - Answer: '%s'\n", answer.getAnswer());
          System.out.format(" - Confidence: '%s'\n", answer.getMatchConfidence());
        }

        KnowledgeAnswers answers = queryResult.getKnowledgeAnswers();
        allKnowledgeAnswers.put(text, answers);
      }
    }
    return allKnowledgeAnswers;
  }
}

Node.js

Para se autenticar no Dialogflow, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

// Imports the Dialogflow client library
const dialogflow = require('@google-cloud/dialogflow').v2beta1;
// Instantiate a DialogFlow client.
const sessionClient = new dialogflow.SessionsClient();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'ID of GCP project associated with your Dialogflow agent';
// const sessionId = `user specific ID of session, e.g. 12345`;
// const languageCode = 'BCP-47 language code, e.g. en-US';
// const knowledgeBaseId = `the ID of your KnowledgeBase`;
// const query = `phrase(s) to pass to detect, e.g. I'd like to reserve a room for six people`;

// Define session path
const sessionPath = sessionClient.projectAgentSessionPath(
  projectId,
  sessionId
);
const knowledgeBasePath =
  'projects/' + projectId + '/knowledgeBases/' + knowledgeBaseId + '';

// The audio query request
const request = {
  session: sessionPath,
  queryInput: {
    text: {
      text: query,
      languageCode: languageCode,
    },
  },
  queryParams: {
    knowledgeBaseNames: [knowledgeBasePath],
  },
};

const responses = await sessionClient.detectIntent(request);
const result = responses[0].queryResult;
console.log(`Query text: ${result.queryText}`);
console.log(`Detected Intent: ${result.intent.displayName}`);
console.log(`Confidence: ${result.intentDetectionConfidence}`);
console.log(`Query Result: ${result.fulfillmentText}`);
if (result.knowledgeAnswers && result.knowledgeAnswers.answers) {
  const answers = result.knowledgeAnswers.answers;
  console.log(`There are ${answers.length} answer(s);`);
  answers.forEach(a => {
    console.log(`   answer: ${a.answer}`);
    console.log(`   confidence: ${a.matchConfidence}`);
    console.log(`   match confidence level: ${a.matchConfidenceLevel}`);
  });
}

Python

Para se autenticar no Dialogflow, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

def detect_intent_knowledge(
    project_id, session_id, language_code, knowledge_base_id, texts
):
    """Returns the result of detect intent with querying Knowledge Connector.

    Args:
    project_id: The GCP project linked with the agent you are going to query.
    session_id: Id of the session, using the same `session_id` between requests
              allows continuation of the conversation.
    language_code: Language of the queries.
    knowledge_base_id: The Knowledge base's id to query against.
    texts: A list of text queries to send.
    """
    from google.cloud import dialogflow_v2beta1 as dialogflow

    session_client = dialogflow.SessionsClient()

    session_path = session_client.session_path(project_id, session_id)
    print("Session path: {}\n".format(session_path))

    for text in texts:
        text_input = dialogflow.TextInput(text=text, language_code=language_code)

        query_input = dialogflow.QueryInput(text=text_input)

        knowledge_base_path = dialogflow.KnowledgeBasesClient.knowledge_base_path(
            project_id, knowledge_base_id
        )

        query_params = dialogflow.QueryParameters(
            knowledge_base_names=[knowledge_base_path]
        )

        request = dialogflow.DetectIntentRequest(
            session=session_path, query_input=query_input, query_params=query_params
        )
        response = session_client.detect_intent(request=request)

        print("=" * 20)
        print("Query text: {}".format(response.query_result.query_text))
        print(
            "Detected intent: {} (confidence: {})\n".format(
                response.query_result.intent.display_name,
                response.query_result.intent_detection_confidence,
            )
        )
        print("Fulfillment text: {}\n".format(response.query_result.fulfillment_text))
        print("Knowledge results:")
        knowledge_answers = response.query_result.knowledge_answers
        for answers in knowledge_answers.answers:
            print(" - Answer: {}".format(answers.answer))
            print(" - Confidence: {}".format(answers.match_confidence))

Detete respostas de intenção

A resposta para o método detectIntent do tipo Sessions é um DetectIntentResponse. Vários fatores afetam a forma como os campos de resposta são preenchidos.

Se uma intenção definida e uma base de conhecimentos forem ambas potenciais correspondências, a confiança da correspondência de cada uma e a preferência de resultados de conhecimentos (consulte as Definições dos conetores de conhecimentos) são usadas para determinar qual correspondência é a correspondência selecionada. A correspondência selecionada é preenchida no campo DetectIntentResponse.queryResult e outras potenciais correspondências são preenchidas no campo DetectIntentResponse.alternativeQueryResults. Ambos os campos contêm mensagens QueryResult.

Se uma base de conhecimentos fornecer uma potencial correspondência:

  • QueryResult.knowledgeAnswers é preenchido com uma lista de potenciais respostas de conhecimentos ordenadas por confiança de correspondência decrescente.
  • Se tiverem sido definidas respostas avançadas para a base de conhecimentos, QueryResult.fulfillmentMessages é preenchido com mensagens de respostas avançadas.

Quando faz um pedido de deteção de intenção, é possível que a consulta de conhecimentos falhe. Quando isto acontece, as intenções definidas são selecionadas, pelo que o pedido de intenção de deteção geral não falha. Pode encontrar informações sobre erros de consultas de conhecimentos no campo DetectIntentResponse.alternativeQueryResults[i].diagnosticInfo.

Faça a gestão das bases de conhecimentos

Para saber como gerir bases de conhecimentos, consulte o artigo Faça a gestão das bases de conhecimentos.

Anterior
Interações da API
Avançar
Formação