Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Configuration de ElastiCache Valkey en tant que magasin vectoriel pour la mémoire agentique
La procédure pas à pas suivante montre comment créer un agent AI activé par la mémoire à l'aide de Mem0 avec ElastiCache pour Valkey comme magasin de vecteurs.
## Étape 1 : Création d'un agent de base sans mémoire
Tout d'abord, installez Strands Agents et créez un agent de base :
```
pip install strands-agents strands-agents-tools strands-agents-builder
```
Initialisez un agent de base avec un outil HTTP pour la navigation sur le 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)
```
Sans mémoire, l'agent exécute les mêmes tâches de recherche à plusieurs reprises pour chaque demande. Lors des tests, l'agent effectue trois appels à l'outil pour répondre à la demande, en utilisant environ 70 000 jetons et en 9 secondes.
## Étape 2 : Configurer Mem0 avec ElastiCache pour Valkey
Installez la bibliothèque Mem0 avec le connecteur de magasin vectoriel Valkey :
```
pip install mem0ai "mem0ai[vector_stores]"
```
Configurez Valkey comme magasin de vecteurs. ElastiCache car Valkey prend en charge les fonctionnalités de recherche vectorielle à partir de la version 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}}Remplacez-le par le point de terminaison de votre ElastiCache cluster. Pour obtenir des instructions sur la manière de trouver le point de terminaison de votre cluster, consultez la section [Accès à votre ElastiCache cluster](accessing-elasticache.md).
## Étape 3 : ajouter des outils de mémoire à l'agent
Créez des outils de mémoire que l'agent peut utiliser pour stocker et récupérer des informations. Le `@tool` décorateur transforme les fonctions Python classiques en outils que l'agent peut invoquer :
```
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])
```
## Étape 4 : tester l'agent activé par la mémoire
Lorsque la mémoire est activée, l'agent stocke les informations issues de ses interactions et les récupère lors de demandes ultérieures :
```
# 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)
```
Lors de la deuxième demande, l'agent extrait les informations de la mémoire au lieu de passer des appels à l'outil Web. Lors des tests, cela a permis de réduire l'utilisation des jetons d'environ 70 000 à 6 300 (soit une réduction de 12 fois) et d'améliorer le temps de réponse de 9,25 secondes à 2 secondes (plus de 3 fois plus rapide).
## Comment ça marche sous le capot
Le tableau suivant montre les commandes Valkey que Mem0 utilise en interne pour implémenter la mémoire agentique. ElastiCache Mem0 extrait ces commandes via son API. Le schéma exact et le nom des clés peuvent varier en fonction de la version et de la configuration de Mem0 :
| Opération | commande Valkey | Description |
| --- | --- | --- |
| Création d'un index vectoriel | FT.CREATE agent\_memory SCHEMA embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1024 DISTANCE\_METRIC COSINE | Crée un index vectoriel pour la recherche sémantique dans la mémoire |
| Stockez la mémoire | HSET mem:{id} memory "..." embedding [bytes] user\_id "user\_123" created\_at "..." | Stocke une mémoire avec son intégration vectorielle |
| Rechercher des souvenirs | FT.SEARCH agent\_memory "\*=>[KNN 5 @embedding $query\_vec]" PARAMS 2 query\_vec [bytes] DIALECT 2 | Trouve les souvenirs les plus sémantiquement similaires |
| Définir l'expiration | EXPIRE mem:{id} 86400 | Définit le TTL pour les entrées de mémoire |