Comment installer et utiliser le serveur et l'API OpenMemory MCP

En tant que développeurs, vous recherchez des solutions de mémoire puissantes qui garantissent également la confidentialité des données, le contrôle et une interopérabilité fluide entre les outils d'IA. La tendance favorise clairement les systèmes de mémoire axés sur le développeur et privilégiant le local. Le concept de Serveur OpenMemory MCP, mis en œuvre par des technologies telles que le framework open-source Mem0, mène ce changement. Il offre une couche de mémoire privée et locale, permettant aux agents d'IA de se souvenir du contexte entre les applications, tandis que vos données restent en sécurité sur votre machine. Ce guide est destiné aux développeurs comme vous. Il s'agit d'une procédure pas à pas complète sur l'installation des composants essentiels à l'aide de Mem0, l'exécution de votre propre Serveur OpenMemory MCP local et l'utilisation habile de son API REST pour créer des applications d'IA plus intelligentes et contextuelles.

Commençons à déverrouiller la mémoire d'IA locale et persistante.

Étape 1 : Préparation de votre environnement de développement

Avant de plonger dans l'installation, il est essentiel d'avoir vos outils de développement de base prêts et de comprendre les composants principaux avec lesquels nous allons travailler. Nous utiliserons principalement le framework open-source Mem0 polyvalent pour établir, puis interagir avec notre Serveur OpenMemory MCP local. Cette interaction se fera en grande partie via son API REST, offrant un moyen standardisé de gérer la mémoire de votre IA.

Vous aurez besoin d'un environnement Python récent, de préférence la version 3.8 ou ultérieure, pour garantir une compatibilité totale avec Mem0 et ses dépendances. Vous pouvez télécharger la dernière version de Python sur python.org. En plus de Python, vous aurez besoin de pip, l'installateur de packages Python, qui est crucial pour l'installation de Mem0 et qui est généralement fourni avec les installations de Python. La bibliothèque Python mem0ai sera notre moteur ; sa nature open-source vous permet d'exécuter un serveur local qui devient effectivement votre Serveur OpenMemory MCP. Cette configuration complète donne la priorité à l'exécution du serveur de mémoire sur votre machine locale, vous donnant un contrôle total sur vos données et vos opérations, un principe clé de la philosophie OpenMemory. Le serveur expose ensuite ses fonctionnalités via une API REST, avec des points de terminaison pour ajouter, rechercher et gérer les mémoires qui s'alignent sur les opérations standard définies par le Model Context Protocol (MCP).

Conseil de pro : L'utilisation d'environnements virtuels (comme venv ou conda) est une bonne initiative. Cela permet de gérer les dépendances du projet et d'éviter les conflits avec d'autres projets Python.

Étape 2 : Comment installer le framework Mem0

L'installation du package mem0ai est votre première étape pratique vers la mise en place d'un serveur de mémoire d'IA local. Cela se fait avec une simple commande qui équipe votre système de la bibliothèque Mem0 de base et de tous les composants nécessaires.

Ouvrez votre terminal (et activez votre environnement virtuel si vous en utilisez un). Ensuite, exécutez la commande d'installation :

pip install mem0ai

Cette commande installe la bibliothèque mem0ai, qui inclut la classe Memory de base pour la gestion directe de la mémoire en Python. Vous bénéficiez également d'une prise en charge de divers modèles de langage volumineux (LLM) et de bases de données vectorielles, ainsi que des composants FastAPI et Uvicorn nécessaires pour exécuter le serveur d'API REST Mem0. Une fois l'installation terminée, vous pouvez la vérifier en vérifiant la version du package installé avec pip show mem0ai, ou en essayant une importation rapide dans une session Python :

import mem0
print(mem0.__version__)

pip gère également automatiquement l'installation des dépendances requises telles que FastAPI (pour la création de l'API), Uvicorn (en tant que serveur ASGI) et diverses bibliothèques de gestion des données. Avec mem0ai installé, vous disposez du logiciel de base. Vous pouvez utiliser la bibliothèque directement dans les scripts Python pour les opérations de mémoire, mais pour l'aspect « serveur » avec lequel les clients MCP peuvent interagir, nous utiliserons sa fonctionnalité de serveur intégrée.

Étape 3 : Comment configurer votre serveur de mémoire local

Avant de démarrer le serveur, vous avez la possibilité de configurer son instance Mem0 sous-jacente. Cette configuration est essentielle car elle détermine quel modèle de langage volumineux (LLM), quelle base de données vectorielle et quel modèle d'intégration alimenteront le traitement et les capacités de récupération de la mémoire de votre serveur, vous personnalisez essentiellement son « cerveau ».

