Marveen memória-gráf klaszterezés / Marveen memory graph clustering

An English version of this article follows below. Jump to the English version.

Az eredeti Marveen (Szotasz/marveen) egy kiváló alap: Claude Code-ra épülő multi-agent keretrendszer, kanban, ütemezés, inter-agent kommunikáció. A memóriakezelés és a generált tartalmak tárolása azonban két ponton törékenynek bizonyult: felhőfüggőség és az áttekinthetőség hiánya. Ez a cikk a fork memória-alrendszerének teljes változásait mutatja be - tényszerűen, IT-biztonsági és adatvédelmi fókusszal.

1. Miért volt szükség a forkra?

2026 júliusától a cett/marveen fork önállóan fejlődik az eredeti Szotasz/marveen alapon. A cél kettős: a monolitikus kódbázis modularizálása (a fejlesztési munka során felhasznált tokenek ~85-90%-kal csökkentve), és a memória-alrendszer teljes átgondolása felhasználói kontroll, IT-biztonság és adatvédelem szempontjából.

Ez a cikk kizárólag a memóriát és az adatkezelést érintő változásokat mutatja be - az eredeti rendszerhez képest, tényszerűen.

Alapelv a forkban: minden olyan adat, amelyet az AI-ágens generál vagy tárol, a felhasználó saját gépen lévő SQLite adatbázisában él - nem kerül külső szerverre, nem fut át harmadik fél infrastruktúráján, és minden egyes hozzáférés naplózva van.

2. Lokális adatkezelés - felhő helyett helyi tárolás

2.1 Artifact store: minden tartalom helyben marad

Az eredeti Marveen rendszerben az ágensek által generált tartalmak (HTML-oldalak, Markdown dokumentumok, JSON riportok) kétféle helyen landolhatnak: laza fájlok a helyi fájlrendszerben, illetve - Claude Code Artifact funkcióján keresztül - a claude.ai felhőszolgáltatásban. Ez utóbbi esetben a tartalom kikerül a felhasználó ellenőrzése alól: nincs egységes hozzáférés-szabályozás, nincs audit trail, és a tartalom visszakereshetősége a felhő galéria-felületére korlátozódik.

GDPR-szempontból ez nem apró technikai részlet. Az EU GDPR 25. cikke (beépített adatvédelem) a "data minimisation" elvét kéri: az adatokat lehetőleg ott tárold, ahol a felhasználó megtartja a kontrollt. Felhős artifact store esetén az AI által generált tartalom harmadik féltől függő infrastruktúrán ül - ez adatfeldolgozói megbízási láncot keletkeztet, amelyhez Data Processing Agreement szükséges. Lokális tárolásnál az adatkezelő egyetlen rendelkezési jogosult marad. Ha a generált tartalom üzleti titkot, személyes adatot vagy jogi dokumentumot érint, ez a különbség nem elhanyagolható.

A forkban minden generált tartalom egy lokális SQLite adatbázisba (claudeclaw.db) kerül, bearer-tokennel védett API mögé. Az adatbázis négy réteget biztosít egyszerre:

  • Zárolt hozzáférés: minden tárolt dokumentumhoz hozzáférési kulcs szükséges. Ha valaki böngészőben nyit meg egy tartalmat, a link csak 5 percig érvényes, és kizárólag arra az egy dokumentumra vonatkozik - nem lehet vele mást elérni.
  • Rosszindulatú tartalom nem tud kitörni: ha egy AI által generált HTML-oldal más felületek adatait próbálná megszerezni, a rendszer ezt automatikusan blokkolja. Az oldal szigorúan korlátozott, izolált környezetben nyílik meg - nem fér hozzá a többi adathoz.
  • Teljes nyomkövetés: minden dokumentumhoz rögzítve van, melyik AI-ágens hozta létre, mikor és milyen feladatból. Nincs "ismeretlen" forrású tartalom, és automatikus szinkron biztosítja, hogy ha valami megjelenik a felhőben, azonnal bekerül a helyi adatbázisba is - nincs tartalom, amely csak kint létezik.
  • Kereshetőség szavakra és értelemre egyaránt: a tárolt dokumentumok kulcsszóval és "hasonló értelmű" kereséssel egyaránt megtalálhatók. Ha nem emlékszel a pontos kifejezésre, de tudod mit keresel, a rendszer megtalálja - úgy, ahogy a jó keresők működnek.

