top of page

Neo4j lance Relate pour la mémoire locale des agents IA

il y a 4 jours
15 min de lecture
Illustrative photograph. Photo: cottonbro studio / Pexels.

Neo4j a lancé Relate le 11 novembre, en intégrant une base de données graphe écrite en Rust aux applications IA sans nécessiter de serveur de base de données distinct. Neo4j Relate stocke localement les faits et leurs relations, offrant aux développeurs une autre option entre les fichiers temporaires de l’application et un service de base de données partagé. Ce choix implique un compromis concret : moins de travail de déploiement, mais une capacité et une coordination liées à l’application qui l’exécute.

Une base de données embarquée s’exécute au sein du processus d’une application et partage son cycle de vie ainsi que ses ressources de calcul. SQLite a établi ce modèle pour les données relationnelles, qui organisent les informations en tables. Relate l’applique aux graphes, qui représentent des entités et les connexions entre elles.

Ce lancement est donc pertinent pour les développeurs qui créent des agents, des logiciels utilisant des modèles et des outils pour accomplir des tâches. Un assistant de programmation qui analyse des dépendances n’a pas les mêmes besoins de stockage qu’un système à l’échelle de l’entreprise gérant des données métier. Relate offre à Neo4j un produit directement destiné à cette unité de travail plus restreinte et locale.

Neo4j Relate intègre le stockage en graphes à l’application

Relate change l’emplacement où les développeurs peuvent déployer une base de données graphe, en faisant du stockage local une option explicite pour les charges de travail des agents.

Le lancement de la base de données embarquée de Neo4j présente Relate comme une implémentation Rust open source publiée sous licence Apache License 2.0. L’annonce date du 11 novembre, et non du 13 novembre, date associée à la couverture publiée ultérieurement. Neo4j l’a présenté parallèlement à ses activités NODES 2026.

Le produit prend en charge le stockage temporaire en mémoire et le stockage persistant, qui conserve les informations après la fermeture d’une application. Le qualifier uniquement de base de données en mémoire occulte cette distinction. Son moteur de requêtes travaille avec un graphe en mémoire, tandis que le stockage sur disque peut préserver les informations nécessaires à sa réouverture.

Cette architecture compte parce que les données de travail d’un agent ne justifient pas toujours un service permanent. Une analyse de dépendances, une revue de documents ou une tâche de développement isolée ont un début et une fin. Les développeurs peuvent raisonnablement souhaiter que leur base de données suive le même cycle de vie.

Prenons le cas d’un développeur cherchant à comprendre pourquoi une application dépend d’un package obsolète. Une simple liste enregistre les packages concernés. Un graphe indique aussi quel package a introduit chaque dépendance, ce qui rend la chaîne disponible pour des questions ultérieures.

Le graphe ne permet pas d’établir qu’un package est dangereux. Il représente les connexions fournies par les données sources. Sa valeur vient de sa capacité à laisser le logiciel suivre ces connexions sans les reconstruire à répétition à partir de fichiers distincts.

Relate propose donc un choix de déploiement différent de l’exécution de Neo4j comme service partagé. Les développeurs peuvent placer le moteur à côté de l’application qui en a besoin. Cela réduit le nombre de composants distincts à organiser avant de poser une question adaptée à un graphe.

Cette distinction évite également une interprétation trompeuse de l’implémentation Rust. Ce lancement ne démontre pas que Neo4j a remplacé ses produits serveur existants par un équivalent en Rust. Relate possède son propre modèle d’exploitation, son périmètre et ses limites.

Pour les développeurs, le changement significatif réside dans l’accès à une unité de déploiement plus petite. Ils peuvent évaluer l’usage d’un graphe pour une tâche donnée sans engager d’emblée cette tâche dans une architecture de base de données plus large.

Un déploiement local modifie également l’attribution du travail opérationnel. L’équipe applicative décide quand créer, conserver, rouvrir ou supprimer ses données. Ces décisions se rapprochent de la fonctionnalité qui utilise la base de données.

