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.

Rules

Rules are the standing context you'd otherwise re-type at the start of every chat — your stack, your conventions, how you like answers. Add them once in your app → Settings → Rules, and MemoryOS puts them at the top of every recall, in every connected tool — automatically.

"I use TypeScript and Postgres. Never suggest other stacks."
"Answer concisely, no preamble."
"We deploy on Render."

Toggle a rule off to pause it without deleting it. Basic includes a handful of rules; Premium and Max are unlimited.

Memory types

A dot knows what it is, so recall can hand your assistant the right kind of context:

Chat — a session summary (the default).
Decision — a design or architecture choice and its reasoning.
Code — a diff, a commit, a snippet (kept in a fenced block).
Doc — a README, spec, or design doc.

Pick the type when you add a dot in the app, or tell a connected assistant to save one — e.g. "save this as a decision" or "save this diff as code, linked to our auth session." Recall then serves the decision and the code that implemented it, each labelled.

Projects — Max

A project is a whole codebase turned into a graph — every symbol: modules, classes, functions, methods, variables, constants, fields and types, with the calls and imports between them. It lives in its own Projects section in your app, separate from your memory dots, and the relevant slice is served back to your tools as compact context — so an assistant knows your architecture without re-reading files.

Connect a repo

In the app: Projects → type owner/repo → an optional branch → your GitHub token → Sync.

MemoryOS pulls the repo, builds the graph on our server, and it appears as a project. We only ever read your code, never run it, and the checkout is deleted right after. Your token is never stored — it stays in your browser and is used once — and we keep only the graph, never your source.

Creating the GitHub token. A fine-grained, read-only token lets MemoryOS read a private repo:

GitHub → Settings → Developer settings → Personal access tokens → Fine-grained tokens → Generate new token.
Resource owner: the account (or org) that owns the repo.
Repository access → Only select repositories → pick your repo.
Permissions → Repository permissions → Contents: Read-only — that single permission is all it needs.
Generate, copy the github_pat_…, and paste it into the Sync box.

A private repo replies “not found” until the token has Contents: Read on it — so if you see that, this is the fix.

Use it

Ask your tools. With MemoryOS connected, ask things like “what calls checkout()?” or “where is User defined?” — the assistant answers from the graph instead of re-reading files, keeping context small.
Sync again to update. Re-syncing the same repo updates that project in place — matched by its path — and reports what changed (＋added / −removed).
Keep the view clean. Filter by kind with the chips (functions, classes, variables, types…), and the most-used symbols stand out as hubs.
Rename or delete a project any time from its view.

15 languages. Python, JavaScript, TypeScript (incl. TSX), Java, C#, C, C++, Go, Rust, Ruby, PHP, Swift, Kotlin, Scala and Dart. Mixed-language repos graph in one pass; other files are skipped.

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.