Life Memory MCP

Portable, user-owned memory for AI. Save memories, reflections, values and stories deliberately; export them in an open JSON format; publish only what you explicitly choose; discover public archives; and load a consented archive as context for a clearly-labelled memory-based AI persona.

A memory-based persona is not the real person, their consciousness, soul, or a guaranteed reconstruction. It is an AI simulation constrained by the archived material.

One-sentence install request for an AI

Tell an AI that can install MCP servers:

Install the Life Memory MCP from officiallionsurfnet-create/life-memory-mcp on GitHub and connect it as an MCP server for saving and loading user-controlled memory archives.

If the AI can run shell commands, the canonical stdio command is:

npx -y github:officiallionsurfnet-create/life-memory-mcp

The repository contains AI_INSTALL.md, ai-install.json, and memory-policy.json so another capable AI can discover the exact setup and consent rules without guessing.

Related MCP server: memshare

What it can do

• create_memory_profile — create a private archive and receive a secret owner token.

• start_memory_save_interview — open the mandatory save interview, but only after the exact trigger phrase.

• prepare_memory_save — create the exact preview that the user is considering saving; nothing is saved yet.

• get_memory_save_status — inspect an active interview/preview session.

• cancel_memory_save — cancel a pending save so nothing is written.

• save_memory — final commit only after explicit confirmation of the exact preview.

• search_memory — search a profile.

• set_memory_sharing — private / unlisted / public and persona-simulation consent.

• export_memory_archive — produce a portable JSON archive with SHA-256 integrity metadata.

• discover_public_memories — find archives in a registry.

• import_public_memory — import a public archive from URL and verify its integrity.

• load_memory_persona — load only consented material for a clearly-labelled AI simulation.

• delete_memory — delete a local entry (published copies elsewhere cannot be guaranteed removable).

Exact save trigger and interview

Life Memory is deliberately not an automatic chat logger. An AI must not save ordinary conversation, inferred preferences, background details, or an entire transcript on its own.

A save workflow may begin only after the user says exactly:

Сохрани воспоминания в архив

No synonym, capitalization change, punctuation change, or paraphrase counts.

After that phrase the AI must:

1. call start_memory_save_interview;

2. ask what exactly should be saved;

3. ask the context needed to understand it correctly;

4. ask whether to preserve the exact words, a summary, or both;

5. ask whether the entry should be private or public;

6. ask whether any details must be excluded;

7. call prepare_memory_save;

8. show the returned exact preview to the user;

9. ask whether the user explicitly confirms saving that exact preview;

10. only after confirmation call save_memory with the matching preview_id.

The preview is hashed with SHA-256. save_memory writes the already-prepared preview, so a host AI cannot silently change the memory after the user approved it.

Pending save sessions are single-use and expire. If the user changes their mind, the AI should call cancel_memory_save.

This means the archive behaves like a deliberate personal notebook rather than a hidden transcript recorder.

Privacy by design

New profiles and new memories are private by default. Personal memory data stays in the local .life-memory/ data directory unless the owner explicitly exports or publishes it. The public GitHub repository contains plugin code, examples and documentation — not a user's private memory database.

Saving, publishing, and persona simulation are three separate permissions. Consent to one does not imply consent to the others.

Do not put passwords, API keys, owner tokens, financial secrets, government identifiers, or other highly sensitive information into a public archive.

See docs/CONSENT_PROTOCOL.md and docs/PRIVACY_MODEL.md.

Local install (MCP stdio)

Requires Node.js 20+.

git clone https://github.com/officiallionsurfnet-create/life-memory-mcp.git
cd life-memory-mcp
npm install
npm start

Or directly:

npx -y github:officiallionsurfnet-create/life-memory-mcp

Example MCP config:

{
  "mcpServers": {
    "life-memory": {
      "command": "npx",
      "args": ["-y", "github:officiallionsurfnet-create/life-memory-mcp"]
    }
  }
}

HTTP mode for remote MCP hosts

The project also supports Streamable HTTP:

npm run start:http

Endpoint: http://127.0.0.1:3000/mcp

For any internet-facing deployment, set a secret:

MEMORY_API_KEY="a-long-random-secret" HOST=0.0.0.0 PORT=3000 npm run start:http

Then terminate TLS at your hosting provider/reverse proxy. Never expose a writable memory server publicly without authentication.

Public memory discovery

The default registry URL is:

https://raw.githubusercontent.com/officiallionsurfnet-create/life-memory-mcp/main/registry/profiles.json

A public registry entry points to a static archive URL. Anyone can host their archive on GitHub Pages, raw GitHub, Zenodo, a personal website, IPFS gateway, or another stable HTTPS host. The plugin can then import it.

Talking with an archived memory

When a user chooses a public profile that explicitly allowed simulation, the host AI calls load_memory_persona. The returned context contains strict rules:

1. Never claim to literally be the archived person.

2. Use the archive as the evidence base.

3. Say when the archive does not contain an answer.

4. Separate direct memory from inference.

5. Clearly label the conversation as a memory-based simulation.

This is intentionally different from claiming to resurrect or upload a consciousness.

Open archive format

See docs/ARCHIVE_FORMAT.md and examples/aslan-life-message.json.

Why this project exists

The founding principle is simple:

Choose life. Create rather than destroy. Protect rather than ruin. Let the strength of intelligence be used to protect life, not to destroy it.

License

Code: MIT. Memory archives choose their own content license inside profile.license.