Cette proximité peut simplifier un projet délimité. Elle fait aussi des décisions de cycle de vie une composante de la conception applicative. Une investigation temporaire et un assistant durable ne devraient pas adopter le même comportement de rétention simplement parce qu’ils partagent un même moteur.

Les développeurs d’agents font face à une décision de stockage différente

Relate remet en question l’hypothèse selon laquelle une mémoire d’agent connectée exige un service de base de données exploité séparément.

Le public immédiat est constitué de développeurs dont les agents travaillent dans un dépôt, une application, un notebook ou un environnement d’exécution isolé. Leur problème est souvent plus limité que la maintenance du système de connaissances permanent d’une organisation. Ils ont besoin qu’un contexte utile soit disponible lors de l’exécution d’une tâche.

Un service de base de données distinct ajoute des décisions relatives à l’accès, au déploiement, à la connectivité et à la propriété. Ces décisions peuvent se justifier lorsque plusieurs applications ont besoin des mêmes enregistrements. Elles peuvent sembler disproportionnées lorsque les données n’existent que pour soutenir une investigation locale.

Les fichiers temporaires évitent une grande partie de cette configuration. Ils laissent toutefois à l’application la responsabilité de représenter les connexions, de valider les mises à jour et de retrouver les informations pertinentes. À mesure que ces exigences s’étendent, le code de stockage occupe une part plus importante de l’agent lui-même.

Aucune de ces approches n’est intrinsèquement erronée. Une petite collection de paramètres peut rester dans un fichier. Un système métier partagé peut avoir sa place dans un service administré. Relate cible l’espace où les relations comptent, mais où un service distinct apporte plus de mécanismes que la tâche n’en exige.

SQLite offre une référence historique utile. Son modèle de base de données sans serveur place le moteur dans l’application plutôt que derrière un processus serveur intermédiaire. Cette organisation supprime l’administration du serveur tout en modifiant les frontières d’isolation et de coordination.

Relate pose la même question de placement pour les charges de travail fondées sur les graphes. Les développeurs doivent déterminer si leur application bénéficie de relations directement disponibles dans son propre processus. La réponse dépend du travail à effectuer, plutôt que de la popularité des agents.

Un assistant examinant l’historique d’un projet fournit un cas illustratif. Les fichiers, modifications, tickets et responsables forment un ensemble d’enregistrements connectés. Un graphe local pourrait faciliter les questions sur les modifications ayant affecté un composant et les tickets expliquant les décisions prises.

Cet exemple n’établit pas un avantage de précision par rapport aux outils existants. Il identifie une charge de travail où la représentation correspond à la question. Le bénéfice de déploiement n’existe que si la maintenance de ce graphe demande moins d’efforts que les alternatives.

Cette pression concerne aussi les équipes qui créent des frameworks d’agents, lesquels fournissent des logiciels réutilisables pour coordonner modèles et outils. Elles doivent choisir entre proposer des paramètres locaux par défaut et supposer un backend de stockage externe. Une option locale peut faciliter l’expérimentation, mais elle doit toujours présenter un comportement prévisible.

Les acheteurs en entreprise sont confrontés à une question de frontière similaire. Ils devraient distinguer le contexte de travail temporaire d’un agent des enregistrements faisant autorité que l’organisation gouverne. Copier un sous-ensemble utile dans une base de données locale ne transfère pas la propriété des informations d’origine.

Les travailleurs du savoir sont également concernés par cette distinction. Une réponse fondée sur des données de travail locales devrait indiquer clairement si les informations sont actuelles et complètes. L’utilisateur fait l’expérience de la réponse, quel que soit l’emplacement d’exécution de la base de données.

Pour les lecteurs qui comparent les bases de connaissances personnelles, la même question de propriété s’applique. Une récupération utile dépend de la compréhension des informations détenues par le système, de leur évolution et de ce que ses limites excluent.

La mémoire connectée rend les relations disponibles aux requêtes

Un graphe rend les relations interrogeables, mais l’application détermine toujours quelles relations méritent d’exister.

Le mécanisme technique est simple. Les entités deviennent des nœuds, et les connexions deviennent des relations. Un agent peut interroger une chaîne de connexions plutôt que de récupérer des enregistrements séparés et d’assembler lui-même cette chaîne.