Le serveur Mem0 (et la classe Memory sur laquelle il est basé) est principalement configuré à l'aide de variables d'environnement. Il s'agit d'une approche flexible qui vous permet de configurer votre backend sans modifier aucun code. Par exemple, pour configurer le LLM, vous pouvez définir OPENAI_API_KEY pour OpenAI, ANTHROPIC_API_KEY pour Anthropic, ou des variables comme MEM0_LLM_PROVIDER="ollama" pour les modèles locaux via Ollama. De même, pour la base de données vectorielle, bien que Mem0 utilise par défaut LanceDB (qui est local et ne nécessite aucune configuration supplémentaire), vous pouvez spécifier des alternatives comme Qdrant à l'aide de variables telles que MEM0_VECTOR_STORE_PROVIDER="qdrant". Les configurations du modèle d'intégration sont souvent liées à votre fournisseur LLM, mais peuvent également être spécifiées indépendamment.

Si vous ne définissez aucune variable d'environnement spécifique, Mem0 tente d'utiliser des valeurs par défaut raisonnables. Cependant, il peut nécessiter une clé OpenAI pour son LLM par défaut si elle n'est pas spécifiée autrement. Ces choix ont un impact significatif sur votre serveur : le LLM affecte la façon dont les mémoires sont comprises, tandis que la base de données vectorielle influence l'efficacité du stockage et la vitesse de recherche. Pour une liste complète de toutes les variables d'environnement et options configurables pour différents LLM, magasins vectoriels et intégrateurs, consultez toujours la documentation officielle de Mem0.

Conseil de pro : Commencez par une configuration locale simple (comme Ollama pour LLM et LanceDB par défaut). Cela vous aide à vous familiariser avec le système. Ensuite, explorez des configurations plus avancées à mesure que vos besoins évoluent.

Étape 4 : Comment exécuter votre Serveur OpenMemory MCP

Avec mem0ai installé et (facultativement) configuré à votre convenance, vous pouvez maintenant démarrer le processus du serveur local. Ce serveur est ce qui expose les points de terminaison de l'API REST, permettant à d'autres applications ou scripts d'effectuer des opérations de mémoire.

Le package mem0ai propose un script de ligne de commande pratique pour exécuter le serveur. Dans votre terminal, tapez simplement :

mem0-server

Vous pouvez également spécifier un hôte et un port personnalisés si nécessaire, par exemple : mem0-server --host 127.0.0.1 --port 8000. La valeur par défaut est généralement 0.0.0.0 (toutes les interfaces réseau disponibles) sur le port 8000. Une fois démarré, Uvicorn (le serveur exécutant votre application FastAPI) affichera des journaux dans la console, indiquant que le serveur est en cours d'exécution et en attente de requêtes. Vous verrez des messages tels que : INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit).

Votre Serveur OpenMemory MCP est maintenant en cours d'exécution localement ! Les clients compatibles MCP, s'ils sont configurés pour pointer vers http://localhost:8000 (ou votre adresse personnalisée), peuvent interagir avec lui. Vous pouvez également utiliser directement son API REST, que nous allons explorer ensuite. Pour arrêter le serveur, appuyez simplement sur CTRL+C dans le terminal où il est en cours d'exécution. La commande mem0-server lance essentiellement un serveur Uvicorn ASGI, qui exécute l'application FastAPI définie dans Mem0. Cette application héberge les points de terminaison de l'API REST, et cette instance en cours d'exécution est votre Serveur OpenMemory MCP local.

Étape 5 : Compréhension des capacités de l'API du serveur

Le serveur Mem0 fournit une API REST complète qui vous permet de gérer par programme les mémoires d'IA. Cette API adhère aux principes de base du Model Context Protocol en offrant des moyens standardisés d'ajouter, de rechercher, de lister et de supprimer des informations.

L'API utilise les protocoles HTTP/HTTPS standard, et JSON est le format de données pour les corps des requêtes et des réponses. Si vous exécutez le serveur localement avec les paramètres par défaut, votre URL de base sera http://localhost:8000. Les opérations de base disponibles via l'API (basées sur les implémentations typiques de l'API REST Mem0) incluent POST /add pour stocker de nouvelles informations, POST /search pour récupérer les mémoires pertinentes, GET /get_all pour lister plusieurs mémoires (avec des options de filtre), GET /get pour récupérer une seule mémoire par son ID, PUT /update pour modifier une mémoire existante, DELETE /delete pour supprimer une mémoire spécifique et DELETE /delete_all pour effacer les mémoires, potentiellement filtrées par utilisateur.

Par défaut, le mem0-server exécuté localement n'implémente pas l'authentification, car il est principalement destiné au développement et à l'utilisation locaux. Si vous deviez envisager des déploiements de production ou exposés (ce qui n'est pas recommandé sans couches de sécurité supplémentaires importantes), l'authentification serait un aspect essentiel à mettre en œuvre.

