빠른 시작: API와의 상호작용

이 빠른 시작은 명령줄에서 REST API를 사용하고 클라이언트 라이브러리를 사용하여 에이전트와 상호작용하는 방법을 보여줍니다.

시작하기 전에

API를 사용할 계획이 없다면 이 빠른 시작을 생략해도 됩니다.

이 가이드를 읽기 전에 다음을 수행해야 합니다.

  1. Dialogflow 기본사항 이해
  2. 설정 단계 수행
  3. 에이전트 빌드 방법 알아보기

에이전트 만들기

이 가이드의 단계에서는 에이전트에 대한 가정을 하므로 새 에이전트로 시작하는 것이 좋습니다. 새 에이전트를 만들기 전에 프로젝트의 기존 에이전트를 삭제해야 합니다. 기존 에이전트를 삭제하려면 다음 안내를 따르세요.

  1. Dialogflow 콘솔로 이동합니다.
  2. 로그인 메시지가 표시되면 Dialogflow 콘솔에 로그인합니다. 자세한 내용은 Dialogflow 콘솔 개요를 참조하세요.
  3. 삭제할 에이전트를 선택합니다.
  4. 에이전트 이름 옆의 설정 settings 버튼을 클릭합니다.
  5. 아래로 스크롤하여 일반 설정 탭으로 이동합니다.
  6. 이 에이전트 삭제를 클릭합니다.
  7. 텍스트 필드에 DELETE를 입력합니다.
  8. Delete(삭제)를 클릭합니다.

에이전트를 만들려면 다음 안내를 따르세요.

  1. Dialogflow 콘솔로 이동합니다.
  2. 로그인 메시지가 표시되면 Dialogflow 콘솔에 로그인합니다. 자세한 내용은 Dialogflow 콘솔 개요를 참조하세요.
  3. 왼쪽 사이드바 메뉴에서 에이전트 만들기를 클릭합니다. 이미 다른 에이전트가 있는 경우 에이전트 이름을 클릭하고 아래로 스크롤하여 새 에이전트 만들기를 클릭합니다.
  4. 에이전트 이름, 기본 언어, 기본 시간대를 입력합니다.
  5. 프로젝트를 이미 만든 경우 해당 프로젝트를 입력합니다. Dialogflow 콘솔이 프로젝트를 만들 수 있게 하려면 새 Google 프로젝트 만들기를 선택하세요.
  6. 만들기 버튼을 클릭합니다.

에이전트로 예시 파일 가져오기

가져오기를 수행하면 에이전트에 인텐트와 항목이 추가됩니다. 기존 인텐트 또는 항목이 가져온 파일에 있는 인텐트 또는 항목과 이름이 같으면 대체됩니다.

파일을 가져오려면 다음 단계를 따르세요.

  1. RoomReservation.zip 파일을 다운로드합니다.
  2. Dialogflow 콘솔로 이동합니다.
  3. 에이전트를 선택합니다.
  4. 에이전트 이름 옆의 설정 버튼을 클릭합니다.
  5. 내보내기 및 가져오기 탭을 선택합니다.
  6. Zip 파일에서 가져오기를 선택하고 다운로드한 Zip 파일을 가져옵니다.

세션

세션은 Dialogflow 에이전트와 최종 사용자 간의 대화를 나타냅니다. 대화를 시작할 때 세션을 만들고 대화 차례마다 이 세션을 사용합니다. 대화가 종료되면 세션 사용을 중단합니다.

여러 최종 사용자와 동시에 진행되는 대화에서 동일한 세션을 사용하면 안 됩니다. Dialogflow는 각 활성 세션에 현재 활성인 컨텍스트를 유지합니다. Dialogflow는 20분 동안 세션 데이터를 저장합니다.

각 세션은 시스템에서 생성되는 세션 ID로 고유하게 구분됩니다. 인텐트 감지 요청에 새 세션 ID를 제공하여 새 세션을 만듭니다. 세션 ID는 최대 36바이트 크기의 문자열입니다. 시스템은 고유한 세션 ID를 생성합니다. 세션 ID는 랜덤 숫자, 해싱된 최종 사용자 식별자 또는 사용자가 생성하기 편리한 기타 값일 수 있습니다.

인텐트 감지

상호작용에 API를 사용하면 서비스는 최종 사용자와 직접 상호작용합니다. 각 대화 차례에서 서비스는 Sessions 유형의 detectIntent 또는 streamingDetectIntent 메서드를 호출하여 Dialogflow에 최종 사용자 표현을 전송합니다. Dialogflow는 일치하는 인텐트, 작업, 매개변수, 인텐트에 정의된 응답에 대한 정보로 응답합니다. 서비스는 필요에 따라 작업을 수행하고(예: 데이터베이스 쿼리 또는 외부 API 호출) 최종 사용자에게 메시지를 전송합니다. 이 프로세스는 대화가 종료될 때까지 계속됩니다.

