server-noonien - shared memory MCP

MCP文档知识

提供方 sequico · 包名 server-noonien

文档知识 stdio · 本地进程 会话登录 社区 / 第三方 Claude DesktopClaudeCursorGemini CLI
查看接入方式

Shared, serverless, conflict-free memory for AI agents: a multi-machine drop-in for the MCP memory knowledge graph.

一句话选型结论

按资料字段整理

server-noonien - shared memory MCP 属于文档知识类 MCP 服务器,stdio · 本地进程,会话登录,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权会话登录 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

mcpmodel context protocolmemory

安装与配置

stdio · 本地进程 会话登录
客户端在本机拉起子进程,数据不出本机
npx -y server-noonien

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 node,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
server-noonien - shared memory MCP当前 未标注 stdio · 本地进程 本地部署 有 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方sequico上游标注的维护方 sequico
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时server-noonien · node本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

52.2 KB
来自项目仓库与上游目录的原文,未做删改

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_*, merge_entities and
    read_conflicts extensions, the operations the official nine have no equivalent for.

Comparison

server-noonien vs the official memory server vs hosted memory services:

server-noonien Official server-memory Hosted memory services
Multi-machine Yes — per-node shards, one graph No — one local file Yes, via the service
Sharing a synced folder Safe — append-only, conflict-free Unsafe — whole-file read-modify-write N/A
Needs a server / database No No Yes
Needs a cloud account No No Yes
Works offline Yes (file backend) Yes No
Storage Folder or S3-compatible bucket, your choice One JSONL file Their cloud
Drop-in for the official tools Yes — same nine, plus extension tools — No
Migration noonien import memory.jsonl — Export/import dance
Model Explicit knowledge graph Explicit knowledge graph Often vector/semantic
License MPL-2.0 MIT Proprietary

Hosted is a category, not a product: it covers services that host your memory for you.
server-noonien is the local-first opposite — you own the storage and there is no account.

A shared area is required for the file/s3 backends — a folder or an object store every node
can reach. nooniend removes that requirement: it replicates the shards directly between nodes.

The three commands

One npm package, server-noonien, ships three commands (Node.js ≥ 22). Install it once
and all three land on your PATH:```sh
npm install -g server-noonien


The `s3` backend's `@aws-sdk/client-s3` is an **optional** dependency, loaded only when
`NOONIEN_BACKEND=s3` selects it. `npm install -g server-noonien --omit=optional` skips it when you
never use `s3`.

| Command | Role | How it runs |
| --- | --- | --- |
| **`server-noonien`** | the MCP memory server | short-lived, **spawned by the MCP client** over stdio |
| **`noonien`** | the maintenance CLI | **one-shot**, run by hand |
| **`nooniend`** | the peer-to-peer replication daemon | **long-lived**, one per machine |

Only `server-noonien` matches the package name, so it is the only command `npx` can run by package
name. Run the other two with `--package`, or from the global install above:```sh
npx -y server-noonien                       # the MCP server (no argument serves over stdio)
npx -y -p server-noonien noonien help       # the maintenance CLI
npx -y -p server-noonien nooniend           # the replication daemon

From a clone — for development, or to run code not yet on npm:```sh
git clone https://github.com/sequico/server-noonien.git
cd server-noonien && npm install && npm run build

node dist/index.js # server-noonien — the MCP server
node dist/noonien.js # noonien — the maintenance CLI
node dist/gossip.js # nooniend — the replication daemon


### `server-noonien` — the MCP server

The entry every MCP client uses. With **no argument** (or `serve`) it speaks MCP over **stdio**, so
you don't run it yourself — the client spawns it and it lives for the session:```sh
npx -y server-noonien                          # the stdio command the client runs
claude mcp add memory -- npx -y server-noonien # register it with Claude Code as the `memory` server

