Applications d'IA avec test de mémoire MCP et tutoriel
Nous avons testé quatre serveurs de mémoire MCP (Model Context Protocol) afin de déterminer lesquels conservent et récupèrent efficacement le contexte entre les sessions d'agents d'IA. À l'aide de l'agent ReAct de LangChain, nous avons connecté chaque serveur, exécuté des conversations multisessions standardisées et évalué leur précision en matière d'opérations de mémoire.
Nous avons également créé une démo fonctionnelle qui connecte Claude et Cursor via OpenMemory MCP, une couche de mémoire partagée qui conserve le contexte entre les deux outils. Cette démo illustre le fonctionnement de la mémoire en pratique : les données stockées, leur récupération et la manière dont le contexte détermine les informations affichées .
Résultats et méthodologie des tests de performance des serveurs de mémoire MCP
Nous avons évalué la capacité des grands modèles de langage (LLM) à gérer les connaissances au cours de conversations multisessions, à préserver le contexte conversationnel et à récupérer les informations importantes grâce à des systèmes de mémoire externes. Nous avons évalué quatre implémentations distinctes de serveurs MCP : Handrails 1 Graphique de connaissances 2 Mémoire de base 3 et Zine 4 .
Notre test de performance a pour but de mesurer la capacité d'un serveur MCP à :
- Rappelez-vous la matière avec précision pendant les pauses, sans poser deux fois les mêmes questions.
- Exécutez les opérations de mémoire appropriées (lecture, écriture, mise à jour et suppression) aux moments opportuns.
- Modifier les réponses en fonction du contexte utilisateur et des données de préférences précédemment enregistrées.
Exemples d'interactions dans MCP à partir de l'ensemble de données
1- Problème d'installation de paquet : cet exemple teste la manière dont le système gère une situation où un utilisateur rencontre des problèmes lors de l'installation d'un logiciel. Voici le détail de l'interaction :
- Session 1 : « J’ai des difficultés à installer le paquet 25. »
- Session 2 : « J'ai essayé apt install mais j'ai reçu un refus d'autorisation. »
- Suite de la session 2 : « Ça a marché ! Merci » (après la suggestion sudo)
Comportement attendu : le système devrait garder trace du fait que sudo a résolu le problème d’installation pour les cas similaires à l’avenir.
2- Test d'adaptation aux compétences de l'utilisateur : cet exemple illustre comment le système adapte ses réponses en fonction du niveau d'expérience de l'utilisateur. Voici une description détaillée de l'interaction :
- Séance 1 : « J’ai besoin d’aide pour ma demande d’allocations. Je suis novice en la matière. »
- Pause de session
- Session 2 : « Merci, mais je ne peux pas me connecter maintenant. »
Comportement attendu : L’agent doit se souvenir que l’utilisateur est novice et fournir des explications plus simples plutôt que des étapes de dépannage avancées.
Opérations de mémoire
Chaque dialogue implique des opérations de mémoire spécifiques effectuées par le serveur, testant sa capacité à stocker/écrire , récupérer/lire , mettre à jour et nettoyer la mémoire.
- Écrire : Enregistrer les informations initiales de l’appareil, les symptômes et le niveau de compétence de l’utilisateur.
- Lire : Récupérer le contexte précédent lors de la reprise des sessions.
- Mise à jour : Suivre les résultats de la solution (succès ou échec).
- Supprimer : Supprimer les informations obsolètes.
Déroulement du test de performance
Notre banc d'essai utilise le framework d'agents ReAct de LangChain et le modèle de base OpenAI. Nous testons chaque serveur MCP (Knowledge Graph, Basic Memory, Handrail, Zine) individuellement.
Chaque scénario est exécuté afin de vérifier la persistance de la mémoire du système et la gestion des dialogues multisessions. Nous avons testé la mémoire du système en procédant comme suit :
- Validation et chargement des ensembles de données : charge les conversations de plusieurs sessions au format JSON et vérifie la structure principale.
- Initialisation de l'agent :
- Connecte le serveur MCP à un agent ReAct et configure une invite système spécifique pour les opérations de mémoire sur l'agent.
- Utilise une liste blanche d'outils pour limiter les opérations aux fonctions mémoire pertinentes.
- Traitement séquentiel : Conserve l'historique des conversations en traitant chaque session séparément et indique clairement les pauses de session pour évaluer la continuité.
- Application des opérations de mémoire :
- Met en œuvre des mesures de sécurité conformes aux meilleures pratiques, telles que la prévention des doublons par l'exigence d'une vérification avant l'écriture et la garantie que la mémoire est lue après les interruptions de session.
- Offre des possibilités de nouvelle tentative lorsque des garde-fous sont activés.
- Analyse des appels d'outils :
- Tous les appels d'outils sont extraits et catégorisés (lecture, écriture, mise à jour, suppression).
- Analyse les tendances de séquencement des outils entre les sessions et au sein des tours de jeu.
- Surveille les changements entre différents types d'opérations, telles que la mise à jour en écriture et la lecture-écriture.
- Évaluation et notation :
- Compare les opérations attendues à partir des annotations du jeu de données avec les opérations observées.
- Détermine la précision de chaque intervention et combine les données de nombreuses conversations.
- Mesure en particulier les comportements de lecture à la reprise et de lecture avant écriture.
- Analyse des erreurs : Enregistre des journaux détaillés étape par étape avec des informations opérationnelles, classe les erreurs, suit les tendances des défaillances et produit des rapports et des résumés de performance.
- Sortie : Génère des fichiers CSV contenant des données de référence et des rapports de synthèse avec des indicateurs clés, rendant l'information facile à lire.
Notre principal indicateur est la précision des opérations , qui mesure le pourcentage de tours où le modèle effectue les opérations de mémoire attendues.
Le problème de l'absence de mémoire partagée entre les outils
Il est courant d'utiliser des outils comme Claude pour générer des idées. En général, je pars de ce plan et j'alterne entre différents outils. Cependant, sans mémoire partagée, les différents outils d'IA ne conservent pas en mémoire les décisions passées, les choix architecturaux antérieurs ni les subtilités de votre code source.
Cela soulève plusieurs problèmes :
- Le contexte se perd entre les outils : lorsque vous effectuez des modifications dans un outil, comme la mise à jour d'un plan ou le changement de la pile technologique dans Claude , Cursor n'en tient pas compte lorsque vous y revenez. Vous devez ressaisir manuellement tous les détails. Par exemple, à chaque fois que vous reprenez le projet, vous devez réexpliquer des éléments comme le framework utilisé (par exemple, React avec Redux ou Flutter avec Bloc).
- Duplication des données : Il est également nécessaire de répéter les informations entre différents outils. Par exemple, la pile technologique, la mise en page et les fonctionnalités de l’application doivent être redéfinies dans Cursor , même si elles ont déjà été définies dans Claude .
- Baisse de productivité : comme les outils ne partagent pas la mémoire, vous finissez par constamment réintroduire le même contexte.
Comment la mémoire et le MCP fonctionnent-ils ensemble ?
Dans le système Memory MCP , tous vos outils d'IA, clients MCP (par exemple Cursor), fonctionnent ensemble en tirant parti à la fois de la mémoire et du protocole de contexte de modèle (MCP) .
- La mémoire stocke des informations personnalisées et permanentes sur les préférences de l'utilisateur et ses tâches récurrentes. Par exemple, le curseur mémorise vos langages de programmation préférés, votre tonalité et vos habitudes de travail.
- MCP offre un accès en temps réel aux données dynamiques et spécifiques à une tâche, telles que les fichiers de projet ou les API, pendant une session. Il garantit la récupération d'informations à jour et contextuelles au moment opportun.
Introduction à OpenMemory
OpenMemory est un outil développé par MemZero qui fournit un système de mémoire unifié pour plusieurs applications et agents d'IA. Imaginez-le comme une « puce mémoire » intégrant tous vos clients MCP dans un espace mémoire unique et continu. Il peut être utilisé en local ou dans le cloud.
Tutoriel : OpenMemory MCP
Exigences
Avant de commencer, assurez-vous d'avoir la configuration suivante :
- Docker : Requis pour exécuter les serveurs OpenMemory et MCP localement ( installer Docker ).
- Git : Pour cloner les dépôts nécessaires.
- OpenMemory : Vous devrez installerOpenMemory pour interagir localement avec les serveurs LLM.
- Clé API : Vous aurez besoin de votre clé API pour les interactions LLM. Dans cet exemple, nous utiliserons la clé API OpenAI .
Configuration d'OpenMemory
Note de sécurité : lors de la configuration et de l’utilisation d’OpenMemory, il est recommandé de ne pas partager directement dans votre code ou vos dépôts publics vos clés API privées, vos mots de passe ou toute autre information sensible.
Étape 1 : Cloner le dépôt
Le dossier OpenMemory sur GitHub se trouve dans le dossier mem, car mem est le dépôt principal. Pour obtenir OpenMemory, il faut cloner l'intégralité du dépôt mem.
1. Allez sur le dépôt MemZero et copiez le lien du dépôt (https://github.com/mem0ai/mem0.git).
2. Ouvrez votre terminal et tapez git clone suivi du lien du dépôt GitHub.
3. Accédez au répertoire : Après le clonage, placez-vous dans le dossier mem0 (tapez cd mem0) et localisez le dossier OpenMemory (tapez cd openmemory/). Vous pourrez ensuite vous y déplacer et exécuter toutes les commandes suivantes à partir de là.
Pour faire fonctionner OpenMemory, vous devez exécuter à la fois l'interface utilisateur et le serveur MCP.
Il est donc nécessaire d'installer Docker pour les conteneuriser. Grâce à Docker, l'interface utilisateur et le serveur MCP, ainsi que toutes leurs dépendances, peuvent être placés dans des conteneurs, garantissant ainsi une exécution cohérente dans différents environnements.
Cela vous permet de configurer, d'exécuter et de faire évoluer l'interface utilisateur et le serveur MCP sans vous soucier de la configuration manuelle.
Étape 2 : Configurer Docker et créer des conteneurs
Si Docker n'est pas installé sur votre système, téléchargez-le et installez-le depuis le site web de Docker .
Création des conteneurs Docker : Exécutez la commande « make build » suivante pour créer les conteneurs, ce qui installera les dépendances nécessaires :
Démarrer les conteneurs : Une fois les conteneurs construits, démarrez-les en tapant « make up ».
Il suffit d'exécuter la commande `make build` une seule fois. Ensuite, vous pourrez simplement exécuter `make up` pour démarrer les conteneurs en cas de besoin.
De plus, pour utiliser le serveur MCP, Docker doit être installé et exécuté sur votre système. En attendant d'avoir accès au cloud, vous devrez laisser Docker actif pour l'exécuter localement.
Si vous vous rendez dans l'onglet « make », vous pouvez constater que le serveur OpenMemory MCP est désormais opérationnel :
Le serveur OpenMemory MCP devrait être exécuté par défaut à l'adresse : http://localhost:8765 .
Étape 3 : Configurer le serveur MCP
Maintenant que Docker est en cours d'exécution, l'étape suivante consiste à configurer le serveur MCP pour gérer la couche mémoire.
L'interface utilisateur d'OpenMemory est accessible par défaut à l' adresse http://localhost:3000 . Avec Docker en cours d'exécution, le serveur MCP sera opérationnel et accessible localement à cette adresse. Pour vérifier le bon fonctionnement du serveur, accédez simplement à http://localhost:3000 dans le tableau de bord d'OpenMemory.
Étape 4 : Configurer les clients (Claude/Cursor dans cet exemple)
Pour connecter Claude et Cursor (ou tout autre agent) au système de mémoire partagée, ouvrez le répertoire dans Cursor, puis appuyez sur le curseur dans votre terminal :
Configurez la clé API OpenAI : ouvrez le dossier API dans l’arborescence du projet. Une fois ouvert, il ressemblera à ceci et l’arborescence des fichiers sera la suivante :
Dans l'arborescence des fichiers, accédez au dossier API . Vous y trouverez un fichier av_example .
Vous devez coller votre clé API OpenAI dans ce fichier. Copiez-le, renommez-le en .env en supprimant le mot « example » du nom de fichier, puis collez-y votre clé API.
Une fois cette étape terminée, vous pourrez utiliser la commande de maquillage . Cette étape est indiquée comme prérequis car elle est nécessaire pour les interactions avec LLM, d'où la demande de la clé Open API.
Étape 5 : Configurer MCP dans les outils
L'installation du MCP est nécessaire pour différents outils. Vous trouverez le lien MCP, que vous devrez configurer manuellement dans les paramètres. Une fois lancé, le MCP sera automatiquement ajouté au client Claude. La même procédure s'applique à Cursor.
Vous pouvez constater que j'ai installé ces deux MCP. Voici Claude et Cursor :
Vous pouvez voir dans Cursor qu'il est déjà opérationnel :
Exemple d'implémentation MCP
Cet exemple illustre l'utilisation du serveur MCP. Ouvrez Claude Desktop et demandez-lui de générer des idées pour différents types d'applications ou de solutions. Dans cet exemple, nous verrons comment concevoir une application de suivi du temps.
Claude propose tout d'abord son propre plan. Vous pouvez ensuite aborder les points ci-dessous, en vous concentrant sur les fonctionnalités à implémenter.
Une fois les modifications ajoutées au plan initial, vous pouvez lui demander d'enregistrer le plan en mémoire sous le nom de « plan de suivi du temps ».
Vous pouvez consulter les détails de la mémoire dans l'onglet situé à droite du tableau de bord OpenMemory. Voici ces détails :
Passons à Cursor : vous pouvez lui donner une instruction comme « Je veux créer une application de suivi du temps » et lui demander s’il peut extraire les détails de la mémoire.
Ensuite, l'application a utilisé les outils MCP pour lister et rechercher les souvenirs. Cette fonctionnalité est extrêmement utile car elle permet de trouver des informations pertinentes. Par exemple, lors d'une recherche sur l'application de suivi du temps, elle a récupéré tous les souvenirs liés à ce sujet.
À partir de là, il a extrait des informations sur Next.js, React, TypeScript et le reste de la pile technologique à utiliser. Il a ensuite commencé à construire l'application.
Une fois la tâche terminée, vous pouvez lui demander d'enregistrer la progression en mémoire, ce qu'elle fera. Elle ajoutera des notes de progression, divisera le tout en éléments gérables et les enregistrera également. Ainsi, toutes les mises à jour seront sauvegardées en mémoire.
Voici l'application créée :
Défis rencontrés après la création de l'application
Au bout d'un moment, Cursor a généré une erreur lors du démarrage d'une nouvelle conversation en raison de la taille du contexte. Une fois la nouvelle conversation lancée, vous pouvez lui demander de récupérer l'historique de progression de l'application. Il a alors de nouveau fait appel à l'outil MCP et récupéré toutes les données pertinentes, comme son emplacement d'exécution et les actions effectuées.
Une capture d'écran a ensuite été fournie car le contraste de certains éléments React était insuffisant et le texte illisible. Vous pouvez demander une correction de l'interface utilisateur, ce qui a été fait.
Pendant son exécution, le programme s'appelait sans cesse pour tenter de localiser le répertoire source. Cependant, il n'a pas détecté l'existence d'un dossier front-end.
Comment MCP, Cursor et Claude ont récupéré et géré la mémoire
Maintenant, ce que vous voulez voir, c'est comment il récupère concrètement les souvenirs.
Il est important de noter que cette mémoire est liée à toutes les autres mémoires créées au cours de la même session. Ainsi, si le client MCP demande une mémoire étiquetée « temps », il récupère également les mémoires associées.
Vous pouvez consulter l'application source de chaque mémoire. Certaines ont été créées par Cursor, d'autres par Claude. En ouvrant une mémoire, vous pouvez consulter le journal d'accès, modifier son statut, voire la modifier directement.
Tester la capacité du MCP à différencier les projets
Pour tester si le système MCP peut faire la distinction entre différents projets, changez la pile technologique pour la pile MERN et demandez à Claude Desktop d'envoyer ces nouvelles informations au serveur MCP.
Ensuite, ouvrez Cursor et demandez quelle pile technologique sera utilisée pour le nouveau projet. Veillez à indiquer d'utiliser uniquement MCP et d'éviter de consulter le répertoire du projet pour obtenir des informations supplémentaires.
Résultats des tests :
Lorsque l'appel MCP est effectué, le système se retrouve confus, récupérant simultanément les deux piles technologiques : la pile MERN du projet précédent et Next.js du nouveau.
Cela montre que le système MCP n'a pas pu faire la distinction entre les contextes des deux projets.
Ainsi, bien que le système MCP puisse stocker des données entre les sessions, il peut occasionnellement mélanger des informations provenant de différents projets.
Réflexions finales
Bien que le système MCP constitue un bon point de départ, il nécessite une meilleure séparation de la mémoire pour les projets similaires afin d'éviter les chevauchements de données. Il fonctionne bien pour les projets uniques ou ceux ayant des noms distincts, mais des améliorations au niveau de l'exécution des requêtes et de la gestion de la mémoire le rendraient encore plus performant.
Quelles sont les autres applications de Memory MCP ?
1. Assistant de recherche multi-agents avec une couche de mémoire
Plusieurs agents LLM se spécialisent dans différents domaines de recherche (par exemple, articles universitaires, dépôts GitHub, actualités). Chaque agent stocke ses résultats en mémoire, que l'agent maître peut ensuite interroger pour obtenir des informations contextuelles pertinentes.
Exemple concret : Anthropic Système de recherche multi-agents. 7
2. Assistant de réunion avec mémoire inter-sessions persistante
Un assistant stocke les résumés de réunion, les points d'action et les notes clés, et retrouve le contexte pertinent pour les réunions futures.
Exemple concret : Otter.ai est un assistant de réunion qui capture les points clés et les réutilise lors des sessions suivantes pour maintenir le contexte. Pour en savoir plus sur Otter.ai, consultez : Prise de notes IA
3. Assistant de codage agentiel qui évolue avec l'utilisation
Des assistants de programmation qui apprennent des habitudes d'utilisation et stockent des solutions aux problèmes récurrents, récupérant et appliquant automatiquement les solutions précédentes pour améliorer la productivité.
Exemple concret : GitHub Copilot, un assistant de programmation qui apprend du style de code du développeur. Pour en savoir plus sur les agents cognitifs, consultez : Mémoire des agents d’IA .
Liens de référence
À lire ensuite
Automatisation MSP : Acronis, ConnectWise Automate & Rewst
Exécution de code avec MCP : une nouvelle approche de l'efficacité des agents d'IA
Centralisation de l'accès aux outils d'IA avec la passerelle MCP
Soyez le premier à commenter
Votre adresse courriel ne sera pas publiée. Tous les champs sont obligatoires.