Manage intents with the API

Intents determine which user requests are understood and what action to take. In most cases, you will use the Dialogflow Console to manage intents. In advanced scenarios, you may wish to use the API to manage intents. This page describes how to create, list, and delete intents using the API.

Set up your GCP project and authentication

Create an agent

Import the example file to your agent

Importing will add intents and entities to your agent. If any existing intents or entities have the same name as those in the imported file, they will be replaced.

To import the file, follow these steps:

  1. Download the RoomReservation.zip file
  2. Go to the Dialogflow Console
  3. Select your agent
  4. Click the settings settings button next to the agent name
  5. Select the Export and Import tab
  6. Select Import From Zip and import the zip file that you downloaded

Create intent

The following samples show how to create an intent. For more information, see the Intents reference.

REST & CMD LINE

To create an intent for your agent, call the create method on the intent resource.

Before using any of the request data below, make the following replacements:

  • project-id: your GCP project ID

HTTP method and URL:

POST https://dialogflow.googleapis.com/v2/projects/project-id/agent/intents

Request JSON body:

{
  "displayName": "ListRooms",
  "priority": 500000,
  "webhookState": "WEBHOOK_STATE_UNSPECIFIED",
  "trainingPhrases": [
    {
      "type": "EXAMPLE",
      "parts": [
        {
          "text": "What rooms are available at 10am today?"
        }
      ]
    }
  ],
  "action": "listRooms",
  "messages": [
    {
      "text": {
        "text": [
          "Here are the available rooms:"
        ]
      }
    }
  ]
}

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

{
  "name": "projects/project-id/agent/intents/5b290a94-55d6-4074-96f4-9c4c4879c2bb",
  "displayName": "ListRooms",
  "priority": 500000,
  "action": "listRooms",
  "messages": [
    {
      "text": {
        "text": [
          "Here are the available rooms:"
        ]
      }
    }
  ]
}

The path segment after intents contains your new intent ID.

C#

        public static int Create(string projectId,
                                 string displayName,
                                 string messageText,
                                 string[] trainingPhrasesParts)
        {
            var client = IntentsClient.Create();

            var text = new Intent.Types.Message.Types.Text();
            text.Text_.Add(messageText);

            var message = new Intent.Types.Message()
            {
                Text = text
            };

            var phraseParts = new List<Intent.Types.TrainingPhrase.Types.Part>();
            foreach (var part in trainingPhrasesParts)
            {
                phraseParts.Add(new Intent.Types.TrainingPhrase.Types.Part()
                {
                    Text = part
                });
            }

            var trainingPhrase = new Intent.Types.TrainingPhrase();
            trainingPhrase.Parts.AddRange(phraseParts);

            var intent = new Intent();
            intent.DisplayName = displayName;
            intent.Messages.Add(message);
            intent.TrainingPhrases.Add(trainingPhrase);

            var newIntent = client.CreateIntent(
                parent: new ProjectAgentName(projectId),
                intent: intent
            );

            Console.WriteLine($"Created Intent: {newIntent.Name}");

            return 0;
        }

Go