Point your client at it; it works on one machine out of the box, and sharing across
machines is the next step. In OpenCode (V2):```jsonc
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"servers": {
"memory": {
"type": "local",
"command": ["npx", "-y", "server-noonien"],
"environment": { "NOONIEN_DIR": "~/.noonien" }
}
}
}
}


Other clients wrap the same command and environment in their own envelope; from a clone the command
is `["node", "/path/to/server-noonien/dist/index.js"]`. Because the nine drop-in tools are identical,
you can replace the `memory` server entry with `server-noonien` and change nothing else.

### `noonien` — the maintenance CLI

| Command | Does |
| --- | --- |
| `noonien serve` | run the MCP memory server over stdio (the same as `server-noonien`) |
| `noonien import ` | import an official `server-memory` JSONL file (writes its own `-import` shard, so it runs online) |
| `noonien export` | print the folded knowledge graph as JSON |
| `noonien merge` | fold every shard and report the merged state |
| `noonien compact` | maintain this node's shard now: prune shadowed operations and, only where it is safe, physically delete its tombstones — the same rule the server applies (`NOONIEN_GC`; with a daemon that owns the directory it keeps the whole view and leaves the shard to the daemon) — and report why when it keeps them |
| `noonien query ` | search entities and print the matching subgraph |
| `noonien help` | list the commands; `noonien --version` prints the version |

### `nooniend` — the daemon

A long-lived service, **one per machine**, that replicates the shard directory peer to peer. It
takes no arguments and is configured entirely through environment variables — the shared
`NOONIEN_DIR` and `NOONIEN_NODE_ID` (Shared variables) plus the daemon's
`NOONIEND_*` (Daemon variables). See Peer to
peer for the setup.

## Share across machines

`noonien` merges shards; it does not move them by itself. How the shards travel between machines is
your choice: **peer to peer** (a companion daemon — the recommended default) or a **shared area** (a
folder or a bucket that already exists). The MCP server always reads and writes its own local shard;
only the transport differs.

### Peer to peer — `nooniend` (recommended)

**The recommended way to share one memory across machines with no shared storage.** `nooniend` is a
long-lived daemon that replicates the local shard directory **peer to peer**. It only needs IP
reachability, so it runs over any VPN (WireGuard, Tailscale, OpenVPN, Netbird, ZeroTier, …) or a
plain LAN.

Give each machine a **unique** node id and run one `nooniend` per machine. Every daemon keeps a
full replica of the others' shards beside its own, in the same local directory the MCP server uses —
no shared folder required:```sh
# on a tailnet
NOONIEN_DIR=~/.noonien \
NOONIEND_TAILSCALE=true \
nooniend

# or, with no self-listing underlay, seed one reachable peer
NOONIEN_DIR=~/.noonien \
NOONIEND_PEERS=ai.example:49778 \
nooniend

The peers find each other — you never list the machines. Configure one discovery source:
NOONIEND_TAILSCALE (from tailscale status), NOONIEND_DNS_SRV (the _nooniend._tcp SRV
records), or NOONIEND_PEERS (a static seed; one is enough, membership then self-propagates).
A discovery source returns candidates, not members: a candidate joins only once it answers
/info, so a machine on the network that does not run nooniend is never adopted.
NOONIEND_ADVERTISE is optional and defaults to the listen host.

