AgentFlow class

Resource for managing an AWS Bedrock Agents Flow.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.bedrock.AgentFlow("example", {
    name: "example-flow",
    executionRoleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentFlow("example",
    name="example-flow",
    execution_role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentFlow("example", new()
    {
        Name = "example-flow",
        ExecutionRoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentFlow(ctx, "example", &bedrock.AgentFlowArgs{
			Name:             pulumi.String("example-flow"),
			ExecutionRoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentflow" "example" {
  name               = "example-flow"
  execution_role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentFlow;
import com.pulumi.aws.bedrock.AgentFlowArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new AgentFlow("example", AgentFlowArgs.builder()
            .name("example-flow")
            .executionRoleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:bedrock:AgentFlow
    properties:
      name: example-flow
      executionRoleArn: ${exampleAwsIamRole.arn}

Default definition

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.bedrock.AgentFlow("example", {
    definition: {
        connections: [
            {
                configuration: {
                    data: {
                        sourceOutput: "document",
                        targetInput: "topic",
                    },
                },
                name: "FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0",
                source: "FlowInputNode",
                target: "Prompt_1",
                type: "Data",
            },
            {
                configuration: {
                    data: {
                        sourceOutput: "modelCompletion",
                        targetInput: "document",
                    },
                },
                name: "Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0",
                source: "Prompt_1",
                target: "FlowOutputNode",
                type: "Data",
            },
        ],
        nodes: [
            {
                configuration: {
                    input: {},
                },
                outputs: [{
                    name: "document",
                    type: "String",
                }],
                name: "FlowInputNode",
                type: "Input",
            },
            {
                configuration: {
                    prompt: {
                        sourceConfiguration: {
                            inline: {
                                inferenceConfiguration: {
                                    text: {
                                        maxTokens: 2048,
                                        stopSequences: ["User:"],
                                        temperature: 0,
                                        topP: 0.8999999761581421,
                                    },
                                },
                                templateConfiguration: {
                                    text: {
                                        inputVariables: [{
                                            name: "topic",
                                        }],
                                        text: "Write a paragraph about {{topic}}.",
                                    },
                                },
                                modelId: "amazon.titan-text-express-v1",
                                templateType: "TEXT",
                            },
                        },
                    },
                },
                inputs: [{
                    expression: "$.data",
                    name: "topic",
                    type: "String",
                }],
                outputs: [{
                    name: "modelCompletion",
                    type: "String",
                }],
                name: "Prompt_1",
                type: "Prompt",
            },
            {
                configuration: {
                    output: {},
                },
                inputs: [{
                    expression: "$.data",
                    name: "document",
                    type: "String",
                }],
                name: "FlowOutputNode",
                type: "Output",
            },
        ],
    },
    name: "example",
    executionRoleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.bedrock.AgentFlow("example",
    definition={
        "connections": [
            {
                "configuration": {
                    "data": {
                        "source_output": "document",
                        "target_input": "topic",
                    },
                },
                "name": "FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0",
                "source": "FlowInputNode",
                "target": "Prompt_1",
                "type": "Data",
            },
            {
                "configuration": {
                    "data": {
                        "source_output": "modelCompletion",
                        "target_input": "document",
                    },
                },
                "name": "Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0",
                "source": "Prompt_1",
                "target": "FlowOutputNode",
                "type": "Data",
            },
        ],
        "nodes": [
            {
                "configuration": {
                    "input": {},
                },
                "outputs": [{
                    "name": "document",
                    "type": "String",
                }],
                "name": "FlowInputNode",
                "type": "Input",
            },
            {
                "configuration": {
                    "prompt": {
                        "source_configuration": {
                            "inline": {
                                "inference_configuration": {
                                    "text": {
                                        "max_tokens": 2048,
                                        "stop_sequences": ["User:"],
                                        "temperature": float(0),
                                        "top_p": 0.8999999761581421,
                                    },
                                },
                                "template_configuration": {
                                    "text": {
                                        "input_variables": [{
                                            "name": "topic",
                                        }],
                                        "text": "Write a paragraph about {{topic}}.",
                                    },
                                },
                                "model_id": "amazon.titan-text-express-v1",
                                "template_type": "TEXT",
                            },
                        },
                    },
                },
                "inputs": [{
                    "expression": "$.data",
                    "name": "topic",
                    "type": "String",
                }],
                "outputs": [{
                    "name": "modelCompletion",
                    "type": "String",
                }],
                "name": "Prompt_1",
                "type": "Prompt",
            },
            {
                "configuration": {
                    "output": {},
                },
                "inputs": [{
                    "expression": "$.data",
                    "name": "document",
                    "type": "String",
                }],
                "name": "FlowOutputNode",
                "type": "Output",
            },
        ],
    },
    name="example",
    execution_role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Bedrock.AgentFlow("example", new()
    {
        Definition = new Aws.Bedrock.Inputs.AgentFlowDefinitionArgs
        {
            Connections = new[]
            {
                new Aws.Bedrock.Inputs.AgentFlowDefinitionConnectionArgs
                {
                    Configuration = new Aws.Bedrock.Inputs.AgentFlowDefinitionConnectionConfigurationArgs
                    {
                        Data = new Aws.Bedrock.Inputs.AgentFlowDefinitionConnectionConfigurationDataArgs
                        {
                            SourceOutput = "document",
                            TargetInput = "topic",
                        },
                    },
                    Name = "FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0",
                    Source = "FlowInputNode",
                    Target = "Prompt_1",
                    Type = "Data",
                },
                new Aws.Bedrock.Inputs.AgentFlowDefinitionConnectionArgs
                {
                    Configuration = new Aws.Bedrock.Inputs.AgentFlowDefinitionConnectionConfigurationArgs
                    {
                        Data = new Aws.Bedrock.Inputs.AgentFlowDefinitionConnectionConfigurationDataArgs
                        {
                            SourceOutput = "modelCompletion",
                            TargetInput = "document",
                        },
                    },
                    Name = "Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0",
                    Source = "Prompt_1",
                    Target = "FlowOutputNode",
                    Type = "Data",
                },
            },
            Nodes = new[]
            {
                new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeArgs
                {
                    Configuration = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationArgs
                    {
                        Input = null,
                    },
                    Outputs = new[]
                    {
                        new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeOutputArgs
                        {
                            Name = "document",
                            Type = "String",
                        },
                    },
                    Name = "FlowInputNode",
                    Type = "Input",
                },
                new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeArgs
                {
                    Configuration = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationArgs
                    {
                        Prompt = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptArgs
                        {
                            SourceConfiguration = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationArgs
                            {
                                Inline = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineArgs
                                {
                                    InferenceConfiguration = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationArgs
                                    {
                                        Text = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationTextArgs
                                        {
                                            MaxTokens = 2048,
                                            StopSequences = new[]
                                            {
                                                "User:",
                                            },
                                            Temperature = 0,
                                            TopP = 0.8999999761581421,
                                        },
                                    },
                                    TemplateConfiguration = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationArgs
                                    {
                                        Text = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextArgs
                                        {
                                            InputVariables = new[]
                                            {
                                                new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextInputVariableArgs
                                                {
                                                    Name = "topic",
                                                },
                                            },
                                            Text = "Write a paragraph about {{topic}}.",
                                        },
                                    },
                                    ModelId = "amazon.titan-text-express-v1",
                                    TemplateType = "TEXT",
                                },
                            },
                        },
                    },
                    Inputs = new[]
                    {
                        new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeInputArgs
                        {
                            Expression = "$.data",
                            Name = "topic",
                            Type = "String",
                        },
                    },
                    Outputs = new[]
                    {
                        new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeOutputArgs
                        {
                            Name = "modelCompletion",
                            Type = "String",
                        },
                    },
                    Name = "Prompt_1",
                    Type = "Prompt",
                },
                new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeArgs
                {
                    Configuration = new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeConfigurationArgs
                    {
                        Output = null,
                    },
                    Inputs = new[]
                    {
                        new Aws.Bedrock.Inputs.AgentFlowDefinitionNodeInputArgs
                        {
                            Expression = "$.data",
                            Name = "document",
                            Type = "String",
                        },
                    },
                    Name = "FlowOutputNode",
                    Type = "Output",
                },
            },
        },
        Name = "example",
        ExecutionRoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentFlow(ctx, "example", &bedrock.AgentFlowArgs{
			Definition: &bedrock.AgentFlowDefinitionArgs{
				Connections: bedrock.AgentFlowDefinitionConnectionArray{
					&bedrock.AgentFlowDefinitionConnectionArgs{
						Configuration: &bedrock.AgentFlowDefinitionConnectionConfigurationArgs{
							Data: &bedrock.AgentFlowDefinitionConnectionConfigurationDataArgs{
								SourceOutput: pulumi.String("document"),
								TargetInput:  pulumi.String("topic"),
							},
						},
						Name:   pulumi.String("FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0"),
						Source: pulumi.String("FlowInputNode"),
						Target: pulumi.String("Prompt_1"),
						Type:   pulumi.String("Data"),
					},
					&bedrock.AgentFlowDefinitionConnectionArgs{
						Configuration: &bedrock.AgentFlowDefinitionConnectionConfigurationArgs{
							Data: &bedrock.AgentFlowDefinitionConnectionConfigurationDataArgs{
								SourceOutput: pulumi.String("modelCompletion"),
								TargetInput:  pulumi.String("document"),
							},
						},
						Name:   pulumi.String("Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0"),
						Source: pulumi.String("Prompt_1"),
						Target: pulumi.String("FlowOutputNode"),
						Type:   pulumi.String("Data"),
					},
				},
				Nodes: bedrock.AgentFlowDefinitionNodeArray{
					&bedrock.AgentFlowDefinitionNodeArgs{
						Configuration: &bedrock.AgentFlowDefinitionNodeConfigurationArgs{
							Input: &bedrock.AgentFlowDefinitionNodeConfigurationInputTypeArgs{},
						},
						Outputs: bedrock.AgentFlowDefinitionNodeOutputTypeArray{
							&bedrock.AgentFlowDefinitionNodeOutputTypeArgs{
								Name: pulumi.String("document"),
								Type: pulumi.String("String"),
							},
						},
						Name: pulumi.String("FlowInputNode"),
						Type: pulumi.String("Input"),
					},
					&bedrock.AgentFlowDefinitionNodeArgs{
						Configuration: &bedrock.AgentFlowDefinitionNodeConfigurationArgs{
							Prompt: &bedrock.AgentFlowDefinitionNodeConfigurationPromptArgs{
								SourceConfiguration: &bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationArgs{
									Inline: &bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineArgs{
										InferenceConfiguration: &bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationArgs{
											Text: &bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationTextArgs{
												MaxTokens: pulumi.Int(2048),
												StopSequences: pulumi.StringArray{
													pulumi.String("User:"),
												},
												Temperature: pulumi.Float64(0),
												TopP:        pulumi.Float64(0.8999999761581421),
											},
										},
										TemplateConfiguration: &bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationArgs{
											Text: &bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextArgs{
												InputVariables: bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextInputVariableArray{
													&bedrock.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextInputVariableArgs{
														Name: pulumi.String("topic"),
													},
												},
												Text: pulumi.String("Write a paragraph about {{topic}}."),
											},
										},
										ModelId:      pulumi.String("amazon.titan-text-express-v1"),
										TemplateType: pulumi.String("TEXT"),
									},
								},
							},
						},
						Inputs: bedrock.AgentFlowDefinitionNodeInputTypeArray{
							&bedrock.AgentFlowDefinitionNodeInputTypeArgs{
								Expression: pulumi.String("$.data"),
								Name:       pulumi.String("topic"),
								Type:       pulumi.String("String"),
							},
						},
						Outputs: bedrock.AgentFlowDefinitionNodeOutputTypeArray{
							&bedrock.AgentFlowDefinitionNodeOutputTypeArgs{
								Name: pulumi.String("modelCompletion"),
								Type: pulumi.String("String"),
							},
						},
						Name: pulumi.String("Prompt_1"),
						Type: pulumi.String("Prompt"),
					},
					&bedrock.AgentFlowDefinitionNodeArgs{
						Configuration: &bedrock.AgentFlowDefinitionNodeConfigurationArgs{
							Output: &bedrock.AgentFlowDefinitionNodeConfigurationOutputTypeArgs{},
						},
						Inputs: bedrock.AgentFlowDefinitionNodeInputTypeArray{
							&bedrock.AgentFlowDefinitionNodeInputTypeArgs{
								Expression: pulumi.String("$.data"),
								Name:       pulumi.String("document"),
								Type:       pulumi.String("String"),
							},
						},
						Name: pulumi.String("FlowOutputNode"),
						Type: pulumi.String("Output"),
					},
				},
			},
			Name:             pulumi.String("example"),
			ExecutionRoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentflow" "example" {
  definition = {
    connections = [{
      "configuration" = {
        "data" = {
          "sourceOutput" = "document"
          "targetInput"  = "topic"
        }
      }
      "name"   = "FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0"
      "source" = "FlowInputNode"
      "target" = "Prompt_1"
      "type"   = "Data"
      }, {
      "configuration" = {
        "data" = {
          "sourceOutput" = "modelCompletion"
          "targetInput"  = "document"
        }
      }
      "name"   = "Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0"
      "source" = "Prompt_1"
      "target" = "FlowOutputNode"
      "type"   = "Data"
    }]
    nodes = [{
      "configuration" = {
        "input" = {}
      }
      "outputs" = [{
        "name" = "document"
        "type" = "String"
      }]
      "name" = "FlowInputNode"
      "type" = "Input"
      }, {
      "configuration" = {
        "prompt" = {
          "sourceConfiguration" = {
            "inline" = {
              "inferenceConfiguration" = {
                "text" = {
                  "maxTokens"     = 2048
                  "stopSequences" = ["User:"]
                  "temperature"   = 0
                  "topP"          = 0.8999999761581421
                }
              }
              "templateConfiguration" = {
                "text" = {
                  "inputVariables" = [{
                    "name" = "topic"
                  }]
                  "text" = "Write a paragraph about {{topic}}."
                }
              }
              "modelId"      = "amazon.titan-text-express-v1"
              "templateType" = "TEXT"
            }
          }
        }
      }
      "inputs" = [{
        "expression" = "$.data"
        "name"       = "topic"
        "type"       = "String"
      }]
      "outputs" = [{
        "name" = "modelCompletion"
        "type" = "String"
      }]
      "name" = "Prompt_1"
      "type" = "Prompt"
      }, {
      "configuration" = {
        "output" = {}
      }
      "inputs" = [{
        "expression" = "$.data"
        "name"       = "document"
        "type"       = "String"
      }]
      "name" = "FlowOutputNode"
      "type" = "Output"
    }]
  }
  name               = "example"
  execution_role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentFlow;
import com.pulumi.aws.bedrock.AgentFlowArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionConnectionArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionConnectionConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionConnectionConfigurationDataArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationInputArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeOutputArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationTextArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextInputVariableArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeInputArgs;
import com.pulumi.aws.bedrock.inputs.AgentFlowDefinitionNodeConfigurationOutputArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new AgentFlow("example", AgentFlowArgs.builder()
            .definition(AgentFlowDefinitionArgs.builder()
                .connections(
                    AgentFlowDefinitionConnectionArgs.builder()
                        .configuration(AgentFlowDefinitionConnectionConfigurationArgs.builder()
                            .data(AgentFlowDefinitionConnectionConfigurationDataArgs.builder()
                                .sourceOutput("document")
                                .targetInput("topic")
                                .build())
                            .build())
                        .name("FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0")
                        .source("FlowInputNode")
                        .target("Prompt_1")
                        .type("Data")
                        .build(),
                    AgentFlowDefinitionConnectionArgs.builder()
                        .configuration(AgentFlowDefinitionConnectionConfigurationArgs.builder()
                            .data(AgentFlowDefinitionConnectionConfigurationDataArgs.builder()
                                .sourceOutput("modelCompletion")
                                .targetInput("document")
                                .build())
                            .build())
                        .name("Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0")
                        .source("Prompt_1")
                        .target("FlowOutputNode")
                        .type("Data")
                        .build())
                .nodes(
                    AgentFlowDefinitionNodeArgs.builder()
                        .configuration(AgentFlowDefinitionNodeConfigurationArgs.builder()
                            .input(AgentFlowDefinitionNodeConfigurationInputArgs.builder()
                                .build())
                            .build())
                        .outputs(AgentFlowDefinitionNodeOutputArgs.builder()
                            .name("document")
                            .type("String")
                            .build())
                        .name("FlowInputNode")
                        .type("Input")
                        .build(),
                    AgentFlowDefinitionNodeArgs.builder()
                        .configuration(AgentFlowDefinitionNodeConfigurationArgs.builder()
                            .prompt(AgentFlowDefinitionNodeConfigurationPromptArgs.builder()
                                .sourceConfiguration(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationArgs.builder()
                                    .inline(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineArgs.builder()
                                        .inferenceConfiguration(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationArgs.builder()
                                            .text(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineInferenceConfigurationTextArgs.builder()
                                                .maxTokens(2048)
                                                .stopSequences("User:")
                                                .temperature(0.0)
                                                .topP(0.8999999761581421)
                                                .build())
                                            .build())
                                        .templateConfiguration(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationArgs.builder()
                                            .text(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextArgs.builder()
                                                .inputVariables(AgentFlowDefinitionNodeConfigurationPromptSourceConfigurationInlineTemplateConfigurationTextInputVariableArgs.builder()
                                                    .name("topic")
                                                    .build())
                                                .text("Write a paragraph about {{topic}}.")
                                                .build())
                                            .build())
                                        .modelId("amazon.titan-text-express-v1")
                                        .templateType("TEXT")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .inputs(AgentFlowDefinitionNodeInputArgs.builder()
                            .expression("$.data")
                            .name("topic")
                            .type("String")
                            .build())
                        .outputs(AgentFlowDefinitionNodeOutputArgs.builder()
                            .name("modelCompletion")
                            .type("String")
                            .build())
                        .name("Prompt_1")
                        .type("Prompt")
                        .build(),
                    AgentFlowDefinitionNodeArgs.builder()
                        .configuration(AgentFlowDefinitionNodeConfigurationArgs.builder()
                            .output(AgentFlowDefinitionNodeConfigurationOutputArgs.builder()
                                .build())
                            .build())
                        .inputs(AgentFlowDefinitionNodeInputArgs.builder()
                            .expression("$.data")
                            .name("document")
                            .type("String")
                            .build())
                        .name("FlowOutputNode")
                        .type("Output")
                        .build())
                .build())
            .name("example")
            .executionRoleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:bedrock:AgentFlow
    properties:
      definition:
        connections:
          - configuration:
              data:
                sourceOutput: document
                targetInput: topic
            name: FlowInputNodeFlowInputNode0ToPrompt_1PromptsNode0
            source: FlowInputNode
            target: Prompt_1
            type: Data
          - configuration:
              data:
                sourceOutput: modelCompletion
                targetInput: document
            name: Prompt_1PromptsNode0ToFlowOutputNodeFlowOutputNode0
            source: Prompt_1
            target: FlowOutputNode
            type: Data
        nodes:
          - configuration:
              input: {}
            outputs:
              - name: document
                type: String
            name: FlowInputNode
            type: Input
          - configuration:
              prompt:
                sourceConfiguration:
                  inline:
                    inferenceConfiguration:
                      text:
                        maxTokens: 2048
                        stopSequences:
                          - 'User:'
                        temperature: 0
                        topP: 0.8999999761581421
                    templateConfiguration:
                      text:
                        inputVariables:
                          - name: topic
                        text: Write a paragraph about {{topic}}.
                    modelId: amazon.titan-text-express-v1
                    templateType: TEXT
            inputs:
              - expression: $.data
                name: topic
                type: String
            outputs:
              - name: modelCompletion
                type: String
            name: Prompt_1
            type: Prompt
          - configuration:
              output: {}
            inputs:
              - expression: $.data
                name: document
                type: String
            name: FlowOutputNode
            type: Output
      name: example
      executionRoleArn: ${exampleAwsIamRole.arn}

Import

Using pulumi import, import Bedrock Agents Flow using the id. For example:

$ pulumi import aws:bedrock/agentFlow:AgentFlow example ABCDEFGHIJ

Constructors

AgentFlow(String name, {AgentFlowArgs? args, CustomResourceOptions? options})
Creates a new AgentFlow. name The Pulumi resource name. args Arguments used to configure this AgentFlow. The set of arguments for AgentFlow. options Resource options controlling this resource's behavior.
AgentFlow.reference(String urn)
Creates a typed reference to an existing AgentFlow resource.

Properties

arn ↔ Output<String>
ARN of the flow.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
createdAt ↔ Output<String>
The time at which the flow was created.
latefinal
customerEncryptionKeyArn ↔ Output<String?>
ARN of the KMS key to encrypt the flow.
latefinal
definition ↔ Output<AgentFlowDefinition?>
A definition of the nodes and connections between nodes in the flow. See Definition for more information.
latefinal
description ↔ Output<String?>
A description for the flow.
latefinal
executionRoleArn ↔ Output<String>
ARN of the service role with permissions to create and manage a flow. For more information, see Create a service role for flows in Amazon Bedrock in the Amazon Bedrock User Guide.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<String>
A name for the flow.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
status ↔ Output<String>
The status of the flow.
latefinal
tags ↔ Output<Map<String, String>?>
Key-value map of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
timeouts ↔ Output<AgentFlowTimeouts?>
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
updatedAt ↔ Output<String>
The time at which the flow was last updated.
latefinal
urn ↔ Output<String>
latefinalinherited
version ↔ Output<String>
The version of the flow.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {AgentFlowState? state, CustomResourceOptions? options}) → AgentFlow
Gets an existing AgentFlow resource's state with the given name and id.