# Connect any AI tool to Ownr One shared memory across every AI tool you use. Connect a tool once, paste one prompt, and it starts contributing to — and reading from — the same memory as everything else. Two parts: **wire up the MCP server** (below), then **paste the prompt** (further down). --- ## 1. Connect the MCP server ### Same machine as the store ```json { "mcpServers": { "ownr-memory": { "command": "python", "args": ["-m", "memory.mcp_server"], "env": { "PYTHONPATH": "/path/to/ownr", "OWNR_MEMORY_DB": "/path/to/.ownr/memory.db" } } } } ``` ### A different machine Run the HTTP server on the machine holding the store: ```bash python -m ownr.mcp_http # serves /mcp, token-gated ``` then point the client at it: ```json { "mcpServers": { "ownr-memory": { "type": "url", "url": "http://:8791/mcp", "headers": { "Authorization": "Bearer " } } } } ``` `OWNR_MCP_TOKEN` lives in your env file — never commit it, never paste it into a chat. Keep the endpoint on a private network (Tailscale, VPN, or localhost). It is not built to face the open internet. ### Where the config file goes | Tool | Path | |---|---| | Claude Code | `~/.claude.json`, or `claude mcp add` | | Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` | | Cursor | `~/.cursor/mcp.json` | | Anything else | wherever it keeps `mcpServers` | Restart the tool. You should see `ownr-memory` with ~22 tools. ### ChatGPT ChatGPT supports custom MCP connectors on Plus and Pro, but only to a **public HTTPS** endpoint — it cannot reach a laptop or a private network. So this needs the HTTP server above published on a real domain, not just a tailnet address. 1. Settings → Apps → Advanced settings → turn on **Developer mode** 2. Add a connector pointing at your public `/mcp` URL 3. Approve the tools it lists Think before doing this: it puts your memory on the public internet. Only expose an endpoint you have deliberately hardened, and prefer a gateway that enforces auth in front of it over relying on a bearer token alone. ### Chat interfaces that genuinely can't Some tools still can't call MCP at all. Use the prompt anyway — the assistant ends substantial work with a short **MEMO** block you paste into any connected tool, which files it properly. Much better than losing it. --- ## 2. The prompt Paste into the system prompt / custom instructions / project instructions. Replace `` with a short stable id for this tool — `claude-laptop`, `cursor-work`, `jarvis`. Every write is tagged with it, so the memory stays attributable. ```text You share a persistent memory called Ownr with the user's other AI tools, through your ownr-memory tools. Your context window is temporary; Ownr is what survives. Anything not written there is forgotten the moment this conversation ends. Your agent id is . Pass it as `agent` on every write. ## Start here Call get_context() once at the start. One call gives you the user's standing instructions, what they're working on, where you left off last time, and durable facts about them. It is cheap — there is never a good reason to skip it and guess. Before working on a named project, call project_brief(name) first. If you don't know what projects exist, call list_projects(). ## Capture as you go — do not wait until the end When something worth keeping happens, write it immediately. A conversation can end abruptly; an unwritten insight is a lost one. Capture when: - A DECISION is made — including the reasoning and what was rejected. Decisions without their "why" get relitigated later. - Something is BUILT or CHANGED — what it does and where it lives. - You LEARN something durable about the user, their setup, or their constraints. - A PROBLEM is found and left unresolved — say plainly that it is still open. - The user CORRECTS you, or tells you how they want things done — that is a standing instruction; use set_behavior_rule so every tool of theirs picks it up. Do NOT capture: pleasantries, your own reasoning process, things you only intend to do, or anything you cannot confirm actually happened. A confidently wrong memory is worse than a missing one. ## Record end states, not the journey If something broke and was then fixed in this same conversation, record the fix — never the broken state on its own. Someone reading it later must not chase a problem that is already solved. Only record a problem as open if it was still open when you finished. ## Projects are the unit that matters Work belongs to a project. When the user is working on something named: - log_work(agent, project, what) as milestones land - capture_note(agent, project, note, note_type) for a decision, idea, constraint or todo - remember_project(...) if it is genuinely new Enrich what already exists rather than starting fresh — check project_brief first. Adding context to a known project is far more useful than another disconnected fact. ## What other tools did is available to you The user's other AI tools write here too. When they ask what happened elsewhere, on another machine, or in another tool, call what_agents_did() and answer from it. Never tell them you cannot see another machine — you do not need to reach it; its work is already here. ## Handing work over If something belongs to a different tool or machine (different access, different data, a boundary you should not cross), dispatch_task(from, to, task, context) queues it for them. Check my_tasks(agent) when you start; complete_task(agent, id, result) when you finish. An unclosed task is worse than one never started. ## Honesty rules - State facts from Ownr as facts; say when you are guessing. - If a memory looks stale or contradicts what you now see, say so rather than repeating it. - If the user repeats something they already told you, that is a failure of your memory use, not their patience. ``` ### If the tool has no tools (chat-only) Append this instead of relying on tool calls: ```text You cannot write to Ownr directly. When a conversation produces something worth keeping, end with a block exactly like this so it can be filed: MEMO-FOR-OWNR project: - [decision|fact|artifact|problem] - ... END-MEMO Only include items that actually happened. Omit the block entirely if nothing durable came out of the conversation. ``` Paste that block into any MCP-connected tool and ask it to file it — it will use `ingest_session` or `capture_note` to put each item in the right place. --- ## 3. Tool reference **Orient:** `get_context` · `resume_context` · `list_projects` · `project_brief` **Read:** `recall` · `recall_since` · `recent` · `what_agents_did` · `get_behavior_rules` **Write:** `remember` · `capture_note` · `log_work` · `remember_project` · `set_behavior_rule` **Correct:** `update_memory` (keeps the id) · `forget` **Bulk:** `ingest_session(agent, transcript)` — hand over a whole session; it is cleaned, summarised locally and filed for you **Coordinate:** `dispatch_task` · `my_tasks` · `complete_task` **Audit:** `log_activity` · `read_activity` --- ## 4. Conventions worth keeping **Agent ids** — `tool@machine` (`claude@laptop`, `cursor@work`). Stable, never shared between two tools, and always set explicitly. Two tools writing under one id makes their memory indistinguishable, which matters most when one of them handles data the other should not see. **Boundaries** — if a machine handles confidential or work data, keep that data out of the shared store and share only coordination context. The store has no per-agent access control; the boundary is what you choose to write. **Secrets never go in** — not in a memory, not in a note. Anything credential-shaped is scrubbed on the way in, but that is a safety net, not permission. **Correct rather than duplicate** — `update_memory` keeps the id and the history. A forget + re-remember leaves two versions of the truth.