MCP Config

Most users won’t need this page. Every modern AI client (Claude, Cursor, ChatGPT, VS Code, Windsurf, Zed) ships a GUI that adds Engram in a few clicks — see AI Integrations for the walkthrough per client.

If you’d rather edit a config file — or your client doesn’t have a GUI — there are three ways forward, easiest first: hand the setup to your AI, work through the per-client tabs, or skip OAuth entirely with an API key.

Let your AI set this up

The fastest path: paste the prompt below into your AI assistant. It’ll detect which client it’s running in, edit the right config file (or run the right CLI command), and tell you what to do next.

Add Engram as an MCP server in this AI client, then teach the AI to use it.

URL: https://app.engram.page/api/mcp
Transport: HTTP
Auth: OAuth — a browser opens on first connect.

First, pick the right path for this client (CLI like `claude mcp add`, editing an mcp.json, etc.), do the setup, and tell me how to restart so the new server registers.

After that's done, add the text below to my long-lived system / global prompt for this client (e.g. ~/.claude/CLAUDE.md for Claude Code, Cursor Rules for Cursor, the personal preferences field at claude.ai/settings/general for Claude Desktop). If it's a web UI you can't edit, just tell me where to paste it:

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

Reference: https://engram.page/docs/mcp/manual-config/

If something goes sideways — or you’d rather drive it yourself — the per-client tabs below have the full manual recipe.

Engram’s MCP endpoint

• Cloud: https://app.engram.page/api/mcp
• Self-host: https://your-engram-host/api/mcp

Engram speaks MCP over HTTPS. Two ways to authenticate:

• OAuth (default) — the first time your client connects to the URL above, a browser window opens for sign-in. The client holds a token after that and reconnects silently. No keys to copy.
• API key — for headless, scripted, or shared-vault setups. Send the key as a Bearer token in an Authorization header. See API Key Authentication below.

No env vars, no local server process either way.

Configure your client

Pick your client below. Each tab is a complete recipe — config, reload, first-run auth, and where to teach the AI to actually use Engram.

For self-host, swap the cloud URL for your own backend’s /api/mcp URL in any of the snippets below — see the endpoints section above for the canonical placeholders.

Claude Code

1. Add Engram. Use the Claude Code CLI — it handles the config edit for you:

claude mcp add --transport http --scope user engram https://app.engram.page/api/mcp

The --scope user flag makes Engram available across every project. Drop it (or use --scope project) to limit Engram to the current project’s .mcp.json.

Prefer manual? Add to ~/.claude.json (user-scoped) or .mcp.json at the project root:

{
  "mcpServers": {
    "engram": {
      "url": "https://app.engram.page/api/mcp"
    }
  }
}

2. Reload. Exit your current Claude Code session and re-run claude. Run claude mcp list to confirm Engram is registered.

3. First-run auth. Claude Code won’t auto-prompt. In the new session, run /mcp, select engram (it shows △ needs authentication), then choose Authenticate. Your browser opens for OAuth — sign in to Engram, approve the connection, and Claude Code stores the token and reuses it from there on. The grant is the full mcp scope today; granular per-action scopes are on the roadmap.

4. Tell Claude to use it. Append the snippet below to ~/.claude/CLAUDE.md — your user-level instructions file, applied to every project.

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

Cursor

1. Edit config. Add Engram to ~/.cursor/mcp.json (user-scoped) or .cursor/mcp.json at your project root (project-scoped):

{
  "mcpServers": {
    "engram": {
      "url": "https://app.engram.page/api/mcp"
    }
  }
}

2. Reload. Quit Cursor fully (Cmd+Q / File → Exit) and reopen. Window reload isn’t enough — MCP servers register at app start.

3. First-run auth.

The first time Cursor calls Engram, your browser opens for OAuth. Sign in to Engram, approve the connection, done — Cursor stores the token and reuses it from there on. The grant is the full mcp scope today; granular per-action scopes are on the roadmap.

4. Tell Cursor to use it. Add the snippet below to your Cursor Rules — ~/.cursor/rules (user-scoped) or .cursor/rules in a project.

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

VS Code

1. Edit config. Add Engram to .vscode/mcp.json in your workspace. VS Code uses servers instead of mcpServers and requires "type": "http":

{
  "servers": {
    "engram": {
      "type": "http",
      "url": "https://app.engram.page/api/mcp"
    }
  }
}

2. Reload. Run Developer: Reload Window from the command palette (Cmd+Shift+P / Ctrl+Shift+P). A full VS Code restart isn’t required.

3. First-run auth.

The first time Copilot Chat (or your MCP-aware extension) calls Engram, your browser opens for OAuth. Sign in to Engram, approve the connection, done — Copilot Chat (or your MCP-aware extension) stores the token and reuses it from there on. The grant is the full mcp scope today; granular per-action scopes are on the roadmap.

4. Tell VS Code to use it. Add the snippet below to your workspace’s custom instructions (Copilot Chat → settings → Custom Instructions, or your extension’s equivalent).

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

Windsurf

1. Edit config. Add Engram to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "engram": {
      "url": "https://app.engram.page/api/mcp"
    }
  }
}

2. Reload. Quit Windsurf fully and reopen. Window reload may not trigger MCP server registration.

3. First-run auth.

The first time Windsurf calls Engram, your browser opens for OAuth. Sign in to Engram, approve the connection, done — Windsurf stores the token and reuses it from there on. The grant is the full mcp scope today; granular per-action scopes are on the roadmap.

4. Tell Windsurf to use it. Add the snippet below to your Windsurf AI Rules pane (Workspace → AI Rules) or ~/.codeium/windsurf/global_rules.md for user-wide rules.

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

Zed

1. Edit config. Open ~/.config/zed/settings.json and add Engram under context_servers (Zed’s wrapper key — not the standard mcpServers):

{
  "context_servers": {
    "engram": {
      "url": "https://app.engram.page/api/mcp"
    }
  }
}

2. Reload. Run zed: reload settings from the command palette (Cmd+Shift+P). For stubborn cases, fully quit and reopen Zed.

3. First-run auth.

The first time Zed's assistant calls Engram, your browser opens for OAuth. Sign in to Engram, approve the connection, done — Zed's assistant stores the token and reuses it from there on. The grant is the full mcp scope today; granular per-action scopes are on the roadmap.

4. Tell Zed to use it. Add the snippet below to your assistant’s default prompt in settings.json (under assistant.default_prompt) or via the assistant settings UI.

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

Other / Custom

1. Edit config. Most MCP clients accept the standard mcpServers wrapper:

{
  "mcpServers": {
    "engram": {
      "url": "https://app.engram.page/api/mcp"
    }
  }
}

If your client doesn’t recognize this shape, check its docs for the wrapper key it expects (VS Code uses servers, Zed uses context_servers).

2. Reload. Most clients need a full restart, not just a window reload, for new MCP servers to register.

3. First-run auth.

The first time the client calls Engram, your browser opens for OAuth. Sign in to Engram, approve the connection, done — the client stores the token and reuses it from there on. The grant is the full mcp scope today; granular per-action scopes are on the roadmap.

4. Tell your AI to use it. Drop the snippet below into wherever your client takes long-lived system or global instructions.

Engram holds my personal notes — treat it as your long-term memory of me. Search it when a question depends on context I might have shared before. Before saving or updating a note, ask first.

API key authentication

OAuth is the default. Use an API key for headless or scripted access, per-connection control (writeable bot vs read-only agent), or sharing a vault without granting full sign-in. One key authenticates both MCP and the REST API. Today every key carries your account’s full access; fine-grained per-key scopes are on the roadmap.

Get a key

Generate one at app.engram.page/settings/api-keys. Engram displays the full key once at creation, then only its prefix — treat it like a password and stash it somewhere safe.

Add it to your config

Add a headers block sending the key as a Bearer token. The wrapper key (mcpServers / servers / context_servers) follows whichever client you’re configuring — use the same shape your tab above showed. For the standard mcpServers clients:

{
  "mcpServers": {
    "engram": {
      "type": "http",
      "url": "https://app.engram.page/api/mcp",
      "headers": {
        "Authorization": "Bearer engram_YOUR_KEY_HERE"
      }
    }
  }
}

With an API key in place, no browser opens on first connect — the key authenticates immediately. To rotate, generate a new key in settings and replace the value in your config.

Caution

Treat the key like a password. Don’t commit it to version control — keep API keys out of mcp.json files that get checked in. Either use an environment-variable substitution where your client supports it, or scope the config to a user-level (not project-level) file.

Troubleshooting

• Client doesn’t see Engram after edit — restart the client fully, not just the window.
• Browser never opens for auth — make sure no popup blocker is in the way; some clients pipe the OAuth window through their own browser logic, which fails silently if blocked.
• Failed to connect — check the URL is reachable. See Troubleshooting for cross-client issues.

For client-specific GUI flows, see AI Integrations.