AgentcoreMemoryStrategy class
Manages an AWS Bedrock AgentCore Memory Strategy. Memory strategies define how the agent processes and organizes information within a memory, such as semantic understanding, summarization, or custom processing logic.
Important Limitations:
- Each memory can have a maximum of 6 strategies total
- Only one strategy of each built-in type (
SEMANTIC,SUMMARIZATION,USER_PREFERENCE,EPISODIC) can exist per memory - Multiple
CUSTOMstrategies are allowed (subject to the total limit of 6)
Example Usage
Semantic Strategy
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const semantic = new aws.bedrock.AgentcoreMemoryStrategy("semantic", {
name: "semantic-strategy",
memoryId: example.id,
type: "SEMANTIC",
description: "Semantic understanding strategy",
namespaceTemplates: ["default"],
});
import pulumi
import pulumi_aws as aws
semantic = aws.bedrock.AgentcoreMemoryStrategy("semantic",
name="semantic-strategy",
memory_id=example["id"],
type="SEMANTIC",
description="Semantic understanding strategy",
namespace_templates=["default"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var semantic = new Aws.Bedrock.AgentcoreMemoryStrategy("semantic", new()
{
Name = "semantic-strategy",
MemoryId = example.Id,
Type = "SEMANTIC",
Description = "Semantic understanding strategy",
NamespaceTemplates = new[]
{
"default",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "semantic", &bedrock.AgentcoreMemoryStrategyArgs{
Name: pulumi.String("semantic-strategy"),
MemoryId: pulumi.Any(example.Id),
Type: pulumi.String("SEMANTIC"),
Description: pulumi.String("Semantic understanding strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("default"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "semantic" {
name = "semantic-strategy"
memory_id = example.id
type = "SEMANTIC"
description = "Semantic understanding strategy"
namespace_templates = ["default"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
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 semantic = new AgentcoreMemoryStrategy("semantic", AgentcoreMemoryStrategyArgs.builder()
.name("semantic-strategy")
.memoryId(example.id())
.type("SEMANTIC")
.description("Semantic understanding strategy")
.namespaceTemplates("default")
.build());
}
}
resources:
semantic:
type: aws:bedrock:AgentcoreMemoryStrategy
properties:
name: semantic-strategy
memoryId: ${example.id}
type: SEMANTIC
description: Semantic understanding strategy
namespaceTemplates:
- default
Summarization Strategy
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const summary = new aws.bedrock.AgentcoreMemoryStrategy("summary", {
name: "summary-strategy",
memoryId: example.id,
type: "SUMMARIZATION",
description: "Text summarization strategy",
namespaceTemplates: ["{sessionId}"],
});
import pulumi
import pulumi_aws as aws
summary = aws.bedrock.AgentcoreMemoryStrategy("summary",
name="summary-strategy",
memory_id=example["id"],
type="SUMMARIZATION",
description="Text summarization strategy",
namespace_templates=["{sessionId}"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var summary = new Aws.Bedrock.AgentcoreMemoryStrategy("summary", new()
{
Name = "summary-strategy",
MemoryId = example.Id,
Type = "SUMMARIZATION",
Description = "Text summarization strategy",
NamespaceTemplates = new[]
{
"{sessionId}",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "summary", &bedrock.AgentcoreMemoryStrategyArgs{
Name: pulumi.String("summary-strategy"),
MemoryId: pulumi.Any(example.Id),
Type: pulumi.String("SUMMARIZATION"),
Description: pulumi.String("Text summarization strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("{sessionId}"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "summary" {
name = "summary-strategy"
memory_id = example.id
type = "SUMMARIZATION"
description = "Text summarization strategy"
namespace_templates = ["{sessionId}"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
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 summary = new AgentcoreMemoryStrategy("summary", AgentcoreMemoryStrategyArgs.builder()
.name("summary-strategy")
.memoryId(example.id())
.type("SUMMARIZATION")
.description("Text summarization strategy")
.namespaceTemplates("{sessionId}")
.build());
}
}
resources:
summary:
type: aws:bedrock:AgentcoreMemoryStrategy
properties:
name: summary-strategy
memoryId: ${example.id}
type: SUMMARIZATION
description: Text summarization strategy
namespaceTemplates:
- '{sessionId}'
User Preference Strategy
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const userPref = new aws.bedrock.AgentcoreMemoryStrategy("user_pref", {
name: "user-preference-strategy",
memoryId: example.id,
type: "USER_PREFERENCE",
description: "User preference tracking strategy",
namespaceTemplates: ["preferences"],
});
import pulumi
import pulumi_aws as aws
user_pref = aws.bedrock.AgentcoreMemoryStrategy("user_pref",
name="user-preference-strategy",
memory_id=example["id"],
type="USER_PREFERENCE",
description="User preference tracking strategy",
namespace_templates=["preferences"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var userPref = new Aws.Bedrock.AgentcoreMemoryStrategy("user_pref", new()
{
Name = "user-preference-strategy",
MemoryId = example.Id,
Type = "USER_PREFERENCE",
Description = "User preference tracking strategy",
NamespaceTemplates = new[]
{
"preferences",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "user_pref", &bedrock.AgentcoreMemoryStrategyArgs{
Name: pulumi.String("user-preference-strategy"),
MemoryId: pulumi.Any(example.Id),
Type: pulumi.String("USER_PREFERENCE"),
Description: pulumi.String("User preference tracking strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("preferences"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "user_pref" {
name = "user-preference-strategy"
memory_id = example.id
type = "USER_PREFERENCE"
description = "User preference tracking strategy"
namespace_templates = ["preferences"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
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 userPref = new AgentcoreMemoryStrategy("userPref", AgentcoreMemoryStrategyArgs.builder()
.name("user-preference-strategy")
.memoryId(example.id())
.type("USER_PREFERENCE")
.description("User preference tracking strategy")
.namespaceTemplates("preferences")
.build());
}
}
resources:
userPref:
type: aws:bedrock:AgentcoreMemoryStrategy
name: user_pref
properties:
name: user-preference-strategy
memoryId: ${example.id}
type: USER_PREFERENCE
description: User preference tracking strategy
namespaceTemplates:
- preferences
Episodic Strategy
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const episodic = new aws.bedrock.AgentcoreMemoryStrategy("episodic", {
name: "episodic-strategy",
memoryId: example.id,
type: "EPISODIC",
description: "Episodic memory strategy",
namespaceTemplates: ["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"],
});
import pulumi
import pulumi_aws as aws
episodic = aws.bedrock.AgentcoreMemoryStrategy("episodic",
name="episodic-strategy",
memory_id=example["id"],
type="EPISODIC",
description="Episodic memory strategy",
namespace_templates=["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var episodic = new Aws.Bedrock.AgentcoreMemoryStrategy("episodic", new()
{
Name = "episodic-strategy",
MemoryId = example.Id,
Type = "EPISODIC",
Description = "Episodic memory strategy",
NamespaceTemplates = new[]
{
"/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "episodic", &bedrock.AgentcoreMemoryStrategyArgs{
Name: pulumi.String("episodic-strategy"),
MemoryId: pulumi.Any(example.Id),
Type: pulumi.String("EPISODIC"),
Description: pulumi.String("Episodic memory strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "episodic" {
name = "episodic-strategy"
memory_id = example.id
type = "EPISODIC"
description = "Episodic memory strategy"
namespace_templates = ["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
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 episodic = new AgentcoreMemoryStrategy("episodic", AgentcoreMemoryStrategyArgs.builder()
.name("episodic-strategy")
.memoryId(example.id())
.type("EPISODIC")
.description("Episodic memory strategy")
.namespaceTemplates("/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}")
.build());
}
}
resources:
episodic:
type: aws:bedrock:AgentcoreMemoryStrategy
properties:
name: episodic-strategy
memoryId: ${example.id}
type: EPISODIC
description: Episodic memory strategy
namespaceTemplates:
- /strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}
Custom Strategy with Semantic Override
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const customSemantic = new aws.bedrock.AgentcoreMemoryStrategy("custom_semantic", {
configuration: {
consolidation: {
appendToPrompt: "Focus on extracting key semantic relationships and concepts",
modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
},
extraction: {
appendToPrompt: "Extract and categorize semantic information",
modelId: "anthropic.claude-3-haiku-20240307-v1:0",
},
type: "SEMANTIC_OVERRIDE",
},
name: "custom-semantic-strategy",
memoryId: example.id,
memoryExecutionRoleArn: example.memoryExecutionRoleArn,
type: "CUSTOM",
description: "Custom semantic processing strategy",
namespaceTemplates: ["{sessionId}"],
});
import pulumi
import pulumi_aws as aws
custom_semantic = aws.bedrock.AgentcoreMemoryStrategy("custom_semantic",
configuration={
"consolidation": {
"append_to_prompt": "Focus on extracting key semantic relationships and concepts",
"model_id": "anthropic.claude-3-sonnet-20240229-v1:0",
},
"extraction": {
"append_to_prompt": "Extract and categorize semantic information",
"model_id": "anthropic.claude-3-haiku-20240307-v1:0",
},
"type": "SEMANTIC_OVERRIDE",
},
name="custom-semantic-strategy",
memory_id=example["id"],
memory_execution_role_arn=example["memoryExecutionRoleArn"],
type="CUSTOM",
description="Custom semantic processing strategy",
namespace_templates=["{sessionId}"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var customSemantic = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_semantic", new()
{
Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
{
Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
{
AppendToPrompt = "Focus on extracting key semantic relationships and concepts",
ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
},
Extraction = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs
{
AppendToPrompt = "Extract and categorize semantic information",
ModelId = "anthropic.claude-3-haiku-20240307-v1:0",
},
Type = "SEMANTIC_OVERRIDE",
},
Name = "custom-semantic-strategy",
MemoryId = example.Id,
MemoryExecutionRoleArn = example.MemoryExecutionRoleArn,
Type = "CUSTOM",
Description = "Custom semantic processing strategy",
NamespaceTemplates = new[]
{
"{sessionId}",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "custom_semantic", &bedrock.AgentcoreMemoryStrategyArgs{
Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
AppendToPrompt: pulumi.String("Focus on extracting key semantic relationships and concepts"),
ModelId: pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
},
Extraction: &bedrock.AgentcoreMemoryStrategyConfigurationExtractionArgs{
AppendToPrompt: pulumi.String("Extract and categorize semantic information"),
ModelId: pulumi.String("anthropic.claude-3-haiku-20240307-v1:0"),
},
Type: pulumi.String("SEMANTIC_OVERRIDE"),
},
Name: pulumi.String("custom-semantic-strategy"),
MemoryId: pulumi.Any(example.Id),
MemoryExecutionRoleArn: pulumi.Any(example.MemoryExecutionRoleArn),
Type: pulumi.String("CUSTOM"),
Description: pulumi.String("Custom semantic processing strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("{sessionId}"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "custom_semantic" {
configuration = {
consolidation = {
append_to_prompt = "Focus on extracting key semantic relationships and concepts"
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
}
extraction = {
append_to_prompt = "Extract and categorize semantic information"
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
}
type = "SEMANTIC_OVERRIDE"
}
name = "custom-semantic-strategy"
memory_id = example.id
memory_execution_role_arn = example.memoryExecutionRoleArn
type = "CUSTOM"
description = "Custom semantic processing strategy"
namespace_templates = ["{sessionId}"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs;
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 customSemantic = new AgentcoreMemoryStrategy("customSemantic", AgentcoreMemoryStrategyArgs.builder()
.configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
.consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
.appendToPrompt("Focus on extracting key semantic relationships and concepts")
.modelId("anthropic.claude-3-sonnet-20240229-v1:0")
.build())
.extraction(AgentcoreMemoryStrategyConfigurationExtractionArgs.builder()
.appendToPrompt("Extract and categorize semantic information")
.modelId("anthropic.claude-3-haiku-20240307-v1:0")
.build())
.type("SEMANTIC_OVERRIDE")
.build())
.name("custom-semantic-strategy")
.memoryId(example.id())
.memoryExecutionRoleArn(example.memoryExecutionRoleArn())
.type("CUSTOM")
.description("Custom semantic processing strategy")
.namespaceTemplates("{sessionId}")
.build());
}
}
resources:
customSemantic:
type: aws:bedrock:AgentcoreMemoryStrategy
name: custom_semantic
properties:
configuration:
consolidation:
appendToPrompt: Focus on extracting key semantic relationships and concepts
modelId: anthropic.claude-3-sonnet-20240229-v1:0
extraction:
appendToPrompt: Extract and categorize semantic information
modelId: anthropic.claude-3-haiku-20240307-v1:0
type: SEMANTIC_OVERRIDE
name: custom-semantic-strategy
memoryId: ${example.id}
memoryExecutionRoleArn: ${example.memoryExecutionRoleArn}
type: CUSTOM
description: Custom semantic processing strategy
namespaceTemplates:
- '{sessionId}'
Custom Strategy with Summary Override
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const customSummary = new aws.bedrock.AgentcoreMemoryStrategy("custom_summary", {
configuration: {
consolidation: {
appendToPrompt: "Create concise summaries while preserving key details",
modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
},
type: "SUMMARY_OVERRIDE",
},
name: "custom-summary-strategy",
memoryId: example.id,
type: "CUSTOM",
description: "Custom summarization strategy",
namespaceTemplates: ["summaries"],
});
import pulumi
import pulumi_aws as aws
custom_summary = aws.bedrock.AgentcoreMemoryStrategy("custom_summary",
configuration={
"consolidation": {
"append_to_prompt": "Create concise summaries while preserving key details",
"model_id": "anthropic.claude-3-sonnet-20240229-v1:0",
},
"type": "SUMMARY_OVERRIDE",
},
name="custom-summary-strategy",
memory_id=example["id"],
type="CUSTOM",
description="Custom summarization strategy",
namespace_templates=["summaries"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var customSummary = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_summary", new()
{
Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
{
Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
{
AppendToPrompt = "Create concise summaries while preserving key details",
ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
},
Type = "SUMMARY_OVERRIDE",
},
Name = "custom-summary-strategy",
MemoryId = example.Id,
Type = "CUSTOM",
Description = "Custom summarization strategy",
NamespaceTemplates = new[]
{
"summaries",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "custom_summary", &bedrock.AgentcoreMemoryStrategyArgs{
Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
AppendToPrompt: pulumi.String("Create concise summaries while preserving key details"),
ModelId: pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
},
Type: pulumi.String("SUMMARY_OVERRIDE"),
},
Name: pulumi.String("custom-summary-strategy"),
MemoryId: pulumi.Any(example.Id),
Type: pulumi.String("CUSTOM"),
Description: pulumi.String("Custom summarization strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("summaries"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "custom_summary" {
configuration = {
consolidation = {
append_to_prompt = "Create concise summaries while preserving key details"
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
}
type = "SUMMARY_OVERRIDE"
}
name = "custom-summary-strategy"
memory_id = example.id
type = "CUSTOM"
description = "Custom summarization strategy"
namespace_templates = ["summaries"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs;
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 customSummary = new AgentcoreMemoryStrategy("customSummary", AgentcoreMemoryStrategyArgs.builder()
.configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
.consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
.appendToPrompt("Create concise summaries while preserving key details")
.modelId("anthropic.claude-3-sonnet-20240229-v1:0")
.build())
.type("SUMMARY_OVERRIDE")
.build())
.name("custom-summary-strategy")
.memoryId(example.id())
.type("CUSTOM")
.description("Custom summarization strategy")
.namespaceTemplates("summaries")
.build());
}
}
resources:
customSummary:
type: aws:bedrock:AgentcoreMemoryStrategy
name: custom_summary
properties:
configuration:
consolidation:
appendToPrompt: Create concise summaries while preserving key details
modelId: anthropic.claude-3-sonnet-20240229-v1:0
type: SUMMARY_OVERRIDE
name: custom-summary-strategy
memoryId: ${example.id}
type: CUSTOM
description: Custom summarization strategy
namespaceTemplates:
- summaries
Custom Strategy with User Preference Override
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const customUserPref = new aws.bedrock.AgentcoreMemoryStrategy("custom_user_pref", {
configuration: {
consolidation: {
appendToPrompt: "Consolidate user preferences and behavioral patterns",
modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
},
extraction: {
appendToPrompt: "Extract user preferences and interaction patterns",
modelId: "anthropic.claude-3-haiku-20240307-v1:0",
},
type: "USER_PREFERENCE_OVERRIDE",
},
name: "custom-user-preference-strategy",
memoryId: example.id,
type: "CUSTOM",
description: "Custom user preference tracking strategy",
namespaceTemplates: ["user_prefs"],
});
import pulumi
import pulumi_aws as aws
custom_user_pref = aws.bedrock.AgentcoreMemoryStrategy("custom_user_pref",
configuration={
"consolidation": {
"append_to_prompt": "Consolidate user preferences and behavioral patterns",
"model_id": "anthropic.claude-3-sonnet-20240229-v1:0",
},
"extraction": {
"append_to_prompt": "Extract user preferences and interaction patterns",
"model_id": "anthropic.claude-3-haiku-20240307-v1:0",
},
"type": "USER_PREFERENCE_OVERRIDE",
},
name="custom-user-preference-strategy",
memory_id=example["id"],
type="CUSTOM",
description="Custom user preference tracking strategy",
namespace_templates=["user_prefs"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var customUserPref = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_user_pref", new()
{
Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
{
Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
{
AppendToPrompt = "Consolidate user preferences and behavioral patterns",
ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
},
Extraction = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs
{
AppendToPrompt = "Extract user preferences and interaction patterns",
ModelId = "anthropic.claude-3-haiku-20240307-v1:0",
},
Type = "USER_PREFERENCE_OVERRIDE",
},
Name = "custom-user-preference-strategy",
MemoryId = example.Id,
Type = "CUSTOM",
Description = "Custom user preference tracking strategy",
NamespaceTemplates = new[]
{
"user_prefs",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "custom_user_pref", &bedrock.AgentcoreMemoryStrategyArgs{
Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
AppendToPrompt: pulumi.String("Consolidate user preferences and behavioral patterns"),
ModelId: pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
},
Extraction: &bedrock.AgentcoreMemoryStrategyConfigurationExtractionArgs{
AppendToPrompt: pulumi.String("Extract user preferences and interaction patterns"),
ModelId: pulumi.String("anthropic.claude-3-haiku-20240307-v1:0"),
},
Type: pulumi.String("USER_PREFERENCE_OVERRIDE"),
},
Name: pulumi.String("custom-user-preference-strategy"),
MemoryId: pulumi.Any(example.Id),
Type: pulumi.String("CUSTOM"),
Description: pulumi.String("Custom user preference tracking strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("user_prefs"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "custom_user_pref" {
configuration = {
consolidation = {
append_to_prompt = "Consolidate user preferences and behavioral patterns"
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
}
extraction = {
append_to_prompt = "Extract user preferences and interaction patterns"
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
}
type = "USER_PREFERENCE_OVERRIDE"
}
name = "custom-user-preference-strategy"
memory_id = example.id
type = "CUSTOM"
description = "Custom user preference tracking strategy"
namespace_templates = ["user_prefs"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs;
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 customUserPref = new AgentcoreMemoryStrategy("customUserPref", AgentcoreMemoryStrategyArgs.builder()
.configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
.consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
.appendToPrompt("Consolidate user preferences and behavioral patterns")
.modelId("anthropic.claude-3-sonnet-20240229-v1:0")
.build())
.extraction(AgentcoreMemoryStrategyConfigurationExtractionArgs.builder()
.appendToPrompt("Extract user preferences and interaction patterns")
.modelId("anthropic.claude-3-haiku-20240307-v1:0")
.build())
.type("USER_PREFERENCE_OVERRIDE")
.build())
.name("custom-user-preference-strategy")
.memoryId(example.id())
.type("CUSTOM")
.description("Custom user preference tracking strategy")
.namespaceTemplates("user_prefs")
.build());
}
}
resources:
customUserPref:
type: aws:bedrock:AgentcoreMemoryStrategy
name: custom_user_pref
properties:
configuration:
consolidation:
appendToPrompt: Consolidate user preferences and behavioral patterns
modelId: anthropic.claude-3-sonnet-20240229-v1:0
extraction:
appendToPrompt: Extract user preferences and interaction patterns
modelId: anthropic.claude-3-haiku-20240307-v1:0
type: USER_PREFERENCE_OVERRIDE
name: custom-user-preference-strategy
memoryId: ${example.id}
type: CUSTOM
description: Custom user preference tracking strategy
namespaceTemplates:
- user_prefs
Custom Strategy with Episodic Override
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const customEpisodic = new aws.bedrock.AgentcoreMemoryStrategy("custom_episodic", {
configuration: {
consolidation: {
appendToPrompt: "Consolidate episodic memories into coherent narratives",
modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
},
extraction: {
appendToPrompt: "Extract key events and episodes from interactions",
modelId: "anthropic.claude-3-haiku-20240307-v1:0",
},
type: "EPISODIC_OVERRIDE",
},
name: "custom-episodic-strategy",
memoryId: example.id,
memoryExecutionRoleArn: example.memoryExecutionRoleArn,
type: "CUSTOM",
description: "Custom episodic processing strategy",
namespaceTemplates: ["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"],
});
import pulumi
import pulumi_aws as aws
custom_episodic = aws.bedrock.AgentcoreMemoryStrategy("custom_episodic",
configuration={
"consolidation": {
"append_to_prompt": "Consolidate episodic memories into coherent narratives",
"model_id": "anthropic.claude-3-sonnet-20240229-v1:0",
},
"extraction": {
"append_to_prompt": "Extract key events and episodes from interactions",
"model_id": "anthropic.claude-3-haiku-20240307-v1:0",
},
"type": "EPISODIC_OVERRIDE",
},
name="custom-episodic-strategy",
memory_id=example["id"],
memory_execution_role_arn=example["memoryExecutionRoleArn"],
type="CUSTOM",
description="Custom episodic processing strategy",
namespace_templates=["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var customEpisodic = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_episodic", new()
{
Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
{
Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
{
AppendToPrompt = "Consolidate episodic memories into coherent narratives",
ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
},
Extraction = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs
{
AppendToPrompt = "Extract key events and episodes from interactions",
ModelId = "anthropic.claude-3-haiku-20240307-v1:0",
},
Type = "EPISODIC_OVERRIDE",
},
Name = "custom-episodic-strategy",
MemoryId = example.Id,
MemoryExecutionRoleArn = example.MemoryExecutionRoleArn,
Type = "CUSTOM",
Description = "Custom episodic processing strategy",
NamespaceTemplates = new[]
{
"/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}",
},
});
});
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.NewAgentcoreMemoryStrategy(ctx, "custom_episodic", &bedrock.AgentcoreMemoryStrategyArgs{
Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
AppendToPrompt: pulumi.String("Consolidate episodic memories into coherent narratives"),
ModelId: pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
},
Extraction: &bedrock.AgentcoreMemoryStrategyConfigurationExtractionArgs{
AppendToPrompt: pulumi.String("Extract key events and episodes from interactions"),
ModelId: pulumi.String("anthropic.claude-3-haiku-20240307-v1:0"),
},
Type: pulumi.String("EPISODIC_OVERRIDE"),
},
Name: pulumi.String("custom-episodic-strategy"),
MemoryId: pulumi.Any(example.Id),
MemoryExecutionRoleArn: pulumi.Any(example.MemoryExecutionRoleArn),
Type: pulumi.String("CUSTOM"),
Description: pulumi.String("Custom episodic processing strategy"),
NamespaceTemplates: pulumi.StringArray{
pulumi.String("/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "custom_episodic" {
configuration = {
consolidation = {
append_to_prompt = "Consolidate episodic memories into coherent narratives"
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
}
extraction = {
append_to_prompt = "Extract key events and episodes from interactions"
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
}
type = "EPISODIC_OVERRIDE"
}
name = "custom-episodic-strategy"
memory_id = example.id
memory_execution_role_arn = example.memoryExecutionRoleArn
type = "CUSTOM"
description = "Custom episodic processing strategy"
namespace_templates = ["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"]
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs;
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 customEpisodic = new AgentcoreMemoryStrategy("customEpisodic", AgentcoreMemoryStrategyArgs.builder()
.configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
.consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
.appendToPrompt("Consolidate episodic memories into coherent narratives")
.modelId("anthropic.claude-3-sonnet-20240229-v1:0")
.build())
.extraction(AgentcoreMemoryStrategyConfigurationExtractionArgs.builder()
.appendToPrompt("Extract key events and episodes from interactions")
.modelId("anthropic.claude-3-haiku-20240307-v1:0")
.build())
.type("EPISODIC_OVERRIDE")
.build())
.name("custom-episodic-strategy")
.memoryId(example.id())
.memoryExecutionRoleArn(example.memoryExecutionRoleArn())
.type("CUSTOM")
.description("Custom episodic processing strategy")
.namespaceTemplates("/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}")
.build());
}
}
resources:
customEpisodic:
type: aws:bedrock:AgentcoreMemoryStrategy
name: custom_episodic
properties:
configuration:
consolidation:
appendToPrompt: Consolidate episodic memories into coherent narratives
modelId: anthropic.claude-3-sonnet-20240229-v1:0
extraction:
appendToPrompt: Extract key events and episodes from interactions
modelId: anthropic.claude-3-haiku-20240307-v1:0
type: EPISODIC_OVERRIDE
name: custom-episodic-strategy
memoryId: ${example.id}
memoryExecutionRoleArn: ${example.memoryExecutionRoleArn}
type: CUSTOM
description: Custom episodic processing strategy
namespaceTemplates:
- /strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}
Custom Strategy with Self-Managed Configuration
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const selfManaged = new aws.bedrock.AgentcoreMemoryStrategy("self_managed", {
configuration: {
selfManaged: [{
invocationConfiguration: [{
topicArn: example.arn,
payloadDeliveryBucketName: exampleAwsS3Bucket.bucket,
}],
triggerConditions: [{
messageBasedTrigger: [{
messageCount: 12,
}],
}],
historicalContextWindowSize: 10,
}],
type: "SELF_MANAGED",
},
name: "self-managed-strategy",
memoryId: exampleAwsBedrockagentcoreMemory.id,
memoryExecutionRoleArn: exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn,
type: "CUSTOM",
description: "Self-managed processing strategy",
});
import pulumi
import pulumi_aws as aws
self_managed = aws.bedrock.AgentcoreMemoryStrategy("self_managed",
configuration={
"self_managed": [{
"invocationConfiguration": [{
"topicArn": example["arn"],
"payloadDeliveryBucketName": example_aws_s3_bucket["bucket"],
}],
"triggerConditions": [{
"messageBasedTrigger": [{
"messageCount": 12,
}],
}],
"historicalContextWindowSize": 10,
}],
"type": "SELF_MANAGED",
},
name="self-managed-strategy",
memory_id=example_aws_bedrockagentcore_memory["id"],
memory_execution_role_arn=example_aws_bedrockagentcore_memory["memoryExecutionRoleArn"],
type="CUSTOM",
description="Self-managed processing strategy")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var selfManaged = new Aws.Bedrock.AgentcoreMemoryStrategy("self_managed", new()
{
Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
{
SelfManaged = new[]
{
{
{ "invocationConfiguration", new[]
{
{
{ "topicArn", example.Arn },
{ "payloadDeliveryBucketName", exampleAwsS3Bucket.Bucket },
},
} },
{ "triggerConditions", new[]
{
{
{ "messageBasedTrigger", new[]
{
{
{ "messageCount", 12 },
},
} },
},
} },
{ "historicalContextWindowSize", 10 },
},
},
Type = "SELF_MANAGED",
},
Name = "self-managed-strategy",
MemoryId = exampleAwsBedrockagentcoreMemory.Id,
MemoryExecutionRoleArn = exampleAwsBedrockagentcoreMemory.MemoryExecutionRoleArn,
Type = "CUSTOM",
Description = "Self-managed processing strategy",
});
});
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.NewAgentcoreMemoryStrategy(ctx, "self_managed", &bedrock.AgentcoreMemoryStrategyArgs{
Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
SelfManaged: []map[string]interface{}{
map[string]interface{}{
"invocationConfiguration": []map[string]interface{}{
map[string]interface{}{
"topicArn": example.Arn,
"payloadDeliveryBucketName": exampleAwsS3Bucket.Bucket,
},
},
"triggerConditions": []map[string][]map[string]int{
{
"messageBasedTrigger": []map[string]int{
{
"messageCount": 12,
},
},
},
},
"historicalContextWindowSize": 10,
},
},
Type: pulumi.String("SELF_MANAGED"),
},
Name: pulumi.String("self-managed-strategy"),
MemoryId: pulumi.Any(exampleAwsBedrockagentcoreMemory.Id),
MemoryExecutionRoleArn: pulumi.Any(exampleAwsBedrockagentcoreMemory.MemoryExecutionRoleArn),
Type: pulumi.String("CUSTOM"),
Description: pulumi.String("Self-managed processing strategy"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "self_managed" {
configuration = {
self_managed = [{
"invocationConfiguration" = [{
"topicArn" = example.arn
"payloadDeliveryBucketName" = exampleAwsS3Bucket.bucket
}]
"triggerConditions" = [{
"messageBasedTrigger" = [{
"messageCount" = 12
}]
}]
"historicalContextWindowSize" = 10
}]
type = "SELF_MANAGED"
}
name = "self-managed-strategy"
memory_id = exampleAwsBedrockagentcoreMemory.id
memory_execution_role_arn = exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn
type = "CUSTOM"
description = "Self-managed processing strategy"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
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 selfManaged = new AgentcoreMemoryStrategy("selfManaged", AgentcoreMemoryStrategyArgs.builder()
.configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
.selfManaged(Arrays.asList(Map.ofEntries(
Map.entry("invocationConfiguration", Arrays.asList(Map.ofEntries(
Map.entry("topicArn", example.arn()),
Map.entry("payloadDeliveryBucketName", exampleAwsS3Bucket.bucket())
))),
Map.entry("triggerConditions", Arrays.asList(Map.of("messageBasedTrigger", Arrays.asList(Map.of("messageCount", 12))))),
Map.entry("historicalContextWindowSize", 10)
)))
.type("SELF_MANAGED")
.build())
.name("self-managed-strategy")
.memoryId(exampleAwsBedrockagentcoreMemory.id())
.memoryExecutionRoleArn(exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn())
.type("CUSTOM")
.description("Self-managed processing strategy")
.build());
}
}
resources:
selfManaged:
type: aws:bedrock:AgentcoreMemoryStrategy
name: self_managed
properties:
configuration:
selfManaged:
- invocationConfiguration:
- topicArn: ${example.arn}
payloadDeliveryBucketName: ${exampleAwsS3Bucket.bucket}
triggerConditions:
- messageBasedTrigger:
- messageCount: 12
historicalContextWindowSize: 10
type: SELF_MANAGED
name: self-managed-strategy
memoryId: ${exampleAwsBedrockagentcoreMemory.id}
memoryExecutionRoleArn: ${exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn}
type: CUSTOM
description: Self-managed processing strategy
Custom Strategy with Self-Managed Configuration
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const selfManaged = new aws.bedrock.AgentcoreMemoryStrategy("self_managed", {
configuration: {
selfManagedConfiguration: {
invocationConfiguration: {
topicArn: example.arn,
payloadDeliveryBucketName: exampleAwsS3Bucket.bucket,
},
triggerCondition: [{
messageBasedTrigger: [{
messageCount: 12,
}],
}],
historicalContextWindowSize: 10,
},
type: "SELF_MANAGED",
},
name: "self-managed-strategy",
memoryId: exampleAwsBedrockagentcoreMemory.id,
memoryExecutionRoleArn: exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn,
type: "CUSTOM",
description: "Self-managed processing strategy",
});
import pulumi
import pulumi_aws as aws
self_managed = aws.bedrock.AgentcoreMemoryStrategy("self_managed",
configuration={
"self_managed_configuration": {
"invocation_configuration": {
"topic_arn": example["arn"],
"payload_delivery_bucket_name": example_aws_s3_bucket["bucket"],
},
"trigger_condition": [{
"messageBasedTrigger": [{
"messageCount": 12,
}],
}],
"historical_context_window_size": 10,
},
"type": "SELF_MANAGED",
},
name="self-managed-strategy",
memory_id=example_aws_bedrockagentcore_memory["id"],
memory_execution_role_arn=example_aws_bedrockagentcore_memory["memoryExecutionRoleArn"],
type="CUSTOM",
description="Self-managed processing strategy")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var selfManaged = new Aws.Bedrock.AgentcoreMemoryStrategy("self_managed", new()
{
Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
{
SelfManagedConfiguration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationArgs
{
InvocationConfiguration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationInvocationConfigurationArgs
{
TopicArn = example.Arn,
PayloadDeliveryBucketName = exampleAwsS3Bucket.Bucket,
},
TriggerCondition = new[]
{
{
{ "messageBasedTrigger", new[]
{
{
{ "messageCount", 12 },
},
} },
},
},
HistoricalContextWindowSize = 10,
},
Type = "SELF_MANAGED",
},
Name = "self-managed-strategy",
MemoryId = exampleAwsBedrockagentcoreMemory.Id,
MemoryExecutionRoleArn = exampleAwsBedrockagentcoreMemory.MemoryExecutionRoleArn,
Type = "CUSTOM",
Description = "Self-managed processing strategy",
});
});
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.NewAgentcoreMemoryStrategy(ctx, "self_managed", &bedrock.AgentcoreMemoryStrategyArgs{
Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
SelfManagedConfiguration: &bedrock.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationArgs{
InvocationConfiguration: &bedrock.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationInvocationConfigurationArgs{
TopicArn: pulumi.Any(example.Arn),
PayloadDeliveryBucketName: pulumi.Any(exampleAwsS3Bucket.Bucket),
},
TriggerCondition: []map[string][]map[string]int{
{
"messageBasedTrigger": []map[string]int{
{
"messageCount": 12,
},
},
},
},
HistoricalContextWindowSize: pulumi.Int(10),
},
Type: pulumi.String("SELF_MANAGED"),
},
Name: pulumi.String("self-managed-strategy"),
MemoryId: pulumi.Any(exampleAwsBedrockagentcoreMemory.Id),
MemoryExecutionRoleArn: pulumi.Any(exampleAwsBedrockagentcoreMemory.MemoryExecutionRoleArn),
Type: pulumi.String("CUSTOM"),
Description: pulumi.String("Self-managed processing strategy"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_bedrock_agentcorememorystrategy" "self_managed" {
configuration = {
self_managed_configuration = {
invocation_configuration = {
topic_arn = example.arn
payload_delivery_bucket_name = exampleAwsS3Bucket.bucket
}
trigger_condition = [{
"messageBasedTrigger" = [{
"messageCount" = 12
}]
}]
historical_context_window_size = 10
}
type = "SELF_MANAGED"
}
name = "self-managed-strategy"
memory_id = exampleAwsBedrockagentcoreMemory.id
memory_execution_role_arn = exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn
type = "CUSTOM"
description = "Self-managed processing strategy"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationInvocationConfigurationArgs;
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 selfManaged = new AgentcoreMemoryStrategy("selfManaged", AgentcoreMemoryStrategyArgs.builder()
.configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
.selfManagedConfiguration(AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationArgs.builder()
.invocationConfiguration(AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationInvocationConfigurationArgs.builder()
.topicArn(example.arn())
.payloadDeliveryBucketName(exampleAwsS3Bucket.bucket())
.build())
.triggerCondition(Arrays.asList(Map.of("messageBasedTrigger", Arrays.asList(Map.of("messageCount", 12)))))
.historicalContextWindowSize(10)
.build())
.type("SELF_MANAGED")
.build())
.name("self-managed-strategy")
.memoryId(exampleAwsBedrockagentcoreMemory.id())
.memoryExecutionRoleArn(exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn())
.type("CUSTOM")
.description("Self-managed processing strategy")
.build());
}
}
resources:
selfManaged:
type: aws:bedrock:AgentcoreMemoryStrategy
name: self_managed
properties:
configuration:
selfManagedConfiguration:
invocationConfiguration:
topicArn: ${example.arn}
payloadDeliveryBucketName: ${exampleAwsS3Bucket.bucket}
triggerCondition:
- messageBasedTrigger:
- messageCount: 12
historicalContextWindowSize: 10
type: SELF_MANAGED
name: self-managed-strategy
memoryId: ${exampleAwsBedrockagentcoreMemory.id}
memoryExecutionRoleArn: ${exampleAwsBedrockagentcoreMemory.memoryExecutionRoleArn}
type: CUSTOM
description: Self-managed processing strategy
Import
Identity Schema
Required
memoryId(String) Memory ID.memoryStrategyId(String) Memory strategy ID.
Optional
accountId(String) Account ID where this resource is managed.region(String) Region where this resource is managed.
Using pulumi import, import memory strategies using memoryId and memoryStrategyId separated by a comma (,). For example:
$ pulumi import aws:bedrock/agentcoreMemoryStrategy:AgentcoreMemoryStrategy example example_memory-5JcvKJ4GP0,example_memory_strategy-pblFzi8VyW
Constructors
- AgentcoreMemoryStrategy(String name, {AgentcoreMemoryStrategyArgs? args, CustomResourceOptions? options})
-
Creates a new AgentcoreMemoryStrategy.
nameThe Pulumi resource name.argsArguments used to configure this AgentcoreMemoryStrategy. The set of arguments for AgentcoreMemoryStrategy.optionsResource options controlling this resource's behavior. - AgentcoreMemoryStrategy.reference(String urn)
- Creates a typed reference to an existing AgentcoreMemoryStrategy resource.
Properties
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
configuration
↔ Output<
AgentcoreMemoryStrategyConfiguration?> -
Custom configuration block. Required when
typeisCUSTOM, must be omitted for other types. SeeconfigurationBlock below.latefinal -
description
↔ Output<
String> -
Description of the memory strategy. Once set, a description cannot be removed via update because the service API ignores a null description and retains the previously stored value.
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
-
memoryExecutionRoleArn
↔ Output<
String?> -
ARN of the IAM role that the memory service assumes to perform operations.
latefinal
-
memoryId
↔ Output<
String> -
ID of the memory to associate with this strategy. Changing this forces a new resource.
latefinal
-
memoryRecordSchema
↔ Output<
AgentcoreMemoryStrategyMemoryRecordSchema?> -
Schema for metadata fields on records generated by this strategy. Valid for all strategy types. See
memoryRecordSchemaBlock below.latefinal -
memoryStrategyId
↔ Output<
String> -
Unique identifier of the Memory Strategy. This corresponds to the service
strategyIdidentifier (AWS API / CloudFormation terminology).latefinal -
name
↔ Output<
String> -
Name of the memory strategy. Changing this forces a new resource, because the service API does not support renaming a strategy.
latefinal
-
namespaces
↔ Output<
List< String> > -
Set of namespace identifiers where this strategy applies. Exactly one of
namespacesornamespaceTemplatesmust be configured. The API treats this as a legacy parameter; prefernamespaceTemplates. Since the API mirrors the two fields, switching an existing configuration fromnamespacestonamespaceTemplateswith the same value is an in-place no-op.latefinal -
namespaceTemplates
↔ Output<
List< String> > -
Set containing exactly one namespace template where this strategy applies (for example
/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}). Namespace templates help organize and scope memory content. Exactly one ofnamespaceTemplatesornamespacesmust be configured for all strategies exceptCUSTOMstrategies usingSELF_MANAGEDconfiguration.latefinal -
reflectionConfiguration
↔ Output<
AgentcoreMemoryStrategyReflectionConfiguration?> -
Configuration for the reflections created with the episodic memory strategy. Valid when
typeisEPISODIC, must be omitted for other types. SeereflectionConfigurationBlock below.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
-
timeouts
↔ Output<
AgentcoreMemoryStrategyTimeouts?> -
latefinal
-
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
type
↔ Output<
String> -
Type of memory strategy. Valid values:
SEMANTIC,SUMMARIZATION,USER_PREFERENCE,EPISODIC,CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC,SUMMARIZATION,USER_PREFERENCE,EPISODIC) can exist per memory.latefinal -
urn
↔ Output<
String> -
latefinalinherited
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, {AgentcoreMemoryStrategyState? state, CustomResourceOptions? options}) → AgentcoreMemoryStrategy -
Gets an existing AgentcoreMemoryStrategy resource's state with the given
nameandid.