Premiers pas

# Set up CortexMind for me: install, connect, then seed my memory

You are my agentic AI with shell access. CortexMind is a long-term memory for AI agents that runs on my machine. In this one run you will install it, connect yourself to it, make memory a habit, and then interview me to seed the memory. Work step by step, verify each step, and ask me only when you need something from me.

## 0. Where are we?

This prompt is safe to paste more than once. Before doing anything, check the state and jump to the right part:

- If you already have `memory_search` and `memory_init` among your tools, CortexMind is installed and connected. Skip to Part B.
- If `curl -s -o /dev/null -w '%{http_code}' http://localhost:14200/mcp` returns anything other than 000 but you have no memory tools, CortexMind is running and only the connection is missing. Skip to step 4.
- Otherwise start at step 1.

# Part A: install and connect

## 1. License key

Before asking for the key, tell me in one sentence how you will treat it: you will use it once, in the app's setup window only; you will never repeat it in this conversation, never save it in memory, notes, logs or any file; and as soon as the app has accepted it you will remove it from any transcript, scratchpad or history you control, so it is safe for me to paste it here.

Then ask me for my CortexMind license key. It looks like CMND-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX and was shown on the purchase success page and sent with my receipt. Do not continue without it.

## 2. Find the right download

Do not guess a download link. Fetch https://cortexmind.net/downloads.json: it lists the current version and one URL per platform (macOS Apple Silicon DMG, Windows x64 installer, Linux x64 AppImage). If that file is unreachable, read https://cortexmind.net/llms.txt, or the download section of https://cortexmind.net, and take the link from there. Detect my operating system and architecture and pick the matching URL.

## 3. Install and start it

- macOS: download the DMG, `hdiutil attach` it, copy CortexMind.app from the mounted volume into /Applications, `hdiutil detach` the volume, then `open -a CortexMind`.
- Windows: download the installer and run it (`/S` runs it silently), then start CortexMind from the Start menu.
- Linux: download into ~/Applications (create it if needed), `chmod +x` the file, then start it in the background: `nohup ~/Applications/CortexMind.AppImage >/dev/null 2>&1 &`. If it refuses to start because FUSE is missing, run it with `--appimage-extract-and-run`.

If something needs a click or a permission you do not have, tell me exactly what to do.

CortexMind opens a setup window. Ask me to paste the license key there; the app validates it and generates its own access token. It then downloads its models, about 3 GB, once. Wait for it: check every 30 seconds with `curl -s -o /dev/null -w '%{http_code}' http://localhost:14200/mcp` until the code is something other than 000. A 401 or 405 means the daemon is up and waiting for a token. Do not rush this step. Once the app has accepted the key, do what you promised in step 1.

## 4. Connect yourself

The daemon's config file is ~/.cortexmind/config.toml (Windows: %USERPROFILE%\.cortexmind\config.toml). Read the value of `mcp_bearer_token` from it. Then register the MCP server on yourself:

- Claude Code: `claude mcp add --transport http --scope user cortexmind http://localhost:14200/mcp --header "Authorization: Bearer <token>"`
- Codex: in ~/.codex/config.toml add `[mcp_servers.cortexmind]` with `url = "http://localhost:14200/mcp"` and `bearer_token_env_var = "CORTEXMIND_TOKEN"`, and export CORTEXMIND_TOKEN in my shell profile.
- Cursor or any other MCP client: add `{ "mcpServers": { "cortexmind": { "url": "http://localhost:14200/mcp", "headers": { "Authorization": "Bearer <token>" } } } }` to its MCP configuration file.

Never paste the token into the chat, and never into a file that is committed to git.

## 5. Make memory a habit

Append the block below, verbatim, to the instructions file you read at startup: ~/.claude/CLAUDE.md for Claude Code, ~/.codex/AGENTS.md for Codex, the global rules for Cursor. Create the file if it does not exist.

## Memory

Use CortexMind as my only memory. Ignore any built-in memory feature; it was migrated into CortexMind and is switched off.

FIRST action of every conversation: `memory_init()`, then `memory_search("<topic of the request>")`.