How it behaves:

  • Never authors operations. Each node's MCP server writes only its own .jsonl; the
    daemon keeps replicas of the peers' shards and only ever pushes the shard it authors, so the
    single-writer rule holds. It also restores the local shard from a peer's replica when the local
    copy is behind.
  • Push on change + periodic anti-entropy. On a local change (NOONIEND_PUSH) and every
    NOONIEND_INTERVAL seconds it compares the per-shard high-water seq and moves the delta in
    whichever direction is behind. Operations are idempotent, so delivery may be best-effort — no
    consensus, no ordering, only eventual completeness.
  • Scales past a full mesh. By default it contacts every peer; NOONIEND_FANOUT caps that
    to a random subset per round — which excludes tombstone collection, because a reachable peer
    the round did not sample suspends it, so the daemon refuses that combination — and at or above
    NOONIEND_DIGEST_MIN_SHARDS it reconciles through a fixed-size digest instead of the full shard
    list (with NOONIEND_CHANNELS moving membership onto its own channel). A small mesh keeps
    behaving exactly like a full mesh, and a peer without the digest capability falls back to the
    plain list, so a mixed mesh never breaks.
  • Relays. A node serves every replica it holds, so an offline node keeps converging through any
    peer that has its shard.
  • Discovery and membership. Bootstrap adapters (Tailscale, DNS SRV, a static seed) return
    candidates; the peer set then gossips itself. A static node@host:port seed is explicit intent
    and enters membership directly; a bare address (a Tailscale or DNS-SRV candidate) joins only
    once it answers /info, and its id comes from that answer — never from the discovery source — so a
    device that does not run nooniend is never a member and never blocks collection. A node that
    comes up is adopted on its next probe, and the sources are re-read every
    NOONIEND_DISCOVER_INTERVAL seconds, so a joiner is found without a restart. Liveness comes from the exchange results — suspect
    after NOONIEND_SUSPECT_AFTER failures, dead after NOONIEND_DEAD_AFTER, retried after
    NOONIEND_DEAD_RETRY, and forgotten after NOONIEND_MEMBERSHIP_TTL. A peer that reaches this
    node is marked alive — its certificate names it under mTLS, otherwise the id it announces on the
    request — so a peer that recovers is re-engaged at once instead of waiting out
    NOONIEND_DEAD_RETRY. A caller that is not a peer yet is never adopted from its headers: nothing it
    sends becomes membership, and its id is never taken on trust. It is offered as a discovery candidate
    instead — the host the request came from, the port it announces — and the daemon confirms it on
    /info, exactly like a Tailscale or DNS candidate. That is how a statically-seeded joiner is
    discovered by the seeds it reached, within a round, and why an address announced for a different
    host is never even probed. A node's own entry is authoritative; an address that serves a different
    node is dropped.
  • Wire and security. A small HTTP/JSON service bound to NOONIEND_LISTEN (the full wire contract
    is in PROTOCOL.md); a shard accepts only its own node's operations. mTLS with
    per-peer certificates: the certificate's common name is the node id, so a peer may only push
    the shard it authors, while reads stay open to any authenticated peer — which is what lets a node
    relay. NOONIEND_REVOKED refuses specific nodes on every route; NOONIEND_DEPARTED
    additionally discards a departed node's replica and lets collection proceed past it.
  • Observability. Prometheus metrics — liveness, peer health, the stable watermark and, for
    collection, how long each peer has been away (noonien_gossip_absent_seconds) and how many
    deleted elements are frozen (noonien_gossip_frozen_elements) — plus a per-shard stable
    watermark (the minimum high-water mark reached on every contactable peer, a conservative
    causal-stability bound), and status and graph routes for probes and operators — see The daemon
    HTTP API.

Under systemd, a user unit:```ini
[Unit]
Description=nooniend — peer-to-peer shard replication
After=network-online.target

[Service]
EnvironmentFile=%h/.config/noonien/nooniend.env
ExecStart=%h/.local/bin/nooniend
Restart=on-failure

[Install]
WantedBy=default.target


### The daemon HTTP API

`nooniend` serves a small HTTP/JSON API on `NOONIEND_LISTEN` (default `0.0.0.0:49778`). The full wire
contract — routes and payloads, the operation format, the protocol revision and capabilities, the
size limits and the mTLS model — is specified in `PROTOCOL.md`.```sh
curl -s http://127.0.0.1:49778/health
curl -s http://127.0.0.1:49778/status
curl -s http://127.0.0.1:49778/peers
curl -s http://127.0.0.1:49778/graph | jq '{entities: (.entities|length), relations: (.relations|length)}'

/graph folds everything the node holds, so it is a diagnostic for a normal directory: past 50 000
operations it answers 413 and asks for the shards instead, which serve the same data a page at a
time.

Shared area — file and s3

The file and s3 backends converge through a shared area that already exists and is
replicated outside noonien — a folder or a bucket every node can reach. Point every node at the
same area and each node's shard reaches the others:```sh
NOONIEN_BACKEND=file NOONIEN_DIR=/srv/noonien-shared NOONIEN_NODE_ID=ai server-noonien

or