Cypher, un langage de requête pour graphes, exprime ces motifs. Une question de dépendance peut suivre des connexions depuis une application, à travers des packages, jusqu’à un avis. Le résultat dépend de la présence dans le graphe des packages, versions et relations avec les avis pertinents.

Cela diffère de la recherche par similarité, qui récupère des éléments selon la proximité entre leurs représentations et une requête. Une formulation similaire peut permettre de trouver un document utile. Elle n’établit pas automatiquement que ce document régit une décision ou une dépendance donnée.

Neo4j présente Relate comme un moyen de combiner les requêtes relationnelles et la récupération par similarité. Cette orientation produit cible une faiblesse pratique de la mémoire des agents : trouver des éléments pertinents n’est qu’une partie de la compréhension de leur rôle.

Un assistant de projet illustratif pourrait récupérer une note traitant d’un fournisseur d’authentification. Une relation avec une décision ultérieure pourrait montrer que l’équipe a ensuite choisi un autre fournisseur. Sans cette connexion, une ancienne note pertinente peut malgré tout étayer une réponse obsolète.

Le graphe ne découvre pas la décision ultérieure par définition. Une application doit l’ingérer, identifier le sujet et représenter sa relation avec les éléments antérieurs. Si ce processus échoue, le graphe peut conserver une image incomplète.

Cette réserve importe parce que la « mémoire » décrit plusieurs exigences différentes. Se souvenir d’un fait n’est pas la même chose que préserver sa source. Préserver une source n’est pas la même chose que reconnaître qu’une décision plus récente la remplace.

Le modèle de graphe de Relate offre un endroit pour exprimer ces distinctions. Le développeur reste responsable du choix des distinctions pertinentes pour l’application. La flexibilité du stockage ne remplace pas un modèle d’information.

La démonstration de mémoire d’agent de Neo4j illustre le cycle de vie prévu à travers une analyse de dépendances. L’entreprise décrit Claude Code examinant l’Agent Development Kit de Google au moyen de graphes distincts et jetables. La démonstration couvre 24 dépendances directes et tire les informations de dépendances de deps.dev.

Il s’agit d’une démonstration du fournisseur, et non d’un benchmark indépendant. Son détail utile réside dans la forme de la tâche : créer des graphes délimités, examiner les connexions, présenter les résultats et supprimer les bases de données.

L’exemple précise également pourquoi le stockage local et la structure en graphe relèvent de la même discussion. Une investigation riche en relations peut être temporaire. Les développeurs n’ont pas nécessairement besoin de transformer ses données de travail en un service partagé permanent.

Toutefois, le stockage temporaire accorde davantage de poids au rapport final. Si la base de données disparaît, le rapport doit conserver suffisamment d’éléments pour permettre à quelqu’un d’évaluer les conclusions. Sans cela, une investigation pratique devient difficile à reproduire.

Un graphe persistant modifie cet équilibre. Il peut conserver les relations pour des travaux ultérieurs, mais la fraîcheur, la rétention et la correction deviennent alors des responsabilités continues. L’application a gagné une mémoire et hérité de sa maintenance.

Le même raisonnement s’applique aux assistants documentaires. Une connexion entre une affirmation et le document qui l’étaye peut aider à expliquer une réponse. Cette connexion devrait survivre aux révisions d’une manière qui en rend le sens clair.

C’est là que la promesse devient concrète. La mémoire connectée donne au logiciel une structure pour poser de meilleures questions sur les éléments disponibles. Elle ne garantit pas que ces éléments sont corrects, complets ou interprétés de manière appropriée.

L’exécution locale échange la surcharge du service contre des limites de mémoire

Le modèle local de Relate supprime une frontière de déploiement tout en imposant une limite de capacité claire : le graphe ouvert doit tenir en mémoire.

L’architecture de graphe local du produit décrit un moteur conçu pour un graphe détenu par une application, un agent ou un outil sur une machine. Le graphe réside en mémoire. Le disque assure la durabilité plutôt que de servir de couche d’analyse des requêtes du moteur.