func CreateIntent(projectID, displayName string, trainingPhraseParts, messageTexts []string) error {
	ctx := context.Background()

	intentsClient, clientErr := dialogflow.NewIntentsClient(ctx)
	if clientErr != nil {
		return clientErr
	}
	defer intentsClient.Close()

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

	parent := fmt.Sprintf("projects/%s/agent", projectID)

	var targetTrainingPhrases []*dialogflowpb.Intent_TrainingPhrase
	var targetTrainingPhraseParts []*dialogflowpb.Intent_TrainingPhrase_Part
	for _, partString := range trainingPhraseParts {
		part := dialogflowpb.Intent_TrainingPhrase_Part{Text: partString}
		targetTrainingPhraseParts = []*dialogflowpb.Intent_TrainingPhrase_Part{&part}
		targetTrainingPhrase := dialogflowpb.Intent_TrainingPhrase{Type: dialogflowpb.Intent_TrainingPhrase_EXAMPLE, Parts: targetTrainingPhraseParts}
		targetTrainingPhrases = append(targetTrainingPhrases, &targetTrainingPhrase)
	}

	intentMessageTexts := dialogflowpb.Intent_Message_Text{Text: messageTexts}
	wrappedIntentMessageTexts := dialogflowpb.Intent_Message_Text_{Text: &intentMessageTexts}
	intentMessage := dialogflowpb.Intent_Message{Message: &wrappedIntentMessageTexts}

	target := dialogflowpb.Intent{DisplayName: displayName, WebhookState: dialogflowpb.Intent_WEBHOOK_STATE_UNSPECIFIED, TrainingPhrases: targetTrainingPhrases, Messages: []*dialogflowpb.Intent_Message{&intentMessage}}

	request := dialogflowpb.CreateIntentRequest{Parent: parent, Intent: &target}

	_, requestErr := intentsClient.CreateIntent(ctx, &request)
	if requestErr != nil {
		return requestErr
	}

	return nil
}

Java


/**
 * Create an intent of the given intent type
 *
 * @param displayName          The display name of the intent.
 * @param projectId            Project/Agent Id.
 * @param trainingPhrasesParts Training phrases.
 * @param messageTexts         Message texts for the agent's response when the intent is detected.
 * @return The created Intent.
 */
public static Intent createIntent(
    String displayName,
    String projectId,
    List<String> trainingPhrasesParts,
    List<String> messageTexts) throws Exception {
  // Instantiates a client
  try (IntentsClient intentsClient = IntentsClient.create()) {
    // Set the project agent name using the projectID (my-project-id)
    ProjectAgentName parent = ProjectAgentName.of(projectId);

    // Build the trainingPhrases from the trainingPhrasesParts
    List<TrainingPhrase> trainingPhrases = new ArrayList<>();
    for (String trainingPhrase : trainingPhrasesParts) {
      trainingPhrases.add(
          TrainingPhrase.newBuilder().addParts(
              Part.newBuilder().setText(trainingPhrase).build())
              .build());
    }

    // Build the message texts for the agent's response
    Message message = Message.newBuilder()
        .setText(
            Text.newBuilder()
                .addAllText(messageTexts).build()
        ).build();

    // Build the intent
    Intent intent = Intent.newBuilder()
        .setDisplayName(displayName)
        .addMessages(message)
        .addAllTrainingPhrases(trainingPhrases)
        .build();

    // Performs the create intent request
    Intent response = intentsClient.createIntent(parent, intent);
    System.out.format("Intent created: %s\n", response);

    return response;
  }
}

Node.js

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

// Instantiates the Intent Client
const intentsClient = new dialogflow.IntentsClient();

// The path to identify the agent that owns the created intent.
const agentPath = intentsClient.projectAgentPath(projectId);

const trainingPhrases = [];

trainingPhrasesParts.forEach(trainingPhrasesPart => {
  const part = {
    text: trainingPhrasesPart,
  };

  // Here we create a new training phrase for each provided part.
  const trainingPhrase = {
    type: 'EXAMPLE',
    parts: [part],
  };

  trainingPhrases.push(trainingPhrase);
});

const messageText = {
  text: messageTexts,
};

const message = {
  text: messageText,
};

const intent = {
  displayName: displayName,
  trainingPhrases: trainingPhrases,
  messages: [message],
};

const createIntentRequest = {
  parent: agentPath,
  intent: intent,
};

// Create the intent
const responses = await intentsClient.createIntent(createIntentRequest);
console.log(`Intent ${responses[0].name} created`);

PHP

namespace Google\Cloud\Samples\Dialogflow;

