sequico/server-noonien

Shared, serverless, conflict-free memory for AI agents — with peer-to-peer sync.
server-noonien is a drop-in replacement for the official
@modelcontextprotocol/server-memory
knowledge graph — the same entities, observations and relations — that converges across machines
with no central server, no database and no merge conflicts.
Its headline feature is peer-to-peer sync: the nooniend daemon replicates each node's shard
directly to the others, so several machines share one memory with no shared folder — only IP
reachability over a VPN or a LAN.
## Table of contents
Why server-noonien
The problem
How server-noonien solves it
Comparison
The three commands
Share across machines
Peer to peer — nooniend (recommended)
The daemon HTTP API
Shared area — file and s3
Configuration
Shared variables
Server variables
Daemon variables
How it works
Compaction
Deletion and collection
Tools
Drop-in compatibility
Security
Development
Why the name noonien?
Documentation
License & Disclaimer
Support the Project
## Why server-noonien
### The problem
Agent memory today is local, and the official memory server is a single JSONL file that every
mutation reads and rewrites in full. That breaks the moment you have more than one machine:
It lives on one host. Switch machine and your agent has forgotten everything.
Sharing it over a synced folder loses writes. The server serializes mutations in-process
only: two hosts each load the whole graph, mutate their own copy and write it back, so the last
write silently discards the other's — and the sync tool forks the file into conflict copies
instead of merging it.
The alternatives want a server, a database or a cloud. The mainstream "shared memory" products
are something you have to host, or they ship your memory off your machines.
### How server-noonien solves it
server-noonien removes the shared file and the central server at the root, and keeps the drop-in
tool surface:
Every node keeps its own memory. Each machine writes only its own append-only shard
( .jsonl); a shard has a single writer by design, so no two nodes ever write the same file
and noonien itself never forks one — a shared area's syncer still can, and a conflict copy is
just another shard to fold.
Shards merge, they do not overwrite. The graph is a CRDT — an LWW-Element-Set ordered by
(HLC, node, sequence) — whose merge is idempotent, commutative, associative and convergent. Any
two machines that have seen the same operations hold the identical graph, in any order, so
there is no "last write wins" data loss.
No shared area, no central server. The shards travel directly between machines with the
nooniend daemon — only IP reachability, over a VPN or a LAN — so several machines share one
memory with no shared folder and no service to host. Prefer a folder or a bucket you
already have? file and s3 work too: the transport is a choice, not a lock-in.
Local-first and offline-friendly. Every node reads and writes its own shard on disk and keeps
a full local replica, so it keeps working offline; the mesh reconverges when the network returns.
Drop-in for the official server. The same nine tools, inputs and outputs, so it slots under
the memory server name with no agent changes — plus the update, mergeentities and