Conectores de conocimiento

beta

Los conectores de conocimiento complementan los intents definidos. Analizan documentos (por ejemplo, Preguntas frecuentes o artículos) a fin de encontrar respuestas automatizadas. Para configurarlos, define una o más bases de conocimiento, que son colecciones de documentos. Puedes habilitar las bases de conocimiento para tu agente, de modo que todas las solicitudes de detección de intent puedan buscar respuestas automatizadas en ellas. También puedes especificar una o más bases de conocimiento en las solicitudes de detección de intent individuales.

Es común que un agente que usa conectores de conocimiento también use intents definidos. Los conectores de conocimiento ofrecen un grado de control y precisión sobre la respuesta menor que los intents. Si usas tanto intents como conectores de conocimiento, debes designar los intents para el manejo de las solicitudes de usuario complejas que requieren una precisión y una administración especiales, y dejar que los conectores de conocimiento se encarguen de las solicitudes simples con respuestas extraídas automáticamente de tus documentos. Si identificas contenido en las Preguntas frecuentes que deseas ampliar, puedes convertir las preguntas en intents definidos para tener un control total.

Si deseas obtener una lista de los idiomas admitidos, consulta la columna Conectores de conocimiento en la página de idiomas.

Antes de comenzar

Debes hacer lo siguiente antes de leer esta guía:

  1. Lee los conceptos básicos de Dialogflow.
  2. Realiza los pasos de configuración.

Crea un agente

En los pasos que se brindan esta guía, damos por sentado determinadas características de tu agente. Por eso, es recomendable que comiences con un agente nuevo. Debes borrar cualquier agente existente en tu proyecto antes de crear uno nuevo. Para borrar un agente existente, haz lo siguiente:

  1. Ve a la Consola de Dialogflow.
  2. Si se te solicita, accede a la consola de Dialogflow. Consulta Descripción general de la consola de Dialogflow para obtener más información.
  3. Selecciona el agente que deseas borrar.
  4. Haz clic en el botón de configuración settings ubicado junto al nombre del agente.
  5. Desplázate hasta la parte inferior de la pestaña de configuración General.
  6. Haz clic en Borrar este agente.
  7. Ingresa BORRAR en el campo de texto.
  8. Haz clic en Borrar.

Para crear un agente, haz lo siguiente:

  1. Ve a la Consola de Dialogflow.
  2. Si se te solicita, accede a la consola de Dialogflow. Consulta Descripción general de la consola de Dialogflow para obtener más información.
  3. Haz clic en Crear agente en el menú de la barra lateral izquierda. Si ya tienes otros agentes, haz clic en el nombre del agente, desplázate hasta la parte inferior y haz clic en Crear agente nuevo.
  4. Ingresa el nombre del agente, y el idioma y la zona horaria predeterminados.
  5. Si ya creaste un proyecto, ingrésalo. Si deseas permitir que la consola de Dialogflow cree el proyecto, selecciona Crear un proyecto de Google nuevo.
  6. Haz clic en el botón Crear.

Habilita las funciones Beta

Puede que debas habilitar la API Beta:

  1. Ve a la consola de Dialogflow.
  2. Selecciona un agente.
  3. Haz clic en el botón de configuración settings ubicado junto al nombre del agente.
  4. Desplázate hacia abajo en la pestaña General y asegúrate de que las funciones Beta estén habilitadas.
  5. Si realizaste cambios, haz clic en Guardar.

Crea una base de conocimiento

Una base de conocimiento contiene información sobre los documentos que Dialogflow usará para buscar respuestas a las solicitudes de los usuarios. En los siguientes ejemplos, se muestra cómo usar la consola de Dialogflow, la API de REST (incluida la línea de comandos) o las bibliotecas cliente para crear una base de conocimiento. Para usar la API, realiza una llamada al método create en el tipo KnowledgeBase.

IU web

Usa la consola de Dialogflow para crear una base de conocimiento:

  1. Ve a la consola de Dialogflow.
  2. Selecciona un agente.
  3. Haz clic en Conocimiento (Knowledge) en el menú de la barra lateral izquierda.
  4. Haz clic en Crear una base de conocimiento.
  5. Ingresa un nombre para la base de conocimiento.
  6. Haz clic en Guardar.

Captura de pantalla del panel izquierdo del conector de conocimiento

REST Y LÍNEA DE COMANDOS

Realiza una llamada al método create en el tipo KnowledgeBase.

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • project-id: el ID de tu proyecto de GCP
  • knowledge-base-display-name: el nombre que quieres darle a la base de conocimiento

Método HTTP y URL:

POST https://dialogflow.googleapis.com/v2beta1/projects/project-id/knowledgeBases

Cuerpo JSON de la solicitud:

    {
      "displayName": "knowledge-base-display-name"
    }
    

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

    {
      "name": "projects/project-id/knowledgeBases/NDA4MTM4NzE2MjMwNDUxMjAwMA",
      "displayName": "knowledge-base-display-name"
    }
    

Anota el valor del campo name. Este es el nombre de tu base de conocimiento nueva. El segmento de ruta después de knowledgeBases es el ID nuevo de la base de conocimiento. Guarda este ID para las solicitudes que se muestran a continuación.

Java


    /**
     * Create a Knowledge base
     *
     * @param projectId   Project/agent id.
     * @param displayName Name of the knowledge base.
     * @return The created KnowledgeBase.
     */
    public static KnowledgeBase createKnowledgeBase(String projectId, String displayName)
        throws Exception {
      // Instantiates a client
      try (KnowledgeBasesClient knowledgeBasesClient = KnowledgeBasesClient.create()) {
        KnowledgeBase knowledgeBase = KnowledgeBase.newBuilder().setDisplayName(displayName).build();
        ProjectName projectName = ProjectName.of(projectId);
        KnowledgeBase response = knowledgeBasesClient.createKnowledgeBase(projectName, knowledgeBase);
        System.out.format("Knowledgebase created:\n");
        System.out.format("Display Name: %s \n", response.getDisplayName());
        System.out.format("Knowledge ID: %s \n", response.getName());

        return response;
      }
    }

Node.js

// Imports the Dialogflow client library
    const dialogflow = require('dialogflow').v2beta1;

    // Instantiate a DialogFlow client.
    const client = new dialogflow.KnowledgeBasesClient();

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const projectId = 'ID of GCP project associated with your Dialogflow agent';
    // const displayName = `your knowledge base display name, e.g. myKnowledgeBase`;

    const formattedParent = client.projectPath(projectId);
    const knowledgeBase = {
      displayName: displayName,
    };
    const request = {
      parent: formattedParent,
      knowledgeBase: knowledgeBase,
    };

    const [result] = await client.createKnowledgeBase(request);
    console.log(`Name: ${result.name}`);
    console.log(`displayName: ${result.displayName}`);
    

Python

def create_knowledge_base(project_id, display_name):
        """Creates a Knowledge base.

        Args:
            project_id: The GCP project linked with the agent.
            display_name: The display name of the Knowledge base."""
        import dialogflow_v2beta1 as dialogflow
        client = dialogflow.KnowledgeBasesClient()
        project_path = client.project_path(project_id)

        knowledge_base = dialogflow.types.KnowledgeBase(
            display_name=display_name)

        response = client.create_knowledge_base(project_path, knowledge_base)

        print('Knowledge Base created:\n')
        print('Display Name: {}\n'.format(response.display_name))
        print('Knowledge ID: {}\n'.format(response.name))

Agrega un documento a la base de conocimiento

La base de conocimiento nueva aún está vacía, así que vamos a agregarle un documento. En este ejemplo, usaremos el documento de Preguntas frecuentes de Cloud Storage. Puedes usar cualquier documento de Preguntas frecuentes. El analizador de Preguntas frecuentes puede manejar la mayor parte de los formatos que se usan en documentos de este tipo. Consulta el contenido admitido a continuación para ver una descripción de las opciones de contenido admitidas.

En los siguientes ejemplos, se muestra cómo usar la consola de Dialogflow, la API de REST (incluida la línea de comandos) o las bibliotecas cliente para crear un documento de conocimiento. Para usar la API, realiza una llamada al método create en el tipo Document.

IU web

Usa la consola de Dialogflow para crear un documento de conocimiento:

  1. Si no continúas desde los pasos anteriores, navega a la configuración de tu base de conocimiento:
    1. Ve a la consola de Dialogflow.
    2. Selecciona un agente.
    3. Haz clic en Conocimiento en el menú de la barra lateral izquierda.
    4. Haz clic en el nombre de tu base de conocimiento.
  2. Haz clic en Documento nuevo o Crear el primero.
  3. Ingresa un nombre para el documento.
  4. Selecciona texto/html para Tipo de Mime.
  5. Selecciona Preguntas frecuentes para Tipo de conocimiento.
  6. Selecciona URL para Fuente de datos (Data Source).
  7. Ingresa https://cloud.google.com/storage/docs/faq en el campo URL.
  8. Haz clic en CREAR.

Captura de pantalla del documento nuevo del conector de conocimiento

REST Y LÍNEA DE COMANDOS

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • project-id: el ID de tu proyecto de GCP
  • knowledge-base-id: tu ID de base de conocimiento que muestra la solicitud anterior
  • document-display-name: el nombre que quieres darle al documento de conocimiento

Método HTTP y URL:

POST https://dialogflow.googleapis.com/v2beta1/projects/project-id/knowledgeBases/knowledge-base-id/documents

Cuerpo JSON de la solicitud:

    {
      "displayName": "document-display-name",
      "mimeType": "text/html",
      "knowledgeTypes": "FAQ",
      "contentUri": "https://cloud.google.com/storage/docs/faq"
    }
    

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

    {
      "name": "projects/project-id/operations/ks-add_document-MzA5NTY2MTc5Mzg2Mzc5NDY4OA"
    }
    

El segmento de ruta que aparece después de operations es tu ID de operación. La creación de un documento es un proceso de larga duración, por lo que puede tardar bastante tiempo en completarse. Puedes consultar el estado de esta operación para ver si se ha completado. Para obtener más información, consulta la página sobre operaciones de larga duración.

Java


    /**
     * @param knowledgeBaseName Knowledge Base id.
     * @param displayName       display name of the Document.
     * @param mimeType          MIME type of the Document. e.g. text/csv, text/html
     * @param knowledgeType     Knowledge Type of the Document. e.g. FAQ, EXTRACTIVE_QA
     * @param contentUri        Uri of the Document. e.g. gs://path/mydoc.csv, http://mypage.com/faq.html
     * @return The created document.
     */
    public static Document createDocument(
        String knowledgeBaseName,
        String displayName,
        String mimeType,
        String knowledgeType,
        String contentUri)
        throws Exception {
      // Instantiates a client
      try (DocumentsClient documentsClient = DocumentsClient.create()) {
        Document document =
            Document.newBuilder()
                .setDisplayName(displayName)
                .setContentUri(contentUri)
                .setMimeType(mimeType)
                .addKnowledgeTypes(KnowledgeType.valueOf(knowledgeType))
                .build();
        CreateDocumentRequest createDocumentRequest =
            CreateDocumentRequest.newBuilder()
                .setDocument(document)
                .setParent(knowledgeBaseName)
                .build();
        OperationFuture<Document, KnowledgeOperationMetadata> response =
            documentsClient.createDocumentAsync(createDocumentRequest);
        Document createdDocument = response.get(120, TimeUnit.SECONDS);
        System.out.format("Created Document:\n");
        System.out.format(" - Display Name: %s\n", createdDocument.getDisplayName());
        System.out.format(" - Knowledge ID: %s\n", createdDocument.getName());
        System.out.format(" - MIME Type: %s\n", createdDocument.getMimeType());
        System.out.format(" - Knowledge Types:\n");
        for (KnowledgeType knowledgeTypeId : document.getKnowledgeTypesList()) {
          System.out.format("  - %s \n", knowledgeTypeId.getValueDescriptor());
        }
        System.out.format(" - Source: %s \n", document.getContentUri());
        return createdDocument;
      }
    }

Node.js

// Imports the Dialogflow client library
    const dialogflow = require('dialogflow').v2beta1;

    // Instantiate a DialogFlow Documents client.
    const client = new dialogflow.DocumentsClient({
      projectId: projectId,
    });

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const projectId = 'ID of GCP project associated with your Dialogflow agent';
    // const knowledgeBaseFullName = `the full path of your knowledge base, e.g my-Gcloud-project/myKnowledgeBase`;
    // const documentPath = `path of the document you'd like to add, e.g. https://dialogflow.com/docs/knowledge-connectors`;
    // const documentName = `displayed name of your document in knowledge base, e.g. myDoc`;
    // const knowledgeTypes = `The Knowledge type of the Document. e.g. FAQ`;
    // const mimeType = `The mime_type of the Document. e.g. text/csv, text/html,text/plain, text/pdf etc.`;

    const request = {
      parent: knowledgeBaseFullName,
      document: {
        knowledgeTypes: [knowledgeTypes],
        displayName: documentName,
        contentUri: documentPath,
        source: `contentUri`,
        mimeType: mimeType,
      },
    };

    const [operation] = await client.createDocument(request);
    const [response] = await operation.promise();
    console.log(`Document created`);
    console.log(`Content URI...${response.contentUri}`);
    console.log(`displayName...${response.displayName}`);
    console.log(`mimeType...${response.mimeType}`);
    console.log(`name...${response.name}`);
    console.log(`source...${response.source}`);
    