use Google\Cloud\Dialogflow\V2\IntentsClient;
use Google\Cloud\Dialogflow\V2\Intent_TrainingPhrase_Part;
use Google\Cloud\Dialogflow\V2\Intent_TrainingPhrase;
use Google\Cloud\Dialogflow\V2\Intent_Message_Text;
use Google\Cloud\Dialogflow\V2\Intent_Message;
use Google\Cloud\Dialogflow\V2\Intent;

/**
* Create an intent of the given intent type.
*/
function intent_create($projectId, $displayName, $trainingPhraseParts = [],
    $messageTexts = [])
{
    $intentsClient = new IntentsClient();

    // prepare parent
    $parent = $intentsClient->projectAgentName($projectId);

    // prepare training phrases for intent
    $trainingPhrases = [];
    foreach ($trainingPhraseParts as $trainingPhrasePart) {
        $part = new Intent_TrainingPhrase_Part;
        $part->setText($trainingPhrasePart);

        // create new training phrase for each provided part
        $trainingPhrase = new Intent_TrainingPhrase();
        $trainingPhrase->setParts([$part]);
        $trainingPhrases[] = $trainingPhrase;
    }

    // prepare messages for intent
    $text = new Intent_Message_Text();
    $text->setText($messageTexts);
    $message = new Intent_Message();
    $message->setText($text);

    // prepare intent
    $intent = new Intent();
    $intent->setDisplayName($displayName);
    $intent->setTrainingPhrases($trainingPhrases);
    $intent->setMessages([$message]);

    // create intent
    $response = $intentsClient->createIntent($parent, $intent);
    printf('Intent created: %s' . PHP_EOL, $response->getName());

    $intentsClient->close();
}

Python

def create_intent(project_id, display_name, training_phrases_parts,
                  message_texts):
    """Create an intent of the given intent type."""
    import dialogflow_v2 as dialogflow
    intents_client = dialogflow.IntentsClient()

    parent = intents_client.project_agent_path(project_id)
    training_phrases = []
    for training_phrases_part in training_phrases_parts:
        part = dialogflow.types.Intent.TrainingPhrase.Part(
            text=training_phrases_part)
        # Here we create a new training phrase for each provided part.
        training_phrase = dialogflow.types.Intent.TrainingPhrase(parts=[part])
        training_phrases.append(training_phrase)

    text = dialogflow.types.Intent.Message.Text(text=message_texts)
    message = dialogflow.types.Intent.Message(text=text)

    intent = dialogflow.types.Intent(
        display_name=display_name,
        training_phrases=training_phrases,
        messages=[message])

    response = intents_client.create_intent(parent, intent)

    print('Intent created: {}'.format(response))

Ruby

# project_id = "Your Google Cloud project ID"
# display_name = "New Display Name"
# message_text = "some message text"
# training_phrases_parts = ["part1", "part2"]

require "google/cloud/dialogflow"

intents_client = Google::Cloud::Dialogflow::Intents.new
parent = intents_client.class.project_agent_path project_id

intent = {
  display_name:     display_name,
  messages:         [{ text: { text: [message_text] } }],
  training_phrases: training_phrases_parts.map do |part|
    { parts: [{ text: part }] }
  end
}
response = intents_client.create_intent parent, intent

puts "Intent created"
puts "Display name: #{response.display_name}"
puts "Messages:     #{response.messages}"

List intents

The following samples show how to lists intents. For more information, see the Intents reference.

REST & CMD LINE

To list the intents for your agent, call the list method on the intents resource.

Before using any of the request data below, make the following replacements:

  • project-id: your GCP project ID

HTTP method and URL:

GET https://dialogflow.googleapis.com/v2/projects/project-id/agent/intents

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

{
  "intents": [
    {
      "name": "projects/project-id/agent/intents/5b290a94-55d6-4074-96f4-9c4c4879c2bb",
      "displayName": "ListRooms",
      "priority": 500000,
      "action": "listRooms",
      "messages": [
        {
          "text": {
            "text": [
              "Here are the available rooms:"
            ]
          }
        }
      ]
    },
    ...
  ]
}

