Wissensdatenbanken verwalten

Eine Wissensdatenbank stellt eine Sammlung von Wissensdokumenten dar, die Sie Dialogflow zur Verfügung stellen. Ihre Wissensdokumente enthalten Informationen, die bei Gesprächen mit Endnutzern nützlich sein können. Einige Dialogflow-Features verwenden Wissensdatenbanken, wenn nach einer Antwort auf einen Endnutzerausdruck gesucht wird. In diesem Leitfaden wird beschrieben, wie Sie Wissensdatenbanken erstellen und verwalten.

Vorbereitung

Bevor Sie diese Anleitung lesen, sollten Sie mit Folgendem vertraut sein:

  1. Grundlagen von Dialogflow
  2. Einrichtungsschritte ausführen

Knowledge Base erstellen

In den folgenden Beispielen wird gezeigt, wie Sie die Dialogflow-Konsole, die REST API (mit Befehlszeilentool) oder die Clientbibliotheken zur Erstellung einer Wissensdatenbank verwenden. Rufen Sie zur Verwendung der API die Methode create des Typs KnowledgeBase auf.

Web-UI

Verwenden Sie die Dialogflow-Konsole, um eine Wissensdatenbank zu erstellen:

  1. Rufen Sie die Dialogflow ES-Konsole auf.
  2. Wählen Sie einen Agent aus.
  3. Klicken Sie im linken Seitenleistenmenü auf Knowledge (Wissen).
  4. Klicken Sie auf Create Knowledge Base (Wissensdatenbank erstellen).
  5. Geben Sie einen Namen für die Wissensdatenbank ein.
  6. Klicken Sie auf Speichern.

REST UND BEFEHLSZEILE

Ersetzen Sie diese Werte, bevor Sie die Anfragedaten unten verwenden:

  • project-id: ID Ihres GCP-Projekts
  • knowledge-base-display-name: Name der gewünschten Wissensdatenbank

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

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

Beachten Sie den Wert im Feld name. Dies ist der Name Ihrer neuen Wissensdatenbank. Das Pfadsegment nach knowledgeBases ist Ihre neue Wissensdatenbank-ID. Speichern Sie diese ID für nachfolgende Anfragen.

Java


import com.google.api.gax.rpc.ApiException;
import com.google.cloud.dialogflow.v2beta1.KnowledgeBase;
import com.google.cloud.dialogflow.v2beta1.KnowledgeBasesClient;
import com.google.cloud.dialogflow.v2beta1.ProjectName;
import java.io.IOException;

public class KnowledgeBaseManagement {

