As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Configurando ElastiCache o Valkey como um armazenamento vetorial para memória agente

O passo a passo a seguir mostra como criar um agente de IA habilitado para memória usando Mem0 com ElastiCache for Valkey como armazenamento vetorial.

Etapa 1: criar um agente básico sem memória

Primeiro, instale o Strands Agents e crie um agente básico:

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

Inicialize um agente básico com uma ferramenta HTTP para navegação na 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)

Sem memória, o agente executa as mesmas tarefas de pesquisa repetidamente para cada solicitação. Nos testes, o agente faz três chamadas de ferramenta para responder à solicitação, usando aproximadamente 70.000 tokens e levando mais de 9 segundos para ser concluída.

Etapa 2: Configurar Mem0 com ElastiCache for Valkey

Instale a biblioteca Mem0 com o conector de armazenamento vetorial Valkey:

pip install mem0ai "mem0ai[vector_stores]"

Configure o Valkey como o armazenamento vetorial. ElastiCache for Valkey suporta recursos de pesquisa vetorial a partir da versão 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.comSubstitua pelo endpoint do seu ElastiCache cluster. Para obter instruções sobre como encontrar seu endpoint de cluster, consulte Como acessar seu ElastiCache cluster.

Etapa 3: Adicionar ferramentas de memória ao agente

Crie ferramentas de memória que o agente possa usar para armazenar e recuperar informações. O @tool decorador transforma funções regulares do Python em ferramentas que o agente pode 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])

Etapa 4: testar o agente habilitado para memória

Com a memória ativada, o agente armazena informações de suas interações e as recupera em solicitações subsequentes:

# 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)

Na segunda solicitação, o agente recupera as informações da memória em vez de fazer chamadas à ferramenta web. Nos testes, isso reduziu o uso de tokens de aproximadamente 70.000 para 6.300 (uma redução de 12 vezes) e melhorou o tempo de resposta de 9,25 segundos para 2 segundos (mais de 3 vezes mais rápido).

Como funciona sob o capô

A tabela a seguir mostra os comandos Valkey que o Mem0 usa internamente para implementar a memória agente. ElastiCache O Mem0 abstrai esses comandos por meio de sua API — o esquema exato e a nomenclatura da chave podem variar dependendo da versão e da configuração do Mem0: