1. Packages
  2. AWS
  3. API Docs
  4. bedrock
  5. AgentcoreMemoryStrategy
AWS v7.11.0 published on Wednesday, Nov 5, 2025 by Pulumi
pulumi/pulumi-aws

aws.bedrock.AgentcoreMemoryStrategy

Start a Neo task
Explain and create an aws.bedrock.AgentcoreMemoryStrategy resource
aws logo
AWS v7.11.0 published on Wednesday, Nov 5, 2025 by Pulumi
pulumi/pulumi-aws

    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) can exist per memory
    • Multiple CUSTOM strategies 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",
    namespaces: ["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",
    namespaces=["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"),
			Namespaces: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    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",
        Namespaces = new[]
        {
            "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.List;
import java.util.ArrayList;
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")
            .namespaces("default")
            .build());

    }
}

    resources:
  semantic:
    type: aws:bedrock:AgentcoreMemoryStrategy
    properties:
      name: semantic-strategy
      memoryId: ${example.id}
      type: SEMANTIC
      description: Semantic understanding strategy
      namespaces:
        - 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",
    namespaces: ["{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",
    namespaces=["{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"),
			Namespaces: pulumi.StringArray{
				pulumi.String("{sessionId}"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    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",
        Namespaces = new[]
        {
            "{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.List;
import java.util.ArrayList;
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")
            .namespaces("{sessionId}")
            .build());

    }
}

    resources:
  summary:
    type: aws:bedrock:AgentcoreMemoryStrategy
    properties:
      name: summary-strategy
      memoryId: ${example.id}
      type: SUMMARIZATION
      description: Text summarization strategy
      namespaces:
        - '{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",
    namespaces: ["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",
    namespaces=["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"),
			Namespaces: pulumi.StringArray{
				pulumi.String("preferences"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    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",
        Namespaces = new[]
        {
            "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.List;
import java.util.ArrayList;
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")
            .namespaces("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
      namespaces:
        - preferences

    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", {
    name: "custom-semantic-strategy",
    memoryId: example.id,
    memoryExecutionRoleArn: example.memoryExecutionRoleArn,
    type: "CUSTOM",
    description: "Custom semantic processing strategy",
    namespaces: ["{sessionId}"],
    configuration: {
        type: "SEMANTIC_OVERRIDE",
        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",
        },
    },
});

    import pulumi
import pulumi_aws as aws

custom_semantic = aws.bedrock.AgentcoreMemoryStrategy("custom_semantic",
    name="custom-semantic-strategy",
    memory_id=example["id"],
    memory_execution_role_arn=example["memoryExecutionRoleArn"],
    type="CUSTOM",
    description="Custom semantic processing strategy",
    namespaces=["{sessionId}"],
    configuration={
        "type": "SEMANTIC_OVERRIDE",
        "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",
        },
    })

    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{
			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"),
			Namespaces: pulumi.StringArray{
				pulumi.String("{sessionId}"),
			},
			Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
				Type: pulumi.String("SEMANTIC_OVERRIDE"),
				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"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    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()
    {
        Name = "custom-semantic-strategy",
        MemoryId = example.Id,
        MemoryExecutionRoleArn = example.MemoryExecutionRoleArn,
        Type = "CUSTOM",
        Description = "Custom semantic processing strategy",
        Namespaces = new[]
        {
            "{sessionId}",
        },
        Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
        {
            Type = "SEMANTIC_OVERRIDE",
            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",
            },
        },
    });

});

    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.List;
import java.util.ArrayList;
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()
            .name("custom-semantic-strategy")
            .memoryId(example.id())
            .memoryExecutionRoleArn(example.memoryExecutionRoleArn())
            .type("CUSTOM")
            .description("Custom semantic processing strategy")
            .namespaces("{sessionId}")
            .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
                .type("SEMANTIC_OVERRIDE")
                .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())
                .build())
            .build());

    }
}

    resources:
  customSemantic:
    type: aws:bedrock:AgentcoreMemoryStrategy
    name: custom_semantic
    properties:
      name: custom-semantic-strategy
      memoryId: ${example.id}
      memoryExecutionRoleArn: ${example.memoryExecutionRoleArn}
      type: CUSTOM
      description: Custom semantic processing strategy
      namespaces:
        - '{sessionId}'
      configuration:
        type: SEMANTIC_OVERRIDE
        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

    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", {
    name: "custom-summary-strategy",
    memoryId: example.id,
    type: "CUSTOM",
    description: "Custom summarization strategy",
    namespaces: ["summaries"],
    configuration: {
        type: "SUMMARY_OVERRIDE",
        consolidation: {
            appendToPrompt: "Create concise summaries while preserving key details",
            modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
        },
    },
});

    import pulumi
import pulumi_aws as aws

custom_summary = aws.bedrock.AgentcoreMemoryStrategy("custom_summary",
    name="custom-summary-strategy",
    memory_id=example["id"],
    type="CUSTOM",
    description="Custom summarization strategy",
    namespaces=["summaries"],
    configuration={
        "type": "SUMMARY_OVERRIDE",
        "consolidation": {
            "append_to_prompt": "Create concise summaries while preserving key details",
            "model_id": "anthropic.claude-3-sonnet-20240229-v1:0",
        },
    })

    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{
			Name:        pulumi.String("custom-summary-strategy"),
			MemoryId:    pulumi.Any(example.Id),
			Type:        pulumi.String("CUSTOM"),
			Description: pulumi.String("Custom summarization strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("summaries"),
			},
			Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
				Type: pulumi.String("SUMMARY_OVERRIDE"),
				Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
					AppendToPrompt: pulumi.String("Create concise summaries while preserving key details"),
					ModelId:        pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    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()
    {
        Name = "custom-summary-strategy",
        MemoryId = example.Id,
        Type = "CUSTOM",
        Description = "Custom summarization strategy",
        Namespaces = new[]
        {
            "summaries",
        },
        Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
        {
            Type = "SUMMARY_OVERRIDE",
            Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
            {
                AppendToPrompt = "Create concise summaries while preserving key details",
                ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
            },
        },
    });

});

    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.List;
import java.util.ArrayList;
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()
            .name("custom-summary-strategy")
            .memoryId(example.id())
            .type("CUSTOM")
            .description("Custom summarization strategy")
            .namespaces("summaries")
            .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
                .type("SUMMARY_OVERRIDE")
                .consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
                    .appendToPrompt("Create concise summaries while preserving key details")
                    .modelId("anthropic.claude-3-sonnet-20240229-v1:0")
                    .build())
                .build())
            .build());

    }
}

    resources:
  customSummary:
    type: aws:bedrock:AgentcoreMemoryStrategy
    name: custom_summary
    properties:
      name: custom-summary-strategy
      memoryId: ${example.id}
      type: CUSTOM
      description: Custom summarization strategy
      namespaces:
        - summaries
      configuration:
        type: SUMMARY_OVERRIDE
        consolidation:
          appendToPrompt: Create concise summaries while preserving key details
          modelId: anthropic.claude-3-sonnet-20240229-v1:0

    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", {
    name: "custom-user-preference-strategy",
    memoryId: example.id,
    type: "CUSTOM",
    description: "Custom user preference tracking strategy",
    namespaces: ["user_prefs"],
    configuration: {
        type: "USER_PREFERENCE_OVERRIDE",
        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",
        },
    },
});

    import pulumi
import pulumi_aws as aws

custom_user_pref = aws.bedrock.AgentcoreMemoryStrategy("custom_user_pref",
    name="custom-user-preference-strategy",
    memory_id=example["id"],
    type="CUSTOM",
    description="Custom user preference tracking strategy",
    namespaces=["user_prefs"],
    configuration={
        "type": "USER_PREFERENCE_OVERRIDE",
        "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",
        },
    })

    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{
			Name:        pulumi.String("custom-user-preference-strategy"),
			MemoryId:    pulumi.Any(example.Id),
			Type:        pulumi.String("CUSTOM"),
			Description: pulumi.String("Custom user preference tracking strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("user_prefs"),
			},
			Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
				Type: pulumi.String("USER_PREFERENCE_OVERRIDE"),
				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"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    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()
    {
        Name = "custom-user-preference-strategy",
        MemoryId = example.Id,
        Type = "CUSTOM",
        Description = "Custom user preference tracking strategy",
        Namespaces = new[]
        {
            "user_prefs",
        },
        Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
        {
            Type = "USER_PREFERENCE_OVERRIDE",
            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",
            },
        },
    });

});

    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.List;
import java.util.ArrayList;
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()
            .name("custom-user-preference-strategy")
            .memoryId(example.id())
            .type("CUSTOM")
            .description("Custom user preference tracking strategy")
            .namespaces("user_prefs")
            .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
                .type("USER_PREFERENCE_OVERRIDE")
                .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())
                .build())
            .build());

    }
}

    resources:
  customUserPref:
    type: aws:bedrock:AgentcoreMemoryStrategy
    name: custom_user_pref
    properties:
      name: custom-user-preference-strategy
      memoryId: ${example.id}
      type: CUSTOM
      description: Custom user preference tracking strategy
      namespaces:
        - user_prefs
      configuration:
        type: USER_PREFERENCE_OVERRIDE
        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

    Create AgentcoreMemoryStrategy Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new AgentcoreMemoryStrategy(name: string, args: AgentcoreMemoryStrategyArgs, opts?: CustomResourceOptions);
    @overload
def AgentcoreMemoryStrategy(resource_name: str,
                            args: AgentcoreMemoryStrategyArgs,
                            opts: Optional[ResourceOptions] = None)

@overload
def AgentcoreMemoryStrategy(resource_name: str,
                            opts: Optional[ResourceOptions] = None,
                            memory_id: Optional[str] = None,
                            namespaces: Optional[Sequence[str]] = None,
                            type: Optional[str] = None,
                            configuration: Optional[AgentcoreMemoryStrategyConfigurationArgs] = None,
                            description: Optional[str] = None,
                            memory_execution_role_arn: Optional[str] = None,
                            name: Optional[str] = None,
                            region: Optional[str] = None,
                            timeouts: Optional[AgentcoreMemoryStrategyTimeoutsArgs] = None)
    func NewAgentcoreMemoryStrategy(ctx *Context, name string, args AgentcoreMemoryStrategyArgs, opts ...ResourceOption) (*AgentcoreMemoryStrategy, error)
    public AgentcoreMemoryStrategy(string name, AgentcoreMemoryStrategyArgs args, CustomResourceOptions? opts = null)
    public AgentcoreMemoryStrategy(String name, AgentcoreMemoryStrategyArgs args)