  // Create a Knowledge base
  public static KnowledgeBase createKnowledgeBase(String projectId, String displayName)
      throws ApiException, IOException {
    // 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('@google-cloud/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 = 'projects/' + 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."""
    from google.cloud import dialogflow_v2beta1 as dialogflow
    client = dialogflow.KnowledgeBasesClient()
    project_path = client.common_project_path(project_id)

    knowledge_base = dialogflow.KnowledgeBase(
        display_name=display_name)

    response = client.create_knowledge_base(
        parent=project_path,
        knowledge_base=knowledge_base
    )

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

Dokument der Knowledge Base hinzufügen

Da die neue Wissensdatenbank noch keine Dokumente enthält, soll ihr ein Dokument hinzugefügt werden. Unter Unterstützter Inhalt unten finden Sie eine Beschreibung aller unterstützten Inhaltsoptionen. Für dieses Beispiel können Sie das FAQ zu Cloud Storage verwenden.

In den folgenden Beispielen wird gezeigt, wie Sie die Dialogflow-Konsole, die REST API (mit Befehlszeilentool) oder die Clientbibliotheken zur Erstellung eines Wissensdokuments verwenden. Rufen Sie zur Verwendung der API die Methode create des Typs Document auf.

Web-UI

Verwenden Sie die Dialogflow-Konsole, um ein Wissensdokument zu erstellen:

  1. Wenn Sie hier nicht die Schritte von oben fortführen, können Sie die Einstellungen der Wissensdatenbank aufrufen:
    1. Rufen Sie die Dialogflow ES-Konsole auf.
    2. Wählen Sie einen Agent aus.
    3. Klicken Sie im linken Seitenleistenmenü auf Knowledge (Wissen).
    4. Klicken Sie auf den Namen Ihrer Wissensdatenbank.
  2. Klicken Sie auf New Document (Neues Dokument) oder Create the first one (Erstes erstellen).
  3. Geben Sie einen Namen für das Dokument ein.
  4. Wählen Sie als Mime Type (Mime-Typ) die Option text/html (Text/HTML) aus.
  5. Wählen Sie als Knowledge Type (Wissenstyp) die Option FAQ aus.
  6. Wählen Sie als Datenquelle die Option URL aus.
  7. Geben Sie im Feld URL https://cloud.google.com/storage/docs/faq ein.
  8. Klicken Sie auf Erstellen.

REST UND BEFEHLSZEILE

Ersetzen Sie diese Werte, bevor Sie die Anfragedaten unten verwenden:

  • project-id: ID Ihres GCP-Projekts
  • knowledge-base-id: ID Ihrer Wissensdatenbank (bei der vorherigen Anfrage zurückgegeben)
  • document-display-name: gewünschter Name des Wissensdokuments

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

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

Das Pfadsegment nach operations ist Ihre Vorgangs-ID.

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.api.gax.rpc.ApiException;
import com.google.cloud.dialogflow.v2beta1.CreateDocumentRequest;
import com.google.cloud.dialogflow.v2beta1.Document;
import com.google.cloud.dialogflow.v2beta1.Document.KnowledgeType;
import com.google.cloud.dialogflow.v2beta1.DocumentsClient;
import com.google.cloud.dialogflow.v2beta1.KnowledgeOperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DocumentManagement {

  public static Document createDocument(
      String knowledgeBaseName,
      String displayName,
      String mimeType,
      String knowledgeType,
      String contentUri)
      throws IOException, ApiException, InterruptedException, ExecutionException, TimeoutException {
    // 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(180, 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('@google-cloud/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."""
    from google.cloud import dialogflow_v2beta1 as dialogflow
    client = dialogflow.DocumentsClient()
    knowledge_base_path = dialogflow.KnowledgeBasesClient.knowledge_base_path(
        project_id, knowledge_base_id)

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

    document.knowledge_types.append(
        getattr(dialogflow.Document.KnowledgeType, knowledge_type)
    )

    response = client.create_document(parent=knowledge_base_path, document=document)
    print('Waiting for results...')
    document = response.result(timeout=120)
    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))

Das Erstellen eines Dokuments kann einige Zeit dauern. Sie können den Status dieses Vorgangs abrufen, um festzustellen, ob er abgeschlossen wurde. Anschließend enthält der Vorgang die neu erstellte Dokument-ID. Speichern Sie diese ID zur späteren Verarbeitung. Weitere Informationen finden Sie unter Vorgänge mit langer Laufzeit.

Wissensdokumente verwalten

Inhalt des Wissensdokuments aktualisieren

Wenn Sie Inhalte aktualisieren, die von einem Wissensdokument referenziert werden, wird Ihr Wissensdokument nicht automatisch aktualisiert.

Zum Aktualisieren des Inhalts von Cloud Storage oder eines öffentlichen URI-Dokuments rufen Sie die Methode reload für den Typ Document auf.

Verwenden Sie zum Aktualisieren hochgeladener Rohinhalte die Methoden delete und create für den Typ Document. Dadurch wird Ihr Dokument neu erstellt.

Wissensdokumente auflisten

Sie können alle Wissensdokumente für Ihre Wissensdatenbank auflisten. Rufen Sie zur Verwendung der API die Methode list des Typs Document auf.

Wissensdokumente löschen

Sie können Wissensdokumente in Ihrer Wissensdatenbank löschen. Rufen Sie zur Verwendung der API die Methode delete des Typs Document auf. Wenn Ihnen die Dokument-ID nicht vorliegt, können Sie die Dokumente wie oben beschrieben auflisten.

Unterstützter Inhalt

Die folgenden Wissensdokumenttypen werden unterstützt:

  • FAQ: Der Dokumentinhalt enthält Frage- und Antwortpaare, entweder als HTML- oder als CSV-Datei. Typische HTML-Formate für FAQ werden genau geparst, für ungewöhnliche Formate hingegen wird dies möglicherweise nicht durchgeführt. CSV-Dateien müssen in der ersten Spalte Fragen und in der zweiten Spalte Antworten enthalten und dürfen keine Kopfzeile haben. Aufgrund dieses expliziten Formats werden sie immer genau geparst.
  • Extractive QA: Dokumente, für die unstrukturierter Text extrahiert und zur Beantwortung von Fragen verwendet wird.

In der folgenden Tabelle finden Sie die unterstützten MIME-Typen nach Wissenstyp und Quelle sortiert.

Wissenstyp/Quelle Hochgeladene Datei (Document.content) (NICHT empfohlen) Hochgeladene Datei (Document.raw_content) (empfohlen) Datei aus Cloud Storage (Document.contentUri) Datei aus öffentlicher URL (Document.contentUri)
FAQ text/csv text/csv text/csv text/html
Extractive QA text/plain, text/html text/plain, text/html, application/pdf text/plain, text/html, application/pdf

Mit dem Dokumentinhalt sind die folgenden bekannten Probleme, Einschränkungen und Best Practices verbunden:

Allgemein:

  • Dateien aus öffentlichen URLs müssen vom Google-Suchindex gecrawlt worden sein, sodass sie im Suchindex erscheinen. Sie können dies mit der Google Search Console prüfen. Beachten Sie, dass Ihre Inhalte durch die Indexierung nicht aktualisiert werden. Sie müssen Ihr Wissensdokument explizit aktualisieren, wenn sich der Quellinhalt ändert.
  • CSV-Dateien müssen Kommas als Trennzeichen verwenden.
  • Konfidenzwerte sind noch nicht zwischen FAQ und Wissensdatenbank-Artikeln kalibriert. Wenn Sie sowohl FAQ als auch Wissensdatenbank-Artikel verwenden, ist das beste Ergebnis möglicherweise nicht immer das mit dem höchsten Konfidenzwert.
  • Dialogflow entfernt HTML-Tags beim Erstellen von Antworten aus dem Inhalt. Daher sollten Sie HTML-Tags vermeiden und nach Möglichkeit nur Text verwenden.
  • Google Assistant-Antworten sind pro Sprechblase auf 640 Zeichen beschränkt. Lange Antworten bei der Integration in Google Assistant werden abgeschnitten.
  • Dokumente können maximal 50 MB groß sein.
  • Wenn Sie Cloud Storage-Dateien verwenden, sollten Sie wahlweise öffentliche URIs oder private URIs verwenden, auf die Ihr Nutzer- oder Dienstkonto Zugriff hat.

Speziell für FAQ:

  • CSV-Dateien müssen in der ersten Spalte Fragen und in der zweiten Spalte Antworten enthalten und dürfen keine Kopfzeile haben.
  • Verwenden Sie nach Möglichkeit das CSV-Format, da dieses genauer geparst wird.
  • Öffentlicher HTML-Inhalt mit einem einzelnen QA-Paar wird nicht unterstützt.
  • Ein Dokument sollte maximal 2000 QA-Paare enthalten.
  • Doppelte Fragen mit unterschiedlichen Antworten werden nicht unterstützt.
  • Sie können auch ein anderes FAQ-Dokument verwenden. Der FAQ-Parser unterstützt die meisten FAQ-Formate.

Speziell für Extractive QA:

  • Extractive QA befindet sich derzeit in der Testphase. Das Verfahren ähnelt den Technologien, die von Google in Produkten wie Suche und Assistant getestet wurden. Senden Sie uns Ihr Feedback hinsichtlich der Funktionsweise mit Dialogflow.
  • Inhalt mit dichtem Text funktioniert am besten. Vermeiden Sie Inhalte mit vielen aus einem einzelnen Satz bestehenden Absätzen.
  • Tabellen und Listen werden nicht unterstützt.
  • Ein Dokument sollte maximal 2.000 Absätze enthalten.
  • Wenn ein Artikel lang ist (> 1000 Wörter), versuchen Sie, ihn in mehrere kleinere Artikel aufzuteilen. Wenn der Artikel mehrere Probleme behandelt, kann er in kürzere Artikel zu den einzelnen Problemen unterteilt werden. Wenn der Artikel nur ein Problem behandelt, konzentrieren Sie den Artikel auf die Problembeschreibung und halten Sie die Problemlösung kurz.
  • Im Idealfall sollte nur der Kerninhalt eines Artikels bereitgestellt werden (Beschreibung und Lösung des Problems). Zusätzlicher Inhalt wie der Name des Autors, der Änderungsverlauf, zugehörige Links und Anzeigen sind nicht wichtig.
  • Fügen Sie eine Beschreibung für die Probleme, bei denen ein Artikel helfen kann, und/oder Beispielabfragen ein, die in diesem Artikel beantwortet werden können.

Cloud Storage verwenden

Wenn Ihr Inhalt nicht öffentlich ist, sollten Sie Ihre Inhalte in Cloud Storage speichern. Beim Erstellen von Wissensdokumenten geben Sie die URLs für Ihre Cloud Storage-Objekte an.

Cloud Storage-Buckets und -Objekte erstellen

Beim Erstellen des Cloud Storage-Buckets:

  • Sie müssen das GCP-Projekt ausgewählt haben, das Sie für Dialogflow verwenden.
  • Verwenden Sie die Standard Storage-Klasse.
  • Legen Sie den Bucket-Speicherort auf einen Standort fest, der Ihrem Standort am nächsten ist. Für einige API-Aufrufe benötigen Sie die Standort-ID, z. B. us-west1. Am besten notieren Sie sich diese.

Folgen Sie der Cloud Storage-Kurzanleitung, um einen Bucket zu erstellen und Dateien hochzuladen.

Cloud Storage-Objekt einem Wissensdatenbankdokument bereitstellen

So stellen Sie Ihre Inhalte bereit:

  • Erstellen Sie eine Wissensdatenbank wie oben beschrieben.
  • Erstellen Sie wie oben beschrieben ein Wissensdokument. Legen Sie beim Aufrufen der Methode create für den Typ Document das Feld contentUri auf die URL Ihres Cloud Storage-Dokuments fest. Das Format dieser URL sieht so aus: gs://bucket-name/object-name.