2.2 Kompakt vektorembedding - kisebb hely, nincs felhő-forgalom

A szemantikus memória-kereséshez az ágenseknek vektoros reprezentációt (embedding) kell tárolniuk minden memória-bejegyzéshez. Az eredeti rendszerben ezek az embeddingek JSON-szövegként kerültek az adatbázisba.

A fork bináris Float32 formátumra váltott: ez egységnyi bejegyzésenként körülbelül 75-80%-kal kisebb tárhelyet jelent. Az automatikus startup-migráció adatvesztés nélkül konvertálja a meglévő bejegyzéseket. A vektoros keresés - az Ollama helyi futású modellre támaszkodva - teljes egészében a felhasználó saját gépén zajlik: nincs külső API-hívás, nincs hálózati forgalom a keresési lekérdezések során.

Ez utóbbi nem csak sebességi kérdés: egy külső LLM API-ra küldött keresési lekérdezés implicit módon feltárhatja, mire keresel - ez az úgynevezett metadata leakage kockázat. Lokális Ollama-modellel a keresési tartalom nem hagyja el a rendszert.

A lokális embedding modell (nomic-embed-text) és a cross-encoder reranker (bge-reranker-base, mBERT alapú, 104 nyelv) egyaránt helyesen kezeli a magyar helyesírást: ékezetes karakterek, ragozás, összetett szavak. Ez a felhős megoldásoknál nem magától értetődő - a helyi modell kifejezetten erre is fel van készítve, nem kell kompromisszumot kötni a nyelvi pontosság és az adatvédelem között.

3. Gyorsabb és pontosabb memória-keresés

3.1 Közelítő szomszéd-keresés (ANN) és hibrid keresés

Az eredeti Marveen memória-keresője teljes vizsgálattal dolgozik: minden egyes lekérdezésnél az összes tárolt vektort összehasonlítja a kérdéssel. Ez kis adatbázisnál elfogadható, de a bejegyzések számával lineárisan növekszik a válaszidő.

A fork HNSW közelítő szomszéd-keresést vezet be a sqlite-vec extension segítségével. A HNSW (Hierarchical Navigable Small World) egy logaritmikus komplexitású gráfstruktúra: a keresési idő O(log n) a korábbi O(n) helyett. A sebességkülönbség adatbázismérettől függ: kb. 100 bejegyzés alatt negligibilis, 10.000 felett drámai. Ha az extension valamiért nem töltődik be (sandboxolt környezet), a rendszer automatikusan visszaesik a teljes vizsgálatos fallbackre - a felhasználó számára átláthatóan.

A keresés hibrid módban működik: az FTS5 kulcsszavas keresés és a vektoros szemantikus keresés eredményeit RRF (Reciprocal Rank Fusion) algoritmussal súlyozza össze. Egy pontos szótalálatot és egy "hasonló értelmű" találatot egyaránt visszaad, rangsorolva - nem kell választani a két mód között.

A keresés a memória-gráf szemantikus éleit is figyelembe veszi: a top találatok szomszédai (1-hop gráf-kiterjesztés) gyengített súllyal kerülnek be az eredménybe, így az összefüggő, de kulcsszavasan nem egyező bejegyzések sem maradnak el.

3.2 Cross-encoder reranker - kétfázisú rangsorolás

A hibrid keresés után opcionálisan egy második rangsorolási fázis is fut: a Xenova/bge-reranker-base cross-encoder modell. Ez a modell - amely 104 nyelvet támogat, köztük a magyart - nem vektorhasonlóságot számol, hanem a lekérdezés-dokumentum párt együttesen értékeli. Pontosabb relevancia-becslést ad, különösen összetett, hosszabb lekérdezéseknél.

A reranker opt-in: a MEMORY_RERANK_ENABLED beállítással kapcsolható be a dashboard Beállítások felületén. Bekapcsolt állapotban lazy singleton módon töltődik be (az első hívásig nincs memóriaigény), és bármilyen hiba esetén automatikusan az RRF-sorrendű listára esik vissza. A pipeline egy RERANK_FACTOR=5 szorzóval dolgozik: az ANN/FTS fázis 5-ször annyi jelöltet hoz be, mint amennyit végül visszaad - ebből választja ki a reranker a legjobb N-et. CPU-n a latency 150-400 ms között mozog.

A recency boost (frissebb bejegyzések előnyben részesítése) mindig aktív, a reranker állapotától függetlenül.

4. Teljes auditálhatóság és nyomon követhetőség

4.1 Ki, mikor, mit olvasott?

Az eredeti Marveen rendszerben a memória-bejegyzések írásra optimalizáltak: mentés, frissítés, törlés jól dokumentált, de az olvasási eseményekről nincs nyilvántartás. Ha egy ágens hozzáfér egy bejegyzéshez, az nyom nélkül történik.

A fork bevezeti a span_reads táblát: minden memória-olvasási esemény rögzítésre kerül - melyik ágens, mikor, milyen kontextusban olvasta az adott bejegyzést. Ez nem csupán naplózás: a rendszer az olvasási mintákat aktívan felhasználja a memória-rangsoroláshoz és a tier-kezeléshez.

Az automatikus tier-átsorolás szabályai:

  • warm → cold átsorolás: ha egy bejegyzést 30 napja egyetlen ágens sem olvasott.
  • cold → warm visszasorolás: ha egy bejegyzést 2 vagy több különböző ágens olvasott - tehát fontossá vált a flotta számára.

A stale-read detekció (GET /api/memories/stale) azonosítja azokat a bejegyzéseket, amelyeket egy ágens egy régebbi verzió alapján olvasott. A COBIT "information accuracy" elve szerint egy elavult bejegyzésre alapozott döntés kockázatát a dashboard badge-jel látható formában jelez.

4.2 Verzióhistória és ownership-safety

Minden memória-bejegyzés módosítása egy memory_versions táblában kerül rögzítésre: az előző tartalom snapshot-ja, a módosítás időbélyege, és - kritikus pont - a changed_by mező, amely azt rögzíti, melyik ágens hajtotta végre a változtatást.

Ez az ownership-safety mechanizmus különösen a megosztott memória-bejegyzéseknél fontos: ha egy ágens szerkeszt egy olyan bejegyzést, amelynek eredetileg más a tulajdonosa, az agent_id (tulajdonos) változatlan marad - csak a changed_by rögzíti a szerkesztőt. A jogosultságok nem csúsznak el egy szerkesztési esemény miatt.

Az ISO 27001 A.12.4 kontroll az audit logging meglétét követeli meg a rendszerhez való hozzáférési eseményekre. A span_reads + memory_versions kombináció pontosan ezt valósítja meg az AI-memória szintjén: ki, mikor, mit olvasott; ki, mikor, mit módosított. Compliance szempontból ez nem kiegészítő funkció - hanem az ellenőrizhetőség alapkövetelménye.

A dashboard Memória-képernyőjén az "Előzmények" fül mutatja egy bejegyzés teljes verzióhistóriáját, beleértve a tier-változásokat is.

5. Memória-gráf és idővonal-vizualizáció

5.1 Élő gráf - az AI-ágens memóriája látható formában

Az eredeti Marveen a memória-bejegyzéseket listaformában jeleníti meg a dashboardon: szűrhető, rendezhető táblázat. Funkcionálisan helyes, de nem ad képet arról, hogyan kapcsolódnak egymáshoz az emlékek, melyek a csomópontok, és hogyan változik a memória-bázis időben.

A fork egy canvas-alapú, force-directed gráf vizualizációt vezet be a Memória képernyőn. Minden bejegyzés egy csomópont; az élek a szemantikus kapcsolatokat (memory_links tábla), valamint az explicit összefüggéseket jelölik. A gráf vizuális jellemzői:

  • Tier-szines glow: hot (aktív feladatok), warm (stabil konfig), cold (hosszú távú tanulságok), shared (más ágensnek is releváns) bejegyzések eltérő színnel jelennek meg.
  • Hub-jelölés: 5 vagy több éllel rendelkező csomópontok kiemelve; az "árva" csomópontok (nincs szemantikus szomszédjuk) szaggatott gyűrűvel jelölve.
  • Animált particle-flow: az élek mentén áramló részecskék jelzik az aktív szemantikus kapcsolatokat.
  • Node-kattintás: egy csomópontra kattintva dark-glass részletező kártya nyílik, amelyen a teljes tartalom, a frissesség/olvasottsági metaadatok, a kulcsszó-chipek, a szomszédok listája és a tier-történet egyaránt elérhető. (A node detail endpoint SQL-jében az eredeti kód UNION ALL karjain belül alkalmazott ORDER BY...LIMIT-et - amit a SQLite nem enged -, ez minden kattintásnál HTTP 500-as hibát okozott. A javítás mindkét kart subquery-be csomagolja.)
