Log inSubmit server
Celiums Memory logo

Celiums Memory

by celiums

Persistent MCP memory with journaling, ethics evaluation, circadian state, hybrid retrieval, and SQLite or clustered storage.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Celiums Memory

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "celiums-celiums-memory": {
      "command": "npx",
      "args": [
        "-y",
        "@celiums/memory"
      ],
      "env": {
        "SQLITE_PATH": "YOUR_VALUE_HERE",
        "DATABASE_URL": "YOUR_VALUE_HERE",
        "QDRANT_URL": "YOUR_VALUE_HERE",
        "VALKEY_URL": "YOUR_VALUE_HERE",
        "CELIUMS_API_KEY": "YOUR_VALUE_HERE",
        "PORT": "YOUR_VALUE_HERE",
        "CELIUMS_LLM_API_KEY": "YOUR_VALUE_HERE",
        "CELIUMS_LLM_BASE_URL": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

We couldn’t confirm it starts correctly

The install command didn't complete successfully in our automated test.

npx -y @celiums/memory

npm notice npm notice New major version of npm available! 10.1.0 -> 12.1.0 npm notice Changelog: <https://github.com/npm/cli/releases/tag/v12.1.0> npm notice Run `npm install -g npm@12.1.0` to update! npm notice npm ERR! could not determine executable to run npm ERR! A complete log of this run can be found in: /home/user/.npm/_logs/2026-09-30T12_29_10_954Z-debug-0.log

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 1mo ago.

Overview

The celiums/celiums-memory MCP server provides persistent memory, journaling, ethics evaluation, knowledge search, and per-user biological-clock state for compatible agents. It exposes 61 typed tools through an HTTP MCP endpoint, with automatic context loading on the first request. Storage can use local SQLite or PostgreSQL with Qdrant and Valkey, while optional LLM providers support AI-backed tools. Reach for it when an agent needs durable, isolated memory and auditable journal or ethics workflows rather than a user-facing application.

Use cases

  • Store and recall agent memories across sessions
  • Maintain a verifiable first-person journal
  • Evaluate requests through layered ethics checks
  • Search supplied skills and knowledge with hybrid retrieval
  • Compose context using per-turn state and checkpoints

Key features

  • Persistent memory with hybrid retrieval
  • Hash-chained agent journal
  • Layered ethics evaluation
  • Circadian and affective state modulation
  • SQLite or PostgreSQL, Qdrant, and Valkey storage
  • 61 typed MCP tools

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 1d ago

Recent health check succeeded.

21/21 checks healthy over the last 91d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 9d ago via OSV.dev · @celiums/memory (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars23Stargazers on the source repository.
npm downloads72Package downloads in the last 30 days.
Last commit2mo agoMost recent push to the default branch.
Install checkInconclusiveInstall command did not finish in our automated test.
Directory activity3 viewsConfig copies, upvotes, and views on AllMCPs.

How Celiums Memory works

What celiums/celiums-memory does

The celiums/celiums-memory MCP server is an engine for embedding memory and related cognitive services into agents, assistants, pipelines, and other software. It has no dashboard or standalone user interface. MCP clients connect over HTTP and can use persistent memory, a first-person journal, hybrid knowledge search, ethics evaluation, and per-user time-state handling.

Memory operations include storing and recalling content, importance scoring, consolidation, lifecycle decay, and retrieval influenced by affective state. The journal is append-only and hash-chained, with support for causal chains, arcs, introspection, dialogue, and chain verification. The ethics subsystem evaluates requests through deterministic, probabilistic, philosophical, and optional precedent layers.

How it works

Each MCP or HTTP request passes through automatic bootstrap, authorization and assurance checks, ethics checks, tool dispatch, storage, and any configured language-model provider. On a client’s first call, bootstrap adds session context so previously available information can be loaded into the response.

The celiums/celiums-memory MCP server supports two storage arrangements. SQLite provides a local, embedded mode without external services. A clustered configuration uses PostgreSQL, Qdrant for vector data, and Valkey for caching. The engine also documents local-only, zero-knowledge encrypted, and cloud-managed synchronization modes.

The forage capability searches skills and knowledge supplied through the skills table or an optional knowledge backend. The large curated module corpus is separate, so search does not depend on that corpus. Ethics Layers A and B operate without extra setup; Layer K requires the separately distributed ethics_knowledge release asset and an OpenSearch instance.

Setup and configuration

Docker Compose starts the PostgreSQL, Qdrant, and Valkey stack. Set at least POSTGRES_PASSWORD, then start the services; the MCP and HTTP server listens on port 3210 by default. For local use, install dependencies, build the project, and start it with SQLITE_PATH set to a database file.

Clients connect to /mcp with a bearer token in the Authorization header. CELIUMS_API_KEY can provide that token; if it is omitted, the server generates one on first run. DATABASE_URL selects the PostgreSQL adapter, while QDRANT_URL and VALKEY_URL configure its vector and cache services. PORT changes the listening port.

Optional configuration includes PERSONALITY, BYO LLM settings through CELIUMS_LLM_API_KEY, CELIUMS_LLM_BASE_URL, and CELIUMS_LLM_MODEL, plus KNOWLEDGE_API_URL and KNOWLEDGE_API_KEY for an external knowledge backend.

Tools and capabilities

The celiums/celiums-memory MCP server groups its 61 tools into several areas:

  • Memory and knowledge: remember, recall, forage, sense, and synthesize.
  • Journaling: journal_write, journal_recall, journal_arc, and journal_verify_chain.
  • Ethics: ethics_lookup, ethics_audit, and ethics_trace.
  • Research: project management, search, and export tools.
  • Writing: project and scene tools plus continuity checking.
  • Proactive context: turn_context, turn_after, and compact_checkpoint.
  • Optional Atlas tools for routing and cognitive operations.

Limitations and notes

The system is an engine rather than an application, so it does not provide a login dashboard. The curated knowledge-module corpus is not included in the repository, and Layer K remains inactive until its release asset is loaded into OpenSearch. AI-backed features require a configured language-model provider and the applicable credentials.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Celiums Memory

celiums/celiums-memory is an MCP server that connects compatible AI clients to a persistent cognitive memory engine over HTTP. Its main tools include `remember`, `recall`, `forage`, journal operations such as `journal_write`, and ethics tools including `ethics_trace`, with support for per-user state and automatic session context.

Install it by cloning the repository and either starting the Docker Compose stack or building a local SQLite deployment. Docker requires `POSTGRES_PASSWORD` at minimum; local mode uses `pnpm install`, `pnpm build`, and `SQLITE_PATH=./celiums.db pnpm start`.

Connect Cursor to the HTTP endpoint at `http://localhost:3210/mcp` and send the bearer token in the `Authorization` header. Set `CELIUMS_API_KEY` or use the key generated on first startup.

Yes, Claude Code is named as a compatible MCP client. Configure an MCP server entry with the Celiums `/mcp` URL and an `Authorization: Bearer` header containing the server API key.

Yes, it can run without Docker in local SQLite mode. Install dependencies, build the project, set `SQLITE_PATH` to a database file, and start the server; this mode does not require external database, vector, or cache services.

Related MCP servers

All in Knowledge & Memory All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewCeliums Memory AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/celiums-celiums-memory?style=directory)](https://allmcps.com/mcp/celiums-celiums-memory)
HTML Embed
<a href="https://allmcps.com/mcp/celiums-celiums-memory"><img src="https://allmcps.com/api/badge/celiums-celiums-memory?style=directory" alt="Celiums Memory on AllMCPs" /></a>