Comment ajouter de la mémoire à votre agent avec Weaviate (Étape par Étape)

Weaviate Ajouter de la Mémoire à Votre Agent : Un Tutoriel de 2500 Mots Sans Blabla

Si vous voulez que votre agent intelligent se souvienne réellement du contexte entre les conversations, vous devez weaviate add memory to your agent de la bonne manière, en utilisant la recherche vectorielle pour stocker et rappeler les interactions précédentes. Nous ne jetons pas simplement des extraits dans une base de données ; nous construisons un véritable graphe de connaissances enrichi par une recherche sémantique qui garde votre agent affûté.

Ce Que Vous Construisez et Pourquoi C’est Important

Nous construisons un agent qui utilise Weaviate pour le stockage de mémoire afin qu’il puisse avoir des conversations significatives, et non juste un Q&A sans état. Oubliez ces démonstrations de chatbots superficielles qui réinitialisent chaque question — il s’agit de persistance contextuelle que vos utilisateurs ressentiront réellement.

Prérequis

• Python 3.11+
• Weaviate Community Edition (dernière version stable, j’ai utilisé 1.19.0)
• Packages Pip : weaviate-client>=4.16.0, requests, dotenv
• Clé API OpenAI ou toute autre clé API de modèle d’embedding (GPT-4, Cohere, ou Huggingface)
• Docker installé (optionnel mais recommandé pour exécuter Weaviate localement)
• Compréhension de base des bases de données vectorielles et de la génération d’embeddings

Statistiques Rapides sur Weaviate

Métrique	Valeur
Étoiles GitHub	15,839
Forks	1,227
Problèmes Ouverts	582 (au 20 mars 2026)
Licence	BSD-3-Clause
Dernière Mise à Jour	20 mars 2026

Ces chiffres montrent que Weaviate est mature mais toujours actif ; vous ne serez pas coincé à attendre une bibliothèque abandonnée.

Étape par Étape : Weaviate Ajouter de la Mémoire à Votre Agent

Étape 1 : Configurer le Serveur Weaviate

# Exécuter Weaviate avec Docker pour des tests locaux rapides
docker run -d \
 -p 8080:8080 \
 -e AUTH_ANONYMOUS_ACCESS_ENABLED=true \
 -e QUERY_DEFAULTS_LIMIT=20 \
 -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
 -v $(pwd)/weaviate_data:/var/lib/weaviate \
 semitechnologies/weaviate:latest

Pourquoi cela compte : Weaviate prend en charge la persistance et l’accès anonyme par défaut ici, ce qui facilite le développement local. Définir QUERY_DEFAULTS_LIMIT=20 vous évite de rencontrer les limites ennuyeuses de 10 résultats sur les requêtes, ce qui peut agacer même les développeurs expérimentés. N’oubliez pas, si vous ne souhaitez pas d’accès anonyme, configurez des clés API. Mais pour les tests, cela convient.

Erreurs courantes : Si le conteneur plante, vérifiez que le port 8080 est libre. Parfois, Docker Desktop ou des conteneurs précédents l’utilisent. De plus, si vous générez des embeddings plus rapidement que les capacités de persistance de Weaviate ne peuvent suivre (rare localement), attendez-vous à un retard.

Étape 2 : Définir un Schéma pour la Mémoire de Votre Agent

import weaviate

client = weaviate.Client("http://localhost:8080")

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Stocke un seul segment de mémoire pour l'agent",
 "properties": [
 {
 "name": "text",
 "dataType": ["text"],
 "description": "Le contenu textuel de la mémoire."
 },
 {
 "name": "embedding",
 "dataType": ["number[]"],
 "description": "Représentation vectorielle de l'embedding."
 },
 {
 "name": "timestamp",
 "dataType": ["date"],
 "description": "Lorsque la mémoire a été stockée."
 }
 ],
 "vectorizer": "none" # Nous injecterons les embeddings nous-mêmes
 }
 ]
}

client.schema.delete_all() # Repartir à zéro
client.schema.create(schema)

Pourquoi pas de vectoriseur ? La principale erreur des débutants est d’utiliser aveuglément les vectoriseurs de texte par défaut de Weaviate. C’est acceptable pour une recherche textuelle simple, mais lorsque vous voulez un contrôle étroit sur votre modèle d’embedding (par exemple, OpenAI, Cohere), vous devez télécharger vous-même les vecteurs. Cela dissipe la confusion des tutoriels concurrents qui abusent des vectoriseurs EMBARQUÉS de Weaviate pour les agents.

Supprimer le schéma avant de créer oblige à faire un nouveau départ, ce qui vous protège des erreurs étranges de « schéma déjà existant ». Certes, cela efface les données, mais c’est du développement local.

Étape 3 : Générer et Télécharger des Embeddings de Mémoire

import os
import requests
from datetime import datetime

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

def get_openai_embedding(text):
 resp = requests.post(
 "https://api.openai.com/v1/embeddings",
 headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
 json={"input": text, "model": "text-embedding-ada-002"}
 )
 resp.raise_for_status()
 return resp.json()["data"][0]["embedding"]