Marveen memória-gráf - teli állapot / Marveen memory graph, full state
A memória-gráf teli állapotban: kék (cold), narancs (warm/hot), sárga (shared) tier-szines csomópontok force-directed elrendezésben.

Miért fontos a vizualizáció IT-biztonsági szempontból? A gráf-nézet nem csupán esztétikai kiegészítés: az "árva" csomópontok azonosítása segít felderíteni az elavult, esetleg érzékeny tartalmú bejegyzéseket, amelyeket már semmi sem hivatkozik. A hub-csomópontok jelzik, melyek a kritikus, sok más bejegyzéssel összefüggő emlékek - ezek tudatos kezelése csökkenti az információ-szivárgás kockázatát egy multi-agent rendszerben.

Marveen memória-gráf klaszterezés / Marveen memory graph clustering
Tier-alapú klaszterezés ambient módban: a kapcsolódó csomópontok vizuálisan csoportosulnak, a hub-ok kiemelkednek.
Memória node detail kártya / Memory node detail card
A node-ra kattintva előugró detail kártya: tier-badge, agent chip, hub-jelölés, kulcsszó chipek, kapcsolatok súlyokkal, tier-történet és akciógombok.

5.2 Idővonal-mód és videó-export

A gráf mellé egy Gource-stílusú temporális visszajátszás is elérhető: az idővonal-módban a csomópontok a created_at időbélyeg szerint animáltan "jelennek meg" a gráfban - így látható, hogyan épült fel a memória-bázis az idő során.

Az idővonal-módban elérhető a Videó gomb: a 30 másodperces lejátszást a böngésző rögzíti kliens-oldalon (canvas.captureStream(30) + MediaRecorder, VP9/WebM), majd automatikusan letölti memoria-fa-[dátum].webm névvel. A rögzítés teljes egészében a helyi gépen történik, nem kerül semmilyen külső szerverre. Ha az FPS 25 alá esne a renderelés közben, a rendszer megerősítést kér a rögzítés megkezdése előtt.

6. Összefoglalás - eredeti Marveen vs. fork

Terület Eredeti Marveen cett/marveen fork
Artifact tárolásFelhő (claude.ai) + laza fájlokTeljes egészében lokális SQLite, bearer-gated API
Artifact biztonságNincs CSP/sandbox a megnyitáshoz5 perces HMAC-token + szigorú CSP sandbox
Embedding tárolásJSON szövegBináris Float32 (~80%-kal kisebb)
Keresés komplexitásaO(n) teljes vizsgálatO(log n) HNSW ANN + FTS5 hibrid
Keresési pontosságVektoros hasonlóságRRF-fúzió + opt-in cross-encoder reranker
Keresési forgalomEmbedding API-hívás (felhő lehetséges)Lokális Ollama, nincs hálózati forgalom
Olvasási auditNincsspan_reads tábla - teljes olvasási napló
VerzióhistóriaNincsmemory_versions tábla, tier-változás naplóval
Ownership-safetyNincs elkülönítésagent_id vs. changed_by szétválasztás
Stale-detekcióNincsAutomatikus, dashboard badge-gel jelezve
Tier-kezelésManuálisAutomatikus (olvasási minták alapján)
Memória-vizualizációLista-nézetForce-directed gráf, tier-szines glow, hub-jelölés
Idővonal-visszajátszásNincsGource-stílusú temporális animáció
Videó-exportNincsKliens-oldali WebM-rögzítés, lokális letöltés
Data residencyFelhős artifact esetén nincs garanciaTeljes lokális tárolás - az adat ott marad, ahol fut
GDPR DPA szükségletFelhős tárolásnál igenNem - nincs harmadik feles adatfeldolgozó