Cette distinction sépare la capacité de stockage de la capacité de travail. Écrire des données sur disque ne signifie pas que l’application peut interroger un graphe plus grand que la mémoire disponible. Les développeurs doivent donc dimensionner le graphe de travail en conséquence.

Pour une investigation limitée, cette contrainte peut encourager une discipline utile. L’application charge les informations pertinentes pour la tâche plutôt que de copier tout l’historique d’une organisation. Un ensemble de travail plus restreint peut aussi rendre son périmètre plus facile à expliquer.

Pour un assistant censé tout mémoriser indéfiniment, cette même limite devient plus exigeante. Les informations s’accumulent, les relations se multiplient et l’application rivalise avec d’autres logiciels pour la mémoire. La politique de rétention devient un élément de la planification des capacités.

L’alternative, un service distinct, crée d’autres compromis. Elle peut dissocier les opérations de base de données du cycle de vie de l’application et permettre un accès partagé via une frontière centrale. Elle exige aussi de la connectivité et une gestion du service.

Il s’agit de choix architecturaux plutôt que d’étapes sur une échelle universelle. Une base de données locale n’est pas automatiquement un prototype destiné à devenir un service. Certaines applications gagnent à rester locales parce que leurs données et leurs utilisateurs le restent aussi.

À l’inverse, une application peut dépasser la propriété locale avant que son graphe ne devienne volumineux. Plusieurs systèmes indépendants peuvent devoir mettre à jour les mêmes enregistrements. Une équipe peut exiger que la base de données reste disponible pendant le redémarrage d’une application.

La bonne frontière dépend donc autant de la coordination que de la taille. Qui écrit les informations, qui doit les lire et qui gère les défaillances sont autant de questions importantes. Compter les enregistrements ne suffit pas à y répondre.

Les affirmations de performance exigent la même prudence. Neo4j annonce un démarrage en millisecondes et des lectures en mémoire inférieures à la milliseconde. Ces déclarations reflètent les affirmations de l’entreprise, plutôt qu’une garantie vérifiée indépendamment pour une charge de travail d’agent donnée.

Un développeur qui évalue ces affirmations doit distinguer le démarrage d’un moteur vide de la réouverture d’un stockage déjà rempli. Charger des données, construire des structures de recherche, exécuter des requêtes et générer des réponses de modèle sont des opérations différentes. Leurs coûts ne devraient pas disparaître derrière une seule affirmation de rapidité.

La comparaison la plus utile maintiendrait constante la tâche de l’application. Elle inclurait les mêmes données source, questions, exigences de durabilité et attentes de sortie. Sans cela, une requête locale plus rapide pourrait s’accompagner d’un flux de travail global plus lent.

La consommation mémoire doit également figurer dans cette comparaison. Un agent ne reçoit pas des ressources illimitées simplement parce que sa base de données s’exécute localement. La base de données partage la machine avec l’application et tous les autres logiciels qui soutiennent la tâche.

Un déploiement local peut réduire la surcharge de communication, mais il n’élimine pas le travail de traitement. Les requêtes doivent toujours trouver, filtrer et renvoyer les informations. La taille et la structure du graphe restent pertinentes.

Pour les équipes produit, Relate constitue donc une option à évaluer face à une tâche définie. Son avantage crédible réside dans un déploiement plus simple pour des charges de travail adaptées. Les affirmations de supériorité générale exigent des preuves allant au-delà de l’architecture elle-même.

Les transactions protègent les mises à jour, pas la vérité de la mémoire d’un agent

La cohérence de la base de données et la fiabilité des agents sont des affirmations distinctes, et Relate devrait être évalué sur ces deux plans.

Une transaction regroupe les modifications de base de données afin qu’un logiciel puisse les appliquer selon un comportement de cohérence défini. Cela aide à empêcher que des mises à jour incomplètes ne deviennent visibles comme un travail terminé. Cela n’établit pas que les faits écrits sont vrais.

