Interaktionen mit der API

Die Verwendung der API für CX ähnelt der Verwendung der API für ES, mit der Ausnahme, dass einige Ressourcenpfade und Methoden geändert wurden, um neue Typen, Methoden und Felder einzuschließen.

Ihr System muss Folgendes verarbeiten:

  • Dialogflow CX unterstützt noch keine Einbundung. Daher muss Ihr System eine Benutzeroberfläche zur direkten Interaktion mit Endnutzern bereitstellen.
  • Sie müssen die Dialogflow API für jeden Sprecherwechsel aufrufen, um Endnutzereingaben an die API zu senden.
  • Wenn die Agent-Antworten nicht nur statisch sind (seltener), müssen Sie einen Webhook-Dienst für die Verarbeitung der Webhook-aktivierten Auftragsausführung hosten.

Das folgende Diagramm zeigt die Schritte, die für einen Sprecherwechsel einer Sitzung ausgeführt werden.

API-Ablaufdiagramm.

  1. Der Endnutzer gibt etwas ein oder sagt etwas. Dies wird als Endnutzereingabe bezeichnet.
  2. Ihr Benutzeroberflächensystem empfängt die Eingabe und leitet sie in einer Anfrage zur Intent-Erkennung an die Dialogflow API weiter.
  3. Die Dialogflow API empfängt die Anfrage zur Intent-Erkennung. Sie ordnet die Eingabe einem Intent- oder Formularparameter zu, legt bei Bedarf Parameter fest und aktualisiert den Sitzungsstatus. Falls eine Webhook-fähige Auftragsausführung aufgerufen werden muss, wird eine Webhook-Anfrage an Ihren Webhook-Dienst gesendet. Fahren Sie andernfalls mit Schritt 6 fort.
  4. Ihr Webhook-Dienst empfängt die Webhook-Anfrage. Der Dienst führt alle erforderlichen Aktionen aus, z. B. das Aufrufen externer APIs, das Abfragen oder Aktualisieren einer Datenbank usw.
  5. Ihr Webhook-Dienst erstellt eine Antwort und sendet eine Webhook-Antwort an Dialogflow.
  6. Dialogflow erstellt eine Antwort für die Intent-Erkennung. Wenn ein Webhook aufgerufen wurde, verwendet es die Webhook-Antwort. Wenn kein Webhook aufgerufen wurde, verwendet es die im Agent definierte statische Antwort. Dialogflow sendet eine Antwort für die Intent-Erkennung an Ihre Benutzeroberfläche.
  7. Ihr Benutzeroberflächensystem empfängt die Antwort für die Intent-Erkennung und leitet die Text- oder Audioantwort an den Endnutzer weiter.
  8. Der Endnutzer sieht oder hört die Antwort.

Das Senden einer Endnutzereingabe zur CX API ist für die Verarbeitung sehr ähnlich wie bei der ES API. Im folgenden Beispiel wird die Methode detectIntent der Ressource Sessions aufgerufen.

REST UND BEFEHLSZEILE

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

  • project-id: ID Ihres GCP-Projekts
  • agent-id: Agent-ID
  • session-id: Sitzungs-ID
  • end-user-input: Endnutzereingabe

HTTP-Methode und URL:

POST https://dialogflow.googleapis.com/v3beta1/projects/project-id/locations/us/agents/agent-id/sessions/session-id:detectIntent

JSON-Text anfordern:

{
  "queryInput": {
    "text": {
      "text": "end-user-input"
    },
    "languageCode": "en"
  },
  "queryParams": {
    "timeZone": "America/Los_Angeles"
  }
}

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

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "responseId": "89dd432b-1df4-48c4-be6b-d6550c3422b0",
  "queryResult": {
    "text": "I want to ask about data plans for international travel.",
    "languageCode": "en",
    "responseMessages": [
      {
        "text": {
          "text": [
            "Sure! I can help with that. "
          ]
        }
      },
      {
        "text": {
          "text": [
            "I need to ask a few questions before I can find the best option for you."
          ]
        }
      },
      {
        "text": {
          "text": [
            "What's your name?"
          ]
        }
      }
    ],
    "currentPage": {
      "name": "projects/project-id/locations/us/agents/027ac861-f275-45ed-a879-92aeb554df4e/pages/48d4352f-c995-4e46-8857-999709882959",
      "displayName": "Collect Customer Info"
    },
    "intent": {
      "name": "projects/project-id/locations/us/agents/027ac861-f275-45ed-a879-92aeb554df4e/intents/d48acf76-10f6-491f-be0c-cb58e1ce74d6",
      "displayName": "Data Plan Intent"
    },
    "intentDetectionConfidence": 1
  }
}

