Wissensconnectors

Wissensconnectors ergänzen definierte Intents. Sie parsen Wissensdokumente (z. B. FAQ oder Artikel), um automatisierte Antworten zu finden. Um diese zu konfigurieren, definieren Sie eine oder mehrere Wissensdatenbanken, bei denen es sich um Sammlungen von Wissensdokumenten handelt.

Sie haben die Möglichkeit, Wissensdatenbanken für Ihren Agent zu aktivieren, sodass darin auf alle Anfragen zur Intent-Erkennung automatisch Antworten ermittelt werden können. Alternativ können Sie in Ihren individuellen Anfragen zur Intent-Erkennung eine oder mehrere Wissensdatenbanken angeben.

Agents, die Wissensconnectors verwenden, nutzen in der Regel auch definierte Intents. Wissensconnectors bieten ungenauere Antworten und Kontrollmöglichkeiten als Intents. Definieren Sie Ihre Intents für die Verarbeitung komplexer Nutzeranfragen und lassen Sie Wissensconnectors einfache Anfragen verarbeiten.

Eine Liste der unterstützten Sprachen finden Sie in der Sprachreferenz in der Spalte Wissensconnectors.

Betafeatures aktivieren

Prüfen Sie, ob die Betafeatures aktiviert sind:

  1. Öffnen Sie die Dialogflow-Konsole.
  2. Wählen Sie einen Agent aus.
  3. Klicken Sie neben dem Agent-Namen auf die Schaltfläche  für die Einstellungen.
  4. Scrollen Sie auf dem Tab General nach unten und prüfen Sie, ob Beta Features aktiviert ist.
  5. Wenn Sie Änderungen vorgenommen haben, klicken Sie auf Save.

Wissensdatenbank und Dokument erstellen

Folgen Sie der Anleitung in der Anleitung zu Wissensdatenbanken, um eine Wissensdatenbank und ein Dokument zu erstellen.

Einstellungen für Wissensconnectors

Sie können für Ihren Agent eine Wissensdatenbanken aktivieren oder deaktivieren. Aktivierte Wissensdatenbanken werden bei allen Anfragen mit Intent-Übereinstimmung berücksichtigt, die keine Wissensdatenbanken angeben. So aktivieren oder deaktivieren Sie Wissensdatenbanken:

  1. Öffnen Sie die Dialogflow-Konsole.
  2. Wählen Sie einen Agent aus.
  3. Klicken Sie im linken Seitenleistenmenü auf Knowledge.
  4. Wählen Sie eine oder mehrere Wissensdatenbanken aus der Liste aus.
  5. Klicken Sie auf Enable oder Disable.

Wenn ein Endnutzerausdruck auch mit einem Intent übereinstimmt, können Sie festlegen, wie stark Sie Wissensergebnisse bevorzugen:

  1. Scrollen Sie nach unten zum Abschnitt Adjust Knowledge Results Preference.
  2. Stellen Sie den Schieberegler zwischen "schwächer" (Intent wird bevorzugt) und "stärker" (Wissen wird bevorzugt) ein. Weitere Informationen finden Sie unten unter Intent-Antworten erkennen.

Antworten konfigurieren

Standardmäßig wird eine Wissensdatenbank mit einer Standardtextantwort konfiguriert, die mit der am besten passenden Wissensantwort gefüllt wird. Sie können diese Antwort ändern und Rich-Media-Antworten hinzufügen. Wissensantworten können mehrere Antworten enthalten, auf die Sie in Ihren konfigurierten Antworten verweisen können. So fügen Sie Antworten hinzu:

  1. Klicken Sie auf der Seite Knowledge auf den Namen Ihrer Wissensdatenbank.
  2. Scrollen Sie nach unten zum Abschnitt Responses und fügen Sie nach Wunsch Antworten hinzu:
    1. Legen Sie bei der ersten Antwort mit $Knowledge.Question[1] und $Knowledge.Answer[1] fest, wo die Frage und die Antwort angegeben werden sollen.
    2. Der Index für $Knowledge.Question und $Knowledge.Answer beginnt bei 1. Erhöhen Sie diesen Index, wenn Sie weitere Antworten einfügen.
  3. Klicken Sie nach der Bearbeitung auf Save.

