DEV Community: Vimal Venugopal

AWS Strands - AgentCore Shorterm Memory Integration

Vimal Venugopal — Sun, 28 Dec 2025 07:40:35 +0000

Prerequisites

Prior Knowledge of

Strands Agents
Python 3.1x
AWS Credentials with access to Bedrock and related components
Access to Anthropic Claude Haiku 4.5
AgentCore Short-term Memory with MemoryManager, AgentInitializedEvent and MessageAddedEvent hooks

We will use MemoryManager to store short term conversational history and retrieve n number of conversations
This is a simple AWS Strands agents that uses a web search tool to query and store the results.
Initialize agents with conversation history using session management
Can use this to help Migrate from MemoryClient to MemoryManager architecture

This example demonstrates Short Term Memory of AgentCore. Below is the high level architecture.

Project Structure

STEP1: Requirements.txt - Packages Needed

STEP2: Packages Installation

STEP3: Import all packages

STEP4: Memory Manager Initialization(Memory_Manager.py)

STEP5: Memory SessionManager Initialization(Memory_Manager.py)

STEP6.1: MemoryHookProvider Initialization - Part 1

STEP6.2: MemoryHookProvider Initialization - Part 2

STEP7: Agent Tools Definition (Agent_Tools.py)

STEP8: Agent Initialization (Personal_Agent.py)

AGENT Testing in Terminal

*Using Streamlit we can display the same history in Web App
*

Summary
This tutorial showed how to build a personal agent using both MemorySessionManager and MemorySession.

You've learned:

MemorySessionManager: High-level manager for memory operations across multiple sessions
MemorySession: Session-specific interface that eliminates repetitive parameter passing. Using MemorySession removes the need to pass actor_id/session_id to every method
Type Safety: Session is bound to specific actor/session at creation time
Better Encapsulation: Session-specific operations are contained within the session object
Memory Hooks: Agent hooks can work with the session-based architecture
Conversation Continuity: Maintaining short-term memory functionality with MemoryManager & MemorySession

Key Benefits of MemorySession:
Simplified API: No need to pass actor_id/session_id to every method call
Pre-configured Context: Session is bound to specific actor/session at creation
Consistent Interface: All session operations use the same pre-configured context

Amazon Bedrock AgentCore Memory: Building Stateful AI Agents

Vimal Venugopal — Sat, 27 Dec 2025 06:56:31 +0000

AgentCore Memory is a fully managed service that lets AI agents retain past interactions, so they can deliver smarter, more context-aware, and personalized experiences. It offers a clean, powerful way to manage both short-term context and long-term knowledge without you having to design or maintain complex infrastructure.

At its core, AgentCore Memory solves a key limitation in agentic AI: stateless behavior. Without memory, agents reset on every interaction and lose all prior context. AgentCore Memory fills this gap by enabling agents to remember, learn, and build a consistent understanding of users over time.

Why we need AgentCore Memory what problem does it solve

Architecture of AgentCore Memory - Key Components

# Creating a new memory resource 
response = agentcore_client.create_memory(
    name="CustomerSupportMemory",
    description="Memory store for our customer support agent",
    eventExpiryDuration=45,  # Store raw events for 45 days
    encryptionKeyArn="arn:aws:kms:us-east-1:123456789012:key/abcd1234-...",  # Optional customer-managed KMS key
)

# Storing a user message as an event
response = agentcore_client.create_event(
    memoryId="mem-908abcd",
    actorId="customer-345",
    sessionId="session-678",
    eventTimestamp=int(time.time() * 1000),
    payload=[
        {
            "conversational": {
                "content": {"text": "I'm looking for a Digital Camera under $500"},
                "role": "USER"
            }
        }
    ]
)

# Retrieving recent conversation history
events = agentcore_client.list_events(
    memoryId="mem-908abcd",
    actorId="customer-345",
    sessionId="session-678",
    maxResults=20,
)

3. Long-term memory
Long-term memory identifies and preserves important information from conversations across multiple sessions, such as user preferences, key facts, and summarized context, enabling durable knowledge retention over time. Long-term memory contains extracted insights, preferences, and knowledge derived from raw events. Unlike short-term memory, which stores verbatim data, long-term memory captures meaningful information that persists across sessions—such as user preferences, conversation summaries, and key insights.

Example: If a customer says they prefer window seats when booking a flight, the agent saves this preference and can automatically offer window seats in future bookings, delivering a more personalized experience.

The extraction process happens asynchronously after events are created, using the memory strategies defined within your memory resource. This managed asynchronous process extracts and consolidates long term memory records for efficient retrieval.

Let’s explore how to create the long-term memory resource for the customer support agent we saw before:

# Creating a new memory resource with long term
response = agentcore_client.create_memory(
    name="CustomerSupportMemory",
    description="Memory store for our support portal",
    eventExpiryDuration=45,  # Store raw events for 45 days
    encryptionKeyArn="arn:aws:kms:us-east-1:123456789012:key/abcderf1234-...",  # Optional customer-managed KMS key
    memoryStrategies=[{
        "userPreferenceMemoryStrategy": {
            "name": "Preferences",
            "namespaces": ["support-portal/{actorId}/preferences"]
        }
    }]
)

Conclusion
Amazon Bedrock AgentCore Memory provides a comprehensive solution to maintaining state, context and learning from interactions. By combining flexible short-term event storage with intelligent long-term memory extraction, you can create more personalized, contextual AI experiences without managing complex memory infrastructure.

Refer to the basic Implementation Guide

Final Overall Architecture
Now that we understand the key components, here’s what the overall AgentCore Memory architecture looks like:

References
https://aws.amazon.com/blogs/machine-learning/amazon-bedrock-agentcore-memory-building-context-aware-agents/

https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/memory.html

Guide to Integrate AWS Strands Agent with AgentCore Runtime using SDK Integration

Vimal Venugopal — Fri, 26 Dec 2025 07:38:09 +0000

Prerequisites
Python 3.10+
AWS account with appropriate permissions
Optional: A container engine (Docker, Finch, or Podman) - only required for local testing and advanced deployment scenarios

There are 2 deployment approaches with AgentCore

SDK Integration
For simple agents and minimal functions which can use quick deploy

with Automatic HTTP setup and built in deployment options.

Custom
For Complex agents, custom middleware, production systems with full
control over HTTP but more setup required, manual server
configuration

SDK Integration
**1. Install and import the package

pip install bedrock-agentcore

2. Create the Agent

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent

app = BedrockAgentCoreApp()
agent = Agent()

@app.entrypoint
def invoke(payload):
    """Process user input and return a response"""
    user_message = payload.get("prompt", "Hello")
    result = agent(user_message)
    return {"result": result.message}

if __name__ == "__main__":
    app.run()

3. Test the Agent

python my_agent.py

# Test with curl:
curl -X POST http://localhost:8080/invocations \
-H "Content-Type: application/json" \
-d '{"prompt": "Hello world!"}'

Choose Your Deployment Method
1. Using StarterToolkit
2. Using Boto3

Method 1: Starter Toolkit (For quick prototyping)

your_project_directory/
├── agent_example.py # Your main agent code
├── requirements.txt # Dependencies for your agent
└── init.py # Makes the directory a Python package

Requirements.txt
strands-agents
bedrock-agentcore

Note: The agentcore launch --local command requires a container engine (Docker, Finch, or Podman) for local deployment testing. This step is optional - you can skip directly to agentcore launch for AWS deployment if you don't need local testing.

Method 2: Manual Deployment with boto3

For more control over the deployment process:

Package your code as a container image and push it to ECR
Create your agent using CreateAgentRuntime:

AWS AI Agent Core Implementation

Vimal Venugopal — Fri, 26 Dec 2025 00:19:13 +0000

Amazon Bedrock AgentCore is an agentic platform for building, deploying, and operating highly effective agents securely at scale using any framework and foundation model.

With AgentCore, you can enable agents to take actions across tools and data with the right permissions and governance, run agents securely at scale, and monitor agent performance and quality in production - all without any infrastructure management.

AgentCore supports open frameowrk models such as

LangGraph
CrewAI
LlamaIndex and
Strands Agents

There are basically two major steps in deploying agents using AgentCore

Create Agent
Deploy Agent
AgentCore Invoke

Create Agent --> Choose a Framework and Model --> Integrations--> New Agent

Deploy Agent --> Basic Starter Deploy --> Prod Deploy --> Configure Runtime

AgentCore Invoke --> Invoke AgentCore using CLI - Agent Response.

Making Amazon Bedrock AgentCore agent Stateful by adding Memory

This is a simple agent to which you can add memory to make it stateful and completely change the narrative that AI Agents are always stateless. This Agent Core Memory is a stateless service which can be used as a short term or long term memory without much of an infrastructure or cost.

AgentCore Memory addresses a fundamental challenge in agentic AI: statelessness. Without memory capabilities, AI agents treat each interaction as a new instance with no knowledge of previous conversations. AgentCore Memory provides this critical capability, allowing your agent to build a coherent understanding of users over time.

Refer to the Hands on Guide on Implementing this in the next part of this article

References:
https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html
https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/agentcore-get-started-toolkit.html
https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-building.html