A fork nem cseréli le az eredeti Marveen alapjait - azok megmaradnak és folyamatosan frissülnek (cherry-pick upstream javításokkal). A memória-alrendszer változásai egy irányba mutatnak: az adatok a felhasználó kezében maradnak, minden hozzáférés nyomon követhető, és a rendszer méretével együtt a keresés is skálázódik - nem lassul.

A cikk a cett/marveen fork 2026-08-14-es állapotát (upstream: aefa693, fork: 82890df) tükrözi. Eredeti projekt: Szotasz/marveen  |  Fork: cett/marveen

Van kérdésed, vagy beszélgetnél a témáról? Írj emailben: info@jonasgergo.hu, vagy keress meg LinkedInen.


Back to the articles

English version

Author: Jónás Gergő | Date: 14 August 2026 | Source: Own development

The original Marveen (Szotasz/marveen) is an excellent base: a multi-agent framework built on Claude Code, with a kanban board, scheduling and inter-agent communication. Its memory handling and the storage of generated content, however, proved fragile at two points: cloud dependence and a lack of transparency. This article sets out all the changes to the fork's memory subsystem, sticking to the facts, with a focus on IT security and data protection.

1. Why was the fork needed?

Since July 2026 the cett/marveen fork has been evolving as a separate line on top of the original Szotasz/marveen base. The aim is twofold: to modularise the monolithic codebase (the tokens used during development work reduced by about 85-90%), and to rethink the memory subsystem entirely from the point of view of user control, IT security and data protection.

This article covers only the changes to memory and data handling, compared with the original system, and sticks to the facts.

The basic principle of the fork: all data that an AI agent generates or stores lives in a SQLite database on the user's own machine. It is not sent to an external server, does not pass through a third party's infrastructure, and every access is logged.

2. Local data handling: local storage instead of the cloud

2.1 Artifact store: all content stays local

In the original Marveen system, the content generated by agents (HTML pages, Markdown documents, JSON reports) could land in two kinds of places: loose files in the local file system, or, through the Artifact feature of Claude Code, in the claude.ai cloud service. In the latter case the content leaves the user's control: there is no unified access control, there is no audit trail, and the content can be retrieved only through the cloud gallery interface.

From a GDPR point of view this is not a minor technical detail. Article 25 of the EU GDPR (data protection by design) asks for the principle of data minimisation: store the data, wherever possible, where the user keeps control. With a cloud artifact store, the content generated by the AI sits on infrastructure operated by a third party. This creates a controller-processor relationship that requires a data processing agreement under Article 28. With local storage, the data controller remains the only party with control over the data. If the generated content contains a business secret, personal data or a legal document, this difference matters.

In the fork, all generated content goes into a local SQLite database (claudeclaw.db), behind an API protected by a bearer token. The database provides four layers at once:

  • Restricted access: every stored document needs an access key. If someone opens a piece of content in the browser, the link is valid for only 5 minutes and applies to that one document only: nothing else can be reached with it.
  • Malicious content cannot escape: if an HTML page generated by an AI tried to obtain data from other parts of the application, the system blocks this automatically. The page opens in a strictly restricted, isolated environment and has no access to the rest of the data.
  • Full traceability: for every document it is recorded which AI agent created it, when, and for what task. There is no content of "unknown" origin, and automatic sync ensures that if something appears in the cloud, it also goes into the local database at once: there is no content that exists only outside.
  • Searchable by words and by meaning alike: the stored documents can be found with a keyword search and with a "similar meaning" search alike. If you do not remember the exact phrase but know what you are looking for, the system finds it, as good search engines do.

2.2 Compact vector embedding: less space, no cloud traffic

For semantic memory search, the agents have to store a vector representation (an embedding) for every memory entry. In the original system these embeddings went into the database as JSON text.

The fork has switched to a binary Float32 format, which means roughly 75-80% less storage per entry. The automatic start-up migration converts the existing entries without data loss. The vector search, which relies on a locally running Ollama model (Ollama is software for running AI models on your own computer), takes place entirely on the user's own machine: there is no external API call and no network traffic during search queries.

This is not only a matter of speed: a search query sent to an external LLM API can implicitly reveal what you are looking for. This is the so-called metadata leakage risk. With a local Ollama model the content of the search does not leave the system.