Conseil de pro : Vous pouvez souvent explorer l'API de manière interactive. Essayez de visiter http://localhost:8000/docs dans votre navigateur une fois le serveur démarré. Le serveur FastAPI de Mem0 propose généralement cette page de documentation utile via Swagger UI.

Étape 6 : Comment ajouter des mémoires à l'aide de l'API

Le point de terminaison /add est votre principal outil pour ingérer des données dans le serveur de mémoire. Il vous permet de stocker des informations textuelles, de les associer à un utilisateur spécifique et d'inclure des métadonnées facultatives pour une meilleure organisation et récupération.

Pour l'utiliser, vous envoyez une requête POST au point de terminaison /add. Le corps de la requête doit être JSON et inclure data (le contenu de la mémoire sous forme de chaîne), user_id (un identifiant pour l'utilisateur associé à cette mémoire – crucial pour organiser et récupérer les mémoires spécifiques à l'utilisateur) et, facultativement, metadata (un objet JSON contenant toutes les paires clé-valeur supplémentaires que vous souhaitez stocker, comme {"source": "chat_log"}).

Voici un exemple utilisant curl :

curl -X POST http://localhost:8000/add \
-H "Content-Type: application/json" \
-d '{
    "data": "Alice préfère Python pour le développement web.",
    "user_id": "user_alice",
    "metadata": {"topic": "preferences", "language": "Python"}
}'

Et voici comment vous pourriez le faire avec la bibliothèque Python requests :

import requests
import json

url = "http://localhost:8000/add"
payload = {
    "data": "Alice préfère Python pour le développement web.",
    "user_id": "user_alice",
    "metadata": {"topic": "preferences", "language": "Python"}
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, data=json.dumps(payload), headers=headers)
print(response.json())

Le serveur répondra avec JSON confirmant l'ajout, incluant souvent l'ID unique de la mémoire nouvellement créée, par exemple : {"message": "Memory added successfully", "memory_id": "some-unique-id"}. Chaque appel à /add crée un nouvel enregistrement de mémoire. Le user_id est essentiel pour les applications multi-utilisateurs ou pour la séparation du contexte, et les métadonnées améliorent considérablement la possibilité de recherche et l'organisation.

Étape 7 : Comment rechercher des mémoires stockées via l'API

Une fois les mémoires stockées, le point de terminaison /search vous permet d'effectuer des recherches sémantiques. Cela signifie que vous pouvez récupérer des informations pertinentes par rapport à une requête et à un contexte utilisateur donnés, même si vos termes de recherche ne correspondent pas exactement au texte stocké.

Vous envoyez une requête POST à /search avec un corps JSON contenant la chaîne query, le user_id dont vous souhaitez rechercher les mémoires et des paramètres facultatifs comme filters (pour des critères plus spécifiques, basés sur les champs de métadonnées – la structure exacte dépend de l'implémentation de Mem0) et limit (pour limiter le nombre de résultats de recherche).

Un exemple curl ressemble à ceci :

curl -X POST http://localhost:8000/search \
-H "Content-Type: application/json" \
-d '{
    "query": "Quelles sont les préférences linguistiques d'Alice ?",
    "user_id": "user_alice",
    "limit": 3
}'

Utilisation de Python requests :

import requests
import json

url = "http://localhost:8000/search"
payload = {
    "query": "Quelles sont les préférences linguistiques d'Alice ?",
    "user_id": "user_alice",
    "limit": 3
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, data=json.dumps(payload), headers=headers)
print(response.json())

La réponse attendue est un tableau JSON d'objets de mémoire qui correspondent à la requête de recherche. Ces objets incluent généralement le contenu de la mémoire, ses métadonnées et un score de pertinence indiquant à quel point il correspondait à la requête, par exemple :
[{"id": "some-unique-id", "data": "Alice préfère Python pour le développement web.", ..., "score": 0.85}].

Conseil de pro : L'utilisation correcte de user_id dans les recherches est essentielle. Il garantit que les utilisateurs ne récupèrent que leurs propres mémoires pertinentes, ce qui est essentiel pour maintenir la confidentialité et offrir des expériences personnalisées.