public AgentcoreMemoryStrategy(String name, AgentcoreMemoryStrategyArgs args, CustomResourceOptions options)

    type: aws:bedrock:AgentcoreMemoryStrategy
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args AgentcoreMemoryStrategyArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args AgentcoreMemoryStrategyArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args AgentcoreMemoryStrategyArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args AgentcoreMemoryStrategyArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args AgentcoreMemoryStrategyArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var agentcoreMemoryStrategyResource = new Aws.Bedrock.AgentcoreMemoryStrategy("agentcoreMemoryStrategyResource", new()
{
    MemoryId = "string",
    Namespaces = new[]
    {
        "string",
    },
    Type = "string",
    Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
    {
        Type = "string",
        Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
        {
            AppendToPrompt = "string",
            ModelId = "string",
        },
        Extraction = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs
        {
            AppendToPrompt = "string",
            ModelId = "string",
        },
    },
    Description = "string",
    MemoryExecutionRoleArn = "string",
    Name = "string",
    Region = "string",
    Timeouts = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
        Update = "string",
    },
});

    example, err := bedrock.NewAgentcoreMemoryStrategy(ctx, "agentcoreMemoryStrategyResource", &bedrock.AgentcoreMemoryStrategyArgs{
	MemoryId: pulumi.String("string"),
	Namespaces: pulumi.StringArray{
		pulumi.String("string"),
	},
	Type: pulumi.String("string"),
	Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
		Type: pulumi.String("string"),
		Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
			AppendToPrompt: pulumi.String("string"),
			ModelId:        pulumi.String("string"),
		},
		Extraction: &bedrock.AgentcoreMemoryStrategyConfigurationExtractionArgs{
			AppendToPrompt: pulumi.String("string"),
			ModelId:        pulumi.String("string"),
		},
	},
	Description:            pulumi.String("string"),
	MemoryExecutionRoleArn: pulumi.String("string"),
	Name:                   pulumi.String("string"),
	Region:                 pulumi.String("string"),
	Timeouts: &bedrock.AgentcoreMemoryStrategyTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
		Update: pulumi.String("string"),
	},
})

    var agentcoreMemoryStrategyResource = new AgentcoreMemoryStrategy("agentcoreMemoryStrategyResource", AgentcoreMemoryStrategyArgs.builder()
    .memoryId("string")
    .namespaces("string")
    .type("string")
    .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
        .type("string")
        .consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
            .appendToPrompt("string")
            .modelId("string")
            .build())
        .extraction(AgentcoreMemoryStrategyConfigurationExtractionArgs.builder()
            .appendToPrompt("string")
            .modelId("string")
            .build())
        .build())
    .description("string")
    .memoryExecutionRoleArn("string")
    .name("string")
    .region("string")
    .timeouts(AgentcoreMemoryStrategyTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .update("string")
        .build())
    .build());

    agentcore_memory_strategy_resource = aws.bedrock.AgentcoreMemoryStrategy("agentcoreMemoryStrategyResource",
    memory_id="string",
    namespaces=["string"],
    type="string",
    configuration={
        "type": "string",
        "consolidation": {
            "append_to_prompt": "string",
            "model_id": "string",
        },
        "extraction": {
            "append_to_prompt": "string",
            "model_id": "string",
        },
    },
    description="string",
    memory_execution_role_arn="string",
    name="string",
    region="string",
    timeouts={
        "create": "string",
        "delete": "string",
        "update": "string",
    })

    const agentcoreMemoryStrategyResource = new aws.bedrock.AgentcoreMemoryStrategy("agentcoreMemoryStrategyResource", {
    memoryId: "string",
    namespaces: ["string"],
    type: "string",
    configuration: {
        type: "string",
        consolidation: {
            appendToPrompt: "string",
            modelId: "string",
        },
        extraction: {
            appendToPrompt: "string",
            modelId: "string",
        },
    },
    description: "string",
    memoryExecutionRoleArn: "string",
    name: "string",
    region: "string",
    timeouts: {
        create: "string",
        "delete": "string",
        update: "string",
    },
});

    type: aws:bedrock:AgentcoreMemoryStrategy
