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
<a name="agentic-memory-setup"></a>

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
<a name="agentic-memory-step1"></a>

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
<a name="agentic-memory-step2"></a>

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}}Substitua pelo endpoint do seu ElastiCache cluster. Para obter instruções sobre como encontrar seu endpoint de cluster, consulte [Como acessar seu ElastiCache cluster](accessing-elasticache.md).

## Etapa 3: Adicionar ferramentas de memória ao agente
<a name="agentic-memory-step3"></a>

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
<a name="agentic-memory-step4"></a>

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 name="agentic-memory-valkey-commands"></a>

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:


| Operation | comando Valkey | Description | 
| --- | --- | --- | 
| Criar índice vetorial | FT.CREATE agent\_memory SCHEMA embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1024 DISTANCE\_METRIC COSINE | Cria um índice vetorial para pesquisa de memória semântica | 
| Armazenar memória | HSET mem:{id} memory "..." embedding [bytes] user\_id "user\_123" created\_at "..." | Armazena uma memória com sua incorporação vetorial | 
| Busque memórias | FT.SEARCH agent\_memory "\*=>[KNN 5 @embedding $query\_vec]" PARAMS 2 query\_vec [bytes] DIALECT 2 | Encontra as memórias mais semanticamente semelhantes | 
| Definir expiração | EXPIRE mem:{id} 86400 | Define TTL para entradas de memória |