Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. AWS
  4. API Docs
  5. bedrock
  6. AgentcoreMemoryStrategy
Viewing docs for AWS v7.41.0
published on Friday, Aug 7, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-aws

aws.bedrock.AgentcoreMemoryStrategy

aws logo aws logo
Viewing docs for AWS v7.41.0
published on Friday, Aug 7, 2026 by Pulumi
Schema (JSON)
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, EPISODIC) 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",
    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"])

    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
	})
}

    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 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

    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"]
}

    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}"])

    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
	})
}

    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 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}'

    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}"]
}

    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"])

    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
	})
}

    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 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

    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"]
}

    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}"])

    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
	})
}

    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 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}

    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}"]
}

    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",
    namespaceTemplates: ["{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",
    namespace_templates=["{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"),
			NamespaceTemplates: 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",
        NamespaceTemplates = 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.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()
            .name("custom-semantic-strategy")
            .memoryId(example.id())
            .memoryExecutionRoleArn(example.memoryExecutionRoleArn())
            .type("CUSTOM")
            .description("Custom semantic processing strategy")
            .namespaceTemplates("{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
      namespaceTemplates:
        - '{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

    pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "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"
  namespace_templates       = ["{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"
    }
  }
}

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

    pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcorememorystrategy" "custom_summary" {
  name                = "custom-summary-strategy"
  memory_id           = example.id
  type                = "CUSTOM"
  description         = "Custom summarization strategy"
  namespace_templates = ["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"
    }
  }
}

    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",
    namespaceTemplates: ["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",
    namespace_templates=["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"),
			NamespaceTemplates: 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",
        NamespaceTemplates = 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.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()
            .name("custom-user-preference-strategy")
            .memoryId(example.id())
            .type("CUSTOM")
            .description("Custom user preference tracking strategy")
            .namespaceTemplates("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
      namespaceTemplates:
        - 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

    pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcorememorystrategy" "custom_user_pref" {
  name                = "custom-user-preference-strategy"
  memory_id           = example.id
  type                = "CUSTOM"
  description         = "Custom user preference tracking strategy"
  namespace_templates = ["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"
    }
  }
}

    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", {
    name: "custom-episodic-strategy",
    memoryId: example.id,
    memoryExecutionRoleArn: example.memoryExecutionRoleArn,
    type: "CUSTOM",
    description: "Custom episodic processing strategy",
    namespaceTemplates: ["/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}"],
    configuration: {
        type: "EPISODIC_OVERRIDE",
        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",
        },
    },
});

    import pulumi
import pulumi_aws as aws

