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

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

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 faisons pas simplement des bout de codes dans une base de données ; nous construisons un véritable graphe de connaissances enrichi avec une recherche sémantique qui maintient votre agent alerte.

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, pas seulement des questions-réponses sans état. Oubliez ces démonstrations de chatbots superficielles qui réinitialisent chaque question — il s’agit d’une 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)
• Paquets Pip : weaviate-client>=4.16.0, requests, dotenv
• Clé API OpenAI ou toute autre clé API de modèle d’incorporation (GPT-4, Cohere ou Huggingface)
• Docker installé (optionnel mais recommandé pour faire fonctionner Weaviate localement)
• Compréhension de base des bases de données vectorielles et de la génération d’incorporations

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 reste 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écutez 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 c’est important : Weaviate prend en charge la persistance et l’accès anonyme par défaut ici, ce qui facilite le développement local. En réglant QUERY_DEFAULTS_LIMIT=20, vous évitez de rencontrer des limites ennuyeuses de 10 résultats sur les requêtes, ce qui agace même les développeurs expérimentés. N’oubliez pas, si vous ne voulez pas d’accès anonyme, configurez des clés API. Mais pour les tests, c’est acceptable.

Erreurs courantes : Si le conteneur plante, vérifiez que le port 8080 est libre. Parfois, Docker Desktop ou des conteneurs précédents l’occupent. De plus, si vous générez des incorporations plus vite que ce que la persistance de Weaviate peut gérer (rare en local), attendez-vous à un décalage.

É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 segment de mémoire unique pour l'agent",
 "properties": [
 {
 "name": "text",
 "dataType": ["text"],
 "description": "Le contenu textuel de la mémoire."
 },
 {
 "name": "embedding",
 "dataType": ["number[]"],
 "description": "Représentation d'incorporation vectorielle."
 },
 {
 "name": "timestamp",
 "dataType": ["date"],
 "description": "Quand la mémoire a été stockée."
 }
 ],
 "vectorizer": "none" # Nous injecterons les incorporations nous-mêmes
 }
 ]
}

client.schema.delete_all() # Tableau propre
client.schema.create(schema)

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

Supprimer le schéma avant de créer force un nouveau départ, ce qui vous préserve des erreurs étranges « le schéma existe déjà ». Certes, cela efface des données, mais c’est du développement local.

Étape 3 : Générer et Télécharger les Incorporations 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 incorporations vous-même ? Parce qu’il est extrêmement précieux de découpler la génération d’incorporations et le stockage de vecteurs. Vous pourriez avoir besoin de changer votre modèle d’incorporation plus tard ou d’agréger des vecteurs de différentes sources. Ces autres tutoriels mélangent tout et vous êtes coincé.

Erreur courante ici : oublier de passer l’incorporation comme paramètre de vecteur vector=embedding dans l’appel data_object.create. Si vous oubliez cela, Weaviate essaiera de le vectoriser automatiquement (et échouera parce que nous avons réglé 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, "De quelle couleur est le 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 dans la 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 d’incorporation 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 à l’exécution pour garder votre agent conscient du contexte sans être submergé par des souvenirs non pertinents.

Étape 5 : Connecter Votre Agent à 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)
 # Concatenation simple 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:"
 
 # Envoyez le prompt au LLM (non couvert ici)
 # Simuler :
 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 étroitement couplé où la gestion du contexte rend votre appel de génération désordonné. Avec ce modèle, vous suivez, stockez et rappelez indépendamment. Si vous souhaitez changer pour un meilleur LLM, ou ajouter de la mise en cache, c’est trivial.

Les Pièges Que Vous N’Entendrez Pas dans D’autres Tutoriels

1. Confusion sur le schéma. De nombreux tutoriels passent vite sur la conception du schéma mais si votre schéma est incorrect, vos vecteurs et métadonnées sont du détritus. Vous regretterez de ne pas avoir prévu des timestamps ou des métadonnées comme des ID d’utilisateur pour filtrer votre mémoire.
2. Les coûts des incorporations comptent. Les incorporations OpenAI ne sont pas gratuites. 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 incorporations de manière agressive.
3. La mémoire excessive tue les performances. 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 bruyants. Un élagage régulier est nécessaire – une dure mais inévitable réalité.
4. Incompatibilités de dimensions vectorielles. Si vous échangez accidentellement des modèles d’incorporation ou des versions, vos vecteurs stockés ne correspondront pas aux vecteurs de requête. Vous n’obtiendrez aucun résultat ou des correspondances trompeuses. Fixez toujours la version de votre modèle d’incorporation dans votre pipeline.
5. La cohérence des données est un problème. Sans support de transaction, des écritures ou mises à jour partielles peuvent laisser des mémoires pendantes sans contexte. Ce bug subtil peut vous hanter en production, surtout si vous mettez à jour les 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?"))

Que faire ensuite ?

Après avoir maîtrisé l’intégration de la mémoire Weaviate, votre prochaine étape concrète est de construire un pipeline de taille et de rafraîchissement de mémoire. Cela signifie évaluer périodiquement quelles mémoires sont obsolètes 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.

Envisagez d’implémenter un système d’obsolescence basé sur le temps ou un classement de l’importance des mémoires pour maintenir votre base de données allégée. Cela affinera le focus de l’agent sur ce qui compte réellement.

FAQ

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

Les vectoriseurs intégrés conviennent pour des démos simples mais vous lient à leur modèle d’embedding spécifique et rendent les mises à jour impossibles. Vous souhaitez 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 renvoient 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émoires ?

Batch embed vos données au lieu d’appels uniques, et mettez en cache les embeddings sur disque ou Redis. Le pré-traitement des nouvelles informations hors ligne peut également aider. Soyez également stratégique quant à 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 Personas Développeurs

Type de Développeur	Étapes Suivantes Recommandées
Chercheur en IA	Intégrez Weaviate avec des embeddings de transformateur personnalisés et explorez la recherche hybride combinant texte et similarité de vecteur.
Ingénieur Backend	Mettez en œuvre la gestion du cycle de vie de la mémoire avec une taille automatique, une reconstruction d’index et un suivi de durabilité.
Développeur Full-Stack	Construisez un tableau de bord UI pour visualiser et gérer les entrées de mémoire, et connectez la mémoire Weaviate avec votre interface de chat frontend.

Données en date du 21 mars 2026. Sources: https://github.com/weaviate/weaviate, https://weaviate.io/product/integrations/mem0

Articles Connexes

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

🕒 Published: March 26, 2026