Java


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

public class DetectIntent {

  // DialogFlow API Detect Intent sample with text inputs.
  public static Map<String, QueryResult> detectIntent(
      String projectId,
      String locationId,
      String agentId,
      String sessionId,
      List<String> texts,
      String languageCode)
      throws IOException, ApiException {
    Map<String, QueryResult> queryResults = Maps.newHashMap();
    // Instantiates a client
    try (SessionsClient sessionsClient = SessionsClient.create()) {
      // Set the session name using the projectID (my-project-id), locationID (global), agentID
      // (UUID), and sessionId (UUID).
      SessionName session = SessionName.of(projectId, locationId, agentId, sessionId);
      System.out.println("Session Path: " + session.toString());

      // Detect intents for each text input.
      for (String text : texts) {
        // Set the text (hello) for the query.
        TextInput.Builder textInput = TextInput.newBuilder().setText(text);

        // Build the query with the TextInput and language code (en-US).
        QueryInput queryInput =
            QueryInput.newBuilder().setText(textInput).setLanguageCode(languageCode).build();

        // Build the DetectIntentRequest with the SessionName and QueryInput.
        DetectIntentRequest request =
            DetectIntentRequest.newBuilder()
                .setSession(session.toString())
                .setQueryInput(queryInput)
                .build();

        // Performs the detect intent request.
        DetectIntentResponse response = sessionsClient.detectIntent(request);

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

        System.out.println("====================");
        System.out.format("Query Text: '%s'\n", queryResult.getText());
        System.out.format(
            "Detected Intent: %s (confidence: %f)\n",
            queryResult.getIntent().getDisplayName(), queryResult.getIntentDetectionConfidence());

        queryResults.put(text, queryResult);
      }
    }
    return queryResults;
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const location = 'global';
// const agentId = 'my-agent';
// const query = ['Hello'];
// const languageCode = 'en'

// Imports the Google Cloud Some API library
const {SessionsClient} = require('@google-cloud/dialogflow-cx');
const client = new SessionsClient();

async function detectIntentText() {
  const sessionId = Math.random().toString(36).substring(7);
  const sessionPath = client.projectLocationAgentSessionPath(
    projectId,
    location,
    agentId,
    sessionId
  );
  console.info(sessionPath);

  const request = {
    session: sessionPath,
    queryInput: {
      text: {
        text: query,
      },
      languageCode,
    },
  };
  const [response] = await client.detectIntent(request);
  console.log(`User Query: ${query}`);
  for (const message of response.queryResult.responseMessages) {
    if (message.text) {
      console.log(`Agent Response: ${message.text.text}`);
    }
  }
  if (response.queryResult.match.intent) {
    console.log(
      `Matched Intent: ${response.queryResult.match.intent.displayName}`
    );
  }
  console.log(
    `Current Page: ${response.queryResult.currentPage.displayName}`
  );
}

detectIntentText();

Python

def run_sample():
    # TODO(developer): Replace these values when running the function
    project_id = "YOUR-PROJECT-ID"
    location_id = "YOUR-LOCATION-ID"
    # For more info on agents see https://cloud.google.com/dialogflow/cx/docs/concept/agent
    agent_id = "YOUR-AGENT-ID"
    agent = f"projects/{project_id}/locations/{location_id}/agents/{agent_id}"
    # For more information on sessions see https://cloud.google.com/dialogflow/cx/docs/concept/session
    session_id = uuid.uuid4()
    texts = ["Hello"]
    # For more supported languages see https://cloud.google.com/dialogflow/es/docs/reference/language
    language_code = "en-us"

    detect_intent_texts(agent, session_id, texts, language_code)

def detect_intent_texts(agent, session_id, texts, language_code):
    """Returns the result of detect intent with texts as inputs.

    Using the same `session_id` between requests allows continuation
    of the conversation."""
    session_client = SessionsClient()
    session_path = f"{agent}/sessions/{session_id}"
    print(f"Session path: {session_path}\n")

    for text in texts:
        text_input = session.TextInput(text=text)
        query_input = session.QueryInput(text=text_input, language_code=language_code)
        request = session.DetectIntentRequest(
            session=session_path, query_input=query_input
        )
        response = session_client.detect_intent(request=request)

        print("=" * 20)
        print(f"Query text: {response.query_result.text}")
        response_messages = [
            " ".join(msg.text.text) for msg in response.query_result.response_messages
        ]
        print(f"Response text: {' '.join(response_messages)}\n")