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

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

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.rproxy.goskope.comSustitú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.

Paso 3: Añada herramientas de memoria al agente

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

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ó

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: