AI Agent with Short-Term Memory on AWS

In the realm of Artificial Intelligence, creating agents that can effectively interact with their environment and solve complex tasks often requires equipping them with a form of short-term memory, also known as “scratchpad” or working memory. This allows the agent to temporarily store and process information relevant to its current goals, enabling contextual awareness, multi-step reasoning, and efficient tool utilization. Amazon Web Services (AWS) provides a rich ecosystem of services that can be leveraged to implement such short-term memory for AI agents.

Why Short-Term Memory is Crucial for AI Agents:

• Contextual Understanding: Agents can maintain context across interactions or during complex tasks, leading to more coherent and relevant behavior.
• Task Decomposition: Complex goals can be broken down into smaller, manageable steps, with the agent using short-term memory to track progress and intermediate results.
• Tool Orchestration: Agents often need to use various tools and APIs. Short-term memory helps manage the inputs, outputs, and the flow of information between these tools.
• Dynamic Planning: Agents can adapt their plans based on new information or unexpected events encountered during execution.
• Improved Reasoning: By temporarily storing intermediate thoughts and hypotheses, agents can perform more sophisticated reasoning.

AWS Services for Implementing Short-Term Memory (with Code Examples):

AWS offers a spectrum of services that can be used, individually or in combination, to build short-term memory for AI agents, depending on the specific requirements of the application:

1. In-Memory Storage within Compute Services:

• Amazon EC2: The instance’s RAM provides direct and fast short-term memory.
• AWS Lambda: Variables within the function’s scope offer ephemeral short-term memory per invocation. The /tmp directory provides limited temporary file storage.
• Amazon ECS/EKS: Container memory can be used for in-memory scratchpads.

Use Case: Simple, localized state management within a single session or task execution.

import time

class InMemoryAgent:
    def __init__(self):
        self.scratchpad = {}

    def process_data(self, user_id, data_point):
        if user_id not in self.scratchpad:
            self.scratchpad[user_id] = []
        self.scratchpad[user_id].append(data_point)
        print(f"User {user_id}'s data: {self.scratchpad[user_id]}")

# Example usage (within an EC2 instance or Lambda execution)
in_memory_agent = InMemoryAgent()
in_memory_agent.process_data("user123", {"timestamp": time.time(), "value": 42})
in_memory_agent.process_data("user123", {"timestamp": time.time() + 5, "value": 99})
    

2. Managed In-Memory Data Stores:

• Amazon ElastiCache (Redis and Memcached): High-performance, managed in-memory data stores. Redis offers advanced data structures for session management and caching.
• Amazon MemoryDB for Redis: Durable, in-memory database compatible with Redis for speed and data durability.

Use Case: Maintaining session state, caching, managing temporary task queues.

import boto3
import json
import time
import redis as py_redis

# Configuration (replace with your actual AWS configuration)
AWS_REGION = "us-east-1"  # Example region
REDIS_ENDPOINT = "your-redis-cluster.cache.amazonaws.com:6379"  # Replace with your actual endpoint

try:
    r = py_redis.Redis(host=REDIS_ENDPOINT.split(":")[0], port=int(REDIS_ENDPOINT.split(":")[1]), db=0)

    r.set('session:user456', json.dumps({'last_activity': time.time(), 'preferences': ['news', 'sports']}))
    user_session_data = json.loads(r.get('session:user456'))
    print(f"User 456 Session Data from Redis: {user_session_data}")

    r.delete('session:user456')

except Exception as e:
    print(f"Error interacting with ElastiCache (Redis): {e}")
    

Remember to replace `”your-redis-cluster.cache.amazonaws.com:6379″` with your actual Redis cluster endpoint.

3. Amazon DynamoDB with Time-to-Live (TTL):

• Amazon DynamoDB with TTL: Scalable NoSQL database with automatic expiration of temporary data.

Use Case: Storing temporary session data, tracking short-lived process states, managing temporary tokens.

import boto3
import time

# Configuration (replace with your actual AWS configuration)
AWS_REGION = "us-east-1"  # Example region

try:
    dynamodb = boto3.resource('dynamodb', region_name=AWS_REGION)
    temp_data_table = dynamodb.Table('your-temp-data-table-name')  # Replace with your table name

    item = {
        'sessionId': 'session789',
        'interactionData': {'query': 'weather in Bentonville', 'timestamp': time.time()},
        'ttl': int(time.time() + 3600)  # Expire in 1 hour
    }
    temp_data_table.put_item(Item=item)
    print(f"Temporary data stored in DynamoDB with TTL for session 789")

    response = temp_data_table.get_item(Key={'sessionId': 'session789'})
    if 'Item' in response:
        print(f"Retrieved temporary data: {response['Item']}")
    else:
        print("Temporary data might have expired or not found.")

    # Note: DynamoDB TTL deletion happens in the background and might not be immediate.

except Exception as e:
    print(f"Error interacting with DynamoDB: {e}")
    

Remember to replace `”your-temp-data-table-name”` with the actual name of your DynamoDB table. Ensure the table has a suitable partition key and the ‘ttl’ attribute configured.

4. AWS Lambda with Local Storage (Ephemeral):

• AWS Lambda: Temporary local storage within a single invocation.

Use Case: Very short-term storage within a single Lambda execution.

import json
import os