위의 단계에서 가져온 에이전트는 간단한 객실 예약 에이전트입니다. 인텐트를 살펴보려면 Dialogflow 콘솔을 방문하고 새 에이전트를 선택하세요.

다음 샘플은 인텐트를 감지하는 방법을 보여줍니다. 각 샘플은 다음 입력의 하위 집합을 받습니다.

  • 프로젝트 ID: 설정 단계에서 생성한 프로젝트의 프로젝트 ID를 사용합니다.
  • 세션 ID: 에이전트 테스트를 위해 무엇이든 사용할 수 있습니다. 예를 들어 '123456789'는 샘플에 자주 사용됩니다.
  • 텍스트: 하나의 최종 사용자 표현 또는 최종 사용자 표현 목록입니다. 여러 표현이 제공되는 경우 샘플 코드는 각 표현에 대해 인텐트 감지를 호출합니다. 'reserve a meeting room for six people'을 입력해 보세요.
  • 언어 코드: 최종 사용자 표현의 언어 코드입니다. 이 예시 에이전트에서는 'en-US'를 사용합니다.

REST 및 명령줄

인텐트를 감지하려면 Sessions 리소스에서 detectIntent 메서드를 호출합니다..

아래의 요청 데이터를 사용하기 전에 다음을 바꿉니다.

  • project-id: GCP 프로젝트 ID
  • session-id: 세션 ID

HTTP 메서드 및 URL:

POST https://dialogflow.googleapis.com/v2/projects/project-id/agent/sessions/session-id:detectIntent

JSON 요청 본문:

{
  "query_input": {
    "text": {
      "text": "reserve a meeting room for six people",
      "language_code": "en-US"
    }
  }
}

요청을 보내려면 다음 옵션 중 하나를 펼칩니다.

C#

        public static int DetectIntentFromTexts(string projectId,
                                                string sessionId,
                                                string[] texts,
                                                string languageCode = "en-US")
        {
            var client = SessionsClient.Create();

            foreach (var text in texts)
            {
                var response = client.DetectIntent(
                    session: new SessionName(projectId, sessionId),
                    queryInput: new QueryInput()
                    {
                        Text = new TextInput()
                        {
                            Text = text,
                            LanguageCode = languageCode
                        }
                    }
                );

                var queryResult = response.QueryResult;

                Console.WriteLine($"Query text: {queryResult.QueryText}");
                if (queryResult.Intent != null)
                {
                    Console.WriteLine($"Intent detected: {queryResult.Intent.DisplayName}");
                }
                Console.WriteLine($"Intent confidence: {queryResult.IntentDetectionConfidence}");
                Console.WriteLine($"Fulfillment text: {queryResult.FulfillmentText}");
                Console.WriteLine();
            }

            return 0;
        }

Go

func DetectIntentText(projectID, sessionID, text, languageCode string) (string, error) {
	ctx := context.Background()

	sessionClient, err := dialogflow.NewSessionsClient(ctx)
	if err != nil {
		return "", err
	}
	defer sessionClient.Close()

	if projectID == "" || sessionID == "" {
		return "", errors.New(fmt.Sprintf("Received empty project (%s) or session (%s)", projectID, sessionID))
	}

	sessionPath := fmt.Sprintf("projects/%s/agent/sessions/%s", projectID, sessionID)
	textInput := dialogflowpb.TextInput{Text: text, LanguageCode: languageCode}
	queryTextInput := dialogflowpb.QueryInput_Text{Text: &textInput}
	queryInput := dialogflowpb.QueryInput{Input: &queryTextInput}
	request := dialogflowpb.DetectIntentRequest{Session: sessionPath, QueryInput: &queryInput}

	response, err := sessionClient.DetectIntent(ctx, &request)
	if err != nil {
		return "", err
	}

	queryResult := response.GetQueryResult()
	fulfillmentText := queryResult.GetFulfillmentText()
	return fulfillmentText, nil
}

자바


/**
 * Returns the result of detect intent with texts as inputs.
 *
 * Using the same `session_id` between requests allows continuation of the conversation.
 *
 * @param projectId    Project/Agent Id.
 * @param texts        The text intents to be detected based on what a user says.
 * @param sessionId    Identifier of the DetectIntent session.
 * @param languageCode Language code of the query.
 * @return The QueryResult for each input text.
 */
public static Map<String, QueryResult> detectIntentTexts(
    String projectId,
    List<String> texts,
    String sessionId,
    String languageCode) throws Exception {
  Map<String, QueryResult> queryResults = Maps.newHashMap();
  // Instantiates a client
  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 (hello) 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();

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

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

      System.out.println("====================");
      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());

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

Node.js


/**
 * TODO(developer): UPDATE these variables before running the sample.
 */
