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.

# Configuración de ElastiCache Valkey como almacén vectorial para la memoria de un agente
<a name="agentic-memory-setup"></a>

El siguiente tutorial muestra cómo crear un agente de IA con memoria habilitada utilizando Mem0 con ElastiCache Valkey como almacén de vectores.

## Paso 1: Crea un agente básico sin memoria
<a name="agentic-memory-step1"></a>

Primero, instala Strands Agents y crea un agente básico:

```
pip install strands-agents strands-agents-tools strands-agents-builder
```

Inicialice un agente básico con una herramienta HTTP para navegar por la web:

```
from strands import Agent
from strands.tools import http_request

# Initialize agent with access to the tool to browse the web
agent = Agent(tools=[http_request])

# Format messages as expected by Strands
formatted_messages = [
    {
        "role": "user",
        "content": [{"text": "What is the URL for the project mem0 and its most important metrics?"}]
    }
]

result = agent(formatted_messages)
```

Sin memoria, el agente realiza las mismas tareas de investigación repetidamente para cada solicitud. Durante las pruebas, el agente realiza tres llamadas a la herramienta para responder a la solicitud, utilizando aproximadamente 70 000 fichas y tardando más de 9 segundos en completarse.

## Paso 2: Configura Mem0 con Valkey ElastiCache
<a name="agentic-memory-step2"></a>

Instale la biblioteca Mem0 con el conector de almacén de vectores Valkey:

```
pip install mem0ai "mem0ai[vector_stores]"
```

Configura Valkey como almacén de vectores. ElastiCache porque Valkey admite las capacidades de búsqueda vectorial a partir de la versión 8.2:

```
from mem0 import Memory

# Configure Mem0 with ElastiCache for Valkey
config = {
    "vector_store": {
        "provider": "valkey",
        "config": {
            "valkey_url": "your-elasticache-cluster.cache.amazonaws.com:6379",
            "index_name": "agent_memory",
            "embedding_model_dims": 1024,
            "index_type": "flat"
        }
    }
}

m = Memory.from_config(config)
```

{{your-elasticache-cluster.cache.amazonaws.com}}Sustitúyalo por el punto final de tu ElastiCache clúster. Para obtener instrucciones sobre cómo encontrar el punto final del clúster, consulta [Acceder al ElastiCache clúster](accessing-elasticache.md).

## Paso 3: Añada herramientas de memoria al agente
<a name="agentic-memory-step3"></a>

Cree herramientas de memoria que el agente pueda utilizar para almacenar y recuperar información. El `@tool` decorador transforma las funciones normales de Python en herramientas que el agente puede invocar:

```
from strands import Agent, tool
from strands.tools import http_request

@tool
def store_memory_tool(information: str, user_id: str = "user") -> str:
    """Store important information in long-term memory."""
    memory_message = [{"role": "user", "content": information}]

    # Create new memories using Mem0 and store them in Valkey
    m.add(memory_message, user_id=user_id)

    return f"Stored: {information}"

@tool
def search_memory_tool(query: str, user_id: str = "user") -> str:
    """Search stored memories for relevant information."""

    # Search memories using Mem0 stored in Valkey
    results = m.search(query, user_id=user_id)
    if results['results']:
        return "\n".join([r['memory'] for r in results['results']])
    return "No memories found"

# Initialize Strands agent with memory tools
agent = Agent(tools=[http_request, store_memory_tool, search_memory_tool])
```

## Paso 4: Pruebe el agente con memoria habilitada
<a name="agentic-memory-step4"></a>

Con la memoria habilitada, el agente almacena la información de sus interacciones y la recupera en solicitudes posteriores:

```
# First request - agent searches the web and stores results in memory
formatted_messages = [
    {
        "role": "user",
        "content": [{"text": "What is the URL for the project mem0 and its most important metrics?"}]
    }
]
result = agent(formatted_messages)

# Second request (same question) - agent retrieves from memory
result = agent(formatted_messages)
```

En la segunda solicitud, el agente recupera la información de la memoria en lugar de realizar llamadas a herramientas web. En las pruebas, esto redujo el uso de fichas de aproximadamente 70 000 a 6 300 (una reducción de 12 veces) y mejoró el tiempo de respuesta de 9,25 a 2 segundos (más de 3 veces más rápido).

## ¿Cómo funciona bajo el capó
<a name="agentic-memory-valkey-commands"></a>

La siguiente tabla muestra los comandos de Valkey que Mem0 usa internamente para implementar la memoria del agente. ElastiCache Mem0 abstrae estos comandos a través de su API; el esquema exacto y la denominación de las claves pueden variar según la versión y la configuración de Mem0:


| Operación | Comando Valkey | Description (Descripción) | 
| --- | --- | --- | 
| Crear índice vectorial | FT.CREATE agent\_memory SCHEMA embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1024 DISTANCE\_METRIC COSINE | Crea un índice vectorial para la búsqueda de memoria semántica | 
| Almacena memoria | HSET mem:{id} memory "..." embedding [bytes] user\_id "user\_123" created\_at "..." | Almacena una memoria con su incrustación vectorial | 
| Busca recuerdos | FT.SEARCH agent\_memory "\*=>[KNN 5 @embedding $query\_vec]" PARAMS 2 query\_vec [bytes] DIALECT 2 | Encuentra los recuerdos más semánticamente similares | 
| Establece la caducidad | EXPIRE mem:{id} 86400 | Establece el TTL para las entradas de memoria |