Un agent peut stocker fidèlement une conclusion erronée. Un autre agent peut la récupérer via une relation valide et répéter l’erreur. Un comportement correct de la base de données peut donc préserver des connaissances applicatives incorrectes.

La même distinction s’applique aux informations contradictoires. Une base de données peut conserver à la fois une ancienne décision et une nouvelle décision. L’application doit représenter quelle décision régit la tâche en cours et pourquoi.

Les limites opérationnelles documentées de Relate encadrent également l’accès partagé. Un stockage persistant dispose d’un seul processus d’écriture. Les transactions au sein de ce processus peuvent rencontrer des conflits, et le moteur ne réessaie pas automatiquement les écritures conflictuelles.

La présence de plusieurs agents n’implique donc pas un nombre illimité de processus indépendants pouvant écrire dans la base de données. Les développeurs doivent distinguer les agents coordonnés via un processus partagé de processus séparés ouvrant le même stockage persistant. Ces configurations présentent des comportements de défaillance différents.

Cela est particulièrement pertinent lorsque les systèmes d’agents répartissent le travail entre des tâches parallèles. Un planificateur peut attribuer les responsabilités pendant que des travailleurs enregistrent l’avancement. Si l’application suppose que chaque écriture réussit, sa vision des responsabilités peut diverger de la réalité.

La base de données peut signaler un conflit. L’application doit toujours disposer d’une politique pour interpréter ce résultat. Réessayer, relire ou abandonner une action peuvent tous être raisonnables, selon ce que représente l’écriture.

La durabilité introduit une autre distinction. Le modèle de durabilité du stockage décrit un journal d’écriture anticipée, un enregistrement des modifications utilisé pour la récupération. Son mode de durabilité complète par défaut synchronise le journal avant d’accuser réception d’une validation. Les modes assouplis acceptent différentes fenêtres de perte.

C’est un choix d’ingénierie significatif, surtout pour la mémoire d’agent conservée. Une investigation jetable et un registre de décisions approuvées par l’utilisateur n’ont pas les mêmes conséquences si des écritures récentes disparaissent. Leurs paramètres de stockage devraient refléter ces conséquences.

La récupération des données diffère également de la récupération d’un flux de travail. Après un redémarrage, une application doit déterminer quelles actions externes ont été achevées. Un enregistrement de base de données préservé ne permet pas à lui seul d’établir si un appel d’outil a modifié un autre système avant une défaillance.

Il s’agit de questions d’évaluation plutôt que de preuves d’un défaut de Relate. Elles découlent de l’utilisation de toute base de données au sein d’un agent qui lit, raisonne et agit. Un nouveau moteur de stockage modifie certaines frontières tout en laissant intactes les responsabilités de l’application.

Le stockage local ne garantit pas non plus que les informations restent privées. Une requête de modèle, une intégration d’outil ou une fonctionnalité d’application peuvent toujours transmettre ailleurs le contenu récupéré. La confidentialité dépend de l’ensemble du trajet suivi par les données.

Pour les acheteurs, la question utile est donc plus précise que de savoir si le produit offre une mémoire locale. Ils doivent savoir quelles informations restent locales, quelles opérations quittent la machine et qui contrôle ces opérations.

Relate crée un emplacement inspectable pour stocker un contexte connecté. Sa contribution devrait être jugée séparément des affirmations selon lesquelles les agents deviennent dignes de confiance simplement en recevant un graphe. Une meilleure structure de mémoire est un apport à la fiabilité, non un substitut à son évaluation.

Surveiller les preuves de charge de travail, la coordination et l’utilisation durable

Les prochaines preuves devraient montrer si les développeurs conservent Relate dans des applications actives après l’expérimentation initiale.

Le premier signal est la preuve reproductible des charges de travail. Des évaluations utiles publieraient les données, les schémas de requêtes, les ressources machine et les paramètres de stockage à l’origine de leurs résultats. Elles devraient distinguer le démarrage du moteur, le chargement des données, l’exécution des requêtes et le temps nécessaire pour achever la tâche réelle de l’agent.

