feat: make memory retrieval config conditional on strategies (#142)

- Short-term memory (no strategies) no longer includes retrieval config
- Long-term memory includes retrieval config based on configured strategies:
  - SEMANTIC → /users/{actor_id}/facts
  - USER_PREFERENCE → /users/{actor_id}/preferences
  - SUMMARIZATION → /summaries/{actor_id}/{session_id}
- Added memoryProviders to render config with strategy information
- Schema now allows empty strategies array for short-term memory

Author: tejaskash

src/assets/python/strands/capabilities/memory/session.py

@@ -1,7 +1,7 @@
 import os
 from typing import Optional
 
-from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
+from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig{{#if memoryProviders.[0].strategies.length}}, RetrievalConfig{{/if}}
 from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager
 
 MEMORY_ID = os.getenv("{{memoryProviders.[0].envVarName}}")
@@ -11,16 +11,28 @@ def get_memory_session_manager(session_id: str, actor_id: str) -> Optional[Agent
     if not MEMORY_ID:
         return None
 
+{{#if memoryProviders.[0].strategies.length}}
+    retrieval_config = {
+{{#if (includes memoryProviders.[0].strategies "SEMANTIC")}}
+        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
+{{/if}}
+{{#if (includes memoryProviders.[0].strategies "USER_PREFERENCE")}}
+        f"/users/{actor_id}/preferences": RetrievalConfig(top_k=3, relevance_score=0.5),
+{{/if}}
+{{#if (includes memoryProviders.[0].strategies "SUMMARIZATION")}}
+        f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5),
+{{/if}}
+    }
+{{/if}}
+
     return AgentCoreMemorySessionManager(
         AgentCoreMemoryConfig(
             memory_id=MEMORY_ID,
             session_id=session_id,
             actor_id=actor_id,
-            retrieval_config={
-                f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
-                f"/users/{actor_id}/preferences": RetrievalConfig(top_k=3, relevance_score=0.5),
-                f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5),
-            }
+{{#if memoryProviders.[0].strategies.length}}
+            retrieval_config=retrieval_config,
+{{/if}}
         ),
         REGION
     )

src/cli/operations/agent/generate/schema-mapper.ts

@@ -8,13 +8,11 @@ import type {
   MemoryStrategy,
   ModelProvider,
 } from '../../../../schema';
-
 import type {
   AgentRenderConfig,
   IdentityProviderRenderConfig,
   MemoryProviderRenderConfig,
 } from '../../../templates/types';
-
 import {
   DEFAULT_MEMORY_EXPIRY_DAYS,
   DEFAULT_NETWORK_MODE,
@@ -47,8 +45,8 @@ function computeCredentialName(projectName: string, providerName: string): strin
  * Maps GenerateConfig memory option to v2 Memory resources.
  *
  * Memory mapping:
- * - "none" -> empty array
- * - "shortTerm" -> [Memory with Summarization strategy]
+ * - "none" -> empty array (no memory)
+ * - "shortTerm" -> [Memory with no strategies] (just base memory with expiration)
  * - "longAndShortTerm" -> [Memory with Semantic + Summarization + UserPreference strategies]
  */
 export function mapGenerateInputToMemories(memory: MemoryOption, projectName: string): Memory[] {
@@ -58,13 +56,14 @@ export function mapGenerateInputToMemories(memory: MemoryOption, projectName: st
 
   const strategies: MemoryStrategy[] = [];
 
+  // Short term memory has no strategies - just base memory with expiration time
+  // Long term memory includes strategies for semantic search, summarization, and user preferences
   if (memory === 'longAndShortTerm') {
     strategies.push({ type: 'SEMANTIC' });
     strategies.push({ type: 'USER_PREFERENCE' });
+    strategies.push({ type: 'SUMMARIZATION' });
   }
 
-  strategies.push({ type: 'SUMMARIZATION' });
-
   return [
     {
       type: 'AgentCoreMemory',
@@ -147,6 +146,34 @@ function mapMemoryOptionToMemoryProviders(
   ];
 }
 
+/**
+ * Compute the memory env var name for a memory resource.
+ * Pattern: MEMORY_{NAME}_ID (matches CDK construct pattern)
+ */
+function computeMemoryEnvVarName(memoryName: string): string {
+  return `MEMORY_${memoryName.toUpperCase()}_ID`;
+}
+
+/**
+ * Maps memory option to memory providers for template rendering.
+ */
+function mapMemoryOptionToMemoryProviders(memory: MemoryOption, projectName: string): MemoryProviderRenderConfig[] {
+  if (memory === 'none') {
+    return [];
+  }
+
+  const memoryName = `${projectName}Memory`;
+  const strategies = mapGenerateInputToMemories(memory, projectName)[0]?.strategies ?? [];
+
+  return [
+    {
+      name: memoryName,
+      envVarName: computeMemoryEnvVarName(memoryName),
+      strategies: strategies.map(s => s.type),
+    },
+  ];
+}
+
 /**
  * Maps GenerateConfig to AgentRenderConfig for template rendering.
  * @param config - Generate config (note: config.projectName is actually the agent name)
@@ -164,5 +191,6 @@ export function mapGenerateConfigToRenderConfig(config: GenerateConfig, actualPr
     hasIdentity: config.modelProvider !== 'Bedrock',
     memoryProviders: mapMemoryOptionToMemoryProviders(config.memory, config.projectName),
     identityProviders: mapModelProviderToIdentityProviders(config.modelProvider, projectNameForCredentials),
+    memoryProviders: mapMemoryOptionToMemoryProviders(config.memory, config.projectName),
   };
 }

src/cli/templates/render.ts

@@ -4,6 +4,10 @@ import * as path from 'node:path';
 
 // Register custom Handlebars helpers
 Handlebars.registerHelper('eq', (a: unknown, b: unknown) => a === b);
+Handlebars.registerHelper('includes', (array: unknown[], value: unknown) => {
+  if (!Array.isArray(array)) return false;
+  return array.includes(value);
+});
 
 /**
  * Renames template files to their actual names.

src/cli/templates/types.ts

@@ -1,4 +1,4 @@
-import type { ModelProvider, SDKFramework, TargetLanguage } from '../../schema';
+import type { MemoryStrategyType, ModelProvider, SDKFramework, TargetLanguage } from '../../schema';
 
 /**
  * Memory provider config for template rendering.
@@ -15,6 +15,16 @@ export interface IdentityProviderRenderConfig {
   envVarName: string;
 }
 
+/**
+ * Memory provider info for template rendering.
+ */
+export interface MemoryProviderRenderConfig {
+  name: string;
+  envVarName: string;
+  /** Strategy types configured for this memory */
+  strategies: MemoryStrategyType[];
+}
+
 /**
  * Configuration needed by template renderers.
  * This is separate from the v2 Agent schema which only stores runtime config.
@@ -29,4 +39,6 @@ export interface AgentRenderConfig {
   memoryProviders: MemoryProviderRenderConfig[];
   /** Identity providers for template rendering (maps to credentials in schema) */
   identityProviders: IdentityProviderRenderConfig[];
+  /** Memory providers for template rendering */
+  memoryProviders: MemoryProviderRenderConfig[];
 }

src/schema/schemas/agentcore-project.ts

@@ -52,9 +52,11 @@ export const MemorySchema = z.object({
   type: MemoryTypeSchema,
   name: MemoryNameSchema,
   eventExpiryDuration: z.number().int().min(7).max(365),
+  // Strategies array can be empty for short-term memory (just base memory with expiration)
+  // Long-term memory includes strategies like SEMANTIC, SUMMARIZATION, USER_PREFERENCE
   strategies: z
     .array(MemoryStrategySchema)
-    .min(1, 'At least one memory strategy is required')
+    .default([])
     .superRefine(
       uniqueBy(
         strategy => strategy.type,