Requisitos previos Paso 1: Crear una memoria AgentCore Paso 2: Escribe los eventos en la memoria Paso 3: Recuperar registros de la memoria a largo plazo Añadir memoria a un agente existente Limpieza Siguientes pasos

Comience con AgentCore Memory

Amazon Bedrock Amazon Bedrock AgentCore Memory le permite crear y administrar recursos de AgentCore memoria que almacenan el contexto de las conversaciones para sus agentes de IA. Esta introducción le guiará sobre la instalación de dependencias y la implementación de funciones de memoria tanto a corto como a largo plazo. Las instrucciones utilizan la AgentCore CLI.

Los pasos son los siguientes:

Cree una AgentCore memoria que contenga una estrategia semántica
Escribe eventos (historial de conversaciones) en el recurso de memoria
Recupera los registros de memoria de la memoria a largo plazo

Para ver otros ejemplos, consulte los ejemplos de Amazon Bedrock AgentCore Memory.

Requisitos previos

Antes de empezar, asegúrese de tener:

AWS Cuenta con credenciales configuradas (aws configure)
Python 3.10+ instalado
Node.js Más de 18 instalados (para la AgentCore CLI)

Para empezar a utilizar Amazon Bedrock Amazon Bedrock AgentCore Memory, instale las dependencias, cree un proyecto de AgentCore CLI y configure un entorno virtual. Los siguientes comandos se pueden ejecutar directamente en el terminal.


pip install bedrock-agentcore
npm install -g @aws/agentcore
agentcore create --name agentcore-memory-quickstart --no-agent
cd agentcore-memory-quickstart
python -m venv .venv
source .venv/bin/activate

La AgentCore CLI proporciona comandos para crear y administrar los recursos de memoria. Se utiliza agentcore add memory para crear una memoria y agentcore deploy aprovisionarla AWS. Para las operaciones de eventos y la administración de sesiones, utilice el SDK de AWS Python (Boto3) (bedrock-agentcore).

nota

La AgentCore CLI le ayuda a crear e implementar recursos de memoria. Para ver el conjunto completo de operaciones de Amazon Bedrock AgentCore Memory, consulte la documentación de Boto3: bedrock-agentcore-control y bedrock-agentcore.

Ejemplo completo: consulte los AgentCore ejemplos de Amazon Bedrock que muestran los pasos 1 a 3.

Paso 1: Crear una memoria AgentCore

Necesita una AgentCore memoria para empezar a almacenar información para su agente. De forma predeterminada, los eventos de la memoria (a los que nos referimos como memoria a corto plazo) se pueden escribir en una AgentCore memoria. Para extraer la información y guardarla en registros de memoria a largo plazo, el recurso requiere una estrategia de memoria, que es una configuración que defina cómo deben procesarse los datos conversacionales y qué información extraer (como datos, preferencias o resúmenes).

En este paso, se crea una AgentCore memoria con una estrategia semántica para poder utilizar tanto la memoria a corto como a largo plazo. Esto tardará entre 2 y 3 minutos. También puede crear recursos AgentCore de memoria en la AWS consola.

Crea memoria con una estrategia semántica:

ejemplo

Tras el despliegue, compruebe que se ha creado la memoria:


agentcore status

Paso 2: Escribe los eventos en la memoria

Puedes escribir eventos en una AgentCore memoria como memoria a corto plazo y extraer información para la memoria a largo plazo.

Escribir eventos en la memoria tiene múltiples propósitos. En primer lugar, el contenido de los eventos (por lo general, el historial de conversaciones) se almacena como memoria a corto plazo. En segundo lugar, la información relevante se extrae de los eventos y se escribe en los registros de la memoria como parte de la memoria a largo plazo.

El identificador del recurso de memoria, el identificador del actor y el identificador de la sesión son necesarios para crear un evento. En este paso, se crean tres eventos, simulando mensajes entre un usuario final y un bot de chat.


import boto3
from bedrock_agentcore.memory import MemorySessionManager
from bedrock_agentcore.memory.constants import ConversationalMessage, MessageRole

control_client = boto3.client('bedrock-agentcore-control', region_name='us-west-2')

# Retrieve the memory created in Step 1
response = control_client.list_memories()
memory = response['memories'][0]
memory_id = memory['id']

# Create a session to store memory events
session_manager = MemorySessionManager(
    memory_id=memory_id,
    region_name="us-west-2")