properties:
    configuration:
        consolidation:
            appendToPrompt: string
            modelId: string
        extraction:
            appendToPrompt: string
            modelId: string
        type: string
    description: string
    memoryExecutionRoleArn: string
    memoryId: string
    name: string
    namespaces:
        - string
    region: string
    timeouts:
        create: string
        delete: string
        update: string
    type: string

    AgentcoreMemoryStrategy Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The AgentcoreMemoryStrategy resource accepts the following input properties:

    MemoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    Namespaces List<string>

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    Type string
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    Configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    Name string
    Name of the memory strategy.
    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Timeouts AgentcoreMemoryStrategyTimeouts
    MemoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    Namespaces []string

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    Type string
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    Configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    Name string
    Name of the memory strategy.
    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Timeouts AgentcoreMemoryStrategyTimeoutsArgs
    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    namespaces List<String>

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    type String
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    name String
    Name of the memory strategy.
    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts AgentcoreMemoryStrategyTimeouts
    memoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    namespaces string[]

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    type string
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description string
    Description of the memory strategy.
    memoryExecutionRoleArn string
    name string
    Name of the memory strategy.
    region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts AgentcoreMemoryStrategyTimeouts
    memory_id str
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    namespaces Sequence[str]

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    type str
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description str
    Description of the memory strategy.
    memory_execution_role_arn str
    name str
    Name of the memory strategy.
    region str
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts AgentcoreMemoryStrategyTimeoutsArgs
    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    namespaces List<String>

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    type String
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration Property Map
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    name String
    Name of the memory strategy.
    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts Property Map

    Outputs

    All input properties are implicitly available as output properties. Additionally, the AgentcoreMemoryStrategy resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    MemoryStrategyId string
    Id string
    The provider-assigned unique ID for this managed resource.
    MemoryStrategyId string
    id String
    The provider-assigned unique ID for this managed resource.
    memoryStrategyId String
    id string
    The provider-assigned unique ID for this managed resource.
    memoryStrategyId string
    id str
    The provider-assigned unique ID for this managed resource.
    memory_strategy_id str
    id String
    The provider-assigned unique ID for this managed resource.
    memoryStrategyId String

    Look up Existing AgentcoreMemoryStrategy Resource

    Get an existing AgentcoreMemoryStrategy resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: AgentcoreMemoryStrategyState, opts?: CustomResourceOptions): AgentcoreMemoryStrategy
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        configuration: Optional[AgentcoreMemoryStrategyConfigurationArgs] = None,
        description: Optional[str] = None,
        memory_execution_role_arn: Optional[str] = None,
        memory_id: Optional[str] = None,
        memory_strategy_id: Optional[str] = None,
        name: Optional[str] = None,
        namespaces: Optional[Sequence[str]] = None,
        region: Optional[str] = None,
        timeouts: Optional[AgentcoreMemoryStrategyTimeoutsArgs] = None,
        type: Optional[str] = None) -> AgentcoreMemoryStrategy
    func GetAgentcoreMemoryStrategy(ctx *Context, name string, id IDInput, state *AgentcoreMemoryStrategyState, opts ...ResourceOption) (*AgentcoreMemoryStrategy, error)
    public static AgentcoreMemoryStrategy Get(string name, Input<string> id, AgentcoreMemoryStrategyState? state, CustomResourceOptions? opts = null)
    public static AgentcoreMemoryStrategy get(String name, Output<String> id, AgentcoreMemoryStrategyState state, CustomResourceOptions options)
    resources:  _:    type: aws:bedrock:AgentcoreMemoryStrategy    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    MemoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    MemoryStrategyId string
    Name string
    Name of the memory strategy.
    Namespaces List<string>

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Timeouts AgentcoreMemoryStrategyTimeouts
    Type string
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    Configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    MemoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    MemoryStrategyId string
    Name string
    Name of the memory strategy.
    Namespaces []string

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Timeouts AgentcoreMemoryStrategyTimeoutsArgs
    Type string
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memoryStrategyId String
    name String
    Name of the memory strategy.
    namespaces List<String>

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts AgentcoreMemoryStrategyTimeouts
    type String
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description string
    Description of the memory strategy.
    memoryExecutionRoleArn string
    memoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memoryStrategyId string
    name string
    Name of the memory strategy.
    namespaces string[]

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts AgentcoreMemoryStrategyTimeouts
    type string
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description str
    Description of the memory strategy.
    memory_execution_role_arn str
    memory_id str
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memory_strategy_id str
    name str
    Name of the memory strategy.
    namespaces Sequence[str]

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    region str
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts AgentcoreMemoryStrategyTimeoutsArgs
    type str
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.
    configuration Property Map
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memoryStrategyId String
    name String
    Name of the memory strategy.
    namespaces List<String>

    Set of namespace identifiers where this strategy applies. Namespaces help organize and scope memory content.

    The following arguments are optional:

    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts Property Map
    type String
    Type of memory strategy. Valid values: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM. Changing this forces a new resource. Note that only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory.

    Supporting Types

    AgentcoreMemoryStrategyConfiguration, AgentcoreMemoryStrategyConfigurationArgs

    Type string
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE. Changing this forces a new resource.
    Consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for processing and organizing memory content. See consolidation below. Once added, this block cannot be removed without recreating the resource.
    Extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for identifying and extracting relevant information. See extraction below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    Type string
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE. Changing this forces a new resource.
    Consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for processing and organizing memory content. See consolidation below. Once added, this block cannot be removed without recreating the resource.
    Extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for identifying and extracting relevant information. See extraction below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    type String
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE. Changing this forces a new resource.
    consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for processing and organizing memory content. See consolidation below. Once added, this block cannot be removed without recreating the resource.
    extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for identifying and extracting relevant information. See extraction below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    type string
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE. Changing this forces a new resource.
    consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for processing and organizing memory content. See consolidation below. Once added, this block cannot be removed without recreating the resource.
    extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for identifying and extracting relevant information. See extraction below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    type str
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE. Changing this forces a new resource.
    consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for processing and organizing memory content. See consolidation below. Once added, this block cannot be removed without recreating the resource.
    extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for identifying and extracting relevant information. See extraction below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    type String
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE. Changing this forces a new resource.
    consolidation Property Map
    Consolidation configuration for processing and organizing memory content. See consolidation below. Once added, this block cannot be removed without recreating the resource.
    extraction Property Map
    Extraction configuration for identifying and extracting relevant information. See extraction below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.

    AgentcoreMemoryStrategyConfigurationConsolidation, AgentcoreMemoryStrategyConfigurationConsolidationArgs

    AppendToPrompt string
    Additional text to append to the model prompt for consolidation processing.
    ModelId string
    ID of the foundation model to use for consolidation processing.
    AppendToPrompt string
    Additional text to append to the model prompt for consolidation processing.
    ModelId string
    ID of the foundation model to use for consolidation processing.
    appendToPrompt String
    Additional text to append to the model prompt for consolidation processing.
    modelId String
    ID of the foundation model to use for consolidation processing.
    appendToPrompt string
    Additional text to append to the model prompt for consolidation processing.
    modelId string
    ID of the foundation model to use for consolidation processing.
    append_to_prompt str
    Additional text to append to the model prompt for consolidation processing.
    model_id str
    ID of the foundation model to use for consolidation processing.
    appendToPrompt String
    Additional text to append to the model prompt for consolidation processing.
    modelId String
    ID of the foundation model to use for consolidation processing.

    AgentcoreMemoryStrategyConfigurationExtraction, AgentcoreMemoryStrategyConfigurationExtractionArgs

    AppendToPrompt string
    Additional text to append to the model prompt for extraction processing.
    ModelId string
    ID of the foundation model to use for extraction processing.
    AppendToPrompt string
    Additional text to append to the model prompt for extraction processing.
    ModelId string
    ID of the foundation model to use for extraction processing.
    appendToPrompt String
    Additional text to append to the model prompt for extraction processing.
    modelId String
    ID of the foundation model to use for extraction processing.
    appendToPrompt string
    Additional text to append to the model prompt for extraction processing.
    modelId string
    ID of the foundation model to use for extraction processing.
    append_to_prompt str
    Additional text to append to the model prompt for extraction processing.
    model_id str
    ID of the foundation model to use for extraction processing.
    appendToPrompt String
    Additional text to append to the model prompt for extraction processing.
    modelId String
    ID of the foundation model to use for extraction processing.

    AgentcoreMemoryStrategyTimeouts, AgentcoreMemoryStrategyTimeoutsArgs

    Create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    Delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    Update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    Create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    Delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    Update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create str
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete str
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update str
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).

    Import

    Using pulumi import, import Bedrock AgentCore Memory Strategy using the memory_id,strategy_id. For example:

    $ pulumi import aws:bedrock/agentcoreMemoryStrategy:AgentcoreMemoryStrategy example MEMORY1234567890,STRATEGY0987654321

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo
    AWS v7.11.0 published on Wednesday, Nov 5, 2025 by Pulumi
    pulumi/pulumi-aws
      Meet Neo: Your AI Platform Teammate