The local embedding model (nomic-embed-text) and the cross-encoder reranker (bge-reranker-base, mBERT-based, 104 languages) both handle Hungarian spelling correctly: accented characters, inflection, compound words. This is not self-evident with cloud solutions: the local model is explicitly prepared for it, so there is no need to compromise between linguistic accuracy and data protection.

3.1 Approximate nearest-neighbour search (ANN) and hybrid search

The memory search of the original Marveen works by full scan: at every query it compares every stored vector with the query. With a small database this is acceptable, but the response time grows linearly with the number of entries.

The fork introduces HNSW approximate nearest-neighbour search with the help of the sqlite-vec extension. HNSW (Hierarchical Navigable Small World) is a graph structure that finds approximate matches without checking every entry: the search time grows roughly with the logarithm of the number of entries, O(log n), instead of in direct proportion to it, O(n). The speed difference depends on the size of the database: below about 100 entries it is negligible, above 10,000 it is dramatic. If the extension does not load for some reason (for example in a sandboxed environment), the system automatically falls back to a full scan, without the user noticing.

The search works in hybrid mode: it merges the results of the FTS5 (SQLite full-text) keyword search and the semantic vector search using the RRF (Reciprocal Rank Fusion) algorithm. It returns exact word matches and "similar meaning" matches together in a single ranked list, so there is no need to choose between the two modes.

