Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# 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:
1. Cree una AgentCore memoria que contenga una estrategia semántica
1. Escribe eventos (historial de conversaciones) en el recurso de memoria
1. Recupera registros de memoria de la memoria a largo plazo
Para ver otros ejemplos, consulte los ejemplos [ de ](memory-examples.md) 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 ](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore-control.html) bedrock-agentcore. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore.html)
**Ejemplo ** completo: [ consulte AgentCore los ](https://github.com/awslabs/amazon-bedrock-agentcore-samples/tree/main/01-features/04-manage-context-of-your-agent/memory) 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:
**Example**
1.
```
agentcore add memory --name CustomerSupportSemantic --strategies SEMANTIC
agentcore deploy
```
1. Ejecute `agentcore` para abrir la TUI, luego seleccione ** agregar ** y elija ** Memoria: **
1. Introduzca el nombre de la memoria:
1. Seleccione la ** estrategia ** semántica y, a continuación, confirme:
A continuación, ejecute `agentcore deploy` para aprovisionar la memoria. AWS
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:
1. Añade un recurso de memoria a tu proyecto:
```
agentcore add memory --name MyMemory --strategies SEMANTIC,SUMMARIZATION
agentcore deploy
```
1. Cree el `memory/` directorio en su agente:
```
mkdir -p app/MyAgent/memory
```
1. Crea`app/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
)
```
1. `main.py`Actualí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
```
1. Implemente el proyecto actualizado:
```
agentcore deploy
```
**nota**
Cada recurso de memoria recibe una variable de entorno `MEMORY__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 ](long-term-enabling-long-term-memory.md#long-term-adding-strategies-to-existing-memory) a tu recurso de memoria.
+ [Habilite la observabilidad ](memory-observability.md) para obtener una mayor visibilidad del funcionamiento de la memoria
+ Vea más [ ejemplos](memory-examples.md).