Étape 8 : Comment récupérer des mémoires spécifiques avec l'API

Au-delà de la recherche, l'API fournit des points de terminaison pour lister plusieurs mémoires ou récupérer une seule mémoire spécifique par son identifiant unique. Ceux-ci sont utiles pour parcourir la banque de mémoire ou accéder directement à des informations connues.

Pour lister plusieurs mémoires, vous utilisez le point de terminaison GET /get_all. Vous pouvez passer des paramètres de requête comme user_id pour filtrer les mémoires par utilisateur, limit pour spécifier le nombre de mémoires à renvoyer et page pour la pagination s'il y a beaucoup de mémoires. Par exemple, curl -X GET "http://localhost:8000/get_all?user_id=user_alice&limit=5" récupérerait les 5 premières mémoires pour « user_alice ». La réponse sera un tableau JSON d'objets de mémoire.

Pour obtenir une mémoire spécifique, utilisez GET /get avec un paramètre de requête memory_id : curl -X GET "http://localhost:8000/get?memory_id=some-unique-id". Cela renverra un objet JSON représentant cette seule mémoire, ou une erreur si elle n'est pas trouvée.

Voici comment utiliser Python requests pour /get_all :

import requests

url = "http://localhost:8000/get_all"
params = {"user_id": "user_alice", "limit": 5}
response = requests.get(url, params=params)
print(response.json())

Le point de terminaison /get_all est particulièrement adapté aux tâches administratives ou lorsque vous devez parcourir la mémoire d'un utilisateur. /get est votre solution lorsque vous avez déjà l'ID d'une mémoire, peut-être à partir d'une réponse /add ou d'un résultat de recherche précédent.

Étape 9 : Comment mettre à jour et supprimer des mémoires à l'aide de l'API

Pour garantir que la base de connaissances de votre IA reste précise et pertinente, l'API fournit les contrôles nécessaires pour mettre à jour les enregistrements de mémoire existants ou les supprimer entièrement.

Pour mettre à jour une mémoire, envoyez une requête PUT à /update avec le memory_id comme paramètre de requête. Le corps de la requête doit être JSON et peut inclure de nouvelles data (contenu textuel) ou de nouvelles metadata (qui remplaceront les métadonnées existantes pour cette mémoire). Par exemple :

curl -X PUT "http://localhost:8000/update?memory_id=some-unique-id" \
-H "Content-Type: application/json" \
-d '{"data": "Alice apprécie désormais également Go pour la programmation système."}'

Pour supprimer une mémoire spécifique, utilisez une requête DELETE à /delete avec le memory_id comme paramètre de requête : curl -X DELETE "http://localhost:8000/delete?memory_id=some-unique-id".

Pour un nettoyage plus large, le point de terminaison DELETE /delete_all peut être utilisé. Si vous fournissez un paramètre de requête user_id (par exemple, curl -X DELETE "http://localhost:8000/delete_all?user_id=user_alice"), il supprimera toutes les mémoires pour cet utilisateur spécifique. Si le user_id est omis, le comportement pourrait être de supprimer toutes les mémoires du système, alors utilisez-le avec une extrême prudence et vérifiez toujours son comportement exact dans la documentation Mem0. Le serveur répondra généralement avec des messages JSON confirmant le succès ou l'échec de ces opérations.

Conseil de pro : Implémentez toujours des vérifications minutieuses et des confirmations utilisateur dans la logique de votre application avant d'appeler les points de terminaison de suppression, en particulier delete_all, pour éviter toute perte de données accidentelle.

Conclusion

Vous avez maintenant parcouru les étapes essentielles de la configuration d'un Serveur OpenMemory MCP local avec le framework open-source Mem0 et de l'utilisation de son API REST. En suivant ces instructions pour installer Mem0, exécuter le serveur et interagir avec son API, vous gagnez un contrôle direct sur la mémoire de vos applications d'IA. Cela favorise de nouveaux niveaux de persistance, de personnalisation et de confidentialité. La possibilité de gérer par programme les mémoires localement ouvre de vastes possibilités pour des systèmes plus intelligents et contextuels, des chatbots qui se souviennent des préférences des utilisateurs aux assistants de développement qui se souviennent des détails du projet. La possibilité de créer une mémoire d'IA locale et basée sur l'API est désormais la vôtre. Expérimentez avec cette API et commencez à créer des applications d'IA qui apprennent et évoluent réellement.