def lambda_handler(event, context):
    temp_context = {}
    user_id = event.get('user_id')
    data = event.get('data')
    temp_file_path = os.path.join("/tmp", f"user_{user_id}_temp.json") # Example using /tmp

    if user_id and data:
        if user_id not in temp_context:
            temp_context[user_id] = []
        temp_context[user_id].append(data)
        print(f"Lambda processing for {user_id}: {temp_context[user_id]}")

        # Example of using /tmp for very short-term storage within this invocation
        with open(temp_file_path, 'w') as f:
            json.dump(temp_context[user_id], f)
        print(f"Data written to {temp_file_path}")

        return {
            'statusCode': 200,
            'body': json.dumps(f'Processed data for {user_id}')
        }
    return {
        'statusCode': 400,
        'body': json.dumps('Invalid input')
    }

# Example invocation (simulated)
lambda_event = {'user_id': 'userABC', 'data': {'step': 1, 'value': 'initial'}}
lambda_handler(lambda_event, None)
lambda_event = {'user_id': 'userABC', 'data': {'step': 2, 'value': 'intermediate'}}
lambda_handler(lambda_event, None)
    

Considerations: Storage is ephemeral and limited to the lifecycle of a single Lambda invocation. The /tmp directory has limited space.

5. Conceptual LangChain with LLM on Bedrock:

• Amazon Bedrock: Managing context within prompts for foundation models.
• LangChain on AWS: Simplifying memory management for LLM agents.

Use Case: Conversational AI, question answering, reasoning with LLMs.

# Note: This requires the LangChain library and appropriate Bedrock setup
# pip install langchain boto3

"""
from langchain.llms import Bedrock
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
import boto3

# Configuration (replace with your actual AWS configuration)
AWS_REGION = "us-east-1"  # Example region

try:
    bedrock_runtime = boto3.client(
        service_name="bedrock-runtime",
        region_name=AWS_REGION
    )
    llm = Bedrock(client=bedrock_runtime, model_id="anthropic.claude-v2") # Example model

    memory = ConversationBufferMemory(memory_key="history")
    conversation = ConversationChain(llm=llm, memory=memory)

    print(conversation.predict(input="Hello, how are you?"))
    print(conversation.predict(input="What is the weather like in Bentonville?"))
    print(conversation.memory.load_memory_variables({})) # Shows the conversation history in memory

except Exception as e:
    print(f"Error with LangChain and Bedrock: {e}")
"""
# To run this, uncomment the code and ensure you have LangChain installed and Bedrock configured.
    

Key Aspects: Effective prompt design and LangChain’s memory abstractions help manage the LLM’s context as short-term memory.

6. Workflow and State Management Services:

• AWS Step Functions: Serverless orchestration with state management for complex workflows.

Use Case: Automating multi-step processes where the agent needs to track state and processed data.

# Example of a simple AWS Step Functions state machine (in JSON format)
# This defines a workflow and implicitly manages state

"""
{
  "Comment": "A simple workflow with temporary state",
  "StartAt": "StepA",
  "States": {
    "StepA": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ProcessInput",
      "Next": "StepB"
    },
    "StepB": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:AnalyzeData",
      "End": true
    }
  }
}
"""
# The input and output of each Step in Step Functions act as temporary state.
    

Key Aspects: Step Functions manages the state of the workflow execution, acting as a form of short-term memory for the process.

Live Use Cases Summary:

• Contextual Pharmaceutical Inquiry Agent: A customer support chatbot for a pharmacy (like one potentially serving the Bentonville area) uses Amazon Lex for natural language understanding and ElastiCache (Redis) to store the conversation history for the current session. If a customer asks about a medication interaction and then, in the next turn, asks about dosage, the agent remembers the previously discussed medication and provides a more relevant answer without needing the customer to repeat the drug name.
• Personalized Local E-commerce Recommendations: An online marketplace popular in Bentonville utilizes in-memory storage on EC2 instances powering their recommendation engine. When a user browses “outdoor gear” and then clicks on a specific “hiking boot,” the system temporarily stores this interest. If the user then navigates to “related items,” the recommendations are tailored to hiking, potentially showing compatible socks or trekking poles, based on the short-term browsing context.
• Smart Home Automation Routine Manager: A smart home application built on AWS IoT Core and utilizing Lambda functions uses DynamoDB with a short TTL (e.g., 30 minutes) to manage the state of complex automation routines. For example, if a user triggers a “leaving home” routine, the system temporarily stores the actions completed (lights off, thermostat adjusted, doors locked). If the user cancels the routine within that timeframe, the stored state allows the system to revert the actions.
• Real-time Anomaly Detection in a Local Manufacturing Plant: An AI agent monitoring sensor data from machinery in a Bentonville manufacturing facility uses Amazon Kinesis Data Streams to ingest real-time data and ElastiCache to maintain a rolling window of recent sensor readings (e.g., last 5 minutes). By comparing the current data point to this short-term history, the agent can quickly identify unusual spikes or dips in temperature or pressure that might indicate a malfunction.

Choosing the Right Approach:

The optimal choice depends on latency, persistence, scalability, data structure complexity, cost, and integration needs. Combining services may be necessary for advanced agents.

As of April 30, 2025, developers in Bentonville, Arkansas, and globally can utilize this comprehensive suite of AWS services to build AI agents with effective short-term memory capabilities, tailored to their specific application requirements.