Connecting 📝MythOS to 📝Cursor gives the AI-native editor direct, identity-aware access to your memos, knowledge graph, and RAG-powered library chat through the 📝Model Context Protocol (MCP).

Cursor is an MCP-compatible client, so any MCP server plugs into it like a first-class tool. MythOS offers its MCP server two ways: a hosted endpoint at https://mythos.one/api/mcp that Cursor signs into with your MythOS account, and the mythos-mcp 📝npm package, which runs locally over stdio with an API key. Once configured, your entire MythOS library becomes a surface Cursor can read from, write to, and reason over — alongside your code, without copy-pasting between tabs. This guide walks through the setup end-to-end: prerequisites, installation, a working configuration, and the workflow patterns that get the most value out of the integration.

Prerequisites

A MythOS account — any plan can connect through the hosted sign-in
Cursor installed with MCP support enabled
(Only for the npm path) A MythOS API key from mythos.one/settings/api, which requires the Scholar or Oracle tier, and Node.js 18+ for npx to fetch mythos-mcp

Installation

Add MythOS to Cursor's MCP configuration. Edit ~/.cursor/mcp.json (global) or .cursor/mcp.json in a specific project.

Hosted connection (recommended). No API key or local package:

{
  "mcpServers": {
    "mythos": {
      "url": "https://mythos.one/api/mcp"
    }
  }
}

Restart Cursor, then click Connect next to MythOS in the MCP panel. Your browser opens the MythOS authorization page; review the permissions and click Allow, and Cursor returns with your library connected. A connection is read-only unless the client asks for write access.

npm package (API key). For setups that prefer a local process:

{
  "mcpServers": {
    "mythos": {
      "command": "npx",
      "args": ["-y", "mythos-mcp"],
      "env": {
        "MYTHOS_API_URL": "https://mythos.one",
        "MYTHOS_API_KEY": "YOUR_API_KEY",
        "MYTHOS_USERNAME": "YOUR_USERNAME"
      }
    }
  }
}

Replace the placeholders with your key and your MythOS username, then restart Cursor. Keep the MYTHOS_API_URL line: without it the package targets a local development server instead of mythos.one. The first npx invocation takes a few seconds while the package fetches; subsequent launches are near-instant. The same block works in any MCP client that reads a JSON server config.

What You Get

Over the hosted connection with write access, Cursor lists 60 MythOS tools, including a gateway that reaches more community, event and recovery tools on demand; a read-only connection lists only the read tools. The npm package is an older build and exposes a smaller set. The highest-leverage tools in an editor workflow:

get_context — loads your four augmentation memos (Soul, Style, Human, Memory) so Cursor writes in your voice and follows your conventions; it is required once per session before other tools work
search_memos — pull architectural decisions, past bug notes, or team conventions directly into the editor
read_memo — load full memo content including 📝Collaborator Notes for rich inline context
chat_with_library — ask 📝RAG questions against your full library; Cursor surfaces the answer inline
create_memo / update_memo — capture a learning or decision mid-session without leaving the editor
list_templates / read_template — use MythOS memo templates (reference, project, person, etc.) from within Cursor

Full tool reference: 📝MythOS MCP — Tools, Resources & Prompts.

Recommended Workflow

The highest-leverage pattern is to let Cursor read from MythOS at session start and write back as you work.

Start of session — ask Cursor "what do you know about this project?" and let it pull the relevant project-context memo. Architectural decisions, deployment rules, and current-state notes load into the conversation before any code is touched
Mid-session — when you hit an issue, "search my library for [pattern]" often surfaces a memo from months ago that saves hours of rediscovery
End of session — "create a memo capturing this decision" ensures the next session — in Cursor, 📝Claude Code, or any other MCP client — inherits today's learning

Troubleshooting

Tools aren't showing up. Cursor caches the MCP tool list at connect time. After editing mcp.json, fully restart Cursor — not just reload the window
Only read tools appear. The connection was authorized read-only. Disconnect MythOS in Cursor and connect again, allowing write access
Authentication errors on the npm path. Verify at mythos.one/settings/api that the key is still active and that MYTHOS_USERNAME matches your MythOS account handle exactly
Requests fail or point at localhost. The MYTHOS_API_URL line is missing from the npm config; add "MYTHOS_API_URL": "https://mythos.one" and restart Cursor
npx failures on first run. If npx -y mythos-mcp fails with a network error, run npm install -g mythos-mcp once outside Cursor, then change the args in mcp.json to ["mythos-mcp"]

FAQ

Does MythOS work in Cursor on Windows and Linux?

Yes. The hosted connection works wherever Cursor runs, and the mythos-mcp npm package runs on macOS, Linux, and Windows wherever Node.js 18+ is installed.

Can I use MythOS in Cursor without an API key?

Yes. The hosted connection at https://mythos.one/api/mcp signs in with your MythOS account, with no API key. An API key still works for the npm package, scripts, and older setups.

Does Cursor see my private memos?

Yes — but only yours. Access is scoped to your account, whether you sign in or use an API key; Cursor cannot access other users' private memos. MythOS's visibility levels (public, link, private, hidden) are enforced at the server level, not the client.

Does Cursor work alongside Claude Code?

Yes. Both clients connect to the same MythOS backend via MCP. Memos created in one surface are immediately visible in the other. A common pattern is Cursor for in-editor work and Claude Code for multi-file refactors — both see the same library.

Can I use MythOS with Cursor's autonomous agent mode?

Yes. Cursor 3's autonomous agents can call any connected MCP tool, so an agent can search your library, capture learnings back into memos, and operate across your knowledge graph without manual prompting.

📝MythOS MCP — full MCP server reference (tools, resources, prompts, architecture)
📝How to Set Up MythOS with Claude Desktop — the same hosted connection in the Claude desktop app
📝How to Set Up Claude Code — companion practitioner guide for the terminal-native workflow
📝Cursor — reference memo on the Cursor editor itself

I don't use Cursor myself — I work terminal-native in Claude Code with multiple parallel agents, each with full MythOS access. But the pattern scales well for developers who prefer an editor-centric workflow. The point is not which client you pick; it's that your knowledge, conventions, and learnings follow you across every client, every session, every device. MCP is the standard that makes that possible. MythOS is the library that makes it worth turning on.