session = session_manager.create_memory_session(
    actor_id="User1",
    session_id="OrderSupportSession1"
)

# Write memory events (conversation turns)
session.add_turns(
    messages=[
        ConversationalMessage(
            "Hi, how can I help you today?",
            MessageRole.ASSISTANT)],
)

session.add_turns(
    messages=[
        ConversationalMessage(
            "Hi, I am a new customer. I just made an order, but it hasn't arrived. The Order number is #35476",
            MessageRole.USER)],
)

session.add_turns(
    messages=[
        ConversationalMessage(
            "I'm sorry to hear that. Let me look up your order.",
            MessageRole.ASSISTANT)],
)

Puedes obtener los eventos (turnos) de un actor específico una vez que se hayan escrito.


# Get the last k turns in the session
turns = session.get_last_k_turns(k=5)

for turn in turns:
    print(f"Turn: {turn}")

En este caso, puedes ver los tres últimos eventos del actor y de la sesión.

Paso 3: Recuperar registros de la memoria a largo plazo

Una vez que los eventos se escribieron en el recurso de memoria, se analizaron y se envió información útil a la memoria a largo plazo. Como la memoria contiene una estrategia de memoria semántica a largo plazo, el sistema extrae y almacena información fáctica.

Puede enumerar todos los registros de memoria con:


# List all memory records
memory_records = session.list_long_term_memory_records(
    namespace_path="/"
)

for record in memory_records:
    print(f"Memory record: {record}")
    print("--------------------------------------------------------------------")

O solicita la información más relevante como parte de una búsqueda semántica:


# Perform a semantic search
memory_records = session.search_long_term_memories(
    query="can you summarize the support issue",
    namespace_path="/",
    top_k=3
)

Es probable que la información importante sobre el usuario esté almacenada en la memoria a largo plazo. Los agentes pueden usar la memoria a largo plazo en lugar de un historial de conversaciones completo para asegurarse de que los LLM no estén sobrecargados de contexto.

Añadir memoria a un agente existente

Si ha creado un agente de Strands sin memoria y quiere añadirlo más adelante, siga estos pasos:

Añada un recurso de memoria a su proyecto:


agentcore add memory --name MyMemory --strategies SEMANTIC,SUMMARIZATION
agentcore deploy

Cree el memory/ directorio en su agente:
```
mkdir -p app/MyAgent/memory
```

Creeapp/MyAgent/memory/session.py:


import os
from typing import Optional
from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager

MEMORY_ID = os.getenv("MEMORY_MYMEMORY_ID")
REGION = os.getenv("AWS_REGION")

def get_memory_session_manager(session_id: str, actor_id: str) -> Optional[AgentCoreMemorySessionManager]:
    if not MEMORY_ID:
        return None

    retrieval_config = {
        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
        f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5)
    }

    return AgentCoreMemorySessionManager(
        AgentCoreMemoryConfig(
            memory_id=MEMORY_ID,
            session_id=session_id,
            actor_id=actor_id,
            retrieval_config=retrieval_config,
        ),
        REGION
    )

Actualiza tu main.py para usar el administrador de sesiones:


from memory.session import get_memory_session_manager

@app.entrypoint
async def invoke(payload, context):
    session_id = getattr(context, 'session_id', 'default-session')
    user_id = getattr(context, 'user_id', 'default-user')

    agent = Agent(
        model=load_model(),
        session_manager=get_memory_session_manager(session_id, user_id),
        system_prompt="You are a helpful assistant.",
    )

    response = agent(payload.get("prompt"))
    return response

Implemente el proyecto actualizado:
```
agentcore deploy
```

nota

Cada recurso de memoria recibe una variable de entorno MEMORY_<NAME>_ID (en mayúsculas y con caracteres de subrayado) que está disponible automáticamente en el entorno de ejecución del agente tras la implementación.

Limpieza

Cuando haya terminado con el recurso de memoria, puede eliminarlo:


agentcore remove memory --name CustomerSupportSemantic
agentcore deploy

Siguientes pasos

Considere lo siguiente:

Agrega otra estrategia a tu recurso de memoria.
Habilite la observabilidad para obtener una mayor visibilidad del funcionamiento de la memoria
Mira más ejemplos.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Compara la memoria a largo plazo con Retrieval-Augmented Generation

Crea un AgentCore recuerdo