
turns your local Mnemosyne OS install into a queryable memory layer for any AI agent that speaks
turns your local Mnemosyne OS install into a queryable memory layer for any AI agent that speaks MCP.
·
@mnemosyne_os/mcp: MCP server for Mnemosyne OS. Gives AI agents access to vault memory, resonances, git context, and to what the other coding agents on this machine are doing.
Product mnemosyne-os.io · Company, press and labs mnemosyne-os.com · Documentation docs.mnemosyne-os.io
Give Claude, Cursor, Hermes Agent, Copilot, and any MCP-compatible agent access to your local Mnemosyne OS memory vault. Code, decisions, architecture notes, git history, semantically queryable. The vaults stay on your machine, and this server opens exactly one socket:
127.0.0.1:7799.
🍳 In a hurry? RECIPES.md gives your coding agent a persistent memory in one copy-paste block, for Claude Code, Cursor, Claude Desktop and the TypeScript SDK.
@mnemosyne_os/mcp is a Model Context Protocol server that
turns your local Mnemosyne OS install into a
queryable memory layer for any AI agent that speaks MCP.
Once configured, your agent can:
ARCHITECTURE, GIT, SOURCE_CODE,
BUGFIX and the rest.The MCP itself opens exactly one socket: 127.0.0.1:7799. It sends nothing anywhere else and keeps no state. Your claude.ai conversation sees only the chronicles you allow. What Mnemosyne OS does behind that socket follows the route you configured.
mnemosyne_memory_ask runs whichever model you picked, local or cloud.
Node.js ≥ 18 is the only hard requirement.
The memory tools additionally need Mnemosyne OS Infinity Edition running. It owns your vaults and exposes the WebSocket gateway on
ws://127.0.0.1:7799. It is a desktop application, and it is where your content lives.
The three agent-awareness tools need neither: mnemosyne_agent_list,
mnemosyne_agent_collisions and mnemosyne_agent_files. They read transcript
files your coding-agent harness already writes to disk, so they answer with the
app closed, with no vault, and without spending a token. They read every
harness they find, so a Claude Code session can see an Antigravity session
running in the same repository.
The MCP is a thin bridge. It does not store anything itself. All data lives in Mnemosyne OS Infinity (
%APPDATA%\@mnemosyne-workspace\infinity-edition\vaults\*.dbon Windows,~/Library/Application Support/...on macOS).
Three different routes, and only one of them ingests anything. Knowing which is which saves you looking for a feature that is not where you expect it.
Your files: source, architecture notes, decision records. You declare a folder, the app watches it, and what lands there is ingested into the vault you chose. Nothing is uploaded and nothing is scanned that you did not name. This is the step people miss: installing the app gives you empty vaults, and declaring the folder is what fills them. See Getting started and DocWatch. The full walkthrough, including why there is an application behind this server at all, is Get your repository into memory.
Your commits. mnemosyne_git_log reads the repository the app is
configured to read, at the moment you call it. Nothing is ingested and nothing
is stored, so history is never stale and never doubled.
What your agents did. mnemosyne_agent_list, mnemosyne_agent_collisions
and mnemosyne_agent_files read the transcript files your harness already
writes. No app, no vault, no token. Those three work the minute this server is
installed, which is why they are the ones to try first.
⚠️ Without the app running, everything else refuses and says so. The refusal
names what it checked: whether ~/.mnemosyne exists tells it whether the app
has ever run on this machine, and it says "install it" and "start it" as two
different sentences, because they are two different problems.
Download Mnemosyne-OS-MCP-2.4.0.mcpb (4.4 MB), then open Claude Desktop → Settings → Extensions and drop the file into that panel. That is the whole install. The 31 tools appear straight away, and the same panel offers the three optional settings: default vault, other vaults, and the port the desktop application listens on.
The bundle rides on the application's current release,
v1.5.1-infinity,
because this package has no release of its own. The file is named after this
package version, not after the application one in the tag. Earlier bundles stay attached
to v1.4.5-infinity, so a link someone saved keeps working.
Two things worth knowing before you do it:
packages/mcp/scripts/build-mcpb.mjs..mcpb extension with
Windows. Drop it into the Extensions panel instead.If you would rather not install an extension, or you are on a build that has no Extensions panel:
Open Claude Desktop → Settings → Developer → Edit config (or edit claude_desktop_config.json directly):
%APPDATA%\Claude\claude_desktop_config.json~/Library/Application Support/Claude/claude_desktop_config.jsonAdd:
{
"mcpServers": {
"mnemosyne": {
"command": "npx",
"args": ["-y", "@mnemosyne_os/mcp"],
"env": {
"MNEMO_DEFAULT_VAULT": "DEV",
"MNEMO_VAULTS": "DEV,PERSONAL,SOCIAL"
}
}
}
}Fully quit and relaunch Claude Desktop (close from the tray icon, not just the window). The mnemosyne server should show up under Settings → Developer → Local MCP Servers with the running badge.
Add to .mcp.json at the root of your project:
{
"mcpServers": {
"mnemosyne": {
"command": "npx",
"args": ["-y", "@mnemosyne_os/mcp"],
"env": {
"MNEMO_DEFAULT_VAULT": "DEV",
"MNEMO_VAULTS": "DEV,PERSONAL,SOCIAL"
}
}
}
}Reload the Claude Code session.
Add to .cursor/mcp.json:
{
"mcpServers": {
"mnemosyne": {
"command": "npx",
"args": ["-y", "@mnemosyne_os/mcp"],
"env": {
"MNEMO_DEFAULT_VAULT": "DEV",
"MNEMO_VAULTS": "DEV,PERSONAL,SOCIAL"
}
}
}
}Hermes Agent from Nous Research ships with MCP support, so there is no extra install step.
Add to ~/.hermes/config.yaml:
mcp_servers:
mnemosyne:
command: "npx"
args: ["-y", "@mnemosyne_os/mcp"]
env:
MNEMO_DEFAULT_VAULT: "DEV"
MNEMO_VAULTS: "DEV,NOTES"Restart Hermes. Your agent now has a sovereign long-term memory it can query semantically, and everything stays on your machine, which is exactly the deal Hermes promises you.
Recommended for autonomous agents: grant read scopes narrowly, to the
vaults the task needs and no others. Point MNEMO_DEFAULT_VAULT at a vault
dedicated to agent work rather than at your personal notes.
The mnemosyne-memory skill is a
portable agentskills.io-standard skill that teaches
any agent the governance rules: discover vaults first, respect protection
levels, ingest with provenance, read before you write.
npx -y @mnemosyne_os/mcpThe MCP speaks standard JSON-RPC over stdio.
In Mnemosyne OS Infinity you create vaults, and watched folders feed them.
Each vault is stored in a folder of its own, and its token is that folder's name
in uppercase. The app also routes three reserved names: DEV, PERSONAL and
SOCIAL. DEV reaches whichever vault mounted first. Two env vars tell
the MCP which vaults your agent may reach:
| Env var | Purpose | When unset |
|---|---|---|
MNEMO_DEFAULT_VAULT | Vault used when the agent does not name one. It is always reachable. | The first vault of MNEMO_VAULTS, or DEV when there is no list |
MNEMO_VAULTS | Comma-separated list of the vaults your agent may reach. | DEV, PERSONAL and SOCIAL |
Once you set MNEMO_VAULTS, it is the whole list. Your agent reaches those
vaults and the default vault, and nothing else. Add DEV, PERSONAL or
SOCIAL to the list if your agent needs them. Up to 2.1.2, these three names
stayed reachable whatever the list said.
A developer whose Infinity tracks ~/Documents/INFINITY/code-projects/:
"env": {
"MNEMO_DEFAULT_VAULT": "CODE_PROJECTS",
"MNEMO_VAULTS": "CODE_PROJECTS,NOTES,RESEARCH"
}A researcher who keeps everything in ~/Documents/INFINITY/papers/:
"env": {
"MNEMO_DEFAULT_VAULT": "PAPERS",
"MNEMO_VAULTS": "PAPERS,REFS,IDEAS"
}If your agent asks for a vault outside the list, the server refuses it with
UNREACHABLE_VAULTand names the vaults it can reach. Add the vault name to the list and restart your MCP client.
Mnemosyne OS ships local, offline text-to-speech engines that can clone a voice from a short reference clip. With one env var, your agent gets three extra tools that turn a written script into a WAV file on disk. They are made for voice-overs: TikTok, YouTube, podcast, narration.
"env": {
"MNEMO_VOICE": "1"
}| Tool | What it does |
|---|---|
mnemosyne_voice_list | List the local engines, installed or not, and the reference voices available for cloning. Call it first. |
mnemosyne_voice_speak | Render a script to a WAV. Long scripts are split at sentence boundaries and re-assembled into one file, with nothing truncated. It returns a job: the tool waits, then hands back a job id if the render is still going. |
mnemosyne_voice_status | Poll or cancel a render. It returns the file path once the render is done. |
Off by default, on purpose. Turning it on makes Mnemosyne OS ask you to
authorize voice:speak. That permission is never auto-granted, not even to
first-party apps like this one, because its subject is your identity rather than
your data. You approve it once, in a dialog that says what it means.
Two limits. The agent never creates or records a voice; you do that in the app, under Settings → Voice. A clone name that does not exist is refused rather than quietly replaced, because a voice-over in the wrong voice sounds perfect and is worthless.
Requirements: the Mnemosyne OS app must be running, since the engines are Python sidecars inside it and the headless daemon cannot speak. A local voice must be installed, and local neural TTS is a licensed feature.
Open a new conversation with your agent and ask, for example:
Use mnemosyne_memory_query to search my vault for "authentication flow", spine_type_filter ARCHITECTURE only.
You should see a structured response with 5–10 chronicles, each tagged with its spineType, score, source, and a content snippet. If the agent says it cannot connect, see Troubleshooting.
Twenty-six are in the table below. The three that read the other agents on this
machine, and the two that update the Mac app, have their own sections further down. Setting MNEMO_VOICE=1 adds the
three voice tools documented further up, and MNEMO_FORGET=1 adds the erasure
tool, for 35 in all.
Six of them read or write the To-do backlog and the calendar. All six carry the same requirement:
Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running.
| Tool | What it does |
|---|---|
mnemosyne_about | Re-read the briefing the agent was handed on connect: the governance tenet, the vault protection model, the spine model, and the rules for an agent working on someone else's memory. Call it if your client did not surface the server instructions. |
mnemosyne_memory_query | Semantic search. It returns raw chronicles, ranked by vector similarity fused with a local BM25 channel and weighted by spineType. Supports spine_type_filter, max_content_chars and limit (50 max). |
mnemosyne_memory_ask | Ask a question, get a synthesized prose answer grounded in the vault, plus its source chronicles. Use it for why, who and how questions that span many memories. It runs the full RAG pipeline, which also makes it the better retriever, and it is slower than query. |
mnemosyne_vault_list | List the vaults this server can reach, with each one's token, name, chronicle count and the description written in its panel in the app. Call it to discover valid vault targets. A vault outside MNEMO_VAULTS is counted, never named, and no local path is printed. A vault with no description is left without one, and the list says how many reachable vaults have none. |
mnemosyne_memory_forget | Erase one chronicle for good, by the id mnemosyne_memory_query returned. Absent unless you set MNEMO_FORGET=1, and the app wants the FORGET intent on top of that. You arm erasure by hand, because writing a new chronicle cannot undo it. |
mnemosyne_memory_ingest | Persist a memory. Pick a spine_type: ARCHITECTURE, DECISION, BUGFIX, FEATURE, NOTE, SESSION, RESONANCE or CUSTOM. |
mnemosyne_todo_add | Put tasks into the user's To-do backlog, in order and optionally under named steps. Name the list, or pass create_list: true. An unknown name is refused with the lists that exist. With a window open the write goes through the widget's own store; on macOS with the window closed the app writes the file directly. Scope todo:write. |
mnemosyne_cockpit_update | Your own status card on the user's canvas: state working, waiting, done, blocked or closed, a title, one status line, up to 4 detail lines. You declare the state, and the app prints it next to the time since your last call, so call at real milestones. "waiting" and "blocked" make the card pulse and the taskbar flash. The answer carries the messages the user left on your card. Send desktop once, with the name of a board the user gives you, and this session’s cards go there for the rest of the conversation; leave it out and they go to whichever board answers for this project. Claude Code names the card by its CLAUDE_CODE_SESSION_ID; other clients (Cursor, Antigravity…) pass session, any stable id for the conversation, on every call. Needs the app window open. Scope cockpit:write. |
mnemosyne_pheme_watch | Add a subreddit, a Hacker News query or a topic to the user's Pheme radar, or take one off. The lists are theirs. An operation that would empty one is refused, each one reports its own outcome, and the user gets a receipt in Pheme naming the agent and what changed. It posts nowhere. Needs the app running, though Pheme itself can be closed. Scope pheme:profile. |
mnemosyne_pheme_radar | Read what the Pheme radar last found: fresh threads in the watched subreddits and Hacker News queries, with a topic score and, after the user's Mnemosyne OS pass, a tier. The answer leads with when the scan ran, because it is only as fresh as the last scan the user ran. "No radar yet" is said in words rather than returned as an empty list. Draft the reply; the user posts it. Needs the app running. Scope pheme:read. |
mnemosyne_review_open | Ask the user to review a video or image you made. It shows in the review panel of Mnemosyne OS and, once they paired the review bot, on their phone (Telegram) with Approve / Change / Reject buttons. The file must be inside ~/.mnemosyne/generations, voiceovers or outbox; anything else is refused. Pass parentId for a retake: the panel shows the versions side by side. Needs the app running. Scope review:ask. |
mnemosyne_review_wait | Wait for the user's answers to that review, from the app or the phone: approve, changes, reject or a plain comment (frame notes can come alone), with the text (a voice note arrives transcribed) and the second of the video it points at. Returns every answer since after. One call waits ~45 s, under the client's own tool timeout; on STILL WAITING, call again with the same after. To wait without a loop, run the mnemosyne-review-wait <id> --after <ms> command this package ships (it exits with the answer). Needs the app running. Scope review:ask. |
mnemosyne_review_get | Read a review as it stands: state, every answer, publishing state. Does not wait. Needs the app running. Scope review:ask. |
mnemosyne_telegram_send | Send one local file (video, photo, audio, pdf) to the user's Telegram home chat — the Hermes bot channel they already configured. Absolute path required; optional caption. Recipient is never chosen by the agent. Caps: 48 MB, allow-listed types. Needs the app running. Scope telegram:homeSend. |
mnemosyne_agenda_add | Put appointments or deadlines into the user's calendar. start and the optional end are ISO 8601, and a time with no offset is read as the user's own machine local time. Supports all_day, recurrence (daily, weekly, monthly, yearly) and alarm_minutes_before. To change or remove one, see mnemosyne_agenda_update and mnemosyne_agenda_remove. Scope agenda:write. |
mnemosyne_todo_list | Read the backlog back: the lists, and every task with the id you need to change it. Call it before mnemosyne_todo_update, which names tasks by id. A phrase like "delete the task about the invoice" reads perfectly and can still match the wrong task. Filters by list, include_done and limit. The archive is counted rather than listed. Scope todo:read. |
mnemosyne_todo_update | Change tasks: edit, complete, move, remove. Every operation names an id from mnemosyne_todo_list. remove archives by default and stays recoverable; permanent: true deletes outright and has to be asked for. The batch applies in order as one save, and each operation reports its own outcome, so a stale id does not sink the ones around it. Scope todo:write. |
mnemosyne_todo_categories | Manage the lists themselves: list.create, list.edit to rename or recolour, list.remove. A list that still holds tasks is never removed, and you are told how many are in the way. Move them first: the app will not pick a destination on someone else's behalf. The three original lists can be renamed, never removed. Scope todo:write. |
mnemosyne_agenda_list | Read the calendar back: appointments in a time window, each with the id the two tools below require. A repeating event appears once, with its cadence and its next occurrence. An event with nothing left to happen says so rather than showing its original start as a future date. Scope agenda:read. |
mnemosyne_agenda_update | Change an appointment: move it, rename it, add or drop a reminder, start or stop it repeating. A field left out is left alone, and null clears it. An unreadable date refuses the change rather than leaving the old one silently in place, and an unknown cadence is refused rather than quietly made a one-off. Scope agenda:write. |
mnemosyne_agenda_remove | Remove appointments, by id only. The calendar has no archive: unlike a To-do task, a removed appointment is gone, so the answer names each one by title and start time for the user to check. A repeating appointment goes as a whole series, since the calendar cannot cancel one occurrence. Scope agenda:write. |
mnemosyne_resonance_list | List the resonances recorded in the default vault. A resonance is a workspace that tracks one ongoing project. |
mnemosyne_position_get | Read where one resonance was left: its phase, and the note written when the work stopped. |
mnemosyne_position_update | Record where you left off. It is stored as a DECISION chronicle. |
mnemosyne_git_log | Recent commits from the git repository Mnemosyne OS is configured to read (requires monorepo:read scope). |
mnemosyne_spine_assignments | How the memories were actually classified: chronicle-to-spine assignments for a vault, newest first, with whole-vault counts per spine and, on request, the taxonomy tree. It is also where the taxon ids come from, so read it instead of guessing a spine_type_filter. |
mnemosyne_dream_bridges | The links the Dream State engine found on its own while the machine sat idle, each with its score and an excerpt of both sides, sometimes across two vaults. An empty list is the normal answer and means it has produced none yet, never that the query failed. |
The Mac build is not notarized yet, so the app cannot update itself. These two let your agent do the update the careful way, with the app closed.
| Tool | What it does |
|---|---|
mnemosyne_mac_update_check | The installed version, the latest release, the macOS version, whether the app runs, and whether the key files exist (never their content). Writes nothing. |
mnemosyne_mac_update_install | Downloads the dmg and checks its sha512 against latest-mac.yml, backs up the key files, asks the app to quit (never kills it), verifies the new app's signature, swaps it in (the old one is kept) and relaunches. Needs the exact version and confirm: true. |
macOS then asks you for Keychain access: click Always Allow. Your agent never clicks it.
These three read the transcripts coding-agent harnesses already write to disk. No app, no vault, no tokens. That is what makes "check before you commit" cheap enough to actually do.
| Tool | What it does |
|---|---|
mnemosyne_agent_collisions | Are two agent sessions live on the same project and branch right now? Call it before git add -A, before a commit and before a rebase. One working tree shares one git index, so a commit from one session picks up whatever the other has staged. |
mnemosyne_agent_list | The sessions on this machine: conversation name, project, branch, model, last tool, file count, and when a line was last written. |
mnemosyne_agent_files | Which files other sessions recently wrote, newest first, with the session each came from. Paths and timestamps only. |
No configuration needed. Every shipped connector whose folder exists on this machine is read, and each answer names the folders it actually opened. Override only if your agent writes somewhere unusual:
"env": {
// Per harness. Absent means "where that agent writes by default".
"MNEMO_AGENT_SESSIONS": "C:/Users/you/.claude/projects",
"MNEMO_AGENT_SESSIONS_ANTIGRAVITY": "…",
"MNEMO_AGENT_SESSIONS_ANTIGRAVITY_IDE": "…",
// OpenClaw has no usual folder: read only when you name the folder holding
// your `openclaw sessions export-trajectory` exports.
"MNEMO_AGENT_SESSIONS_OPENCLAW": "…",
// Restrict to a subset. Absent means all of them.
"MNEMO_AGENT_SOURCES": "claude-code,antigravity"
}One line you do want, though: ← you. A stdio MCP server is launched with the
env its config declares, so the caller's own session id does not arrive on its
own. Without it the report cannot mark which line is yours, and it counts one
session too many, which is the exact miscount these tools exist to prevent.
Pass it through:
"env": {
"CLAUDE_CODE_SESSION_ID": "${CLAUDE_CODE_SESSION_ID}"
}If you skip it, or if the variable is not set where Claude Code runs (it then
arrives as the literal ${CLAUDE_CODE_SESSION_ID}), the answer says so in one
sentence and tells you which of the two happened. It never guesses: an id it
cannot place stays neutral rather than becoming "none of these is you", because
that would add a phantom session to every warning.
Four limits these tools hold to. A tool that overstates its evidence is worse than no tool.
A file is marked recorded when the harness logged a file-writing tool call, and from a command when a redirection was read out of a shell command that may never have completed. Those are different kinds of fact and are never merged.
mnemosyne_cockpit_update puts your session on the user's canvas, but only
when the model decides to call it. A session that forgets leaves a card saying
"working" long after it stopped, and a message the human typed on that card
waits for a call that may never come.
The package ships a Claude Code hook that closes both gaps. Install the package so the binary is on your path, then wire it in your own settings. The package never touches them.
npm install -g @mnemosyne_os/mcp// .claude/settings.json, or ~/.claude/settings.json for every project
{
"hooks": {
"SessionStart": [{ "hooks": [{ "type": "command", "command": "mnemosyne-cockpit-hook" }] }],
"UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "mnemosyne-cockpit-hook" }] }],
"Notification": [{ "hooks": [{ "type": "command", "command": "mnemosyne-cockpit-hook" }] }],
"Stop": [{ "hooks": [{ "type": "command", "command": "mnemosyne-cockpit-hook" }] }],
"SessionEnd": [{ "hooks": [{ "type": "command", "command": "mnemosyne-cockpit-hook" }] }]
}
}The event name arrives on stdin, so one command serves all five. What each does:
| Event | The card | Your mail |
|---|---|---|
SessionStart | appears, working | delivered as context |
UserPromptSubmit | working, status is your prompt's first line | delivered as context |
Notification | waiting, and the question the harness is putting to you | — |
Stop | done, status is the answer's first line | if mail is waiting, the stop is refused and the mail is the reason, so the session reads it instead of ending |
SessionEnd | goes away | — |
Nothing clears waiting on its own, because answering a question is not a prompt. The card holds it until the turn ends or you type something. The host says how long it has been unconfirmed rather than quietly moving on.
Do not reach for npx here, even though the server line above uses it.
npx --package=@mnemosyne_os/mcp mnemosyne-cockpit-hook does work, and it cost
2.1 to 3.7 seconds a run on the machine where the installed binary cost 0.4 to
0.7. UserPromptSubmit fires on every message you send, so that difference is
the whole feature.
It cannot cost you a session. Every failure path writes one line to stderr and exits 0. Measured on Windows through the installed binary: 0.40 to 0.58 s with Mnemosyne OS running, 0.47 to 0.66 s with it closed. Most of that is Node starting and the shim npm writes on Windows, since a closed local port refuses at once. A refused stop cannot loop either: the mail is marked delivered when it is handed over, so the next stop finds none and ends normally.
Claude Code only. The event names and the refusal format are Claude Code's hook contract. Cursor and Antigravity have their own and will not fire this one. The three agent-awareness tools above work with every harness; this hook does not.
mnemosyne_memory_query, full parameter reference{
query: string; // required; be specific, longer is fine
limit?: number; // default 10, capped at 50 server-side
vault?: string; // default: $MNEMO_DEFAULT_VAULT
spine_type_filter?: string[]; // e.g. ["ARCHITECTURE"], ["GIT","BUGFIX"]
max_content_chars?: number; // default 600; trims each result snippet
}The MCP automatically opts into the semantic ranking branch (Vertex 768D / e5-base) and applies an exact-term boost for identifier-like tokens in your query (codenames, hyphenated tokens, version numbers). The result is a list of chronicles ranked by true semantic relevance, not recency.
At session start
agent → mnemosyne_position_get("my-project")
← phase, last position, what was being worked on
During the session
agent → mnemosyne_memory_query("auth refactor decisions",
spine_type_filter=["ARCHITECTURE","DECISION"])
← top 10 chronicles, ranked by relevance
When making a decision worth keeping
agent → mnemosyne_memory_ingest(
content="Chose JWT over session cookies because we need stateless
workers; trade-off: token revocation needs a denylist.",
spine_type="DECISION")
At session end
agent → mnemosyne_position_update("my-project",
position="JWT migration shipped, next:
denylist via Redis",
phase="Phase 12")
Next session
agent → mnemosyne_position_get("my-project")
← Resumes from Phase 12 with full contextMnemosyne OS Infinity is not running. Launch it. The MCP retries on every tool call, so once Infinity is up, the next query will succeed.
UNREACHABLE_VAULT or SCOPE_DENIED on a vaultThe vault is not in MNEMO_VAULTS. Edit your MCP client config, add the name
(uppercased), restart the client. The list is the whole grant, so keep every
vault the agent already uses.
Ask the agent to run mnemosyne_vault_list. It lists the vaults your
MNEMO_VAULTS config grants, with their token, name and chronicle count.
The other vaults of the machine are only counted: their names, descriptions
and paths stay off the agent's screen, and out of the model it sends them to.
To grant one, read its token in the vault panel of the app, add it to
MNEMO_VAULTS and restart the client.
Use max_content_chars to shrink each snippet. The default is 600. Drop it to
200 for browsing, or raise it to 4000 to read a full file. You can also filter
with spine_type_filter to drop noisy types.
DocWatch ingests on file save with a small delay. Check the spine: if you wrote a markdown with spine: IDEATIONAL frontmatter, it lands as IDEATIONAL. Query with spine_type_filter=["IDEATIONAL"] to
surface it.
This server is a bridge, not a service. It has no backend of its own, no account and no
hosted endpoint: it opens a WebSocket to 127.0.0.1:7799 on your own machine and relays to
the Mnemosyne OS desktop application running there.
What it collects. Nothing. No telemetry, no usage tracking, no analytics, no crash reporting. It holds no identifier for you and never asks for one.
What it stores. Nothing of its own, since it is stateless between calls. Your chronicles live in vaults on your disk, written and managed by the desktop application. The agent-awareness tools read your coding agents' transcript files locally and return metadata only (paths, counts, timestamps), never the text of a message or the contents of a file, and they open no network connection at all.
Who else sees it. Two parties, both of them your choice, and nobody beyond them:
MNEMO_VAULTS to the domains a given agent should reach. A vault left out is
refused, including vaults that exist on the machine.The server itself shares with no one, sells nothing and rents nothing.
How long it is kept. By this server, not at all. In the application, for as long as you
keep it: memory is deleted where it is made, in the app and by you. Note that
mnemosyne_memory_ingest writes a permanent chronicle. It is the one call
here the agent cannot undo afterwards.
Contact. Privacy questions go to [email protected], XPACEGEMS LLC, 2932 NW 72 Ave, Miami, FL 33122, USA. Full policy: https://mnemosyne-os.io/confidentialite. Bugs and security reports: https://github.com/Mnemosyne-OS/Mnemosyne-Neural-OS/issues.
This package is the memory. The desktop app ships a second MCP server, Mnemosyne OS actions, for what the OS can do. It is not on npm: the app carries it and keeps it at its own version.
| Tool | What it does |
|---|---|
os_find | Looks up an action the OS can perform, from the person's request in their own words. The answer gives each matching action with its exact arguments, or says that none exists. |
os_run | Runs one action found with os_find: open, arrange or close windows on the board, compose a desktop, or drive an installed app (Atlas, Vitrine Studio, the CRM and the others). Several steps of one app go in one call. |
os_image_generate | Draws a picture, billed per picture on the person's Mnemosyne credits. |
os_video_generate, os_video_status | Makes a short video clip from a first and a last picture, billed per second on the same credits. |
os_avatar_film, os_avatar_status | Makes a video of the person's particle avatar saying the lines given, with a voice of Mnemosyne OS, on their computer. No credits. |
Connect it. In the app, open Settings › Agents › Connect my coding agent.
For Cursor and Antigravity, one click writes both servers into the agent's
config. For Claude Code, the panel prints the two claude mcp add lines to
copy. The same panel is on the first screen of the setup wizard.
What the person keeps. The first os_run opens a dialog inside the app,
and the person allows the catalog there. Pictures ask once, and videos ask once
more on their own, because both spend the person's credits. Every action needs the app running.
@mnemosyne_os packagesAll of them live under one npm organization: npmjs.com/org/mnemosyne_os
| Package | What it is |
|---|---|
@mnemosyne_os/sdk | Build a Layer 2 app: a Node or browser process talking to the local WebSocket surface |
@mnemosyne_os/create-app | npm create @mnemosyne_os/app scaffolds that Layer 2 app in one command |
@mnemosyne_os/cartridge-sdk | Build an in-app cartridge: a sandboxed iframe widget rendered on the canvas |
@mnemosyne_os/mcp (you are here) | MCP server: plug Claude, Cursor or any MCP agent into the vaults |
@mnemosyne_os/design-sdk | Skin the OS with JSON alone, no TypeScript |
@mnemosyne_os/public-contracts | The shared types and Zod schemas. No business logic |
@mnemosyne_os/agent-transcripts | Read what coding agents already write on disk: the connector format and the interpreter |
@mnemosyne_os/affine-reader | Read a local AFFiNE workspace and render its documents to Markdown |
@mnemosyne_os/forge | CLI: scaffold, list chronicles, import and export |
@mnemosyne_os/sync | The name of the P2P layer to come. A placeholder today, not the library |
Published by XPACEGEMS LLC. Its official addresses:
io.github.Mnemosyne-OS/mcp on https://registry.modelcontextprotocol.ioMIT © Tony Trochet / XPACEGEMS LLC
Mnemosyne OS Infinity Edition · download · mnemosyne-os.io · mnemosyne-os.com
Pick your client and paste the snippet. Each one is the same server, written the way that client expects it.
claude mcp add mnemosyne -- npx -y @mnemosyne_os/mcp{
"mcpServers": {
"mnemosyne": {
"env": {
"MNEMO_VAULTS": "",
"MNEMO_DEFAULT_VAULT": ""
},
"args": [
"-y",
"@mnemosyne_os/mcp"
],
"command": "npx"
}
}
}code --add-mcp '{"name":"mnemosyne","env":{"MNEMO_VAULTS":"","MNEMO_DEFAULT_VAULT":""},"args":["-y","@mnemosyne_os/mcp"],"command":"npx"}'[mcp_servers.mnemosyne]
command = "npx"
args = ["-y", "@mnemosyne_os/mcp"]Runs locally on your device. Your client starts the server itself, so nothing has to be hosted.
Paste this prompt into your agent. It reads this page and does the setup for you.
Read https://aiagentslisting.com/mcp/mcp-9 to learn what the "Mcp" MCP server does and how to install it. Add it to my coding agent's MCP configuration as documented on that page, then confirm the server connects and list the tools it exposes.Agents can also browse this directory over MCP at https://aiagentslisting.com/api/mcp
npx -y @mnemosyne_os/mcp| Name | What it does |
|---|---|
mnemosyne_about | Re-read the server instructions: the governance tenet, the vault protection model (NORMAL and MAXIMUM, mixableWith, isolated sandbox vaults), the spine model, and the rules for an agent working on som |
mnemosyne_memory_query | Search a vault and get the matching memories back word for word: notes, code, decisions, session summaries, commit history. Nothing is rewritten, so use this when you need the source text itself, to q |
mnemosyne_memory_ask | Ask a question and get a prose answer grounded in the vault, plus the memories it drew on. It runs the full local RAG pipeline: deeper retrieval, lexical fusion and a re-rank. That also makes it the b |
mnemosyne_vault_list | List the memory vaults this Mnemosyne OS exposes, each with its token, display name and memory count. Call it first when you are unsure which vault to work against, or when the user names a store you |
mnemosyne_memory_ingest | Write a memory into a vault: a decision, an architecture note, a debug finding, a session summary. It is stored permanently and indexed for every future agent to retrieve. Use it at the end of a meani |
mnemosyne_resonance_list | List the resonances recorded in the default vault. A resonance is a workspace that tracks one ongoing project. Each entry carries its id, its last phase, how many minutes ago it moved, and the id of t |
mnemosyne_position_get | Read where one resonance was left: the phase, and the free-text note an agent or the cockpit wrote when it stopped. Read-only. It returns the resonance id, when it was saved, the spine type of the mem |
mnemosyne_position_update | Record where you left off on a resonance: phase, current state, next steps. Call it at the end of a session. It is stored as a DECISION memory in the vault. |
mnemosyne_git_log | Read recent commits from the git repository this Mnemosyne OS is configured to read. Read-only. Each commit carries an 8-character hash, the subject line, the author and the date, newest first. The pa |
mnemosyne_dream_bridges | List the connections the Dream State engine found between memories while the machine was idle. Each bridge links two memories, sometimes from different vaults, with a Dream Bridge Score, a raw cosine |
mnemosyne_spine_assignments | See how Mnemosyne classified its memories. It returns the memory-to-spine assignments for one vault, newest first, and the per-spine counts for the whole vault. Use it to check whether memories landed |
mnemosyne_agent_list | List the other coding-agent sessions on this machine, read from the transcript files their harnesses already write to disk. Metadata only: conversation name, project, git branch, model, last tool, how |
mnemosyne_agent_collisions | Check whether two agent sessions are live in the same git working tree and branch right now, across every installed harness. Call it before `git add -A`, before a commit, and before a rebase: one work |
mnemosyne_agent_files | List the files other agent sessions wrote or edited recently, newest first, with the session each one came from. Paths and timestamps only. Each entry says how it is known. `recorded` means the harnes |
mnemosyne_cockpit_update | Update your own status card on the user's canvas, the cockpit. Call it when you start a task ("working", with a short title and status), when you need the user ("waiting"), when you are stuck ("blocke |
mnemosyne_pheme_watch | Add a subreddit, a Hacker News search query or a topic to the user's Pheme radar, or take one off. Pheme is their reputation cartridge: it finds fresh threads worth a genuine reply. The lists belong t |
mnemosyne_pheme_radar | Read what the user's Pheme radar last found: fresh threads in the subreddits and Hacker News queries they watch. Each thread carries a topic score, and a tier once they have run the Mnemosyne pass. Th |
mnemosyne_todo_add | Put tasks into the user's To-do backlog, the To-do widget on their canvas, in order and optionally under named steps. Use it when a conversation has settled what to do. Name the destination list in "l |
mnemosyne_todo_list | Read the user's To-do backlog back: the lists that exist and the tasks in them, each with the id you need to change it. Call this before mnemosyne_todo_update, which names tasks by id. A phrase like " |
mnemosyne_todo_update | Change the user's To-do backlog: edit a task, tick it off, move it to another list, or take it out. Every operation names a task by the id from mnemosyne_todo_list, so call that first. Removing a task |
mnemosyne_todo_categories | Manage the lists of the user's To-do backlog: create one, rename or recolour one, remove an empty one. It is separate from mnemosyne_todo_update because these change the shape of a workspace rather th |
mnemosyne_agenda_list | Read the user's calendar back: the appointments in a time window, each with the id you need to change or remove it. Call this before mnemosyne_agenda_update and mnemosyne_agenda_remove, which both nam |
mnemosyne_agenda_update | Change an appointment already in the user's calendar: move it, rename it, add or drop a reminder, start or stop it repeating. It names appointments by the id from mnemosyne_agenda_list, so call that f |
mnemosyne_agenda_remove | Remove appointments from the user's calendar. Read them with mnemosyne_agenda_list first and pass the ids. This tool matches by id only, because "remove my meetings on Thursday" is how an agent remove |
mnemosyne_agenda_add | Put appointments or deadlines into the user's calendar, the Agenda widget on their canvas. Use it when a conversation names a date and time to remember: a meeting, a deadline, "add this to my calendar |
Read live from the server on October 28, 2026.
Maintain this server? Claiming proves you own the listing and earns the last 4 points.
Claim this listingPaste this line near the top of your repository's README. The badge always renders the current score.
[](https://aiagentslisting.com/mcp/mcp-9)Nothing comparable is listed yet.
v2.2.1-infinityMnemosyne OS Infinity v2.2.1 · Stronger BackupsRelease notesv2.2.0-infinityMnemosyne OS Infinity v2.2.0 · The SentinelRelease notesv2.1.0-infinityMnemosyne OS Infinity v2.1.0 · The Local ModelRelease notesv2.0.0-infinityMnemosyne OS Infinity v2.0.0 · The AvatarRelease notesv1.9.1-infinityMnemosyne OS Infinity v1.9.1 · The TopicsRelease notesv1.9.0-infinityMnemosyne OS Infinity v1.9.0 · The OrbRelease notesv1.8.0-infinityMnemosyne OS Infinity v1.8.0 · The LibraryRelease notesv1.7.0-infinityMnemosyne OS Infinity v1.7.0 · The HandsRelease notesv1.6.0-infinityMnemosyne OS Infinity v1.6.0Release notesv1.5.1-infinityMnemosyne OS Infinity v1.5.1Release notesv1.5.0-infinityMnemosyne OS Infinity Edition v1.5.0 · The SynapseRelease notesv1.4.5Mnemosyne OS v1.4.5 — downloads are on v1.4.5-infinityRelease notesv1.4.5-infinityMnemosyne OS — Infinity Edition v1.4.5 · The Locked DoorRelease notesv1.4.4Mnemosyne OS v1.4.4 — downloads are on v1.4.4-infinityRelease notesv1.4.4-infinityMnemosyne OS — Infinity Edition v1.4.4 · The Whole DocumentRelease notesv1.4.3-infinityMnemosyne OS — Infinity Edition v1.4.3 · What Your Agent KnowsRelease notesv1.4.3Mnemosyne OS v1.4.3 — downloads are on v1.4.3-infinityRelease notesv1.4.2-infinityMnemosyne OS — Infinity Edition v1.4.2 · The Clean CutRelease notesv1.4.1-infinityMnemosyne OS — Infinity Edition v1.4.1 · The Closed PipeRelease notesv1.4.0-infinityMnemosyne OS — Infinity Edition v1.4.0 · The Infinite VisionRelease notesConnect to the AI Agents Listing MCP server at https://aiagentslisting.com/api/mcp using the HTTP transport and complete the sign-in when it asks. Then call the submit_review tool for the listing "mcp-9" with a rating from 1 to 5 and a short note on what worked and what did not.No reviews yet
Be the first to share your experience with this tool.
One email a week. New agents, MCP servers and skills, and what is actually getting traction.