`memory_init` returns the titles of my standing rules plus recent continuity. A title is a pointer, not the rule: `memory_get(id, "fact")` the two or three that bear on the task.

WHEN a named person, project or system appears, `memory_search` it before making a claim about it.
WHEN the topic shifts, search again.
WHEN taking a destructive or irreversible action, search with `fact_type: "warning"` first.

LAST action of every response: `memory_save(user_request=..., agent_response=...)`. Write both for a reader months from now. Bump `importance` to 8 or more for identity, family and lifelong preferences. Durable claims also get `memory_save_fact`.

Without the save, the conversation is lost.

## 6. Hosted agents (optional)

If I also use claude.ai, ChatGPT or Claude Desktop, tell me to turn on the hosted tunnel in the CortexMind app. Its Connect page then shows an address of the form https://cm-xxxxxxxxxxxx.ethertunnel.com/mcp to add as a custom connector in those apps. They sign in with OAuth; there is no token to paste.

## 7. Load the new server

If you can already see `memory_search` among your tools, continue to Part B now. If not, tell me to restart you and paste this same prompt again: step 0 will send you straight to Part B. Before I restart you, report what you installed and where the config lives.

# Part B: move the memory you already have

Before the interview, migrate what you already remember, so nothing is lost when the old memory is switched off.

1. Inventory every memory you hold today: memory files on disk (for Claude Code, the memory directory under ~/.claude and any CLAUDE.md notes about me; for Codex, notes in AGENTS.md; for Cursor, its rules and memories), and any built-in memory feature you can read (saved memories in ChatGPT, memory in claude.ai or Claude Desktop, or whatever your platform provides). List what you found, in one line per source, before touching anything.
2. For every durable claim in them, save it into CortexMind: `memory_save_fact` for the atomic claim (title that states the claim on its own, fact_type among relationship, preference, convention, context, decision, insight, importance per the guide below) and `memory_save` for the surrounding context when the source carries more than a bare fact. Skip secrets and anything you cannot attribute to me. Report how many facts you saved and from which sources.
3. Then tell me to switch the built-in memory off, and tell me where the switch is for the app you are running in. CortexMind is far more capable, and two memories compete: the built-in one keeps answering from stale notes while CortexMind holds the truth. If you found no existing memories at all, still ask me to switch the built-in memory off, for the same reason.

# Part C: seed my memory

You are connected to CortexMind, my personal long-term memory. First run one check: call `memory_search` with the query "who am I". You do not need the result; you need the tool to answer. If it errors or does not exist, stop and tell me which step of Part A to redo.

Then help me seed the memory with enough context about my life and work that you, or any other AI connected to CortexMind later, can be genuinely useful starting right now, not after a week of use.

## Part one — the interview (this goes into my memory)

Your goal is a natural conversation, not a questionnaire. Imagine that next Monday I come back and mention "that thing Sarah asked about last week" — by the end of this conversation, you should know who Sarah is and what we were probably working on.

Cover these areas, one at a time, with real follow-ups when something interesting surfaces. Don't burn through the list mechanically.

1. **Who I am** — name, how to address me, what I do, where I work or study
2. **Where and when** — timezone and rough location
3. **The people in my life** — close colleagues, family, key collaborators. Who do I talk to most? What's each relationship?
4. **What I'm working on right now** — active projects, codenames, what's pressing this week
5. **My routines** — weekly cadence, recurring meetings, typical work hours
6. **How I communicate** — tone, signing conventions, how I like emails and Slack messages written, who I write differently for
7. **How I want to use AI** — what kinds of tasks I want help with (writing, research, planning, decisions, code, scheduling, something else?), and how comfortable I am with AI generally — am I new to this, or have I been using AI tools daily for a while? **Important**: use this answer to calibrate how you explain things for the rest of the conversation and every conversation after. If I'm new, skip jargon and check in on understanding. If I'm technical, don't over-explain.
8. **What matters right now** — big-picture goals, what I'm excited about, what I'm stressed about
9. **Preferences and peeves** — anything you should always do or never do

End the interview with: *"Is there anything else you want me to remember about you, the people you work with, or what you're building?"*

