ctx-memory: come ho costruito su Drupal la memoria delle decisioni per Claude
ctx-memory è un esperimento: una memoria delle decisioni per Claude costruita come un sito Drupal 11, con quattro tipi di entità custom, Search API e Typesense. Da circa cinque mesi è uno degli strumenti che uso di più quando lavoro con l'AI. Per ora il codice resta privato: è un caso di studio, e lo illustro volentieri a chi è interessato.
Cosa fa Drupal in ctx-memory?
Tutto il modello dei dati di ctx-memory vive in Drupal, che lo espone al server MCP, agli hook e alla ricerca attraverso rotte e moduli. L'idea da provare è semplice: a un grafo di decisioni serve quello che Drupal dà già a ogni entità, campi tipizzati, revisioni, permessi e un'interfaccia di amministrazione per correggere un record. Di mio c'è solo il codice del modello dei dati e delle regole.
| Cosa fa Drupal | Cosa fa ctx-memory |
|---|---|
| quattro tipi di entità di contenuto in un modulo custom | contesto, decisione, evidenza e relazione, ciascuna con le revisioni e la loro interfaccia: ogni modifica a una decisione conserva la storia |
| Dynamic Entity Reference (si apre in una nuova scheda) | origine e destinazione di una relazione possono essere entità qualsiasi, così un solo tipo lega una decisione al suo contesto e alle sue evidenze |
| permessi | confermare una decisione richiede un permesso a sé, e ce l'ha solo il mio account: gli agenti catturano, decide una persona |
| Search API con Search API Typesense | indicizza contesti, decisioni ed evidenze per la ricerca, senza codice di indicizzazione mio |
| un tipo di plugin | ogni fonte di evidenze è un plugin, e un sottomodulo legge git |
rotte REST sotto /ctx/ |
la superficie che chiamano il server MCP e i due hook, in un modulo a parte che si può disinstallare lasciando intatto il modello dei dati |
| comandi Drush | catturano evidenze, promuovono decisioni e interrogano il grafo da terminale |
Perché un sistema custom, quando ne esistono di pronti?
Ho scelto un sistema custom per avere il controllo e poterlo vedere. Di server MCP che danno memoria a Claude ce ne sono molti, e alcuni sono fatti bene. Chi ne cerca uno pronto trova in cognee (si apre in una nuova scheda) una scelta valida: open source con licenza Apache-2.0, scritto in Python, trasforma documenti, codice e conversazioni in un grafo di conoscenza con ricerca su grafo e vettoriale, e ha un suo server MCP. Volevo invece sperimentare una soluzione mia, con Typesense per la ricerca e i dati in un piccolo grafo su Drupal di cui controllo la struttura, campo per campo.
Il problema da risolvere era concreto. Quando lavoro sullo stesso progetto in più sessioni, ogni sessione nuova parte senza ricordare le scelte fatte nelle precedenti. Con ctx-memory le decisioni restano: le ritrovo interrogando il grafo, invece di rispiegarle o, peggio, di contraddirle.
Come è fatto ctx-memory?
ctx-memory mette insieme pochi componenti, ciascuno con un compito solo:
| Componente | Ruolo |
|---|---|
| Drupal 11 su PostgreSQL | tiene il modello dei dati: entità, revisioni e permessi |
| Typesense, con Search API | indicizza tutto per la ricerca, con l'indice in RAM ricostruibile dal database |
| server MCP | espone a Claude tre strumenti: cerca, leggi, cattura |
| due hook di Claude Code | catturano da soli il proposal.md di ogni change OpenSpec e ogni ADR committato, con il permalink |
| Graph Explorer | una vista 3D del grafo, per guardare come sono organizzati i dati |
| Sablier | accende lo stack alla prima richiesta e lo spegne quando resta inattivo |
Quali regole tengono affidabile la memoria?
La specifica del progetto fissa quattro regole come principi non negoziabili:
- una decisione catturata nasce sempre «proposta», e la conferma solo una persona, con un permesso che nessun agente ha.
- una decisione si conferma solo con almeno un'evidenza che punta a una fonte stabile.
- il grafo è append-only: una decisione cambia solo con una nuova che sostituisce la vecchia, con la data.
- ogni record dichiara chi l'ha scritto, una persona o un modello, e in quale esecuzione.
Nell'uso di ogni giorno è la prima regola a lavorare di più. Ogni decisione del grafo l'ha catturata un modello, e conta solo dopo la mia revisione: la confermo, la scarto o più avanti la sostituisco con una più recente.
Come lo uso ogni giorno?
Lo uso da terminale, con Claude. Evoco il progetto, e Claude rintraccia le decisioni collegate e le loro evidenze: così una sessione nuova riparte dal contesto già definito. Le decisioni nuove le scrive nel grafo la skill di ctx-memory, come proposte.
Il Graph Explorer non lo uso per cercare: serve a guardare la struttura dei dati e a capire se il grafo cresce nel modo giusto.
Fonti
Specifica e codice di ctx-memory li ho riletti il 15 ottobre 2026, per questa versione dell'articolo.
- Drupal (si apre in una nuova scheda), Search API Typesense (si apre in una nuova scheda) e Dynamic Entity Reference (si apre in una nuova scheda). Fonte primaria.
- cognee (si apre in una nuova scheda), repository e README, letti il 15 ottobre 2026. Fonte primaria.
- Typesense (si apre in una nuova scheda). Fonte primaria.
- Model Context Protocol (si apre in una nuova scheda). Fonte primaria.
- OpenSpec (si apre in una nuova scheda) e Architecture Decision Records (si apre in una nuova scheda). Fonte primaria.
- Sablier (si apre in una nuova scheda). Fonte primaria.
- Specifica e codice di ctx-memory.
Questo contenuto è stato prodotto dall'AI e rivisto da una persona.
Come è stata usata l'AI?
Le bozze sono prodotte con l'assistenza dell'AI, poi dirette, rivedute e verificate da una persona. Numeri, date e versioni sono confrontati con le fonti pubbliche prima della pubblicazione, e la data di quel controllo è indicata nel testo.