Update documentation

Author: Mike Wrighton

documentation/docs/examples/semantic_search.md

@@ -3,33 +3,31 @@
 This example demonstrates the complete workflow for creating a memory resource with semantic strategy, writing events, and retrieving memory records.
 
 ```python
+# Semantic Search Memory Example
+
+from bedrock_agentcore_starter_toolkit.operations.memory.manager import MemoryManager
+from bedrock_agentcore.memory.session import MemorySessionManager
+from bedrock_agentcore.memory.constants import StrategyType, ConversationalMessage, MessageRole
+from bedrock_agentcore_starter_toolkit.operations.memory.models.strategies import SemanticStrategy
 import time
-from bedrock_agentcore.memory import MemoryManager
-from bedrock_agentcore.models.strategies.semantic import SemanticStrategy
-from bedrock_agentcore.session import MemorySessionManager
-from bedrock_agentcore.constants import ConversationalMessage, MessageRole
 
 memory_manager = MemoryManager(region_name="us-west-2")
 
 print("Creating memory resource...")
 
 memory = memory_manager.get_or_create_memory(
-    name="CustomerSupportSemantic5",
+    name="CustomerSupportSemantic",
     description="Customer support memory store",
     strategies=[
         SemanticStrategy(
             name="semanticLongTermMemory",
+            namespaces=['/strategies/{memoryStrategyId}/actors/{actorId}'],
         )
     ]
 )
 
 print(f"Memory ID: {memory.get('id')}")
 
-# View all memories
-memories = memory_manager.list_memories()
-for memory in memories:
-    print(f"Memory: {memory}")
-
 # Create a session to store memory events
 session_manager = MemorySessionManager(
     memory_id=memory.get("id"),
@@ -73,8 +71,8 @@ for event in events:
     print(f"Event: {event}")
     print("--------------------------------------------------------------------")
 
-print("Waiting 30 seconds for semantic processing...")
-time.sleep(30)
+print("Waiting 2 minutes for semantic processing...")
+time.sleep(120)
 
 # List all memory records
 memory_records = session_manager.list_memory_records(
@@ -97,4 +95,5 @@ memory_records = session_manager.retrieve_memory_records(
 for record in memory_records.get("memoryRecordSummaries", []):
     print(f"retrieved memory: {record}")
     print("--------------------------------------------------------------------")
+
 ```

documentation/docs/user-guide/memory/quickstart.md

@@ -7,7 +7,6 @@ The steps are as follows
 1. Create a memory resource containing a semantic strategy
 2. Write events (conversation history) to the memory resource.
 3. Retrieve memory records from long term memory
-4. Integrate with an agent
 
 ## Prerequisites
 
@@ -25,6 +24,7 @@ cd agentcore-memory-quickstart
 python -m venv .venv
 source .venv/bin/activate
 pip install bedrock-agentcore
+pip install bedrock-agentcore-starter-toolkit
 ```
 
 
@@ -38,10 +38,11 @@ A memory resource is needed to start storing information for your agent. By defa
 We are going to create a memory resource with a semantic strategy so that both short term and long term memory can be utilized. This will take 1-2 minutes. Memory resources can also be created in the AWS console.
 
 ```python
-from bedrock_agentcore.memory import MemoryManager
-from bedrock_agentcore.session import MemorySessionManager
-from bedrock_agentcore.constants import StrategyType
-from bedrock_agentcore.models.strategies.semantic import SemanticStrategy
+from bedrock_agentcore_starter_toolkit.operations.memory.manager import MemoryManager
+from bedrock_agentcore.memory.session import MemorySessionManager
+from bedrock_agentcore.memory.constants import StrategyType
+from bedrock_agentcore_starter_toolkit.operations.memory.models.strategies import (
+    SemanticStrategy)
 
 memory_manager = MemoryManager(region_name="us-west-2")
 
@@ -58,6 +59,7 @@ memory = memory_manager.get_or_create_memory(
 )
 
 print(f"Memory ID: {memory.get('id')}")