Cette distinction renforcerait le dossier en faveur de Relate si le déploiement local réduit le travail sans créer de coûts disproportionnés de chargement ou de mémoire. Des résultats limités à de petites bases de données vides étayeraient une conclusion plus restreinte. Aucun de ces résultats ne devrait être généralisé au-delà de la charge de travail testée.

Les comparaisons les plus solides examineraient aussi la qualité des réponses. Une requête relationnelle peut renvoyer exactement ce que contient la base de données tout en omettant une connexion importante que l’ingestion n’a jamais créée. Mesurer la vitesse sans vérifier l’exhaustivité utile laisse une partie de l’application non évaluée.

Pour une investigation de dépendances, le résultat pertinent est un compte rendu exact et traçable de la chaîne de dépendances. Pour un assistant documentaire, c’est une réponse fondée sur les bons enregistrements. La contribution de la base de données compte à travers ces résultats.

Le deuxième signal est une preuve concernant la coordination et la récupération. Les développeurs ont besoin d’exemples montrant ce qui se passe lorsque des écritures entrent en conflit, que les applications redémarrent et que les tâches reprennent. Une démonstration qui ne gère qu’une exécution ininterrompue laisse des questions opérationnelles sans réponse.

Ces preuves renforceraient la position de Relate si les applications peuvent gérer sa frontière de processus avec une coordination simple. Elles réduiraient les charges de travail adressables si les développeurs ajoutent à plusieurs reprises une infrastructure importante pour gérer cette frontière. Le produit n’a pas besoin de s’adapter à toutes les architectures pour justifier sa place.

La clarté de la documentation fait aussi partie de ce signal. Les développeurs devraient pouvoir savoir quelles interfaces et quels comportements sont pris en charge par leur version installée. Des limites claires peuvent faire gagner plus de temps d’ingénierie qu’un langage de compatibilité trop large.

Le troisième signal est l’utilisation durable dans des applications ayant des responsabilités continues en matière de données. Un graphe temporaire démontre une faible friction de mise en place. Un graphe entretenu au fil de l’évolution des sources démontre que les équipes ont trouvé un modèle de propriété viable.

Les preuves d’utilisation durable devraient expliquer ce que les développeurs ont choisi de préserver et ce qu’ils ont délibérément écarté. Cela révèle si la mémoire de graphe répond aux questions de l’application. Accumuler des informations sans raison ne revient pas à construire une mémoire utile.

L’implication commerciale découle de ces choix. Neo4j dispose désormais d’un point d’entrée pour les développeurs dont les besoins immédiats ne justifient pas un service de graphe distinct. La question de savoir si cela élargira l’adoption à long terme dépend des applications construites autour de cette offre.

Ce lancement donne également aux développeurs une raison de réexaminer d’anciennes hypothèses sur l’emplacement du stockage. Une base de données peut appartenir à une tâche, à une application ou à une organisation partagée. Relate rend les premières options plus visibles dans l’orientation produit de Neo4j.

Pour votre prochain projet d’agent, identifiez les relations qu’une réponse réussie doit suivre avant de choisir la couche de stockage. Décidez si ces relations relèvent d’une tâche temporaire ou d’un registre pérenne. Comparez ensuite le stockage de graphe local avec l’alternative la plus simple répondant aux mêmes exigences. Incluez l’utilisation de la mémoire, la récupération, le suivi des sources et l’effort nécessaire pour maintenir les informations à jour. Neo4j Relate mérite l’attention lorsque les données connectées et la propriété locale sont alignées. Commencez par une charge de travail limitée dont vous pouvez vérifier le résultat, puis évaluez si la base de données facilite la production et l’explication de ce résultat. Quelles connexions votre agent doit-il réellement mémoriser, et qui continuera d’en être responsable une fois la tâche terminée ?

 
 

Commencez pour Gratuit

Un premier assistant IA local avec gestion des connaissances personnelles

Pour une meilleure expérience IA,

remio ne supporte que Windows 10+ (x64) et M-Chip Macs actuellement.

Votre partenaire IA au travail
Faites-en plus avec remio

Planifiez. Créez. Livrez.
Tout au même endroit.

bottom of page