The path segments after intents contain your intent IDs.

C#

        public static int List(string projectId)
        {
            var client = IntentsClient.Create();

            var intents = client.ListIntents(new ProjectAgentName(projectId));

            foreach (var intent in intents)
            {
                Console.WriteLine($"Intent name: {intent.Name}");
                Console.WriteLine($"Intent display name: {intent.DisplayName}");
                Console.WriteLine($"Action: {intent.Action}");
                Console.WriteLine($"Root follow-up intent: {intent.RootFollowupIntentName}");
                Console.WriteLine($"Parent follow-up intent: {intent.ParentFollowupIntentName}");

                Console.WriteLine($"Input contexts:");
                foreach (var inputContextName in intent.InputContextNames)
                {
                    Console.WriteLine($"Input context name: {inputContextName}");
                }

                Console.WriteLine($"Output contexts:");
                foreach (var outputContex in intent.OutputContexts)
                {
                    Console.WriteLine($"Output context name: {outputContex.Name}");
                }
                Console.WriteLine("Messages:");
                foreach (var message in intent.Messages)
                {
                    if (message.Text != null)
                    {
                        foreach (var text in message.Text.Text_)
                        {
                            Console.WriteLine($"Message text: {text}");
                        }
                    }
                }
                Console.WriteLine($"Training Phrases ({intent.TrainingPhrases.Count})");
                foreach (var trainingPhrase in intent.TrainingPhrases)
                {
                    Console.WriteLine($"Phrase name: {trainingPhrase.Name}");
                    Console.WriteLine($"Phrase type: {trainingPhrase.Type}");
                    foreach (var phrasePart in trainingPhrase.Parts)
                    {
                        Console.WriteLine($"Phrase part: {phrasePart.Text}");
                    }
                }
                Console.WriteLine();
            }

            return 0;
        }

Go


func ListIntents(projectID string) ([]*dialogflowpb.Intent, error) {
	ctx := context.Background()

	intentsClient, clientErr := dialogflow.NewIntentsClient(ctx)
	if clientErr != nil {
		return nil, clientErr
	}
	defer intentsClient.Close()

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

	parent := fmt.Sprintf("projects/%s/agent", projectID)

	request := dialogflowpb.ListIntentsRequest{Parent: parent}

	intentIterator := intentsClient.ListIntents(ctx, &request)
	var intents []*dialogflowpb.Intent

	for intent, status := intentIterator.Next(); status != iterator.Done; {
		intents = append(intents, intent)
		intent, status = intentIterator.Next()
	}

	return intents, nil
}

Java


/**
 * List intents
 *
 * @param projectId Project/Agent Id.
 * @return Intents found.
 */
public static List<Intent> listIntents(String projectId) throws Exception {
  List<Intent> intents = Lists.newArrayList();
  // Instantiates a client
  try (IntentsClient intentsClient = IntentsClient.create()) {
    // Set the project agent name using the projectID (my-project-id)
    ProjectAgentName parent = ProjectAgentName.of(projectId);

    // Performs the list intents request
    for (Intent intent : intentsClient.listIntents(parent).iterateAll()) {
      System.out.println("====================");
      System.out.format("Intent name: '%s'\n", intent.getName());
      System.out.format("Intent display name: '%s'\n", intent.getDisplayName());
      System.out.format("Action: '%s'\n", intent.getAction());
      System.out.format("Root followup intent: '%s'\n", intent.getRootFollowupIntentName());
      System.out.format("Parent followup intent: '%s'\n", intent.getParentFollowupIntentName());

      System.out.format("Input contexts:\n");
      for (String inputContextName : intent.getInputContextNamesList()) {
        System.out.format("\tName: %s\n", inputContextName);
      }
      System.out.format("Output contexts:\n");
      for (Context outputContext : intent.getOutputContextsList()) {
        System.out.format("\tName: %s\n", outputContext.getName());
      }

      intents.add(intent);
    }
  }
  return intents;
}

Node.js

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

// Instantiates clients
const intentsClient = new dialogflow.IntentsClient();

// The path to identify the agent that owns the intents.
const projectAgentPath = intentsClient.projectAgentPath(projectId);

const request = {
  parent: projectAgentPath,
};

console.log(projectAgentPath);

// Send the request for listing intents.
const [response] = await intentsClient.listIntents(request);
response.forEach(intent => {
  console.log('====================');
  console.log(`Intent name: ${intent.name}`);
  console.log(`Intent display name: ${intent.displayName}`);
  console.log(`Action: ${intent.action}`);
  console.log(`Root folowup intent: ${intent.rootFollowupIntentName}`);
  console.log(`Parent followup intent: ${intent.parentFollowupIntentName}`);

  console.log('Input contexts:');
  intent.inputContextNames.forEach(inputContextName => {
    console.log(`\tName: ${inputContextName}`);
  });

  console.log('Output contexts:');
  intent.outputContexts.forEach(outputContext => {
    console.log(`\tName: ${outputContext.name}`);
  });
});

PHP

namespace Google\Cloud\Samples\Dialogflow;

use Google\Cloud\Dialogflow\V2\IntentsClient;

function intent_list($projectId)
{
    // get intents
    $intentsClient = new IntentsClient();
    $parent = $intentsClient->projectAgentName($projectId);
    $intents = $intentsClient->listIntents($parent);

    foreach ($intents->iterateAllElements() as $intent) {
        // print relevant info
        print(str_repeat("=", 20) . PHP_EOL);
        printf('Intent name: %s' . PHP_EOL, $intent->getName());
        printf('Intent display name: %s' . PHP_EOL, $intent->getDisplayName());
        printf('Action: %s' . PHP_EOL, $intent->getAction());
        printf('Root followup intent: %s' . PHP_EOL,
            $intent->getRootFollowupIntentName());
        printf('Parent followup intent: %s' . PHP_EOL,
            $intent->getParentFollowupIntentName());
        print(PHP_EOL);

        print('Input contexts: ' . PHP_EOL);
        foreach ($intent->getInputContextNames() as $inputContextName) {
            printf("\t Name: %s" . PHP_EOL, $inputContextName);
        }

        print('Output contexts: ' . PHP_EOL);
        foreach ($intent->getOutputContexts() as $outputContext) {
            printf("\t Name: %s" . PHP_EOL, $outputContext->getName());
        }
    }
    $intentsClient->close();
}

Python

def list_intents(project_id):
    import dialogflow_v2 as dialogflow
    intents_client = dialogflow.IntentsClient()

    parent = intents_client.project_agent_path(project_id)

    intents = intents_client.list_intents(parent)

    for intent in intents:
        print('=' * 20)
        print('Intent name: {}'.format(intent.name))
        print('Intent display_name: {}'.format(intent.display_name))
        print('Action: {}\n'.format(intent.action))
        print('Root followup intent: {}'.format(
            intent.root_followup_intent_name))
        print('Parent followup intent: {}\n'.format(
            intent.parent_followup_intent_name))

        print('Input contexts:')
        for input_context_name in intent.input_context_names:
            print('\tName: {}'.format(input_context_name))

        print('Output contexts:')
        for output_context in intent.output_contexts:
            print('\tName: {}'.format(output_context.name))

Ruby

# project_id = "Your Google Cloud project ID"

require "google/cloud/dialogflow"

intents_client = Google::Cloud::Dialogflow::Intents.new
parent = intents_client.class.project_agent_path project_id

intents = intents_client.list_intents parent

