# server-noonien [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/sequico/server-noonien  
**GitHub Stars:** 2  
**npm Downloads (last month):** 1352  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/server-noonien

## Description
Shared, serverless, conflict-free knowledge-graph memory for AI agents

## Tools
Capabilities this server exposes over MCP:

- **create_entities** — Create multiple new entities in the knowledge graph
- **create_relations** — Create multiple new relations between entities in the knowledge graph. Relations should be in active voice
- **add_observations** — Add new observations to existing entities in the knowledge graph
- **update_entities** — Prefer this to deleting an entity and re-creating it under another name: rename existing entities and/or change their entity type, keeping their observations and relations
- **update_observations** — Prefer this to delete_observations followed by add_observations: replace observation contents on existing entities in place
- **update_relations** — Prefer this to deleting a relation and creating another: change the type of existing relations and/or repoint their endpoints
- **merge_entities** — Prefer this to deleting one entity and re-adding its observations and relations to another: merge an entity into another, unioning their observations and repointing its relations
- **delete_entities** — Delete multiple entities and their associated relations from the knowledge graph
- **delete_observations** — Delete specific observations from entities in the knowledge graph
- **delete_relations** — Delete multiple relations from the knowledge graph
- **read_graph** — Read the knowledge graph, or a page of it: the optional limit and offset take a slice of the entities in name order
- **search_nodes** — Search for nodes in the knowledge graph based on a query
- **open_nodes** — Open specific nodes in the knowledge graph by their names
- **read_conflicts** — Call this when a write may have been superseded by another machine, or before trusting an edit: it lists the elements more than one node has written, with their authors, so a last-writer-wins resolution is visible instead of silent

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "server-noonien": {
    "command": "npx",
    "args": ["-y","server-noonien"]
  }
}
```

## Documentation

## What server-noonien does

server-noonien exposes a knowledge graph over the Model Context Protocol, using entities, typed relations, and observations as its core data model. It is designed as a drop-in replacement for the official MCP memory server, preserving its main memory tools while adding operations for updates, entity merges, and conflict inspection.

Unlike a single shared JSONL file, each node writes to its own append-only shard. The graph uses an LWW-Element-Set CRDT ordered by hybrid logical clock, node identifier, and sequence number. Shard merges are idempotent, commutative, associative, and convergent, so replicas that receive the same operations reach the same graph regardless of delivery order.

## How it works

The MCP command is short-lived and is normally spawned by an MCP client over stdio. It reads and writes a complete local replica, allowing the agent to continue working when disconnected. When connectivity returns, replicas can reconverge.

For direct machine-to-machine replication, run the long-lived `nooniend` daemon on each machine. It exchanges shards directly over reachable IP addresses, such as through a LAN or VPN, without requiring a shared folder, hosted service, or central server. The package also supports `file` and `s3` sharing backends when a shared folder or S3-compatible object store is preferred.

## Setup and configuration

The package requires Node.js 22 or newer. Install it globally with:

```sh
npm install -g server-noonien
```

An MCP client can launch the server with:

```sh
npx -y server-noonien
```

The command uses stdio and is intended to be registered in the client's MCP configuration. Claude Code can register it as a server named `memory` with `claude mcp add memory -- npx -y server-noonien`. A local storage directory can be set with `NOONIEN_DIR`, as shown in the OpenCode configuration example. Set `NOONIEN_BACKEND` when selecting a backend such as `s3`; the S3 SDK is an optional dependency loaded for that backend.

The same package also provides the one-shot `noonien` maintenance CLI and the long-running `nooniend` replication daemon. With a global install, both commands are available on `PATH`; `npx -p server-noonien noonien help` and `npx -p server-noonien nooniend` can run them without a global install.

## Tools and capabilities

The graph-management tools include:

- `create_entities`, `update_entities`, and `merge_entities` for creating, renaming, changing types, and combining entities.
- `create_relations`, `update_relations`, and `delete_relations` for managing directed, typed connections.
- `add_observations`, `update_observations`, and `delete_observations` for maintaining entity observations.
- `delete_entities` for removing entities and their associated relations.
- `read_graph` for retrieving the full graph.
- `search_nodes` for matching names, entity types, and observation content.
- `open_nodes` for retrieving named nodes.
- `read_conflicts` for listing elements written by more than one node and identifying their authors.

## Limitations and notes

Peer-to-peer synchronization requires IP reachability between participating machines, typically over a LAN or VPN. The `file` and `s3` backends instead require a shared folder or object store accessible to every node. The MCP server itself is a stdio process; replication is handled separately by `nooniend`. The project is licensed under MPL-2.0.

_Full upstream README: https://allmcps.com/mcp/server-noonien/readme_