+
 ```
 
 
@@ -157,135 +159,6 @@ Important information about the user is likely stored is long term memory. Agent
 
 The full example source file showing steps 1 - 3 is available [here](../../examples/semantic_search.md).
 
-## Step Four: Putting it all together
-
-Now that the concepts are clear, let’s incorporate this in an agent. The following example shows a conversational AI agent built using the Strands SDK that automatically extracts and remembers user preferences from conversations. 
-
-Install dependencies for the strands SDK.
-
-```bash
-pip install strands
-pip install flask
-```
-
-Create a new file called `preference_saver.py` and add the following code.
-
-```python
-from bedrock_agentcore.memory import MemoryManager
-from bedrock_agentcore.session import MemorySessionManager
-from bedrock_agentcore.constants import StrategyType, ConversationalMessage, MessageRole
-from strands import Agent
-from flask import Flask, request, jsonify
-import uuid
-
-# Initialize memory storage for the agent
-# This creates a persistent memory that can store user preferences and conversation history
-memory_manager = MemoryManager(region_name="us-west-2")
-memory = memory_manager.create_memory_and_wait(
-    name=f"PreferenceSaverMemory",
-    strategies=[
-        {
-            # User preference strategy stores personalized information about each user
-            StrategyType.USER_PREFERENCE.value: {
-                "name": "UserPreference",
-                "namespaces": ["/users/{actorId}"],  # Separate memory space per user
-            }
-        }
-    ],
-)
-memory_id = memory["id"]
-print(f"✅ Memory created: {memory_id}")
-
-# Session manager handles conversation turns and memory retrieval
-session_manager = MemorySessionManager(memory_id=memory_id, region_name="us-west-2")
-
-# Initialize the conversational AI agent
-agent = Agent()
-
-# Create Flask web server to handle HTTP requests
-app = Flask(__name__)
-
-@app.route('/invoke', methods=['POST'])
-def invoke():
-    """
-    Main endpoint for processing user messages.
-    Retrieves relevant memories, generates a response, and saves the conversation.
-    """
-    payload = request.get_json()
-    message = payload.get("message", "Hello!")
-    user_id = payload.get("user_id", "user1")
-    session_id = f"session_{user_id}"
-
-    # Retrieve relevant memories for context
-    # This searches the user's memory for information related to their current message
-    try:
-        memories = session_manager.retrieve_memory_records(
-            memoryId=memory_id,
-            namespace=f"/users/{user_id}",
-            searchCriteria={"searchQuery": message, "topK": 3}
-        )
-        # Extract content from memory records to provide context
-        context = "\n".join([m.get("content", "") for m in memories.get("memoryRecordSummaries", [])])
-        if context:
-            # Prepend relevant memories to the current message for better responses
-            message = f"Previous: {context}\n\n{message}"
-    except:
-        # Continue without memory context if retrieval fails
-        pass
-
-    # Generate response using the AI agent
-    response = agent(message)
-
-    # Save the conversation turn to memory for future reference
-    # This stores both the user's message and the agent's response
-    try:
-        session_manager.add_turns(
-            actor_id=user_id,
-            session_id=session_id,
-            messages=[
-                ConversationalMessage(payload.get('message'), MessageRole.USER),
-                ConversationalMessage(response.message, MessageRole.ASSISTANT)
-            ]
-        )
-    except:
-        # Continue even if memory saving fails
-        pass
-
-    return jsonify({"response": response.message})
-
-if __name__ == "__main__":
-    print("🚀 Starting memory-enhanced conversational agent server on port 8080...")
-    print("Send POST requests to http://localhost:8080/invoke with JSON: {'message': 'your message', 'user_id': 'user123'}")
-    app.run(host='0.0.0.0', port=8080, debug=True)
-```
-
-Execute the agent code with:
-
-```bash
-python `preference_saver.py`
-```
-
-and wait for the “Memory created” message. In another terminal, invoke the agent using the following commands:
-
-#### Invocation 1:
-```bash
-curl -X POST http://localhost:8080/invoke -H "Content-Type: application/json" -d '{"message": "My name is Alice and I like pepperoni on pizza", "user_id": "alice"}'
-```
-
-The preference is extracted asynchronously and can take up to a minute to be extracted. Please give it a minute before the next invocation.
-
-#### Invocation 2:
-
-```bash
-curl -X POST http://localhost:8080/invoke -H "Content-Type: application/json" -d '{"message": "What topping do I like on pizza?", "user_id": "alice"}'
-```
-
-
-The agent stores each conversation turn as a memory event, allowing the UserPreferenceMemoryStrategy to automatically extract and consolidate personal preferences over time. Before responding to new messages, it queries the
-memory store to retrieve relevant context, then saves the new user-bot exchange as another memory event.
-
-The end result is a context-aware agent!
-
 ## What’s Next?
 
 Consider the following as you continue your AgentCore journey