Configure AWS Bedrock Agent Memory Strategies

The aws:bedrock/agentcoreMemoryStrategy:AgentcoreMemoryStrategy resource, part of the Pulumi AWS provider, defines how a Bedrock agent processes and organizes information within a memory: semantic understanding, summarization, user preferences, or custom logic. This guide focuses on three capabilities: built-in strategy types, custom overrides with model selection, and namespace scoping.

Memory strategies attach to existing Bedrock AgentCore memories. Custom strategies may require IAM execution roles and access to specific foundation models. The examples are intentionally small. Combine them with your own memory resources and IAM configuration.

Enable semantic understanding with a built-in strategy

Agents that need to understand relationships and concepts in conversation history start with semantic processing.

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

const semantic = new aws.bedrock.AgentcoreMemoryStrategy("semantic", {
    name: "semantic-strategy",
    memoryId: example.id,
    type: "SEMANTIC",
    description: "Semantic understanding strategy",
    namespaces: ["default"],
});

import pulumi
import pulumi_aws as aws

semantic = aws.bedrock.AgentcoreMemoryStrategy("semantic",
    name="semantic-strategy",
    memory_id=example["id"],
    type="SEMANTIC",
    description="Semantic understanding strategy",
    namespaces=["default"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreMemoryStrategy(ctx, "semantic", &bedrock.AgentcoreMemoryStrategyArgs{
			Name:        pulumi.String("semantic-strategy"),
			MemoryId:    pulumi.Any(example.Id),
			Type:        pulumi.String("SEMANTIC"),
			Description: pulumi.String("Semantic understanding strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("default"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var semantic = new Aws.Bedrock.AgentcoreMemoryStrategy("semantic", new()
    {
        Name = "semantic-strategy",
        MemoryId = example.Id,
        Type = "SEMANTIC",
        Description = "Semantic understanding strategy",
        Namespaces = new[]
        {
            "default",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var semantic = new AgentcoreMemoryStrategy("semantic", AgentcoreMemoryStrategyArgs.builder()
            .name("semantic-strategy")
            .memoryId(example.id())
            .type("SEMANTIC")
            .description("Semantic understanding strategy")
            .namespaces("default")
            .build());

    }
}

resources:
  semantic:
    type: aws:bedrock:AgentcoreMemoryStrategy
    properties:
      name: semantic-strategy
      memoryId: ${example.id}
      type: SEMANTIC
      description: Semantic understanding strategy
      namespaces:
        - default

The type property selects the strategy behavior; SEMANTIC extracts meaning and relationships from interactions. The namespaces property scopes where this strategy applies within the memory. Built-in strategies require no additional configuration.

Summarize conversation history automatically

Long conversations benefit from automatic summarization to maintain context without overwhelming the agent.

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

const summary = new aws.bedrock.AgentcoreMemoryStrategy("summary", {
    name: "summary-strategy",
    memoryId: example.id,
    type: "SUMMARIZATION",
    description: "Text summarization strategy",
    namespaces: ["{sessionId}"],
});

import pulumi
import pulumi_aws as aws

summary = aws.bedrock.AgentcoreMemoryStrategy("summary",
    name="summary-strategy",
    memory_id=example["id"],
    type="SUMMARIZATION",
    description="Text summarization strategy",
    namespaces=["{sessionId}"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreMemoryStrategy(ctx, "summary", &bedrock.AgentcoreMemoryStrategyArgs{
			Name:        pulumi.String("summary-strategy"),
			MemoryId:    pulumi.Any(example.Id),
			Type:        pulumi.String("SUMMARIZATION"),
			Description: pulumi.String("Text summarization strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("{sessionId}"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var summary = new Aws.Bedrock.AgentcoreMemoryStrategy("summary", new()
    {
        Name = "summary-strategy",
        MemoryId = example.Id,
        Type = "SUMMARIZATION",
        Description = "Text summarization strategy",
        Namespaces = new[]
        {
            "{sessionId}",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var summary = new AgentcoreMemoryStrategy("summary", AgentcoreMemoryStrategyArgs.builder()
            .name("summary-strategy")
            .memoryId(example.id())
            .type("SUMMARIZATION")
            .description("Text summarization strategy")
            .namespaces("{sessionId}")
            .build());

    }
}

resources:
  summary:
    type: aws:bedrock:AgentcoreMemoryStrategy
    properties:
      name: summary-strategy
      memoryId: ${example.id}
      type: SUMMARIZATION
      description: Text summarization strategy
      namespaces:
        - '{sessionId}'

The SUMMARIZATION type condenses conversation history into summaries. The {sessionId} placeholder in namespaces creates per-session scoping, isolating summaries by user session.

Track user preferences across interactions

Agents that personalize responses need to remember user preferences and patterns.

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

const userPref = new aws.bedrock.AgentcoreMemoryStrategy("user_pref", {
    name: "user-preference-strategy",
    memoryId: example.id,
    type: "USER_PREFERENCE",
    description: "User preference tracking strategy",
    namespaces: ["preferences"],
});

import pulumi
import pulumi_aws as aws

user_pref = aws.bedrock.AgentcoreMemoryStrategy("user_pref",
    name="user-preference-strategy",
    memory_id=example["id"],
    type="USER_PREFERENCE",
    description="User preference tracking strategy",
    namespaces=["preferences"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreMemoryStrategy(ctx, "user_pref", &bedrock.AgentcoreMemoryStrategyArgs{
			Name:        pulumi.String("user-preference-strategy"),
			MemoryId:    pulumi.Any(example.Id),
			Type:        pulumi.String("USER_PREFERENCE"),
			Description: pulumi.String("User preference tracking strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("preferences"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var userPref = new Aws.Bedrock.AgentcoreMemoryStrategy("user_pref", new()
    {
        Name = "user-preference-strategy",
        MemoryId = example.Id,
        Type = "USER_PREFERENCE",
        Description = "User preference tracking strategy",
        Namespaces = new[]
        {
            "preferences",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var userPref = new AgentcoreMemoryStrategy("userPref", AgentcoreMemoryStrategyArgs.builder()
            .name("user-preference-strategy")
            .memoryId(example.id())
            .type("USER_PREFERENCE")
            .description("User preference tracking strategy")
            .namespaces("preferences")
            .build());

    }
}

resources:
  userPref:
    type: aws:bedrock:AgentcoreMemoryStrategy
    name: user_pref
    properties:
      name: user-preference-strategy
      memoryId: ${example.id}
      type: USER_PREFERENCE
      description: User preference tracking strategy
      namespaces:
        - preferences

The USER_PREFERENCE type stores and retrieves user preferences for personalization. Each memory can have only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE).

Customize semantic processing with specific models

Teams that need fine-grained control over semantic extraction can override the built-in behavior.

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

const customSemantic = new aws.bedrock.AgentcoreMemoryStrategy("custom_semantic", {
    name: "custom-semantic-strategy",
    memoryId: example.id,
    memoryExecutionRoleArn: example.memoryExecutionRoleArn,
    type: "CUSTOM",
    description: "Custom semantic processing strategy",
    namespaces: ["{sessionId}"],
    configuration: {
        type: "SEMANTIC_OVERRIDE",
        consolidation: {
            appendToPrompt: "Focus on extracting key semantic relationships and concepts",
            modelId: "anthropic.claude-3-sonnet-20240229-v1:0",
        },
        extraction: {
            appendToPrompt: "Extract and categorize semantic information",
            modelId: "anthropic.claude-3-haiku-20240307-v1:0",
        },
    },
});

import pulumi
import pulumi_aws as aws

custom_semantic = aws.bedrock.AgentcoreMemoryStrategy("custom_semantic",
    name="custom-semantic-strategy",
    memory_id=example["id"],
    memory_execution_role_arn=example["memoryExecutionRoleArn"],
    type="CUSTOM",
    description="Custom semantic processing strategy",
    namespaces=["{sessionId}"],
    configuration={
        "type": "SEMANTIC_OVERRIDE",
        "consolidation": {
            "append_to_prompt": "Focus on extracting key semantic relationships and concepts",
            "model_id": "anthropic.claude-3-sonnet-20240229-v1:0",
        },
        "extraction": {
            "append_to_prompt": "Extract and categorize semantic information",
            "model_id": "anthropic.claude-3-haiku-20240307-v1:0",
        },
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreMemoryStrategy(ctx, "custom_semantic", &bedrock.AgentcoreMemoryStrategyArgs{
			Name:                   pulumi.String("custom-semantic-strategy"),
			MemoryId:               pulumi.Any(example.Id),
			MemoryExecutionRoleArn: pulumi.Any(example.MemoryExecutionRoleArn),
			Type:                   pulumi.String("CUSTOM"),
			Description:            pulumi.String("Custom semantic processing strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("{sessionId}"),
			},
			Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
				Type: pulumi.String("SEMANTIC_OVERRIDE"),
				Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
					AppendToPrompt: pulumi.String("Focus on extracting key semantic relationships and concepts"),
					ModelId:        pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
				},
				Extraction: &bedrock.AgentcoreMemoryStrategyConfigurationExtractionArgs{
					AppendToPrompt: pulumi.String("Extract and categorize semantic information"),
					ModelId:        pulumi.String("anthropic.claude-3-haiku-20240307-v1:0"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var customSemantic = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_semantic", new()
    {
        Name = "custom-semantic-strategy",
        MemoryId = example.Id,
        MemoryExecutionRoleArn = example.MemoryExecutionRoleArn,
        Type = "CUSTOM",
        Description = "Custom semantic processing strategy",
        Namespaces = new[]
        {
            "{sessionId}",
        },
        Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
        {
            Type = "SEMANTIC_OVERRIDE",
            Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
            {
                AppendToPrompt = "Focus on extracting key semantic relationships and concepts",
                ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
            },
            Extraction = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs
            {
                AppendToPrompt = "Extract and categorize semantic information",
                ModelId = "anthropic.claude-3-haiku-20240307-v1:0",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationExtractionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var customSemantic = new AgentcoreMemoryStrategy("customSemantic", AgentcoreMemoryStrategyArgs.builder()
            .name("custom-semantic-strategy")
            .memoryId(example.id())
            .memoryExecutionRoleArn(example.memoryExecutionRoleArn())
            .type("CUSTOM")
            .description("Custom semantic processing strategy")
            .namespaces("{sessionId}")
            .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
                .type("SEMANTIC_OVERRIDE")
                .consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
                    .appendToPrompt("Focus on extracting key semantic relationships and concepts")
                    .modelId("anthropic.claude-3-sonnet-20240229-v1:0")
                    .build())
                .extraction(AgentcoreMemoryStrategyConfigurationExtractionArgs.builder()
                    .appendToPrompt("Extract and categorize semantic information")
                    .modelId("anthropic.claude-3-haiku-20240307-v1:0")
                    .build())
                .build())
            .build());

    }
}

resources:
  customSemantic:
    type: aws:bedrock:AgentcoreMemoryStrategy
    name: custom_semantic
    properties:
      name: custom-semantic-strategy
      memoryId: ${example.id}
      memoryExecutionRoleArn: ${example.memoryExecutionRoleArn}
      type: CUSTOM
      description: Custom semantic processing strategy
      namespaces:
        - '{sessionId}'
      configuration:
        type: SEMANTIC_OVERRIDE
        consolidation:
          appendToPrompt: Focus on extracting key semantic relationships and concepts
          modelId: anthropic.claude-3-sonnet-20240229-v1:0
        extraction:
          appendToPrompt: Extract and categorize semantic information
          modelId: anthropic.claude-3-haiku-20240307-v1:0

Custom strategies use type CUSTOM with a configuration block. The SEMANTIC_OVERRIDE configuration type specifies custom behavior for semantic processing. The consolidation and extraction blocks each define a modelId (which Bedrock model to use) and appendToPrompt (instructions appended to the model’s prompt). This extends the basic semantic strategy with custom prompts and model selection.

Customize summarization with specific models

Applications that need specialized summarization behavior can override the built-in strategy.

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

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

import pulumi
import pulumi_aws as aws

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

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreMemoryStrategy(ctx, "custom_summary", &bedrock.AgentcoreMemoryStrategyArgs{
			Name:        pulumi.String("custom-summary-strategy"),
			MemoryId:    pulumi.Any(example.Id),
			Type:        pulumi.String("CUSTOM"),
			Description: pulumi.String("Custom summarization strategy"),
			Namespaces: pulumi.StringArray{
				pulumi.String("summaries"),
			},
			Configuration: &bedrock.AgentcoreMemoryStrategyConfigurationArgs{
				Type: pulumi.String("SUMMARY_OVERRIDE"),
				Consolidation: &bedrock.AgentcoreMemoryStrategyConfigurationConsolidationArgs{
					AppendToPrompt: pulumi.String("Create concise summaries while preserving key details"),
					ModelId:        pulumi.String("anthropic.claude-3-sonnet-20240229-v1:0"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var customSummary = new Aws.Bedrock.AgentcoreMemoryStrategy("custom_summary", new()
    {
        Name = "custom-summary-strategy",
        MemoryId = example.Id,
        Type = "CUSTOM",
        Description = "Custom summarization strategy",
        Namespaces = new[]
        {
            "summaries",
        },
        Configuration = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationArgs
        {
            Type = "SUMMARY_OVERRIDE",
            Consolidation = new Aws.Bedrock.Inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs
            {
                AppendToPrompt = "Create concise summaries while preserving key details",
                ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategy;
import com.pulumi.aws.bedrock.AgentcoreMemoryStrategyArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreMemoryStrategyConfigurationConsolidationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var customSummary = new AgentcoreMemoryStrategy("customSummary", AgentcoreMemoryStrategyArgs.builder()
            .name("custom-summary-strategy")
            .memoryId(example.id())
            .type("CUSTOM")
            .description("Custom summarization strategy")
            .namespaces("summaries")
            .configuration(AgentcoreMemoryStrategyConfigurationArgs.builder()
                .type("SUMMARY_OVERRIDE")
                .consolidation(AgentcoreMemoryStrategyConfigurationConsolidationArgs.builder()
                    .appendToPrompt("Create concise summaries while preserving key details")
                    .modelId("anthropic.claude-3-sonnet-20240229-v1:0")
                    .build())
                .build())
            .build());

    }
}

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

The SUMMARY_OVERRIDE configuration type customizes summarization. Unlike semantic overrides, summary overrides typically only need consolidation (not extraction), as shown here. Multiple CUSTOM strategies are allowed per memory, subject to the total limit of 6 strategies.

Beyond these examples

These snippets focus on specific memory strategy features: built-in strategy types, custom strategy overrides with model selection, and namespace scoping and session isolation. They’re intentionally minimal rather than full agent memory configurations.

The examples reference pre-existing infrastructure such as Bedrock AgentCore memory (memoryId), IAM execution roles for custom strategies, and access to specified Bedrock foundation models. They focus on configuring the strategy rather than provisioning the surrounding memory infrastructure.

To keep things focused, common strategy patterns are omitted, including:

Multiple custom strategies per memory (up to 6 total)
User preference override configuration (extraction and consolidation)
Memory execution role ARN for custom strategies
Strategy limits and type restrictions per memory

These omissions are intentional: the goal is to illustrate how each strategy feature is wired, not provide drop-in agent memory modules. See the Bedrock AgentCore Memory Strategy resource reference for all available configuration options.

Let's configure AWS Bedrock Agent Memory Strategies

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Strategy Limits & Constraints

How many strategies can I create per memory?

Each memory can have a maximum of 6 strategies total, regardless of type.

Can I create multiple strategies of the same built-in type?

No, only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory. However, you can create multiple CUSTOM strategies (subject to the 6-strategy total limit).

What properties can't be changed after creation?

Both memoryId and type are immutable; changing either forces creation of a new resource.

Strategy Types & Configuration

What's the difference between built-in and CUSTOM strategy types?

Built-in types (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) work without a configuration block. CUSTOM type requires a configuration block with override settings and model specifications.

When do I need the configuration block?

The configuration block is required when type is CUSTOM and must be omitted for built-in types (SEMANTIC, SUMMARIZATION, USER_PREFERENCE).

What configuration override types are available for CUSTOM strategies?

CUSTOM strategies support three override types: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, and USER_PREFERENCE_OVERRIDE. Each can include consolidation and extraction settings with custom prompts and model IDs.

Why would I use CUSTOM type instead of a built-in type?

Use CUSTOM type when you need multiple similar strategies (since only one of each built-in type is allowed), or when you want to customize the processing with specific models and prompts via override configurations.

Namespaces & Organization

What are namespaces used for?

Namespaces help organize and scope memory content. They’re required identifiers that determine where the strategy applies within the memory.

Can I use dynamic values in namespaces?

Yes, namespaces support placeholders like {sessionId} for dynamic scoping based on runtime context.

Using a different cloud?

Explore analytics guides for other cloud providers:

Azure Guides GCP Guides