Make every AI tool remember.

Connect a tool, add the instruction, and your AI remembers. That's the whole manual.

Quickstart

Create an account at thememoryos.com/signup.
Copy your connector URL — it's the same for every tool:
https://thememoryos.com/mcp
Add it as a custom connector (MCP) in each tool — exact steps below. Each tool asks you to approve access once.
Add the standing instruction (next section) so saving and recalling happen without being asked.

The standing instruction

Paste this into each tool's custom instructions (chat apps) or rules file (IDEs: CLAUDE.md, .cursorrules, .windsurfrules):

MemoryOS is connected. When a conversation reaches a conclusion or the
topic changes, call store_dot with a short title, a 2-3 sentence
self-contained summary of what was decided, and comma-separated tags -
then tell me the returned mos:id. When I say 'save a deep dot' (or type
/deepdot), instead compact this ENTIRE session into store_dot with
compact: true - sections: topic & goal; key insights and decisions
with their reasoning; corrections or confusion points; current state
and outcomes; next steps. Include key code snippets in fenced ```
blocks. Title deep dots '[Domain] - [Topic]', tag with topic and skill
tags, and if the session continues an earlier dot, pass its mos:id in
link_to. When I write mos:<id>, call get_dot
first and use that context. When I reference past work, call find_dots
before asking me to re-explain. Keep MemoryOS replies brief - confirm a
save with its mos:id in one line, use recalled context without
narrating it, and don't explain MemoryOS internals unless I ask.

Using it daily

With the instruction installed, this is the entire interface — four habits, no UI required:

You…	What happens
finish a piece of work	The assistant saves a dot on its own — a 2–3 sentence summary — and tells you its `mos:` id. Say "save the dot" any time to force one.
say "save a deep dot"	The whole session is compacted into one structured dot — goal, every decision with its reasoning, current state, open threads. Premium & Max. (In chat apps `/deepdot` works too.)
type a `mos:id` in any tool	That dot plus its connected context is served right there — the cross-tool handoff. Research on your phone, type the id in Cursor, keep building.
mention past work	The assistant searches your memory first instead of asking you to re-explain.

One verb, two sizes: "save the dot" = small and quick, keeps the graph clean. "save a deep dot" = deliberate, before stepping away from something big. The adjective is the command.

ChatGPT

Settings → Apps & Connectors → Advanced settings → enable Developer mode → back to Apps → Create → name it MemoryOS, paste the URL, authentication OAuth → Create → Connect.

Needs a paid ChatGPT plan. Set it up on desktop web once — the connector then works in the mobile apps too. Put the standing instruction in Settings → Personalization → Custom instructions.

Claude

Settings → Connectors → Add custom connector → name it MemoryOS, paste the URL → Add → Connect and approve.

Works on claude.ai and the desktop app; enable it from the tools menu inside a chat.

Claude Code

claude mcp add --transport http memoryos https://thememoryos.com/mcp

Then inside a session: /mcp → memoryos → Authenticate (your browser opens to approve).

Add the standing instruction to your project's CLAUDE.md and every coding session stores its decisions automatically.

Cursor

Cursor Settings → MCP → Add new global MCP server, then add:

{ "mcpServers": {
    "memoryos": { "url": "https://thememoryos.com/mcp" } } }

Save, then click Sign in next to memoryos and approve. Tip: add the instruction to .cursorrules so every session stores dots on its own.

Windsurf

Windsurf Settings → Cascade → MCP servers → Manage, then add:

{ "mcpServers": {
    "memoryos": { "serverUrl": "https://thememoryos.com/mcp" } } }

Refresh the server list and authenticate when prompted. .windsurfrules makes it automatic.

VS Code

Ctrl/⌘ ⇧ P → MCP: Add Server… → HTTP → paste the URL → name it memoryos → allow the sign-in.

Requires Copilot agent mode. Commit .vscode/mcp.json to share the setup with your team:

{ "servers": {
    "memoryos": { "type": "http", "url": "https://thememoryos.com/mcp" } } }

Gemini CLI

Add to ~/.gemini/settings.json:

{ "mcpServers": {
    "memoryos": { "httpUrl": "https://thememoryos.com/mcp" } } }

The Gemini web app doesn't accept custom connectors yet — use the CLI, or the copy-paste path below.

Anything else

Tools without custom connectors (Replit, Base44, Lovable, v0…) still work, manually and in both directions: open a dot in your graph → Copy context → paste it at the top of your prompt. To save the conclusion afterwards, use ＋ Add session in the app.

Deep dots — Premium & Max

Say "save a deep dot" (in chat apps /deepdot works too) and the assistant saves the entire session — goal, decisions, current state, next steps, code included — as one dot you can bring back anywhere with its mos: id.

If the assistant answers "Memory updated" (its own built-in memory) instead of returning a mos: id, the MemoryOS connector isn't active in that chat — say "save a deep dot to MemoryOS" and check the tool's ＋ menu.

The Agent — Max

The ✦ Agent button in your graph opens a chat that works on your memory: ask what's in it, or tell it to organize. It can build packs — named sub-graphs around a hub dot — plus link and tag dots. It never deletes anything.

"What do I have about auth?" — searches and answers from your dots.
"Create a pack of everything related to my launch" — finds the dots, builds the hub.
"Tag my billing dots with stripe" — bulk-tags what it finds.

Every pack becomes a tab above your graph: tap it to view that sub-graph on its own, and All dots to come back. In the graph itself, packs are the ringed dots.

Personal API — Max

Generate a token in the app under Profile → Personal API token, then call your memory from scripts with a Bearer header:

# search your memory
curl -H "Authorization: Bearer mospat_..." \
  "https://thememoryos.com/api/recall?q=auth&limit=5"

# save a dot
curl -H "Authorization: Bearer mospat_..." \
  -H "Content-Type: application/json" \
  -d '{"title":"Deploy decision","body":"Render + Cloudflare; disk at /srv.",
       "source":"manual","tags":"deploy,infra"}' \
  https://thememoryos.com/api/save

Endpoint	Returns
`GET /api/me`	Account, plan, dot count, tokens saved.
`GET /api/graph`	All dots and edges — your whole graph as JSON.
`GET /api/recall?q=&limit=&hops=`	Matching dots + a rendered context block.
`POST /api/save`	`{title, body, source?, tags?}` → the new dot's `mos:` id.

The token is shown once when you generate it — we keep only a fingerprint. Revoking it in the app kills it instantly, and it stops working if the plan lapses. Deleting dots is deliberately not in the token API — that stays in the dashboard, so a leaked token can never destroy your memory.