custom_episodic = aws.bedrock.AgentcoreMemoryStrategy("custom_episodic",
    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}"],
    configuration={
        "type": "EPISODIC_OVERRIDE",
        "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",
        },
    })

    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{
			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}"),
			},
			Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
				Type: pulumi.String("EPISODIC_OVERRIDE"),
				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"),
				},
			},
		})
		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 customEpisodic = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_episodic", new()
    {
        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}",
        },
        Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
        {
            Type = "EPISODIC_OVERRIDE",
            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",
            },
        },
    });

});

    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()
            .name("custom-episodic-strategy")
            .memoryId(example.id())
            .memoryExecutionRoleArn(example.memoryExecutionRoleArn())
            .type("CUSTOM")
            .description("Custom episodic processing strategy")
            .namespaceTemplates("/strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}")
            .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
                .type("EPISODIC_OVERRIDE")
                .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())
                .build())
            .build());

    }
}

    resources:
  customEpisodic:
    type: aws:bedrock:AgentcoreMemoryStrategy
    name: custom_episodic
    properties:
      name: custom-episodic-strategy
      memoryId: ${example.id}
      memoryExecutionRoleArn: ${example.memoryExecutionRoleArn}
      type: CUSTOM
      description: Custom episodic processing strategy
      namespaceTemplates:
        - /strategies/{memoryStrategyId}/actors/{actorId}/sessions/{sessionId}
      configuration:
        type: EPISODIC_OVERRIDE
        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

    pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcorememorystrategy" "custom_episodic" {
  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}"]
  configuration = {
    type = "EPISODIC_OVERRIDE"
    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"
    }
  }
}

    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,
                            type: Optional[str] = None,
                            configuration: Optional[AgentcoreMemoryStrategyConfigurationArgs] = None,
                            description: Optional[str] = None,
                            memory_execution_role_arn: Optional[str] = None,
                            name: Optional[str] = None,
                            namespace_templates: Optional[Sequence[str]] = None,
                            namespaces: Optional[Sequence[str]] = None,
                            reflection_configuration: Optional[AgentcoreMemoryStrategyReflectionConfigurationArgs] = 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.


    resource "aws_bedrock_agentcore_memory_strategy" "name" {
    # resource properties
}

    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",
    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",
        },
        Reflection = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationReflectionArgs
        {
            AppendToPrompt = "string",
            ModelId = "string",
            NamespaceTemplates = new[]
            {
                "string",
            },
        },
    },
    Description = "string",
    Name = "string",
    NamespaceTemplates = new[]
    {
        "string",
    },
    ReflectionConfiguration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyReflectionConfigurationArgs
    {
        NamespaceTemplates = new[]
        {
            "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"),
	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"),
		},
		Reflection: &bedrock.AgentcoreMemoryStrategyConfigurationReflectionArgs{
			AppendToPrompt: pulumi.String("string"),
			ModelId:        pulumi.String("string"),
			NamespaceTemplates: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
	Description: pulumi.String("string"),
	Name:        pulumi.String("string"),
	NamespaceTemplates: pulumi.StringArray{
		pulumi.String("string"),
	},
	ReflectionConfiguration: &bedrock.AgentcoreMemoryStrategyReflectionConfigurationArgs{
		NamespaceTemplates: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Region: pulumi.String("string"),
	Timeouts: &bedrock.AgentcoreMemoryStrategyTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
		Update: pulumi.String("string"),
	},
})

    resource "aws_bedrock_agentcore_memory_strategy" "agentcoreMemoryStrategyResource" {
  lifecycle {
    create_before_destroy = true
  }
  memory_id = "string"
  type      = "string"
  configuration = {
    type = "string"
    consolidation = {
      append_to_prompt = "string"
      model_id         = "string"
    }
    extraction = {
      append_to_prompt = "string"
      model_id         = "string"
    }
    reflection = {
      append_to_prompt    = "string"
      model_id            = "string"
      namespace_templates = ["string"]
    }
  }
  description         = "string"
  name                = "string"
  namespace_templates = ["string"]
  reflection_configuration = {
    namespace_templates = ["string"]
  }
  region = "string"
  timeouts = {
    create = "string"
    delete = "string"
    update = "string"
  }
}

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

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

    const agentcoreMemoryStrategyResource = new aws.bedrock.AgentcoreMemoryStrategy("agentcoreMemoryStrategyResource", {
    memoryId: "string",
    type: "string",
    configuration: {
        type: "string",
        consolidation: {
            appendToPrompt: "string",
            modelId: "string",
        },
        extraction: {
            appendToPrompt: "string",
            modelId: "string",
        },
        reflection: {
            appendToPrompt: "string",
            modelId: "string",
            namespaceTemplates: ["string"],
        },
    },
    description: "string",
    name: "string",
    namespaceTemplates: ["string"],
    reflectionConfiguration: {
        namespaceTemplates: ["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
        reflection:
            appendToPrompt: string
            modelId: string
            namespaceTemplates:
                - string
        type: string
    description: string
    memoryId: string
    name: string
    namespaceTemplates:
        - string
    reflectionConfiguration:
        namespaceTemplates:
            - 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.
    Type 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.

    The following arguments are optional:

    Configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    Name string
    Name of the memory strategy.
    NamespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    Namespaces List<string>
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    ReflectionConfiguration AgentcoreMemoryStrategyReflectionConfiguration
    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 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.
    Type 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.

    The following arguments are optional:

    Configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    Name string
    Name of the memory strategy.
    NamespaceTemplates []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 of namespaceTemplates or namespaces must be configured.
    Namespaces []string
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    ReflectionConfiguration AgentcoreMemoryStrategyReflectionConfigurationArgs
    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 string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Timeouts AgentcoreMemoryStrategyTimeoutsArgs
    memory_id string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    type 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.

    The following arguments are optional:

    configuration object
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description string
    Description of the memory strategy.
    memory_execution_role_arn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    name string
    Name of the memory strategy.
    namespace_templates 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 of namespaceTemplates or namespaces must be configured.
    namespaces list(string)
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflection_configuration object
    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 string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts object
    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    type 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.

    The following arguments are optional:

    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    name String
    Name of the memory strategy.
    namespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    namespaces List<String>
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflectionConfiguration AgentcoreMemoryStrategyReflectionConfiguration
    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 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.
    type 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.

    The following arguments are optional:

    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description string
    Description of the memory strategy.
    memoryExecutionRoleArn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    name string
    Name of the memory strategy.
    namespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    namespaces string[]
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflectionConfiguration AgentcoreMemoryStrategyReflectionConfiguration
    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 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.
    type str

    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:

    configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description str
    Description of the memory strategy.
    memory_execution_role_arn str
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    name str
    Name of the memory strategy.
    namespace_templates Sequence[str]
    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.
    namespaces Sequence[str]
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflection_configuration AgentcoreMemoryStrategyReflectionConfigurationArgs
    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 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.
    type 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.

    The following arguments are optional:

    configuration Property Map
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    name String
    Name of the memory strategy.
    namespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    namespaces List<String>
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflectionConfiguration Property Map
    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 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
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    Id string
    The provider-assigned unique ID for this managed resource.
    MemoryStrategyId string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    id string
    The provider-assigned unique ID for this managed resource.
    memory_strategy_id string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    id String
    The provider-assigned unique ID for this managed resource.
    memoryStrategyId String
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    id string
    The provider-assigned unique ID for this managed resource.
    memoryStrategyId string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    id str
    The provider-assigned unique ID for this managed resource.
    memory_strategy_id str
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    id String
    The provider-assigned unique ID for this managed resource.
    memoryStrategyId String
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).

    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,
        namespace_templates: Optional[Sequence[str]] = None,
        namespaces: Optional[Sequence[str]] = None,
        reflection_configuration: Optional[AgentcoreMemoryStrategyReflectionConfigurationArgs] = 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}
    import {
  to = aws_bedrock_agentcore_memory_strategy.example
  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 Block below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    MemoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    MemoryStrategyId string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    Name string
    Name of the memory strategy.
    NamespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    Namespaces List<string>
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    ReflectionConfiguration AgentcoreMemoryStrategyReflectionConfiguration
    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 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, 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:

    Configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    Description string
    Description of the memory strategy.
    MemoryExecutionRoleArn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    MemoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    MemoryStrategyId string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    Name string
    Name of the memory strategy.
    NamespaceTemplates []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 of namespaceTemplates or namespaces must be configured.
    Namespaces []string
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    ReflectionConfiguration AgentcoreMemoryStrategyReflectionConfigurationArgs
    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 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, 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:

    configuration object
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description string
    Description of the memory strategy.
    memory_execution_role_arn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    memory_id string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memory_strategy_id string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    name string
    Name of the memory strategy.
    namespace_templates 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 of namespaceTemplates or namespaces must be configured.
    namespaces list(string)
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflection_configuration object
    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 string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    timeouts object
    type 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.

    The following arguments are optional:

    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memoryStrategyId String
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    name String
    Name of the memory strategy.
    namespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    namespaces List<String>
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflectionConfiguration AgentcoreMemoryStrategyReflectionConfiguration
    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 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, 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:

    configuration AgentcoreMemoryStrategyConfiguration
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description string
    Description of the memory strategy.
    memoryExecutionRoleArn string
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    memoryId string
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memoryStrategyId string
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    name string
    Name of the memory strategy.
    namespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    namespaces string[]
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflectionConfiguration AgentcoreMemoryStrategyReflectionConfiguration
    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 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, 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:

    configuration AgentcoreMemoryStrategyConfigurationArgs
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description str
    Description of the memory strategy.
    memory_execution_role_arn str
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    memory_id str
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memory_strategy_id str
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    name str
    Name of the memory strategy.
    namespace_templates Sequence[str]
    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.
    namespaces Sequence[str]
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflection_configuration AgentcoreMemoryStrategyReflectionConfigurationArgs
    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 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, 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:

    configuration Property Map
    Custom configuration block. Required when type is CUSTOM, must be omitted for other types. See configuration Block below.
    description String
    Description of the memory strategy.
    memoryExecutionRoleArn String
    ARN of the IAM role that the memory service assumes to perform operations.

    Deprecated: memory_execution_role_arn is deprecated. Use memoryExecutionRoleArn on the aws.bedrock.AgentcoreMemory resource instead.

    memoryId String
    ID of the memory to associate with this strategy. Changing this forces a new resource.
    memoryStrategyId String
    Unique identifier of the Memory Strategy. This corresponds to the service strategyId identifier (AWS API / CloudFormation terminology).
    name String
    Name of the memory strategy.
    namespaceTemplates 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 of namespaceTemplates or namespaces must be configured.
    namespaces List<String>
    Set of namespace identifiers where this strategy applies. Exactly one of namespaces or namespaceTemplates must 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.

    Deprecated: namespaces is deprecated. Use namespaceTemplates instead.

    reflectionConfiguration Property Map
    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 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, 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:

    Supporting Types

    AgentcoreMemoryStrategyConfiguration, AgentcoreMemoryStrategyConfigurationArgs

    Type string
    Type of custom override. Valid values: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, USER_PREFERENCE_OVERRIDE, EPISODIC_OVERRIDE. Changing this forces a new resource.
    Consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    Extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    Reflection AgentcoreMemoryStrategyConfigurationReflection
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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, EPISODIC_OVERRIDE. Changing this forces a new resource.
    Consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    Extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    Reflection AgentcoreMemoryStrategyConfigurationReflection
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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, EPISODIC_OVERRIDE. Changing this forces a new resource.
    consolidation object
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    extraction object
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    reflection object
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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, EPISODIC_OVERRIDE. Changing this forces a new resource.
    consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    reflection AgentcoreMemoryStrategyConfigurationReflection
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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, EPISODIC_OVERRIDE. Changing this forces a new resource.
    consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    reflection AgentcoreMemoryStrategyConfigurationReflection
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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, EPISODIC_OVERRIDE. Changing this forces a new resource.
    consolidation AgentcoreMemoryStrategyConfigurationConsolidation
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    extraction AgentcoreMemoryStrategyConfigurationExtraction
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    reflection AgentcoreMemoryStrategyConfigurationReflection
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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, EPISODIC_OVERRIDE. Changing this forces a new resource.
    consolidation Property Map
    Consolidation configuration for the memory strategy. See consolidation Block below. Once added, this block cannot be removed without recreating the resource.
    extraction Property Map
    Extraction configuration for the memory strategy. See extraction Block below. Cannot be used with type set to SUMMARY_OVERRIDE. Once added, this block cannot be removed without recreating the resource.
    reflection Property Map
    Reflection configuration for the memory strategy. See reflection Block below. Can only be used, and is required, with type set to EPISODIC_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.
    append_to_prompt string
    Additional text to append to the model prompt for consolidation processing.
    model_id 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.
    append_to_prompt string
    Additional text to append to the model prompt for extraction processing.
    model_id 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.

    AgentcoreMemoryStrategyConfigurationReflection, AgentcoreMemoryStrategyConfigurationReflectionArgs

    AppendToPrompt string
    Additional text to append to the model prompt for reflection processing.
    ModelId string
    ID of the foundation model to use for reflection processing.
    NamespaceTemplates List<string>
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.
    AppendToPrompt string
    Additional text to append to the model prompt for reflection processing.
    ModelId string
    ID of the foundation model to use for reflection processing.
    NamespaceTemplates []string
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.
    append_to_prompt string
    Additional text to append to the model prompt for reflection processing.
    model_id string
    ID of the foundation model to use for reflection processing.
    namespace_templates list(string)
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.
    appendToPrompt String
    Additional text to append to the model prompt for reflection processing.
    modelId String
    ID of the foundation model to use for reflection processing.
    namespaceTemplates List<String>
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.
    appendToPrompt string
    Additional text to append to the model prompt for reflection processing.
    modelId string
    ID of the foundation model to use for reflection processing.
    namespaceTemplates string[]
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.
    append_to_prompt str
    Additional text to append to the model prompt for reflection processing.
    model_id str
    ID of the foundation model to use for reflection processing.
    namespace_templates Sequence[str]
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.
    appendToPrompt String
    Additional text to append to the model prompt for reflection processing.
    modelId String
    ID of the foundation model to use for reflection processing.
    namespaceTemplates List<String>
    Namespace templates for episodic reflection. Can be less nested than the episodic namespaces.

    AgentcoreMemoryStrategyReflectionConfiguration, AgentcoreMemoryStrategyReflectionConfigurationArgs

    NamespaceTemplates List<string>
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.
    NamespaceTemplates []string
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.
    namespace_templates list(string)
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.
    namespaceTemplates List<String>
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.
    namespaceTemplates string[]
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.
    namespace_templates Sequence[str]
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.
    namespaceTemplates List<String>
    Namespace templates over which to create reflections. Can be less nested than episode namespaces.

    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 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 logo
    Viewing docs for AWS v7.41.0
    published on Friday, Aug 7, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-aws

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial