

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

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:

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

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

```python
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:

```bash
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:

```python
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:

```python
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:

```python
# 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 | 