Quatre stratégies de mémoire pour les agents d’IA : fenêtres déroulantes, FAISS et GraphRAG
Comparez les différentes façons de fournir une mémoire à un agent LLM, allant de l’historique complet et des fenêtres déroulantes aux index inversés, à la recherche sémantique FAISS et au graphe de connaissances GraphRAG.
Un agent composé uniquement d’un LLM et de quelques outils fonctionne, d’une certaine manière. Ce qui en fait un agent fiable et personnalisé, c’est la mémoire : un stockage des échanges précédents et du contexte qui permet à l’agent de répondre plus précisément au fil du temps. La mémoire permet également au contexte de persister entre les interactions, y compris lorsque plusieurs agents coopèrent pour une tâche, de sorte que le système garde en mémoire ce que l’utilisateur souhaite réellement.
Avec les informations de contexte pertinentes ainsi que l’entrée actuelle, un agent peut choisir parmi plusieurs options : utiliser un outil, poser une question à l’utilisateur pour obtenir des précisions ou répondre directement. C’est la mémoire qui le transforme d’un simple interlocuteur réactif en un assistant cohérent.
Voici quatre stratégies de mémoire, classées du plus simple au plus performant : l’envoi de l’historique complet, une fenêtre temporelle déroulante, une recherche de similarité parmi les messages passés et un graphe de connaissances.
Option 1 : envoyer l’ensemble de l’historique
Les modèles de fondation actuels supportent des fenêtres de contexte très larges. La famille GPT-5.4, par exemple, atteint 1,05 million de tokens, ce qui suffit pour des bases de code entières ou de grands ensembles de documents. Cela rend tentante une approche négligente : ajouter chaque message précédent, éventuellement provenant de plusieurs sessions, à chaque nouvelle demande et laisser l’attention s’en occuper.
messages: Annotated[List[BaseMessage], add_messages]
C’est simple à mettre en place et adapté aux tâches de courte durée. Cependant, à mesure que les conversations s’allongent, les problèmes se multiplient :
- Trop de contexte irrélevant peut submerger le modèle.
- L’attention est opaque, ce qui peut entraîner des résultats incohérents.
- Les ingénieurs ont du mal à expliquer pourquoi des entrées presque identiques donnent des réponses différentes.
- L’utilisation de tokens augmente à chaque échange, tout comme le coût.
- Des contextes plus importants nécessitent davantage de traitement, ce qui augmente la latence.
Le coût et le délai par requête augmentent constamment à mesure que l’historique s’allonge, et dans les systèmes d’agents en production cette approche devient gaspilleuse et difficile à gérer.
Option 2 : une fenêtre de contexte dynamique
L’alternative consiste à limiter le nombre d’interactions récentes envoyées. Il s’agit d’une fenêtre de contexte dynamique, dont la taille peut être déterminée en fonction du nombre de messages ou des tokens.
En ne prenant en compte que les dernières N interactions, on permet aux développeurs de contrôler la consommation de tokens, d’obtenir une latence plus faible et des factures prévisibles. Cela convient aux tâches principalement déclenchées par des échanges récents. Cependant, lorsque l’agent a besoin de faits plus anciens ou à long terme, une fenêtre temporelle trop courte entraîne une compréhension partielle et des résultats erronés.
WINDOW_SIZE = 6
#Added a wrapper method for return window messages
def rolling_add_messages(old, new):
combined = add_messages(old, new)
return combined[-WINDOW_SIZE:]
class AgentState(TypedDict):
messages: Annotated[List[BaseMessage], rolling_add_messages]
Option 3 : recherche par mots, puis par sens
Un index inversé est une structure de données conçue pour des recherches de texte complet très rapides. Il associe directement les mots ou les nombres aux endroits où ils apparaissent dans un ou plusieurs documents.
L’appliquer à l’historique des conversations signifie indexer les messages précédents, puis sélectionner ceux qui correspondent le mieux aux mots d’une nouvelle requête. Le modèle ne reçoit que les parties correspondantes, ce qui réduit fortement le contexte tout en conservant le matériel pertinent, même provenant des premières étapes de la conversation.
La faiblesse réside dans une correspondance littérale. Une requête peut utiliser des mots différents pour exprimer la même idée, ce qui exclut le contexte et favorise les hallucinations ; de plus, des questions similaires peuvent obtenir des réponses très différentes. Un index de base peut être créé et consulté de cette manière :
def build_inverted_index(messages):
index = defaultdict(set)
for i, msg in enumerate(messages):
words = msg.lower().split()
for word in words:
index[word].add(i)
return index
def search_context(query, index, messages):
query_words = query.lower().split()
matched_ids = set()
for word in query_words:
if word in index:
matched_ids.update(index[word])
return [messages[i] for i in matched_ids]
Recherche sémantique élimine cette faiblesse en interprétant l’intention et le sens, et non seulement les mots-clés. Elle réduit les hallucinations et rend les réponses plus fiables. Le processus se déroule comme suit : une phrase est divisée en tokens, qui sont ensuite transformés en vecteurs par un modèle d’embedding léger. Chaque vecteur de token est ajusté en fonction de ses voisins, et ces vecteurs sont regroupés en un seul vecteur représentant toute la phrase. Ces vecteurs sont stockés dans une base de données vectorielle.
Une requête subit la même transformation et est comparée aux vecteurs stockés par similitude cosinus, qui correspond au cosinus de l’angle entre deux vecteurs. Un score proche de 0,9 indique un sens très similaire, tandis qu’un score inférieur à 0,3 signifie généralement qu’il n’y a pas de lien. Les applications peuvent définir leur propre seuil. Les résultats les plus pertinents sont ensuite transmis au modèle de base.
Le code d’exemple associe un petit modèle Sentence Transformers préentraîné à FAISS, une base de données vectorielle en mémoire, afin de récupérer du contexte par signification.
from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
# Sample data
sentences = [
"schedule meeting tomorrow",
"send project report",
"prepare meeting agenda"
]
# Load embedding model
model = SentenceTransformer("all-MiniLM-L6-v2")
# Convert sentences into vectors
embeddings = model.encode(sentences)
# Create FAISS index
index = faiss.IndexFlatL2(embeddings.shape[1])
index.add(np.array(embeddings))
# Search
query = "plan meeting"
query_vector = model.encode([query])
distances, indices = index.search(np.array(query_vector), k=2)
print([sentences[i] for i in indices[0]])
Sans une telle récupération, chaque requête commence à zéro et ignore ce que les échanges précédents ont appris, offrant ainsi une expérience superficielle et impersonnelle. Avec elle, le système cherche parmi les interactions antérieures un contexte sémantiquement proche chaque fois qu’une requête arrive. La fenêtre de contexte est alors divisée afin d’y faire place à la fois à la conversation la plus récente et à l’historique récupéré. L’agent peut ainsi répondre en fonction des préférences de l’utilisateur et des échanges précédents, ce qui donne une impression de cohérence et de familiarité accrues. En effet, les connaissances acquises précédemment servent de base pour améliorer la réponse actuelle.
Option 4 : un graphe de connaissances avec GraphRAG
Il devient difficile de trouver le bon contexte lorsque les connaissances sont dispersées dans diverses interactions ou documents. La recherche sémantique pure ne parvient peut-être à capturer qu’une partie des informations nécessaires, et elle peut omettre des détails qui diffèrent dans leur formulation mais sont logiquement liés.
Prenez la question « Pourquoi le paiement a-t-il été retardé ? ». La recherche sémantique peut afficher des messages concernant un retard de paiement ou une transaction en attente, mais elle peut néanmoins manquer des indications telles que « L’approbation de l’équipe financière est en attente » ou « La vérification de conformité n’est pas terminée ». Ces éléments expliquent également le retard, mais leur formulation ne correspond que peu à la question, de sorte que la simple similarité ne suffit pas à les retrouver.
GraphRAG aide dans ce cas. Il modélise les informations sous forme de graphe, où chaque document ou concept représente un nœud et les relations des arêtes, ce qui permet une recherche plus structurée et connectée. Le coût réside dans la maintenance : un graphe qui doit évoluer en temps réel à mesure que de nouvelles informations arrivent entraîne des calculs intensifs et des charges de conception importantes.
La création d’un graphe de connaissances suit généralement quatre étapes :
- Identifier les nœuds, c’est-à-dire les entités ou les concepts.
- Identifier les relations entre eux.
- Définir une ontologie, qui correspond à la structure et au schéma du graphe.
- Remplir le graphe de données.
La structure ainsi obtenue fournit un contexte plus riche et mieux connecté que la simple similarité, avec moins de connexions manquantes.
La bibliothèque GraphRAG de Microsoft peut détecter automatiquement les entités et les relations dans le contenu et assembler le graphe.
Étape 1 : mettre en place le projet. Installer GraphRAG et initialiser un répertoire de travail.
pip install graphrag
graphrag init --root ./graphrag_demo
La commande crée un dossier contenant input/, settings.yaml et prompts/. Les documents sources sont placés dans input/.
Étape 2 : construire le graphe. La commande d’indexation extrait les entités, identifie les relations et construit le graphe.
graphrag index --root ./graphrag_demo
Étape 3, interrogez-le. Le graphe généré peut alors être interrogé.
graphrag query \
— root ./graphrag_demo \
— method global \
“Why was the payment delayed?”
Le système rassemble le contexte associé dans tout le graphe, ce qui permet un raisonnement à plusieurs étapes au lieu de se fonder uniquement sur la similarité sémantique.
Comment les éléments s’assemblent
Des agents précis et personnalisés ont besoin de plus que simplement une correspondance de mots-clés ou une similarité isolée. Un index inversé permet de filtrer efficacement le contexte, et la recherche sémantique conserve l’intention initiale, mais tous deux peuvent négliger les relations réparties sur plusieurs éléments de connaissance. GraphRAG comble cette lacune en organisant les informations sous forme d’entités et de relations liées, permettant ainsi au raisonnement de passer d’un contexte à un autre plutôt que de collecter des fragments ayant un aspect similaire. Cela fait passer les agents d’une simple récupération de surface à une compréhension des relations entre concepts.
Ensemble, les fenêtres déroulantes, la recherche sémantique, la mémoire des expériences et le récupération par graphes permettent aux agents de se remémorer des détails pertinents et de raisonner à leur sujet, fournissant ainsi des réponses plus complètes, moins d’hallucinations et une expérience plus stable et personnalisée. La mémoire des agents évolue du stockage d’informations vers la connexion des connaissances, ce qui permet aux assistants IA de passer d’un fonctionnement basé sur la compréhension du contexte à un fonctionnement fondé sur le raisonnement dans ce même contexte.