Python

def create_document(project_id, knowledge_base_id, display_name, mime_type,
                        knowledge_type, content_uri):
        """Creates a Document.

        Args:
            project_id: The GCP project linked with the agent.
            knowledge_base_id: Id of the Knowledge base.
            display_name: The display name of the Document.
            mime_type: The mime_type of the Document. e.g. text/csv, text/html,
                text/plain, text/pdf etc.
            knowledge_type: The Knowledge type of the Document. e.g. FAQ,
                EXTRACTIVE_QA.
            content_uri: Uri of the document, e.g. gs://path/mydoc.csv,
                http://mypage.com/faq.html."""
        import dialogflow_v2beta1 as dialogflow
        client = dialogflow.DocumentsClient()
        knowledge_base_path = client.knowledge_base_path(project_id,
                                                         knowledge_base_id)

        document = dialogflow.types.Document(
            display_name=display_name, mime_type=mime_type,
            content_uri=content_uri)

        document.knowledge_types.append(
            dialogflow.types.Document.KnowledgeType.Value(knowledge_type))

        response = client.create_document(knowledge_base_path, document)
        print('Waiting for results...')
        document = response.result(timeout=90)
        print('Created Document:')
        print(' - Display Name: {}'.format(document.display_name))
        print(' - Knowledge ID: {}'.format(document.name))
        print(' - MIME Type: {}'.format(document.mime_type))
        print(' - Knowledge Types:')
        for knowledge_type in document.knowledge_types:
            print('    - {}'.format(KNOWLEDGE_TYPES[knowledge_type]))
        print(' - Source: {}\n'.format(document.content_uri))

Configuración para conectores de conocimiento

A fin de acceder a la configuración de los conectores de conocimiento, haz lo siguiente:

  1. Ve a la consola de Dialogflow.
  2. Selecciona un agente.
  3. Haz clic en Conocimiento en el menú de la barra lateral izquierda.

Puedes habilitar una o más bases de conocimiento para tu agente. Las bases de conocimiento habilitadas se usarán para todas las solicitudes de detección de intent, a menos que las anules mediante la especificación de bases de conocimiento específicas en una solicitud. Selecciona las bases de conocimiento en la configuración y haz clic en HABILITAR o INHABILITAR según corresponda.

También puedes establecer el valor AJUSTAR PREFERENCIAS DE RESULTADOS DE CONOCIMIENTO. Dialogflow usa este valor cuando una solicitud de detección de intent tiene coincidencias posibles de intent y base de conocimiento. Consulta Respuestas de detección de intent.

Integraciones y respuestas enriquecidas

Puedes usar conectores de conocimiento con Integraciones y respuestas enriquecidas:

  1. Si no continúas desde los pasos anteriores, navega a la configuración de tu base de conocimiento:
    1. Ve a la consola de Dialogflow.
    2. Selecciona un agente.
    3. Haz clic en Conocimiento en el menú de la barra lateral izquierda.
    4. Haz clic en el nombre de tu base de conocimiento.
  2. Desplázate hacia abajo hasta la sección Respuestas y agrega las respuestas que desees:
    1. Cuando definas la primera respuesta para el intent, usa $Knowledge.Question[1] y $Knowledge.Answer[1] en los lugares en los que deben proporcionarse la pregunta y la respuesta.
    2. El índice para $Knowledge.Question y $Knowledge.Answer comienza en 1, así que aumenta este índice cuando agregues más respuestas.
  3. Cuando termines de editar, haz clic en GUARDAR.

Ten en cuenta los siguientes puntos cuando definas las respuestas:

  • Si la cantidad de respuestas definidas es mayor que el número N de coincidencias de respuestas del conector de conocimiento, solo se mostrarán N respuestas.
  • Dado que la precisión podría ser inferior a cuando se detectan coincidencias con intents definidos de forma explícita, recomendamos que muestres tres o más respuestas a los usuarios cuando sea posible.

Ejemplo:

Captura de pantalla de la integración del conector de conocimiento

Detecta el intent con la base de conocimiento

Cuando realizas una solicitud de detección de intent, puedes especificar una o más bases de conocimiento para una respuesta posible.

En los siguientes ejemplos, se muestra cómo usar la consola de Dialogflow, la API de REST (incluida la línea de comandos) o las bibliotecas cliente para detectar intents. Para usar la API, realiza una llamada al método detectIntent en el tipo Sessions.

IU web

Puedes interactuar con el agente y recibir respuestas del conector de conocimiento a través del simulador de Dialogflow:

  1. Sigue los pasos anteriores para habilitar una base de conocimiento.
  2. Sigue los pasos anteriores para definir respuestas.
  3. Escribe “¿Cómo me registro?” en el simulador.

REST Y LÍNEA DE COMANDOS

Realiza una llamada al método detectIntent en el tipo Sessions y especifica la base de conocimiento en el campo queryParams.

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • project-id: el ID de tu proyecto de GCP
  • knowledge-base-id: el ID de tu base de conocimiento

Método HTTP y URL:

POST https://dialogflow.googleapis.com/v2beta1/projects/project-id/agent/sessions/123456789:detectIntent

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

    {
      ...
      "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


    /**
     * Returns the result of detect intent with text as input.
     *
     * <p>Using the same `session_id` between requests allows continuation of the conversation.
     *
     * @param projectId         Project/Agent Id.
     * @param knowledgeBaseName Knowledge base Id.
     * @param sessionId         Identifier of the DetectIntent session.
     * @param languageCode      Language code of the query.
     * @param texts             The texts to be processed.
     * @return The KnowledgeAnswers found for each text.
     */
    public static Map<String, KnowledgeAnswers> detectIntentKnowledge(
        String projectId,
        String knowledgeBaseName,
        String sessionId,
        String languageCode,
        List<String> texts) throws Exception {
      // 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
          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.getFulfillmentText());
          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

// Imports the Dialogflow client library
    const dialogflow = require('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 knowledgeBaseFullName = `the full path of your knowledge base, e.g my-Gcloud-project/myKnowledgeBase`;
    // 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.sessionPath(projectId, sessionId);
    const knowbase = new dialogflow.KnowledgeBasesClient();
    const knowledgeBasePath = knowbase.knowledgeBasePath(
      projectId,
      knowledgeBaseFullName
    );

    // 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

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.
        """
        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.types.TextInput(
                text=text, language_code=language_code)

            query_input = dialogflow.types.QueryInput(text=text_input)

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

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

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

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

Respuestas de detección de intent

La respuesta para el método detectIntent de tipo Sessions es una DetectIntentResponse. La forma en que se propaga la información a los campos de la respuesta depende de varios factores.

Si se identifican posibles coincidencias tanto con un intent definido como con una base de conocimiento, se selecciona una de estas opciones según la confianza de la coincidencia de cada alternativa y las preferencias de resultados de conocimiento (consulta la sección Configuración para conectores de conocimiento). La coincidencia seleccionada se propaga al campo DetectIntentResponse.queryResult, y las otras coincidencias potenciales se propagan al campo DetectIntentResponse.alternativeQueryResults. Ambos campos contienen mensajes QueryResult.

Si una base de conocimiento proporciona una posible coincidencia, sucede lo siguiente:

  • Se propaga a QueryResult.knowledgeAnswers una lista de posibles respuestas de conocimiento ordenadas de mayor a menor confianza de la coincidencia.
  • Si se definieron respuestas enriquecidas para la base de conocimiento, se propagan a QueryResult.fulfillmentMessages los mensajes de respuesta enriquecida.

Cuando se realiza un solicitud de detección de intent, es posible que falle la consulta de conocimiento. En ese caso, se seleccionarán los intents definidos, de modo que la solicitud de detección de intent general no fallará. Puedes encontrar información sobre el error de consulta de conocimiento en el campo DetectIntentResponse.alternativeQueryResults[i].diagnosticInfo.

Usa Cloud Storage

Puedes proporcionar tu contenido en un objeto de Cloud Storage.

Cómo crear depósitos y objetos de Cloud Storage

Haz lo siguiente cuando crees un depósito de Cloud Storage:

  • Asegúrate de seleccionar el proyecto de GCP que usas para Dialogflow.
  • Usa la clase Standard Storage.
  • Como ubicación de depósito, selecciona la opción más cercana a donde te encuentres. Necesitarás el ID de ubicación (por ejemplo, us-west1) para algunas llamadas a la API, así que toma nota de tu elección.

Sigue las instrucciones de la guía de inicio rápido de Cloud Storage para crear un depósito y subir archivos.

Cómo proporcionar un objeto de Cloud Storage a un documento de la base de conocimiento

Sigue estas instrucciones para proporcionar tu contenido:

  • Crea una base de conocimiento como se describió anteriormente.
  • Crea un documento de conocimiento como se describió anteriormente. Cuando llames al método create en el tipo Document, establece el campo contentUri en la URL de tu documento de Cloud Storage. El formato de la URL es gs://bucket-name/object-name.

Cómo actualizar el contenido de Cloud Storage

El documento de conocimiento no se actualiza automáticamente cuando se modifica el contenido que está en Cloud Storage. Para que se actualice, llama al método reload en el tipo Document.

Contenido admitido

En la siguiente tabla, se muestran los tipos de MIME admitidos por Tipo de conocimiento y Fuente.

Tipo de conocimiento/Fuente Archivo subido (Document.content) (NO recomendado) Archivo subido (Document.raw_content) (Recomendado) Archivo de Cloud Storage (Document.contentUri) Archivo de URL pública (Document.contentUri)
Preguntas frecuentes texto/csv texto/csv texto/csv text/html
Artículo de base de conocimiento texto/sin formato, texto/html texto/sin formato, texto/html, aplicación/pdf texto/sin formato, texto/html, aplicación/pdf N/A

El contenido del documento tiene las siguientes limitaciones, recomendaciones y problemas conocidos:

General:

  • Los archivos de las URL públicas se incluyen en el índice de búsqueda solo si el indexador de Búsqueda de Google los rastreó. Puedes verificar esto con Google Search Console. Ten en cuenta que el indexador no mantiene actualiza el contenido automáticamente. Cuando modifiques el contenido, deberás actualizar tu documento de conocimiento de forma explícita.
  • Los archivos CSV deben usar comas como delimitadores.
  • Actualmente, los agentes son compatibles con el uso de Preguntas frecuentes o artículos de base de conocimiento. Sin embargo, no puedes usar ambos a la vez. Las puntuaciones de confianza de los artículos de base de conocimiento y las Preguntas frecuentes aún no están calibradas entre sí, por lo que si usas ambas fuentes de información, es posible que no siempre se le asigne la puntuación más alta al resultado más idóneo.
  • Durante la creación de las respuestas, Dialogflow quita las etiquetas HTML del contenido. Debido a esto, es recomendable que evites las etiquetas HTML y uses texto sin formato siempre sea posible.
  • Las respuestas del Asistente de Google tienen un límite de 640 caracteres por cuadro de chat, por lo que las respuestas largas se truncan cuando se integran en el Asistente de Google.
  • El tamaño máximo del documento depende de tu edición y plan de precios:
    • Estándar: 50 MB
    • Essentials: 50 MB
    • Plus: ilimitado
  • Cuando usas archivos de Cloud Storage, debes usar URI públicos o privados a los que tu cuenta de servicio o usuario tenga acceso.

Información específica sobre las Preguntas frecuentes:

  • El CSV debe tener preguntas en la primera columna y respuestas en la segunda, sin encabezado.
  • Usa CSV cuando sea posible, porque el CSV se analiza con mayor precisión.
  • El contenido HTML público con un único par de QA no es compatible.
  • La cantidad de pares de QA en un documento no debe ser superior a 2,000.
  • Las preguntas duplicadas con diferentes respuestas no son compatibles.

Información específica sobre los artículos de base de conocimiento:

  • Por el momento, el artículo de base de conocimiento es experimental. Se basa en tecnologías similares que se probaron en productos de Google, como la Búsqueda y el Asistente. Envíanos comentarios sobre su funcionamiento en Dialogflow.
  • Se obtienen mejores resultados con contenido de texto denso. Evita el contenido que tenga muchos párrafos de una sola oración.
  • Las tablas y listas no son compatibles.
  • Cada documento puede tener 2,000 párrafos como máximo.
  • Si un artículo es largo (más de 1,000 palabras), intenta dividirlo en varios artículos más pequeños. Si se tratan varios temas juntos, puedes dividirlo en varios artículos más breves sobre cada tema. Si todo el artículo trata sobre un solo tema, enfoca el artículo en la descripción del problema y mantén breve la solución.
  • Lo ideal es que proporciones solo el contenido principal del artículo (la descripción del problema y su solución). El contenido adicional (como el nombre del autor, el historial de modificaciones, los vínculos relacionados y los anuncios) no es importante.
  • Es recomendable que incluyas una descripción de los problemas para los que puede servir el artículo o ejemplos de consultas que pueden responderse con el artículo.