Neo4j lancia Relate per la memoria locale degli agenti AI
Neo4j ha rilasciato Relate l'11 novembre, portando un database a grafo Rust all'interno delle applicazioni AI senza richiedere un server di database separato. Neo4j Relate archivia localmente fatti e relative relazioni, offrendo agli sviluppatori un'altra opzione tra file applicativi temporanei e un servizio di database condiviso. La scelta introduce un compromesso pratico: meno lavoro di deployment, ma capacità e coordinamento legati all'applicazione che lo esegue.
Un database embedded viene eseguito all'interno del processo di un'applicazione, condividendone ciclo di vita e risorse di calcolo. SQLite ha affermato questo modello per i dati relazionali, che organizzano le informazioni in tabelle. Relate lo applica ai grafi, che rappresentano entità e connessioni tra di esse.
Questo rende il lancio rilevante per gli sviluppatori che creano agenti, software che usa modelli e strumenti per svolgere attività. Un assistente di programmazione che indaga sulle dipendenze necessita di uno storage diverso da un sistema aziendale che gestisce record commerciali. Relate offre a Neo4j un prodotto rivolto direttamente a quell'unità di lavoro più piccola e locale.
Neo4j Relate porta l'archiviazione a grafo nell'applicazione
Relate cambia il luogo in cui gli sviluppatori possono collocare un database a grafo, rendendo lo storage locale un'opzione esplicita per i carichi di lavoro degli agenti.
Il lancio del database embedded di Neo4j descrive Relate come un'implementazione Rust open source rilasciata con licenza Apache License 2.0. L'annuncio risale all'11 novembre, non al 13 novembre associato alla copertura successiva. Neo4j lo ha presentato insieme alle proprie attività NODES 2026.
Il prodotto supporta l'archiviazione temporanea in memoria e quella persistente, che conserva le informazioni dopo la chiusura di un'applicazione. Definirlo soltanto un database in-memory trascura questa distinzione. Il suo motore di query lavora con un grafo in memoria, mentre lo storage su disco può preservare le informazioni necessarie per riaprirlo.
Questa architettura è importante perché i dati di lavoro di un agente non meritano sempre un servizio permanente. Un'indagine sulle dipendenze, una revisione di documenti o un'attività di sviluppo isolata hanno un inizio e una fine. Gli sviluppatori possono ragionevolmente volere che il relativo database segua lo stesso ciclo di vita.
Consideriamo uno sviluppatore che indaga sul motivo per cui un'applicazione dipende da un pacchetto obsoleto. Un semplice elenco registra i pacchetti coinvolti. Un grafo registra anche quale pacchetto ha introdotto ogni dipendenza, rendendo la catena disponibile per domande successive.
Il grafo non stabilisce se un pacchetto sia insicuro. Rappresenta le connessioni fornite dai dati sorgente. Il suo valore deriva dal consentire al software di seguire tali connessioni senza ricostruirle ripetutamente a partire da file separati.
Relate offre quindi una scelta di deployment diversa rispetto all'esecuzione di Neo4j come servizio condiviso. Gli sviluppatori possono collocare il motore accanto all'applicazione che ne ha bisogno. Questo riduce il numero di componenti separati da predisporre prima di porre una domanda strutturata come un grafo.
La distinzione evita anche una lettura fuorviante dell'implementazione Rust. Questo lancio non dimostra che Neo4j abbia sostituito i propri prodotti server esistenti con un equivalente Rust. Relate ha un proprio modello operativo, ambito e limiti.
Per gli sviluppatori, il cambiamento significativo è l'accesso a un'unità di deployment più piccola. Possono valutare un grafo per un'attività specifica senza impegnare prima tale attività in un'architettura di database più ampia.
Un deployment locale cambia anche chi gestisce il lavoro operativo. Il team dell'applicazione decide quando creare, conservare, riaprire o eliminare i propri dati. Queste decisioni si avvicinano alla funzionalità che utilizza il database.
Questa prossimità può semplificare un progetto circoscritto. Rende però anche le decisioni sul ciclo di vita parte della progettazione dell'applicazione. Un'indagine temporanea e un assistente di lunga durata non dovrebbero ereditare lo stesso comportamento di conservazione soltanto perché condividono un motore.
Gli sviluppatori di agenti affrontano una decisione diversa sullo storage
Relate mette in discussione l'ipotesi che la memoria connessa degli agenti richieda un servizio di database gestito separatamente.
Il pubblico immediato è costituito dagli sviluppatori i cui agenti operano all'interno di un repository, un'applicazione, un notebook o un ambiente di esecuzione isolato. Il loro problema è spesso più ristretto rispetto alla manutenzione del sistema di conoscenza permanente di un'organizzazione. Hanno bisogno di contesto utile disponibile quando viene eseguita un'attività.
Un servizio di database separato aggiunge decisioni su accesso, deployment, connettività e responsabilità. Tali decisioni possono essere giustificate quando molte applicazioni necessitano degli stessi record. Possono sembrare sproporzionate quando i dati esistono solo per supportare un'indagine locale.
I file temporanei evitano gran parte di questa configurazione. Lasciano però all'applicazione la responsabilità di rappresentare le connessioni, convalidare gli aggiornamenti e recuperare informazioni pertinenti. Con l'espandersi di questi requisiti, il codice di storage diventa una parte più ampia dell'agente stesso.
Nessuno dei due approcci è intrinsecamente sbagliato. Una piccola raccolta di impostazioni può rimanere un file. Un sistema aziendale condiviso può appartenere a un servizio gestito. Relate si rivolge allo spazio in cui le relazioni contano, ma un servizio separato introduce più infrastruttura di quanta ne richieda l'attività.
SQLite offre un utile riferimento storico. Il suo modello di database serverless colloca il motore all'interno dell'applicazione anziché dietro un processo server intermediario. Questa soluzione elimina l'amministrazione del server, modificando al contempo i confini di isolamento e coordinamento.
Relate porta la stessa questione di collocazione ai carichi di lavoro a grafo. Gli sviluppatori devono decidere se la loro applicazione tragga vantaggio dall'avere le relazioni direttamente disponibili nel proprio processo. La risposta dipende dal lavoro, non dalla popolarità degli agenti.
Un assistente che esamina la cronologia di un progetto offre un caso illustrativo. File, modifiche, issue e responsabili formano un insieme connesso di record. Un grafo locale potrebbe supportare domande su quali modifiche abbiano interessato un componente e quali issue spieghino le decisioni.
Questo esempio non dimostra un vantaggio in termini di accuratezza rispetto agli strumenti esistenti. Identifica un carico di lavoro in cui la rappresentazione si adatta alla domanda. Il vantaggio di deployment esiste soltanto se mantenere quel grafo richiede meno impegno delle alternative.
La pressione raggiunge anche i team che creano framework per agenti, i quali forniscono software riutilizzabile per coordinare modelli e strumenti. Devono scegliere tra offrire impostazioni locali predefinite e presumere un backend di storage esterno. Un'opzione locale può rendere più semplice la sperimentazione, ma deve comunque esporre un comportamento prevedibile.
Gli acquirenti enterprise affrontano una questione di confine correlata. Dovrebbero distinguere il contesto di lavoro temporaneo di un agente dai record autorevoli governati dall'organizzazione. Copiare un sottoinsieme utile in un database locale non trasferisce la proprietà delle informazioni originali.
Anche i knowledge worker hanno interesse in questa distinzione. Una risposta basata su dati di lavoro locali dovrebbe chiarire se le informazioni siano aggiornate e complete. L'utente sperimenta la risposta, indipendentemente da dove venga eseguito il database.
Per i lettori che confrontano le basi di conoscenza personali, si applica la stessa questione di proprietà. Un recupero utile dipende dalla comprensione di quali informazioni detenga il sistema, di come cambino e di cosa escludano i suoi confini.
La memoria connessa rende le relazioni disponibili alle query
Un grafo rende le relazioni interrogabili, ma l'applicazione determina comunque quali relazioni meritino di esistere.
Il meccanismo tecnico è semplice. Le entità diventano nodi e le connessioni diventano relazioni. Un agente può interrogare una catena di connessioni anziché recuperare record separati e assemblare autonomamente quella catena.
Cypher, un linguaggio di query per grafi, esprime questi pattern. Una domanda sulle dipendenze può seguire le connessioni da un'applicazione attraverso i pacchetti fino a un avviso. Il risultato dipende dal fatto che il grafo contenga i pacchetti, le versioni e le relazioni con gli avvisi pertinenti.
Questo differisce dalla ricerca per similarità, che recupera elementi in base a quanto le loro rappresentazioni corrispondano a una query. Una formulazione simile può individuare un documento utile. Non stabilisce automaticamente che il documento regoli una decisione o una dipendenza specifica.
Neo4j presenta Relate come un modo per combinare query sulle relazioni con il recupero per similarità. Questa direzione di prodotto mira a una debolezza pratica della memoria degli agenti: trovare materiale pertinente è solo una parte della comprensione del suo ruolo.
Un assistente di progetto illustrativo potrebbe recuperare una nota che discute un provider di autenticazione. Una relazione con una decisione successiva potrebbe mostrare che il team ha poi selezionato un altro provider. Senza tale connessione, una vecchia nota pertinente può comunque sostenere una risposta superata.
Il grafo non scopre per definizione la decisione successiva. Un'applicazione deve acquisirla, identificarne l'argomento e rappresentarne la relazione con il materiale precedente. Se questo processo fallisce, il grafo può preservare un quadro incompleto.
Questa precisazione è importante perché “memoria” descrive diversi requisiti. Ricordare un fatto è diverso dal preservarne la fonte. Preservare una fonte è diverso dal riconoscere che una decisione più recente la sostituisce.
Il modello a grafo di Relate fornisce uno spazio per esprimere queste distinzioni. Lo sviluppatore rimane responsabile della scelta delle distinzioni importanti per l'applicazione. La flessibilità dello storage non sostituisce un modello informativo.
La dimostrazione della memoria degli agenti di Neo4j illustra il ciclo di vita previsto attraverso l'analisi delle dipendenze. L'azienda descrive Claude Code mentre esamina l'Agent Development Kit di Google utilizzando grafi separati e usa e getta. La dimostrazione copre 24 dipendenze dirette e ricava informazioni sulle dipendenze da deps.dev.
Si tratta di una dimostrazione del fornitore, non di un benchmark indipendente. Il dettaglio utile è la forma dell'attività: creare grafi delimitati, indagare le connessioni, riportare i risultati e disporre dei database.
L'esempio chiarisce inoltre perché storage locale e struttura a grafo appartengano alla stessa discussione. Un'indagine ricca di relazioni può essere temporanea. Gli sviluppatori non devono necessariamente trasformare i suoi dati di lavoro in un servizio condiviso permanente.
Tuttavia, lo storage temporaneo attribuisce maggiore peso al rapporto finale. Se il database scompare, il rapporto deve preservare prove sufficienti affinché qualcuno possa valutare le conclusioni. In caso contrario, un'indagine conveniente diventa difficile da riprodurre.
Un grafo persistente cambia questo equilibrio. Può preservare le relazioni per lavori successivi, ma allora aggiornamento, conservazione e correzione diventano responsabilità continue. L'applicazione ha acquisito memoria e ha ereditato manutenzione.
Lo stesso ragionamento si applica agli assistenti per documenti. Una connessione tra un'affermazione e il documento che la supporta può aiutare a spiegare una risposta. Tale connessione dovrebbe sopravvivere alle revisioni in un modo che ne renda chiaro il significato.
Qui la promessa diventa concreta. La memoria connessa offre al software una struttura per porre domande migliori sulle prove disponibili. Non garantisce che le prove siano corrette, complete o interpretate in modo appropriato.
L'esecuzione locale scambia il sovraccarico del servizio con limiti di memoria
Il modello locale di Relate rimuove un confine di deployment imponendo al contempo un chiaro confine di capacità: il grafo aperto deve entrare in memoria.
L'architettura a grafo locale del prodotto descrive un motore progettato per un grafo posseduto da un'applicazione, un agente o uno strumento su una macchina. Il grafo risiede in memoria. Il disco offre persistenza anziché fungere da livello di scansione delle query del motore.
Questa distinzione separa la capacità di archiviazione dalla capacità operativa. Scrivere dati su disco non significa che l'applicazione possa interrogare un grafo più grande della memoria disponibile. Gli sviluppatori devono quindi dimensionare il grafo operativo di conseguenza.
Per un'indagine circoscritta, questo limite può incoraggiare una disciplina utile. L'applicazione carica le informazioni pertinenti al compito anziché copiare l'intera cronologia di un'organizzazione. Un insieme di lavoro più ridotto può inoltre renderne più semplice spiegare l'ambito.
Per un assistente che dovrebbe ricordare tutto indefinitamente, lo stesso limite diventa più impegnativo. Le informazioni si accumulano, le relazioni si moltiplicano e l'applicazione compete per la memoria con altri software. La politica di conservazione diventa parte della pianificazione della capacità.
L'alternativa, un servizio separato, comporta compromessi diversi. Può separare le operazioni del database dal ciclo di vita dell'applicazione e supportare l'accesso condiviso tramite un confine centrale. Richiede però connettività e gestione del servizio.
Si tratta di scelte architetturali, non di fasi di una scala universale. Un database locale non è automaticamente un prototipo destinato a diventare un servizio. Alcune applicazioni traggono vantaggio dal restare locali perché i loro dati e utenti restano locali.
Viceversa, un'applicazione può superare il modello di proprietà locale prima che il suo grafo diventi grande. Diversi sistemi indipendenti potrebbero dover aggiornare gli stessi record. Un team potrebbe richiedere che il database rimanga disponibile mentre un'applicazione viene riavviata.
Il confine corretto dipende quindi dal coordinamento tanto quanto dalle dimensioni. Chi scrive le informazioni, chi deve leggerle e chi gestisce i guasti sono tutti fattori importanti. Contare solo i record non risponde a queste domande.
Le affermazioni sulle prestazioni richiedono la stessa cautela. Neo4j pubblicizza un avvio in millisecondi e letture in memoria inferiori al millisecondo. Queste dichiarazioni descrivono affermazioni dell'azienda, non una garanzia verificata indipendentemente per un carico di lavoro arbitrario di un agente.
Uno sviluppatore che valuta tali affermazioni deve distinguere l'avvio di un motore vuoto dalla riapertura di un archivio popolato. Caricare dati, costruire strutture di ricerca, eseguire query e generare risposte del modello sono operazioni diverse. I relativi costi non dovrebbero scomparire dentro un'unica affermazione sulla velocità.
Il confronto più utile manterrebbe costante il compito dell'applicazione. Includerebbe gli stessi dati di origine, domande, requisiti di persistenza e aspettative di output. Altrimenti, una query locale più veloce potrebbe accompagnarsi a un flusso di lavoro complessivo più lento.
Anche il consumo di memoria rientra in questo confronto. Un agente non riceve risorse illimitate solo perché il suo database viene eseguito localmente. Il database condivide la macchina con l'applicazione e con qualunque altro software supporti il compito.
L'esecuzione locale può ridurre il sovraccarico di comunicazione, ma non elimina il lavoro di elaborazione. Le query devono comunque trovare, filtrare e restituire informazioni. Dimensione e struttura del grafo restano pertinenti.
Per i team di prodotto, questo rende Relate un'opzione da valutare rispetto a un compito definito. Il beneficio credibile è un deployment più semplice per carichi di lavoro adatti. Le affermazioni di superiorità generale richiedono prove che vadano oltre l'architettura stessa.
Le transazioni proteggono gli aggiornamenti, non la verità della memoria dell'agente
La coerenza del database e l'affidabilità dell'agente sono affermazioni distinte, e Relate dovrebbe essere valutato su entrambe.
Una transazione raggruppa le modifiche al database affinché il software possa applicarle con un comportamento di coerenza definito. Questo aiuta a evitare che aggiornamenti incompleti diventino visibili come lavoro concluso. Non stabilisce però se i fatti scritti siano veri.
Un agente può memorizzare fedelmente una conclusione errata. Un altro agente può recuperarla attraverso una relazione valida e ripetere l'errore. Un comportamento corretto del database può quindi preservare conoscenza applicativa errata.
La stessa distinzione si applica alle informazioni in conflitto. Un database può conservare sia una decisione precedente sia una nuova decisione. L'applicazione deve rappresentare quale decisione regola il compito corrente e perché.
I limiti operativi documentati di Relate definiscono inoltre confini per l'accesso condiviso. Un archivio persistente dispone di un unico processo di scrittura. Le transazioni all'interno di quel processo possono incontrare conflitti e il motore non ritenta automaticamente le scritture in conflitto.
Più agenti non implicano quindi un numero illimitato di writer di database indipendenti. Gli sviluppatori devono distinguere gli agenti coordinati tramite un processo condiviso dai processi separati che aprono lo stesso archivio persistente. Queste configurazioni hanno comportamenti diversi in caso di guasto.
Ciò è particolarmente rilevante quando i sistemi di agenti dividono il lavoro tra attività parallele. Un pianificatore potrebbe assegnare la responsabilità mentre i worker registrano i progressi. Se l'applicazione presume che ogni scrittura riesca, la sua visione delle responsabilità può divergere dalla realtà.
Il database può segnalare un conflitto. L'applicazione necessita comunque di una politica per interpretare quel risultato. Ritentare, rileggere o abbandonare un'azione possono essere tutte scelte ragionevoli, a seconda di ciò che rappresenta la scrittura.
La persistenza introduce un'altra distinzione. Il modello di persistenza dello storage descrive un write-ahead log, un registro delle modifiche usato per il ripristino. La modalità predefinita di piena persistenza sincronizza il log prima di confermare un commit. Le modalità meno rigorose accettano diverse finestre di perdita.
È una scelta ingegneristica significativa, soprattutto per la memoria persistente di un agente. Un'indagine usa e getta e un registro di decisioni approvate dagli utenti hanno conseguenze diverse se le scritture recenti scompaiono. Le loro impostazioni di archiviazione dovrebbero riflettere tali conseguenze.
Il recupero dei dati differisce inoltre dal recupero di un flusso di lavoro. Dopo il riavvio, un'applicazione deve determinare quali azioni esterne sono state completate. Un record di database preservato da solo non stabilisce se una chiamata a uno strumento abbia modificato un altro sistema prima di un guasto.
Si tratta di domande di valutazione, non di prove di un difetto in Relate. Derivano dall'uso di qualsiasi database all'interno di un agente che legge, ragiona e agisce. Un nuovo motore di archiviazione cambia alcuni confini lasciando intatte le responsabilità dell'applicazione.
Allo stesso modo, l'archiviazione locale non garantisce che le informazioni restino private. Una richiesta a un modello, un'integrazione con strumenti o una funzionalità dell'applicazione possono comunque trasmettere altrove contenuti recuperati. La privacy dipende dall'intero percorso seguito dai dati.
Per gli acquirenti, la domanda utile è quindi più specifica che chiedersi se il prodotto offra memoria locale. Devono sapere quali informazioni restano locali, quali operazioni escono dalla macchina e chi controlla tali operazioni.
Relate crea un luogo ispezionabile in cui archiviare contesto connesso. Il suo contributo dovrebbe essere giudicato separatamente dalle affermazioni secondo cui gli agenti diventano affidabili semplicemente ricevendo un grafo. Una migliore struttura della memoria è un input per l'affidabilità, non un sostituto della sua valutazione.
Osservare le prove sui carichi di lavoro, il coordinamento e l'uso continuativo
Le prossime prove dovrebbero mostrare se gli sviluppatori mantengono Relate nelle applicazioni operative dopo l'esperimento iniziale.
Il primo segnale è una prova riproducibile sui carichi di lavoro. Valutazioni utili pubblicherebbero i dati, i modelli di query, le risorse della macchina e le impostazioni di archiviazione alla base dei risultati. Dovrebbero distinguere l'avvio del motore, il caricamento dei dati, l'esecuzione delle query e il tempo necessario per completare il compito effettivo dell'agente.
Questa distinzione rafforzerebbe la tesi a favore di Relate se il deployment locale riducesse il lavoro senza creare costi sproporzionati di caricamento o memoria. Risultati limitati a database minuscoli e vuoti sosterrebbero una conclusione più circoscritta. Nessuno dei due esiti dovrebbe essere generalizzato oltre il carico di lavoro testato.
I confronti più solidi esaminerebbero anche la qualità delle risposte. Una query sulle relazioni può restituire esattamente ciò che il database contiene, pur tralasciando una connessione importante che l'ingestione non ha mai creato. Misurare la velocità senza verificare una completezza utile lascia una parte dell'applicazione non valutata.
Per un'indagine sulle dipendenze, il risultato rilevante è un resoconto accurato e tracciabile della catena di dipendenze. Per un assistente documentale, è una risposta fondata sui record corretti. Il contributo del database conta attraverso questi risultati.
Il secondo segnale riguarda le prove su coordinamento e ripristino. Gli sviluppatori hanno bisogno di esempi che mostrino cosa accade quando le scritture entrano in conflitto, le applicazioni si riavviano e le attività riprendono. Una dimostrazione che gestisce solo un'esecuzione senza interruzioni lascia senza risposta le domande operative.
Queste prove rafforzerebbero la posizione di Relate se le applicazioni potessero gestire il suo confine di processo con un coordinamento diretto. Ridurrebbero l'ampiezza dei carichi di lavoro indirizzabili se gli sviluppatori aggiungessero ripetutamente un'infrastruttura sostanziale per gestire tale confine. Il prodotto non deve adattarsi a ogni architettura per giustificare il proprio ruolo.
Anche la chiarezza della documentazione rientra in questo segnale. Gli sviluppatori dovrebbero poter capire quali interfacce e comportamenti supporta la versione installata. Limiti chiari possono far risparmiare più tempo di ingegneria rispetto a un linguaggio di compatibilità generico.
Il terzo segnale è l'uso continuativo in applicazioni con responsabilità persistenti sui dati. Un grafo temporaneo dimostra un basso attrito di configurazione. Un grafo mantenuto mentre il materiale di origine cambia dimostra che i team hanno trovato un modello di proprietà praticabile.
Le prove di uso continuativo dovrebbero spiegare cosa gli sviluppatori hanno scelto di conservare e cosa hanno deliberatamente scartato. Questo rivela se la memoria a grafo sta servendo le domande dell'applicazione. Accumulare informazioni senza una ragione non equivale a costruire memoria utile.
L'implicazione commerciale deriva da queste scelte. Neo4j dispone ora di un punto di ingresso per gli sviluppatori le cui esigenze immediate non giustificano un servizio a grafo separato. Che questo ampli l'adozione a lungo termine dipende dalle applicazioni costruite intorno a esso.
Il lancio offre inoltre agli sviluppatori un motivo per rivedere vecchie ipotesi sulla collocazione dell'archiviazione. Un database può appartenere a un compito, a un'applicazione o a un'organizzazione condivisa. Relate rende le prime opzioni più visibili nella direzione di prodotto di Neo4j.
Per il vostro prossimo progetto con agenti, identificate le relazioni che una risposta riuscita deve seguire prima di scegliere il livello di archiviazione. Decidete se tali relazioni appartengono a un compito temporaneo o a un record continuativo. Quindi confrontate l'archiviazione locale a grafo con l'alternativa più semplice che soddisfi gli stessi requisiti. Includete l'uso della memoria, il ripristino, il tracciamento delle fonti e lo sforzo necessario per mantenere aggiornate le informazioni. Neo4j Relate merita attenzione dove dati connessi e proprietà locale coincidono. Iniziate con un carico di lavoro circoscritto il cui risultato potete verificare, poi valutate se il database rende quel risultato più facile da produrre e spiegare. Quali connessioni deve realmente ricordare il vostro agente e chi resterà responsabile di esse dopo la fine del compito?



