Requisitos previos Paso 1: Crear un recuerdo AgentCore Paso 2: escribir eventos en la memoria Paso 3: Recuperar registros de la memoria a largo plazo Agregar memoria a un agente existente Limpieza Siguientes pasos

Comience con AgentCore Memory

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 guía de introducción lo guiará a través de la instalación de dependencias y la implementación de funciones de memoria a corto y 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 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 20 instalados (para la CLI) AgentCore

Para empezar a usar 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 la terminal.


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

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

nota

La AgentCore CLI le ayuda a crear e implementar recursos de memoria. Para conocer las operaciones directas de la API de servicio, consulte la documentación de Boto3: bedrock-agentcore-control y bedrock-agentcore. https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore.html

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

Paso 1: Crear un recuerdo AgentCore

Necesita una AgentCore memoria para empezar a almacenar información para su agente. De forma predeterminada, los eventos de memoria (a los que nos referimos como memoria a corto plazo) se pueden escribir en una AgentCore memoria. Para extraer información y guardarla en registros de memoria a largo plazo, el recurso requiere una estrategia de memoria, es decir, una configuración que defina cómo se deben procesar los datos de una conversación y qué información extraer (por ejemplo, hechos, 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 creó la memoria:


agentcore status

Paso 2: escribir eventos en la memoria

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

La escritura de eventos en la memoria tiene varios propósitos. En primer lugar, el contenido de los eventos (normalmente 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 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 los mensajes entre un usuario final y un robot 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 eventos (turnos) para un actor específico después de 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 escritos los eventos en el recurso de memoria, se analizaron y la información útil se envió a la memoria a largo plazo. Como la memoria contiene una estrategia de memoria semántica a largo plazo, el sistema extrae y almacena la 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 completo de conversaciones para asegurarse de que los LLM no estén sobrecargados de contexto.

Agregar memoria a un agente existente

Si has creado un agente de Strands sin memoria y quieres añadirlo más adelante, sigue estos pasos:

Añade un recurso de memoria a tu proyecto:


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

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

Creaapp/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
    )

main.pyActualízalo 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(str(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, con guiones bajos) que está disponible automáticamente en el entorno de ejecución de su agente después de 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
Vea 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