The search also takes the semantic edges of the memory graph into account: the neighbours of the top hits (one step along the graph's edges) are added to the result with a reduced weight, so that entries that are related but share no keywords are not missed either.

3.2 Cross-encoder reranker: two-phase ranking

After the hybrid search, a second ranking phase can optionally run as well: the Xenova/bge-reranker-base cross-encoder model. This model, which supports 104 languages, Hungarian among them, does not compute vector similarity but evaluates the query-document pair jointly. It gives a more accurate relevance estimate, especially for complex, longer queries.

The reranker is opt-in: it can be switched on with the MEMORY_RERANK_ENABLED setting in the Settings screen of the dashboard. When switched on, it is loaded only when first needed (so it uses no memory until the first call), and on any error it automatically falls back to the list in RRF order. The pipeline works with a RERANK_FACTOR=5 multiplier: the ANN/FTS phase brings in five times as many candidates as it finally returns, and the reranker chooses the best N of these. On a CPU the latency is between 150 and 400 ms.

The recency boost (favouring fresher entries) is always active, whether or not the reranker is switched on.

4. Full auditability and traceability

4.1 Who read what, and when?

In the original Marveen system, memory is built around writing: saving, updating and deleting are well documented, but read events are not recorded. If an agent accesses an entry, no trace is left.

The fork introduces the span_reads table: every memory read event is recorded, that is, which agent read the given entry, when and in what context. This is not mere logging: the system actively uses the read patterns for memory ranking and tier management.

The memory has four tiers: hot (active tasks), warm (stable configuration), cold (long-term lessons) and shared (relevant to other agents too). The rules of the automatic tier reassignment:

  • warm → cold reassignment: if no agent has read an entry for 30 days.
  • cold → warm reassignment: if an entry has been read by at least two different agents, which means it has become important for the fleet.

The stale-read detection (GET /api/memories/stale) identifies the entries that an agent read on the basis of an older version. By the COBIT principle of "information accuracy", the risk of a decision based on an outdated entry is shown visibly with a badge on the dashboard.

4.2 Version history and ownership safety

Every modification of a memory entry is recorded in a memory_versions table: a snapshot of the previous content, the timestamp of the modification and, critically, the changed_by field, which records which agent made the change.

This ownership-safety mechanism is especially important for shared memory entries: if an agent edits an entry that is owned by another agent, the agent_id (the owner) stays unchanged, and only changed_by records the editor. Ownership does not shift because of an edit.

Control A.12.4 of ISO 27001 requires audit logging of access events to the system. The span_reads + memory_versions combination implements exactly this at the level of AI memory: who read what, and when; who modified what, and when. From a compliance point of view this is not an add-on but a basic prerequisite for verifiability.

On the Memory screen of the dashboard, the "History" tab shows the full version history of an entry, including tier changes.

5. Memory graph and timeline visualisation

5.1 A live graph: the AI agent's memory made visible

The original Marveen displays the memory entries on the dashboard as a list: a filterable, sortable table. It is functionally sound, but it gives no picture of how the memories connect to one another, which of them are central, or how the memory base changes over time.

The fork introduces a canvas-based, force-directed graph visualisation on the Memory screen (a layout in which related entries are pulled together and unrelated ones pushed apart). Every entry is a node; the edges mark the semantic connections (the memory_links table) and the explicit relations. The visual features of the graph:

  • Tier-coloured glow: entries in the hot, warm, cold and shared tiers appear in different colours.
  • Hub marking: nodes with 5 or more edges are highlighted; "orphan" nodes (with no semantic neighbour) are marked with a dashed ring.
  • Animated particle flow: particles flowing along the edges show the active semantic connections.
  • Node click: clicking a node opens a dark-glass detail card showing the full content, the freshness and read metadata, the keyword chips, the list of neighbours and the tier history. (In the SQL of the node detail endpoint, the original code applied ORDER BY...LIMIT within the arms of a UNION ALL, which SQLite does not allow, and this caused an HTTP 500 error at every click. The fix wraps both arms in a subquery.)
Marveen memory graph, full state
The memory graph in its full state: nodes coloured by tier, blue (cold), orange (warm/hot), yellow (shared), in a force-directed layout.

Why does the visualisation matter from an IT-security point of view? The graph view is not merely an aesthetic extra: identifying the "orphan" nodes helps to uncover outdated entries, possibly with sensitive content, that nothing refers to any more. The hub nodes show which memories are critical and connected to many other entries, and handling these consciously reduces the risk of information leakage in a multi-agent system.

Marveen memory graph clustering
Tier-based clustering in ambient mode: related nodes group together visually, and the hubs stand out.
Memory node detail card
The detail card that pops up when a node is clicked: tier badge, agent chip, hub marking, keyword chips, connections with weights, tier history and action buttons.

5.2 Timeline mode and video export

Alongside the graph there is also a temporal replay in the style of Gource (a tool that animates how a software project grows over time): in timeline mode the nodes "appear" in the graph one by one, in the order of their created_at timestamps, so you can see how the memory base was built up over time.

In timeline mode the Video button is available: the browser records the 30-second playback on the client side, that is, in the browser (canvas.captureStream(30) + MediaRecorder, VP9/WebM), then downloads it automatically under the name memoria-fa-[date].webm. The recording happens entirely on the local machine, and nothing goes to any external server. If the frame rate (FPS) were to fall below 25 during rendering, the system asks for confirmation before starting the recording.

6. Summary: the original Marveen vs. the fork

Area The original Marveen The cett/marveen fork
Artifact storageCloud (claude.ai) + loose filesEntirely local SQLite, a bearer-gated API
Artifact securityNo CSP (Content Security Policy) or sandbox for openingA 5-minute HMAC token + a strict CSP sandbox
Embedding storageJSON textBinary Float32 (about 75-80% smaller)
Search complexityO(n) full scanO(log n) HNSW ANN + FTS5 hybrid
Search accuracyVector similarityRRF rank merging + an opt-in cross-encoder reranker
Search trafficEmbedding API call (cloud possible)Local Ollama, no network traffic
Read auditNoneThe span_reads table: a full read log
Version historyNoneThe memory_versions table, with a tier-change log
Ownership safetyNo separationagent_id vs. changed_by separation
Stale detectionNoneAutomatic, shown with a dashboard badge
Tier managementManualAutomatic (based on read patterns)
Memory visualisationA list viewA force-directed graph, tier-coloured glow, hub marking
Timeline replayNoneA Gource-style temporal animation
Video exportNoneClient-side WebM recording, a local download
Data residencyNo guarantee with a cloud artifactEntirely local storage: the data stays where it runs
GDPR DPA requirementYes, with cloud storageNo: there is no third-party processor

The fork does not replace the foundations of the original Marveen; they remain and are kept up to date by cherry-picking upstream fixes. The changes in the memory subsystem point in one direction: the data stays in the user's hands, every access can be traced, and with the size of the system the search scales too, it does not slow down.

This article reflects the state of the cett/marveen fork on 14 August 2026 (upstream: aefa693, fork: 82890df). Original project: Szotasz/marveen  |  Fork: cett/marveen

Do you have a question, or would you like to talk about the topic? Write to me by email: info@jonasgergo.hu, or find me on LinkedIn.