Configure AWS Bedrock Agent Memory Strategies

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

Strategies attach to existing Bedrock agent 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 configuration and model access policies.

Enable semantic understanding with a built-in strategy

Agents that need to understand relationships between concepts start with semantic strategies, which extract meaning and connections from conversation history.

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 set to SEMANTIC enables semantic understanding. The namespaces property defines where this strategy applies; here, it processes content in the “default” namespace. Built-in strategies require no additional configuration.

Summarize conversations with a built-in strategy

Long conversations benefit from summarization strategies that condense interaction history while preserving key information.

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 type property set to SUMMARIZATION enables conversation summarization. The namespaces property uses {sessionId} as a placeholder, creating per-session summaries that isolate each user’s conversation history.

Track user preferences with a built-in strategy

Personalized agents track user preferences across sessions to adapt responses and recommendations.

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 type property set to USER_PREFERENCE enables preference tracking. The namespaces property scopes preferences to the “preferences” namespace, separating them from other memory content.

Customize semantic processing with specific models

Teams that need fine-grained control over semantic extraction can override the built-in behavior with custom model selections and prompts.

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 configuration.type property set to SEMANTIC_OVERRIDE customizes semantic processing. The consolidation and extraction blocks each specify a modelId (the Bedrock model to use) and appendToPrompt (instructions added to the model’s prompt). This lets you choose faster models for extraction and more capable models for consolidation.

Customize summarization with specific models

Custom summarization strategies let you control how conversations are condensed, choosing models and prompts that match your application’s needs.

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 configuration.type property set to SUMMARY_OVERRIDE customizes summarization. Unlike semantic overrides, summarization only requires a consolidation block; there’s no separate extraction phase. The appendToPrompt property guides how the model creates summaries.

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 agent memory (memoryId), IAM execution roles for custom strategies, and access to specified Bedrock foundation models. They focus on strategy configuration rather than provisioning the surrounding memory infrastructure.

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

Strategy limits (6 total, 1 per built-in type)
Multiple custom strategies per memory
Namespace organization patterns
Model selection criteria and performance tradeoffs

These omissions are intentional: the goal is to illustrate how each strategy type 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 & Types

What are the strategy limits per memory?

Each memory can have a maximum of 6 strategies total. Only one strategy of each built-in type (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) can exist per memory, but multiple CUSTOM strategies are allowed (subject to the 6-strategy limit).

How do I create multiple semantic strategies for the same memory?

Use the CUSTOM type with SEMANTIC_OVERRIDE configuration. Since only one built-in SEMANTIC strategy is allowed per memory, custom strategies with semantic overrides let you create additional semantic processing logic.

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

Built-in types (SEMANTIC, SUMMARIZATION, USER_PREFERENCE) don’t require configuration and are limited to one per memory. CUSTOM type requires a configuration block with override types and allows multiple instances per memory.

Configuration & Customization

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 override types are available for custom strategies?

Custom strategies support three override types: SEMANTIC_OVERRIDE, SUMMARY_OVERRIDE, and USER_PREFERENCE_OVERRIDE. Each corresponds to a built-in strategy type but allows custom model configuration.

What's the difference between consolidation and extraction blocks?

Both blocks configure appendToPrompt and modelId. SEMANTIC_OVERRIDE and USER_PREFERENCE_OVERRIDE use both consolidation and extraction, while SUMMARY_OVERRIDE uses only consolidation.

What models are shown in the examples?

Examples use anthropic.claude-3-sonnet-20240229-v1:0 for consolidation and anthropic.claude-3-haiku-20240307-v1:0 for extraction.

Namespaces & Scoping

What are namespaces used for?

Namespaces organize and scope memory content. They’re required identifiers that help partition strategy application within a memory.

Can I use dynamic namespace patterns?

Yes, namespaces support dynamic patterns like {sessionId} for session-scoped organization, in addition to static strings like default or preferences.

Resource Management

What properties are immutable after creation?

Both memoryId and type are immutable. Changing either property forces creation of a new resource.

Using a different cloud?

Explore analytics guides for other cloud providers:

Azure Guides GCP Guides