def add_memory_entry(client, text):
 embedding = get_openai_embedding(text)
 memory_obj = {
 "text": text,
 "embedding": embedding,
 "timestamp": datetime.utcnow().isoformat()
 }
 client.data_object.create(memory_obj, "MemoryEntry", vector=embedding)

# Exemple d'utilisation
add_memory_entry(client, "Je me souviens que le ciel est bleu.")
add_memory_entry(client, "Le sens de la vie est 42.")

Pourquoi générer les embeddings vous-même ? Parce qu’il est extrêmement précieux de découpler la génération d’embeddings et le stockage vectoriel. Vous pourriez avoir besoin de changer votre modèle d’embedding plus tard ou d’agréger des vecteurs provenant de différentes sources. Ces autres tutoriels mélangent le tout et vous vous retrouvez coincé.

Erreur courante ici : oublier de passer l’embedding comme paramètre vector vector=embedding dans l’appel data_object.create. Si vous omettez cela, Weaviate essaiera de le vectoriser automatiquement (et échouera parce que nous avons défini vectorizer: none).

Étape 4 : Interroger la Mémoire avec une Recherche Sémantique

def query_memory(client, question, top_k=3):
 question_embedding = get_openai_embedding(question)
 near_vector = {"vector": question_embedding}
 response = client.query.get("MemoryEntry", ["text", "timestamp"])\
 .with_near_vector(near_vector)\
 .with_limit(top_k)\
 .do()
 results = response.get("data", {}).get("Get", {}).get("MemoryEntry", [])
 return results

# Testez-le
results = query_memory(client, "Quelle est la couleur du ciel ?")
for res in results:
 print(f"Mémoire : {res['text']} (stockée à {res['timestamp']})")

Pourquoi la recherche sémantique ? La recherche par mots-clés en mémoire est inutile pour les agents qui doivent gérer des conversations à plusieurs tours avec des requêtes nuancées. La véritable magie réside dans la recherche par embedding pour des « pensées similaires » sans chevauchement exact de mots-clés.

La fonctionnalité clé est la façon dont vous mélangez et associez ces requêtes dynamiquement au moment de l’exécution pour garder votre agent conscient du contexte sans être étouffé par des mémoires non pertinentes.

Étape 5 : Connecter Votre Agent pour Utiliser la Mémoire Weaviate

class MemoryAgent:
 def __init__(self, weaviate_client):
 self.client = weaviate_client

 def remember(self, text):
 add_memory_entry(self.client, text)

 def recall(self, question):
 return query_memory(self.client, question, top_k=5)

 def chat(self, question):
 memories = self.recall(question)
 # Simple concaténation pour le prompt — remplacez par votre modèle de prompt
 prompt_context = "\n".join([m["text"] for m in memories])
 prompt = f"Contexte :\n{prompt_context}\n\nQuestion : {question}\nRéponse :"
 
 # Envoyer le prompt au LLM (non couvert ici)
 # Simulation :
 return f"Réponse simulée basée sur les mémoires :\n{prompt}"

agent = MemoryAgent(client)
agent.remember("L'agent a été créé le 20 mars 2026.")
agent.remember("Python est le langage de programmation reconnu pour l'IA.")

print(agent.chat("Quand l'agent a-t-il été créé ?"))

Pourquoi ce design ? Séparer la gestion de la mémoire de la logique de « chat » de l’agent est crucial. Je déteste le code fortement couplé où la gestion du contexte rend votre appel de génération compliqué. Avec ce modèle, vous suivez, stockez et rappelez indépendamment. Si vous souhaitez intégrer un meilleur LLM ou ajouter un cache, c’est trivial.

Les Pièges Dont Vous N’Entendrez Pas Parler Dans D’Autres Tutoriels

1. Confusion de schéma. De nombreux tutoriels passent sous silence la conception de schéma, mais si votre schéma est erroné, vos vecteurs et métadonnées seront inutilisables. Vous regretterez de ne pas avoir planifié des horodatages ou des métadonnées comme des identifiants d’utilisateur pour filtrer votre mémoire.
2. Les coûts d’embedding comptent. Les embeddings OpenAI ne sont pas gratuits. Si vous ajoutez des milliers de mémoires, attendez-vous à une facture. Regroupez votre génération pour réduire les coûts et mettez en cache les embeddings de manière agressive.
3. La surcharge de mémoire tue la performance. Interroger une base de données vectorielle avec des dizaines de milliers d’entrées ? Vous verrez des pics de latence et des résultats de rappel bruités. Un épandage régulier est nécessaire — une réalité difficile mais inévitable.
4. Mésalignements de dimensions vectorielles. Si vous changez accidentellement de modèles ou de versions d’embeddings, vos vecteurs stockés ne correspondront pas aux vecteurs de requête. Vous obtiendrez zéro résultat ou des correspondances trompeuses. Fixez toujours la version de votre modèle d’embedding dans votre pipeline.
5. La cohérence des données est un casse-tête. Sans support transactionnel, des écritures ou mises à jour partielles peuvent laisser des mémoires suspendues sans contexte. Ce bug subtil peut vous hanter en production, surtout si vous mettez à jour des mémoires.