intents.each do |intent|
  puts "Intent name:            #{intent.name}"
  puts "Intent display name:    #{intent.display_name}"
  puts "Action:                 #{intent.action}"
  puts "Root followup intent:   #{intent.root_followup_intent_name}"
  puts "Parent followup intent: #{intent.parent_followup_intent_name}"

  puts "Input contexts:"
  intent.input_context_names.each do |input_context_name|
    puts "\tName: #{input_context_name}"
  end

  puts "Output contexts:"
  intent.output_contexts.each do |output_context|
    puts "\tName: #{output_context.name}"
  end
end

Delete intents

The following samples show how to delete an intent. For more information, see the Intents reference.

REST & CMD LINE

To delete an intent for your agent, call the delete method on the intents resource.

Before using any of the request data below, make the following replacements:

  • project-id: your GCP project ID
  • intent-id: your intent ID

HTTP method and URL:

DELETE https://dialogflow.googleapis.com/v2/projects/project-id/agent/intents/intent-id

To send your request, expand one of these options:

You should receive a successful status code (2xx) and an empty response.

C#

        public static int Delete(string projectId, string intentId)
        {
            var client = IntentsClient.Create();
            client.DeleteIntent(new IntentName(projectId, intentId));

            Console.WriteLine($"Deleted Intent: {intentId}");

            return 0;
        }

Go

func DeleteIntent(projectID, intentID string) error {
	ctx := context.Background()

	intentsClient, clientErr := dialogflow.NewIntentsClient(ctx)
	if clientErr != nil {
		return clientErr
	}
	defer intentsClient.Close()

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

	targetPath := fmt.Sprintf("projects/%s/agent/intents/%s", projectID, intentID)

	request := dialogflowpb.DeleteIntentRequest{Name: targetPath}

	requestErr := intentsClient.DeleteIntent(ctx, &request)
	if requestErr != nil {
		return requestErr
	}

	return nil
}

Java


/**
 * Delete intent with the given intent type and intent value
 *
 * @param intentId  The id of the intent.
 * @param projectId Project/Agent Id.
 */
public static void deleteIntent(String intentId, String projectId) throws Exception {
  // Instantiates a client
  try (IntentsClient intentsClient = IntentsClient.create()) {
    IntentName name = IntentName.of(projectId, intentId);
    // Performs the delete intent request
    intentsClient.deleteIntent(name);
  }
}

Node.js

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

// Instantiates clients
const intentsClient = new dialogflow.IntentsClient();

const intentPath = intentsClient.intentPath(projectId, intentId);

const request = {name: intentPath};

// Send the request for deleting the intent.
const result = await intentsClient.deleteIntent(request);
console.log(`Intent ${intentPath} deleted`);
return result;

PHP

namespace Google\Cloud\Samples\Dialogflow;

use Google\Cloud\Dialogflow\V2\IntentsClient;

/**
* Delete intent with the given intent type and intent value.
*/
function intent_delete($projectId, $intentId)
{
    $intentsClient = new IntentsClient();
    $intentName = $intentsClient->intentName($projectId, $intentId);

    $intentsClient->deleteIntent($intentName);
    printf('Intent deleted: %s' . PHP_EOL, $intentName);

    $intentsClient->close();
}

Python

def delete_intent(project_id, intent_id):
    """Delete intent with the given intent type and intent value."""
    import dialogflow_v2 as dialogflow
    intents_client = dialogflow.IntentsClient()

    intent_path = intents_client.intent_path(project_id, intent_id)

    intents_client.delete_intent(intent_path)

Ruby

# project_id = "Your Google Cloud project ID"
# intent_id = "Existing Intent ID"

require "google/cloud/dialogflow"

intents_client = Google::Cloud::Dialogflow::Intents.new
intent_path = intents_client.class.intent_path project_id, intent_id

intents_client.delete_intent intent_path

puts "Deleted Intent: #{intent_id}"
nt.py" region_tag="dialogflow_delete_intent" %}

Kunde den här sidan hjälpa dig? Berätta:

Skicka feedback om ...

Dialogflow Documentation
Behöver du hjälp? Besök vår supportsida.