Beachten Sie beim Definieren von Antworten folgende Punkte:

  • Ist die Anzahl der definierten Antworten größer als die Anzahl N der Übereinstimmungen der Antworten des Wissensconnectors, werden nur N Antworten zurückgegeben.
  • Da die Genauigkeit niedriger als bei der Übereinstimmung mit explizit definierten Intents sein kann, empfiehlt es sich, nach Möglichkeit mindestens drei Antworten an die Nutzer zurückzugeben.

Beispiel:

Screenshot der Integration von Wissensconnectors

Intent mit Wissensdatenbank erkennen

Beim Erstellen einer Anfrage zur Intent-Erkennung können Sie eine oder mehrere Wissensdatenbanken für eine mögliche Antwort angeben. Die explizite Angabe von Wissensdatenbanken in einer Anfrage überschreibt die Einstellungen für aktivierte und deaktivierte Wissensdatenbanken.

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

Web-UI

Sie können über den Dialogflow-Simulator mit dem Agent interagieren und Antworten für Wissensconnetors erhalten:

  1. Aktivieren Sie mithilfe der obigen Schritte eine Wissensdatenbank.
  2. Definieren Sie mithilfe der obigen Schritte Antworten.
  3. Geben Sie in den Simulator Folgendes ein: "How do I sign up?" (Wie melde ich mich an?).

REST UND BEFEHLSZEILE

Rufen Sie die Methode detectIntent des Typs Sessions auf und geben Sie die Wissensbasis im Feld queryParams an.

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • project-id: ID Ihres GCP-Projekts
  • knowledge-base-id: Ihre Wissensdatenbank-ID

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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


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.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('@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

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

Intent-Antworten erkennen

Die Antwort für die Methode detectIntent des Typs Sessions ist ein DetectIntentResponse. Wie Antwortfelder ausgefüllt werden, hängt von mehreren Faktoren ab.

Wenn ein definierter Intent und eine Wissensdatenbank jeweils potenzielle Übereinstimmungen zurückgeben, erfolgt die Auswahl der Übereinstimmung anhand des jeweiligen Konfidenzwerts und der Einstellung für Wissensergebnisse. Weitere Informationen erhalten Sie unter Einstellungen für Wissensconnectors. Die ausgewählte Übereinstimmung sehen Sie im Feld DetectIntentResponse.queryResult. Weitere potenzielle Übereinstimmungen werden im Feld DetectIntentResponse.alternativeQueryResults angegeben. Beide Felder enthalten Nachrichten vom Typ QueryResult.

Folgendes geschieht, wenn eine Wissensdatenbank eine potenzielle Übereinstimmung liefert:

  • QueryResult.knowledgeAnswers wird mit einer Liste potenzieller Wissensantworten gefüllt, die absteigend nach Konfidenzwert sortiert sind.
  • Wenn für die Wissensdatenbank umfangreiche Antworten definiert wurden, wird QueryResult.fulfillmentMessages mit umfangreichen Antwortnachrichten gefüllt.

Wenn Sie eine Anfrage zur Intent-Erkennung stellen, kann die Wissensabfrage fehlschlagen. In diesem Fall werden definierte Intents ausgewählt, sodass die allgemeine Anfrage zur Intent-Erkennung erfolgreich ist. Informationen zu Fehlern bei Wissensanfragen finden Sie im Feld DetectIntentResponse.alternativeQueryResults[i].diagnosticInfo.

Wissensdatenbanken verwalten

Weitere Informationen zum Verwalten von Wissensdatenbanken finden Sie unter Wissensdatenbanken verwalten.