Exemple Complet Fonctionnel

import os
import requests
from datetime import datetime
import weaviate

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
WEAVIATE_URL = "http://localhost:8080"

def get_openai_embedding(text):
 r = requests.post(
 "https://api.openai.com/v1/embeddings",
 headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
 json={"input": text, "model": "text-embedding-ada-002"},
 )
 r.raise_for_status()
 return r.json()["data"][0]["embedding"]

client = weaviate.Client(WEAVIATE_URL)
client.schema.delete_all()

schema = {
 "classes": [
 {
 "class": "MemoryEntry",
 "description": "Stocke la mémoire de l'agent",
 "properties": [
 {"name": "text", "dataType": ["text"]},
 {"name": "embedding", "dataType": ["number[]"]},
 {"name": "timestamp", "dataType": ["date"]}
 ],
 "vectorizer": "none"
 }
 ]
}
client.schema.create(schema)

def add_memory(text):
 embedding = get_openai_embedding(text)
 data = {"text": text, "embedding": embedding, "timestamp": datetime.utcnow().isoformat()}
 client.data_object.create(data, "MemoryEntry", vector=embedding)

def query_memories(question, top_k=5):
 q_emb = get_openai_embedding(question)
 near_vector = {"vector": q_emb}
 res = client.query.get("MemoryEntry", ["text", "timestamp"])\
 .with_near_vector(near_vector).with_limit(top_k).do()
 return res.get("data", {}).get("Get", {}).get("MemoryEntry", [])

class Agent:
 def __init__(self, client):
 self.client = client

 def remember(self, text):
 add_memory(text)

 def chat(self, question):
 memories = query_memories(question)
 context = "\n".join([m["text"] for m in memories])
 prompt = f"Contexte:\n{context}\n\nQuestion: {question}\nRéponse:"
 # Réponse fictive
 return prompt

agent = Agent(client)
agent.remember("Le ciel est bleu.")
agent.remember("L'eau bout à 100 degrés Celsius.")
print(agent.chat("Quelle est la couleur du ciel ?"))

Et après ?

Après avoir maîtrisé l’intégration de la mémoire Weaviate, votre prochaine étape concrète est de construire un pipeline de jardinage et de rafraîchissement de la mémoire. Cela signifie évaluer périodiquement quelles mémoires sont périmées ou non pertinentes et les supprimer ou les mettre à jour. Si vous laissez la mémoire croître sans contrôle, les réponses de votre agent ralentiront et deviendront incohérentes.

Pensez à implémenter un déclin basé sur le temps ou une hiérarchisation de l’importance des souvenirs pour garder votre base de données légère. Cela affinera la concentration de l’agent sur ce qui compte vraiment.

FAQ

Pourquoi devrais-je désactiver le vectoriseur intégré de Weaviate ?

Les vectoriseurs intégrés sont suffisants pour des démonstrations simples mais vous enferment dans leur modèle d’embedding spécifique et rendent la mise à jour impossible. Vous voulez injecter vos propres embeddings générés à partir de modèles comme le text-embedding-ada-002 d’OpenAI, afin de contrôler la qualité des vecteurs et les coûts API.

Que faire si mes requêtes ne retournent aucun résultat ?

Tout d’abord, confirmez que les dimensions de vos embeddings correspondent. Les embeddings ada-002 d’OpenAI sont des vecteurs de 1536 dimensions. Si vos vecteurs stockés et vos vecteurs de requête diffèrent en dimension, la recherche de similarité ne retourne rien. Vérifiez également que le vectoriseur de votre schéma est ‘none’ et que vous envoyez explicitement vos propres vecteurs lors de la création d’objets.

Comment gérer les coûts d’embedding avec des milliers d’entrées mémoire ?

Intégrez vos données par lots au lieu d’appels uniques, et mettez en cache les embeddings sur disque ou Redis. Le prétraitement de nouvelles informations hors ligne peut également aider. De plus, soyez stratégique dans ce que vous stockez – stockez des résumés, pas des conversations complètes. Enfin, explorez des modèles open-source moins chers, mais attention à la précision.

Recommandations pour les profils de développeur

Type de développeur	Étapes suivantes recommandées
Chercheur en IA	Intégrez Weaviate avec des embeddings de transformateurs personnalisés et explorez la recherche hybride combinant texte et similarité vectorielle.
Ingénieur Backend	Implémentez la gestion du cycle de vie de la mémoire avec un jardinage automatisé, la reconstruction d’index et la surveillance de la durabilité.
Développeur Full-Stack	Construisez un tableau de bord UI pour visualiser et gérer les entrées mémoire, et connectez la mémoire Weaviate avec votre interface de chat frontend.

Données à jour au 21 mars 2026. Sources : https://github.com/weaviate/weaviate, https://weaviate.io/product/integrations/mem0

Articles connexes

• Améliorer les LLM avec des Graphiques de Connaissances Fiables : L’Innovation de Qinggang Zhang
• Déverrouillez Votre Marque : Créer le Logo Parfait pour un Réseau de Neurones Convolutionnels
• Pourquoi Utiliser l’Architecture d’Agent IA

🕒 Published: March 26, 2026