// projectId: ID of the GCP project where Dialogflow agent is deployed
// const projectId = 'PROJECT_ID';
// sessionId: Random number or hashed user identifier
// const sessionId = 123456;
// queries: A set of sequential queries to be send to Dialogflow agent for Intent Detection
// const queries = [
//   'Reserve a meeting room in Toronto office, there will be 5 of us',
//   'Next monday at 3pm for 1 hour, please', // Tell the bot when the meeting is taking place
//   'B'  // Rooms are defined on the Dialogflow agent, default options are A, B, or C
// ]
// languaceCode: Indicates the language Dialogflow agent should use to detect intents
// const languageCode = 'en';

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

// Instantiates a session client
const sessionClient = new dialogflow.SessionsClient();

async function detectIntent(
  projectId,
  sessionId,
  query,
  contexts,
  languageCode
) {
  // The path to identify the agent that owns the created intent.
  const sessionPath = sessionClient.sessionPath(projectId, sessionId);

  // The text query request.
  const request = {
    session: sessionPath,
    queryInput: {
      text: {
        text: query,
        languageCode: languageCode,
      },
    },
  };

  if (contexts && contexts.length > 0) {
    request.queryParams = {
      contexts: contexts,
    };
  }

  const responses = await sessionClient.detectIntent(request);
  return responses[0];
}

async function executeQueries(projectId, sessionId, queries, languageCode) {
  // Keeping the context across queries let's us simulate an ongoing conversation with the bot
  let context;
  let intentResponse;
  for (const query of queries) {
    try {
      console.log(`Sending Query: ${query}`);
      intentResponse = await detectIntent(
        projectId,
        sessionId,
        query,
        context,
        languageCode
      );
      console.log('Detected intent');
      console.log(
        `Fulfillment Text: ${intentResponse.queryResult.fulfillmentText}`
      );
      // Use the context from this response for next queries
      context = intentResponse.queryResult.outputContexts;
    } catch (error) {
      console.log(error);
    }
  }
}
executeQueries(projectId, sessionId, queries, languageCode);

PHP

namespace Google\Cloud\Samples\Dialogflow;

use Google\Cloud\Dialogflow\V2\SessionsClient;
use Google\Cloud\Dialogflow\V2\TextInput;
use Google\Cloud\Dialogflow\V2\QueryInput;

/**
 * Returns the result of detect intent with texts as inputs.
 * Using the same `session_id` between requests allows continuation
 * of the conversation.
 */
function detect_intent_texts($projectId, $texts, $sessionId, $languageCode = 'en-US')
{
    // new session
    $sessionsClient = new SessionsClient();
    $session = $sessionsClient->sessionName($projectId, $sessionId ?: uniqid());
    printf('Session path: %s' . PHP_EOL, $session);

    // query for each string in array
    foreach ($texts as $text) {
        // create text input
        $textInput = new TextInput();
        $textInput->setText($text);
        $textInput->setLanguageCode($languageCode);

        // create query input
        $queryInput = new QueryInput();
        $queryInput->setText($textInput);

        // get response and relevant info
        $response = $sessionsClient->detectIntent($session, $queryInput);
        $queryResult = $response->getQueryResult();
        $queryText = $queryResult->getQueryText();
        $intent = $queryResult->getIntent();
        $displayName = $intent->getDisplayName();
        $confidence = $queryResult->getIntentDetectionConfidence();
        $fulfilmentText = $queryResult->getFulfillmentText();

        // output relevant info
        print(str_repeat("=", 20) . PHP_EOL);
        printf('Query text: %s' . PHP_EOL, $queryText);
        printf('Detected intent: %s (confidence: %f)' . PHP_EOL, $displayName,
            $confidence);
        print(PHP_EOL);
        printf('Fulfilment text: %s' . PHP_EOL, $fulfilmentText);
    }

    $sessionsClient->close();
}

Python

def detect_intent_texts(project_id, 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."""
    import dialogflow_v2 as dialogflow
    session_client = dialogflow.SessionsClient()

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

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

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

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

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

Ruby

# project_id = "Your Google Cloud project ID"
# session_id = "mysession"
# texts = ["hello", "book a meeting room"]
# language_code = "en-US"

require "google/cloud/dialogflow"

session_client = Google::Cloud::Dialogflow::Sessions.new
session = session_client.class.session_path project_id, session_id
puts "Session path: #{session}"

texts.each do |text|
  query_input = { text: { text: text, language_code: language_code } }
  response = session_client.detect_intent session, query_input
  query_result = response.query_result

  puts "Query text:        #{query_result.query_text}"
  puts "Intent detected:   #{query_result.intent.display_name}"
  puts "Intent confidence: #{query_result.intent_detection_confidence}"
  puts "Fulfillment text:  #{query_result.fulfillment_text}\n"
end

이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...

Dialogflow 문서
도움이 필요하시나요? 지원 페이지를 방문하세요.