Package com.pulumi.aws.bedrock

Class AgentcoreMemoryStrategy

  • public class AgentcoreMemoryStrategy
extends com.pulumi.resources.CustomResource
    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. > **Note:** Each memory can have a maximum of 6 strategies. Only one strategy of each built-in type (`SEMANTIC`, `SUMMARIZATION`, `USER_PREFERENCE`, `EPISODIC`) can exist per memory. Multiple `CUSTOM` strategies are allowed, subject to the total limit of 6. ## Example Usage ### Semantic 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 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());
 
     }
 }
    ### Summarization 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 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());
 
     }
 }
    ### User Preference 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 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());
 
     }
 }
    ### Episodic 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 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());
 
     }
 }
    ### Custom Strategy with Semantic Override 
     
 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());
 
     }
 }
    ### Custom Strategy with Summary Override 
     
 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());
 
     }
 }
    ### Custom Strategy with User Preference Override 
     
 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());
 
     }
 }
    ### Custom Strategy with Episodic Override 
     
 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 com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationReflectionArgs;
 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())
                 .reflection(AgentcoreMemoryStrategyConfigurationReflectionArgs.builder()
                     .appendToPrompt("Reflect on episodes to derive cross-session insights")
                     .modelId("anthropic.claude-3-sonnet-20240229-v1:0")
                     .namespaceTemplates("/strategies/{memoryStrategyId}/actors/{actorId}")
                     .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());
 
     }
 }
    ### Custom Strategy with Self-Managed Configuration 
     
 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.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationTriggerConditionsArgs;
 import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationTriggerConditionsMessageBasedTriggerArgs;
 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()
                     .triggerConditions(AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationTriggerConditionsArgs.builder()
                         .messageBasedTrigger(AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationTriggerConditionsMessageBasedTriggerArgs.builder()
                             .messageCount(12)
                             .build())
                         .build())
                     .invocationConfiguration(AgentcoreMemoryStrategyConfigurationSelfManagedConfigurationInvocationConfigurationArgs.builder()
                         .topicArn(example.arn())
                         .payloadDeliveryBucketName(exampleAwsS3Bucket.bucket())
                         .build())
                     .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());
 
     }
 }
    ## Import ### Identity Schema #### Required * `memoryId` (String) Memory ID. * `memoryStrategyId` (String) Memory strategy ID. #### Optional * `accountId` (String) AWS Account 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: ```sh $ pulumi import aws:bedrock/agentcoreMemoryStrategy:AgentcoreMemoryStrategy example example_memory-5JcvKJ4GP0,example_memory_strategy-pblFzi8VyW ```

    • Constructor Detail

      • AgentcoreMemoryStrategy

        public AgentcoreMemoryStrategy​(java.lang.String name)
        Parameters:
        name - The _unique_ name of the resulting resource.

      • AgentcoreMemoryStrategy

        public AgentcoreMemoryStrategy​(java.lang.String name,
                               AgentcoreMemoryStrategyArgs args)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.

      • AgentcoreMemoryStrategy

        public AgentcoreMemoryStrategy​(java.lang.String name,
                               AgentcoreMemoryStrategyArgs args,
                               @Nullable
                               com.pulumi.resources.CustomResourceOptions options)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.
        options - A bag of options that control this resource's behavior.

    • Method Detail

      • configuration

        public com.pulumi.core.Output<java.util.Optional<AgentcoreMemoryStrategyConfiguration>> configuration()
        Returns:
        Custom configuration block. Required when `type` is `CUSTOM`, must be omitted for other types. See `configuration` Block below.

      • description

        public com.pulumi.core.Output<java.lang.String> description()
        Returns:
        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.

      • memoryExecutionRoleArn

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> memoryExecutionRoleArn()
        Returns:
        ARN of the IAM role that the memory service assumes to perform operations.

      • memoryId

        public com.pulumi.core.Output<java.lang.String> memoryId()
        Returns:
        ID of the memory to associate with this strategy. Changing this forces a new resource.

      • memoryRecordSchema

        public com.pulumi.core.Output<java.util.Optional<AgentcoreMemoryStrategyMemoryRecordSchema>> memoryRecordSchema()
        Returns:
        Schema for metadata fields on records generated by this strategy. Valid for all strategy types. See `memoryRecordSchema` Block below.

      • memoryStrategyId

        public com.pulumi.core.Output<java.lang.String> memoryStrategyId()
        Returns:
        Unique identifier of the Memory Strategy. This corresponds to the service `strategyId` identifier (AWS API / CloudFormation terminology).

      • name

        public com.pulumi.core.Output<java.lang.String> name()
        Returns:
        Name of the memory strategy. Changing this forces a new resource, because the service API does not support renaming a strategy.

      • namespaceTemplates

        public com.pulumi.core.Output<java.util.List<java.lang.String>> namespaceTemplates()
        Returns:
        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 of `namespaceTemplates` or `namespaces` must be configured, except for `CUSTOM` strategies using `SELF_MANAGED` configuration, where neither can be configured.

      • namespaces

        public com.pulumi.core.Output<java.util.List<java.lang.String>> namespaces()
        Returns:
        Set of namespace identifiers where this strategy applies. Exactly one of `namespaces` or `namespaceTemplates` must be configured, except for `CUSTOM` strategies using `SELF_MANAGED` configuration, where neither can be configured. The API treats this as a legacy parameter; prefer `namespaceTemplates`. Since the API mirrors the two fields, switching an existing configuration from `namespaces` to `namespaceTemplates` with the same value is an in-place no-op.

      • reflectionConfiguration

        public com.pulumi.core.Output<java.util.Optional<AgentcoreMemoryStrategyReflectionConfiguration>> reflectionConfiguration()
        Returns:
        Configuration for the reflections created with the episodic memory strategy. Valid when `type` is `EPISODIC`, must be omitted for other types. See `reflectionConfiguration` Block below.

      • region

        public com.pulumi.core.Output<java.lang.String> region()
        Returns:
        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

      • type

        public com.pulumi.core.Output<java.lang.String> type()
        Returns:
        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. The following arguments are optional:

      • get

        public static AgentcoreMemoryStrategy get​(java.lang.String name,
                                          com.pulumi.core.Output<java.lang.String> id,
                                          @Nullable
                                          AgentcoreMemoryStrategyState state,
                                          @Nullable
                                          com.pulumi.resources.CustomResourceOptions options)
        Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
        Parameters:
        name - The _unique_ name of the resulting resource.
        id - The _unique_ provider ID of the resource to lookup.
        state -
        options - Optional settings to control the behavior of the CustomResource.