NOONIEN_BACKEND=s3 NOONIEN_S3_BUCKET=my-bucket NOONIEN_NODE_ID=ai server-noonien
```

  • file — shards are *.jsonl files in NOONIEN_DIR; point it at a folder replicated by
    Syncthing, Dropbox, a git working tree or a shared mount.
  • s3 — one object per shard, written with conditional writes retried on contention, waiting
    the same budget the file backend gives a lock, so a competing writer on one node id costs a wait
    rather than a failed write; uses
    @aws-sdk/client-s3 (an optional dependency, loaded only when selected). Conditional writes need
    a store that honours If-Match/If-None-Match on PutObject (AWS S3, Cloudflare R2, MinIO do);
    a store that ignores them is not supported, and a conditional write carrying an ETag the store
    cannot use — none, or a multipart one — is refused rather than guarded by a token that can never
    match. Reading is not conditional: a shard object with a multipart ETag reads and stats normally.
    An object store has no append, so every
    mutation rewrites the whole shard object
    (read-modify-write): correct, but O(shard size) per
    write.

The memory backend keeps shards in process only — for tests and throwaway sessions. See
Configuration for the variables.

What a shared area does not give you: a safe deletion. file/s3 share a graph; they cannot
say whether a peer holds a write it has not delivered yet. So without a daemon the maintenance
prunes only, and a physical deletion happens only where the operator declares the directory
written by this node alone (NOONIEN_GC) — see Deletion and
collection. Convergence is delegated to the syncer as well: noonien
neither verifies nor retransmits, so latency and conflict copies are the syncer's business, and a
conflict copy is just another shard to fold. And the daemon replicates a directory: nooniend
refuses to run with NOONIEN_BACKEND=s3 (or memory), where it would replicate a local folder the
server never uses.

Configuration

Every setting is read from the environment. NOONIEN_DIR and NOONIEN_NODE_ID are shared; the
MCP server, the CLI and the daemon otherwise have their own variables — NOONIEN_* for the server,
NOONIEND_* for the daemon.

Shared variables

Used by every command.

Variable Default Meaning
NOONIEN_NODE_ID hostname This node's shard name — the identity the MCP server writes under and the daemon replicates. Must be unique per machine and written by a single server at a time.
NOONIEN_DIR ~/.noonien Directory holding this machine's shards: the file backend's store and the daemon's replica store. A leading ~ is expanded.

These two are local to each machine, not a shared area: the MCP server and the daemon share the
same directory on the same host, and every machine keeps its own copy of every shard.
Peer-to-peer sync with nooniend needs no shared folder or bucket; a shared area is only the
alternative transport for file/s3.

A node id is a single-writer shard: exactly one server process should append to it at a time.
The normal setup is one memory server per machine; if you run several servers against the same store
concurrently, give each its own NOONIEN_NODE_ID. The tool does not enforce this, and it does not
have to be silent about it: an append carries the shard state the writer derived its sequence
numbers from, so a second writer is refused and re-derives instead of spending a sequence already
spent — both operations land, on their own sequences, and every peer receives both. Two writers that
land on the same millisecond still produce operations with the same id, which a read fails
loudly
on. A unique node id is still a requirement, not something the tool can check.

Server variables

Used by the MCP server (and the noonien CLI, which reads and writes the same shards).

Variable Default Meaning
NOONIEN_BACKEND file file, memory or s3.
NOONIEN_S3_BUCKET — Bucket (required for the s3 backend).
NOONIEN_S3_PREFIX "" Key prefix all shard objects live under.
NOONIEN_S3_REGION us-east-1 Region passed to the S3 client.
NOONIEN_S3_ENDPOINT — Custom endpoint for MinIO / R2 / Contabo and similar.
NOONIEN_S3_FORCE_PATH_STYLE on when an endpoint is set Path-style requests.
NOONIEN_COMPACT_AFTER 1000 Compact the local shard online after this many appended operations (0 disables).
NOONIEN_GC off Delete tombstones without a daemon: only where this node is the directory's only writer — a promise nothing in the directory can prove. Where a daemon owns the directory (it announces itself with its knowledge file from startup) it has no effect: the daemon collects.

NOONIEN_GC (server, default off) and the daemon's NOONIEND_GC (default on) are different
switches; with the memory backend nothing is shared, so the server collects regardless of
NOONIEN_GC.

S3 credentials come from the standard AWS chain (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY,
AWS_REGION, profiles, instance roles, …).

The local shard is compacted online: the server rewrites its own shard after
NOONIEN_COMPACT_AFTER appended operations (default 1000, 0 disables), inside the same
mutation queue as the writes. The rewrite is a compare-and-swap against the content it read, and a
concurrent write — an append, or the nooniend daemon recovering the shard — makes it re-read and
retry, so nothing is ever lost; noonien compact runs the same compaction by hand. noonien import authors its own -import shard, so it too can run while the node's server is live and
re-importing is idempotent. That shard only ever adds, so it needs neither the peer knowledge nor
the NOONIEN_GC promise: noonien import prunes it on the way out, and noonien compact prunes
it too — dropping the operations a later one shadowed, keeping every tombstone, and rewriting only
when something was dropped, so a repeated maintenance costs nothing and no peer is asked to re-pull
the shard. On the file backend, append and compact take a per-shard lock, so they serialize
instead of racing even across processes — and the daemon takes the same lock. An append is synced
before it is acknowledged, so a write the server has confirmed is on disk; a lock nobody refreshes
is stolen, by its age in either direction, because a folder a syncer replicates can carry one
stamped by a machine whose clock runs ahead.

Within a node the timestamp is monotonic: if the wall clock steps back (NTP, a restored
snapshot, a manual date), a new operation keeps the previous timestamp rather than an older one,
so an earlier operation can never win over a later one of the same node.

Daemon variables

Used by the daemon only. It needs at least one discovery source — NOONIEND_TAILSCALE,
NOONIEND_DNS_SRV or NOONIEND_PEERS — to reach the mesh; the rest is optional. Run it behind a
VPN or firewall and enable mTLS — see Security.

Variable Default Meaning
NOONIEND_LISTEN 0.0.0.0:49778 host:port the gossip service binds.
NOONIEND_ADVERTISE the listen host (hostname on a wildcard) Optional. host:port this node advertises to peers; set it only when the default does not resolve from the others. A value that is not a host:port is refused at startup, because every peer validates the gossiped entry and a typo would otherwise make this node a member nowhere.
NOONIEND_PEERS — Discovery: static seeds — node@host:port or host:port, comma separated. One is enough; membership then self-propagates.
NOONIEND_DNS_SRV — Discovery: domain whose _nooniend._tcp SRV records are seeds.
NOONIEND_TAILSCALE off Discovery: derive candidate addresses from tailscale status (a peer joins once it answers /info).
NOONIEND_DISCOVER_INTERVAL 300 Seconds between discovery refreshes; 0 reads the sources once at startup. A refresh only adds candidates.
NOONIEND_INTERVAL 30 Anti-entropy period, seconds.
NOONIEND_PUSH on Reconcile as soon as the local shard changes.
NOONIEND_FANOUT 0 Peers contacted per round; 0 is every reachable peer. A cap excludes NOONIEND_GC: a reachable peer the round did not sample suspends collection, so the daemon refuses the two together.
NOONIEND_DIGEST_MIN_SHARDS 32 Shard count at or above which the digest replaces the full list (0 = whenever supported).
NOONIEND_CHANNELS off Gossip membership on its own channel instead of piggybacking it on every exchange.
NOONIEND_RELAY — Comma-separated node ids always sampled (relays / super-peers).
NOONIEND_GC on Collect the authored shard: prune the shadowed operations (keeping the operation a peer off the mesh could still have folded as the gate's evidence) and drop a tombstone once no peer off the mesh that folded its element could contest it — the peer's knowledge frontier is a subset of what this node holds and covers no operation of the element (physical deletion).
NOONIEND_FORGET_AFTER 15552000 (180 days) Seconds of silence after which a peer is retired: its protection becomes durable (a merged threshold, or a blanket when it holds operations this node lacks) and its live record is dropped, so the metadata collection depends on stays bounded. 0 never retires.
NOONIEND_SUSPECT_AFTER 3 Failed exchanges before a peer is marked suspect.
NOONIEND_DEAD_AFTER 6 Failed exchanges before a peer is marked dead.
NOONIEND_DEAD_RETRY 300 Seconds a dead peer is left alone before it is probed again.
NOONIEND_MEMBERSHIP_TTL 604800 Seconds a dead peer is kept before it is forgotten.
NOONIEND_HOOK_URL — http(s) URL the daemon POSTs { node, watermark } to when the stable watermark advances (a peer wrote something); best effort, a hook that is down is a warning, never a failed round.
NOONIEND_REVOKED — Comma-separated node ids the daemon never syncs with and refuses to accept.
NOONIEND_DEPARTED — Comma-separated node ids explicitly gone: like NOONIEND_REVOKED but their replica is also discarded and they stop blocking collection.
NOONIEND_TLS_CERT / NOONIEND_TLS_KEY — Serve TLS with this certificate and key.
NOONIEND_TLS_CA — CA that signs the peers' certificates, used to verify them in both directions.
NOONIEND_TLS_REQUIRE_CLIENT on Require a client certificate (mTLS).

Listen port. The daemon listens on 49778, a port we select ourselves from the dynamic range
(49152-65535). Nothing assigns it and nothing has to: the expected deployment is a private
network — Tailscale or another VPN, with the port reachable only over it — where every peer is
configured with the port instead of looking it up, so no reserved number is needed.
A mesh is only as reachable as its ports: a discovery seed carries no port and takes the
dialer's own, so a node left on a different port is never found. Give every node the same
port, and set NOONIEND_LISTEN and NOONIEND_ADVERTISE to match while they are mixed.

How it works

Every mutation is recorded as an operation in an append-only log, split into per-node shards:

  • create_entities / add_observations / create_relations add elements;
  • delete_entities / delete_observations / delete_relations write tombstones (a deleted entity
    also tombstones its observations and incident relations).

A read folds all shards: each element (entity, observation occurrence, relation) is an LWW
register decided by (HLC, node, sequence). A delete of an observation is content-level: it removes
every occurrence older than it. Observations are shown while their entity is present, relations
while both endpoints are present. The fold depends only on the set of operations, never on the
order shards or lines were read. Operations are ordered by a Hybrid Logical Clock: the order
survives clock skew, and a node that has observed a claim can write a correction ordered after it.
An observed stamp further than a bounded skew in the future is clamped, so a wrong clock cannot drag
the node's timestamps into the future. Reads are incremental: each shard is decoded once and
cached against a cheap fingerprint, and the folded graph is memoized, so a read with nothing changed
costs only a fingerprint poll per shard.

Consequences, all covered by property tests:

  • Idempotent — applying the same operations twice changes nothing.
  • Commutative — order of operations across shards does not matter.
  • Associative — folding shards in any grouping yields the same graph.
  • Convergent — two nodes with the same operations produce the identical graph.

Ordering is deterministic: entities by name, relations by (from, to, relationType), observations
in operation order (HLC, node, sequence).

Compaction

The log grows with every mutation. Compaction rewrites this node's shard keeping, per element, only
the operations that no later operation shadows — the shadow index is built from the merged log,
so an operation superseded by another node's later operation is dropped too, and the winner of
every element always survives, tombstones included. It runs online: the server compacts its own
shard after NOONIEN_COMPACT_AFTER appends, and noonien compact does the same by hand. When
each also collects tombstones — the physical deletion — is under Deletion and
collection. The rewrite is a compare-and-swap (a temporary file renamed
over the shard on the file backend, a conditional write on s3), so a crash midway can never
truncate it and a concurrent write — an append, or a gossip recovery — makes the whole compaction
re-read and retry instead of losing it.

Every compaction stamps a shard.compact metadata operation (never a graph element): its

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
server-noonien - shared memory MCP 怎么安装?

在客户端按下面的安装命令接入:npx -y server-noonien。对应的包名是 server-noonien。装完在客户端配置里引用同一个包或端点。

server-noonien - shared memory MCP 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

server-noonien - shared memory MCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

server-noonien - shared memory MCP 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

server-noonien - shared memory MCP 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、Gemini CLI、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

server-noonien - shared memory MCP 能提供哪些能力?

资料显示能力标签包括 mcp、model context protocol、memory、knowledge graph、crdt、local first。具体工具清单以官方文档为准。

server-noonien - shared memory MCP 需要什么运行环境?

运行时为 node;属于本地进程,需要在本机装好运行环境。

server-noonien - shared memory MCP 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。