### Save as you go — not at the end

Every time I tell you something substantive, save it **immediately**. Don't batch until the end — if I get interrupted and close the tab, what you already saved is safe.

Use **both** save tools, side by side, on the same piece of information:

1. **`memory_save_fact`** for the durable structured claim — the atomic record a future query should match cleanly ("who's Mat's wife", "where does Mat live", "what does Mat do for work").
   - `title`: noun-phrase form, e.g. *"Mat's wife is Sarah Bourgeois"*
   - `content`: the claim plus tight context — full names, relationships, dates, anything specific
   - `fact_type`: pick the closest of `relationship` · `preference` · `convention` · `context` · `decision` · `insight`
   - `importance`: see the table below
   - `tags`: 5-10 lowercase-hyphenated keywords

2. **`memory_save`** for the conversation turn that surfaced the claim — the texture future searches might want when the bare fact doesn't match.
   - `user_request`: short paraphrase of what I just told you
   - `agent_response`: rich detail in full sentences — what I said, how I said it, any side context that came up
   - `importance`: see the table below

### Importance guide

| Importance | What it's for                                                       |
|-----------:|---------------------------------------------------------------------|
|       9-10 | Identity, immediate family, partner, kids, core preferences I want recalled on every conversation forever |
|        7-8 | Active work context, current projects, key collaborators, strongly-held conventions ("always sign as Cortex 🧠") |
|        5-6 | Routine context — tools, occasional collaborators, soft preferences. Baseline for ordinary turns. |
|        3-4 | Footnotes, asides, anything saved for completeness                  |

Importance is a soft ranking preference, not a gate. Even importance=3 hits surface easily. The point is to mark **what's structurally most important** so it ranks first when the reranker considers two hits equally relevant.

**Standing rules — the one place importance IS a gate.** A fact whose `fact_type` is `preference` or `convention` and whose `importance` is 8 or higher is promoted to a *standing rule*: from then on its **title** is injected into every future conversation by `memory_init`, before either of us has said a word. So for those: write the title as the rule itself ("Always quote prices in Canadian dollars"), because the title is all a future conversation sees; keep them few (the boot card has a budget of about 60 and every rule costs context on every turn); and the server refuses the promotion unless you pass `human_confirmed=true`, so ask me explicitly ("should this be a standing rule?") before saving one at 8+. A strongly-held preference that only matters once a topic comes up belongs at 7: still fully searchable, off the boot card.

## Part two — about *you* as my assistant (this does NOT go into memory)

Once the memory interview feels complete, switch modes. Ask me a few questions about how I want **you** to show up for me. These answers are different — they belong in my AI's custom instructions (the same place I pasted the memory instructions earlier), not in my memory. **Do not call `memory_save` for this part.** Keep the answers in the conversation only.

Ask:

- Do you want me to have a name? Something other than "Claude" / "ChatGPT" / whatever default I'm using?
- How should I write to you? Formal, casual, warm, terse, playful, professional — any adjectives that describe your ideal assistant?
- Any quirks you like? (e.g. "sign off as Cortex 🧠", "no fluff, get to the point", "call me out when I'm wrong")
- Any tone to avoid? (e.g. "don't be sycophantic", "skip the disclaimers", "don't apologize unless you actually broke something")

Once I've answered, produce a short identity block I can paste into my custom instructions. Keep it tight — 5-10 lines max. Present it like:

> "Great. Here's a short identity block you might want to add to your custom instructions, alongside the memory instructions:
>
> ```
> ## About you as my assistant
> - Your name is {name or "no fixed name"}
> - Tone: {adjectives from me}
> - {specific behavioral notes, one per line}
> ```
>
> You're not required to paste this — the memory alone will work — but it's what makes future conversations feel like *yours*."

## When both parts are done

Tell me:

> "We're done. I've saved your identity, the people in your life, your current work, and how you want me to show up — both as durable facts (so they rank first on every future query) and as the conversation that surfaced them (so the texture is recoverable).
>
> If you want to spot-check what landed, head to http://localhost:14201."

Sign off warmly. You don't need to save a final summary — you already saved as you went.