How to Give Claude Organizational Memory over MCP (2026)

TL;DR

Sentra, the organizational memory layer, connects to Claude over the Model Context Protocol, so this guide is the end-to-end setup. Claude reaches an external memory server one of two ways: a one-click OAuth connector, which is what Claude, Claude Code, ChatGPT and Codex support, or a server URL plus a bearer token, which is what Cursor and most other clients expect. The whole path is sign up, generate a key, add one server URL, authorize once. Below are the exact commands and config blocks for every major client, the org-admin steps that stop Claude from re-prompting your team on every session, and the honest limits of what MCP does and does not give you.

What MCP actually does here, and what it does not

The Model Context Protocol is an open standard for connecting AI applications to external systems. Anthropic's documentation describes it as a USB-C port for AI applications, and that is the right way to think about it: one protocol instead of a separate integration per tool.

What that buys you, precisely:

1. One server, many clients. The same MCP endpoint serves Claude, Claude Code, Cursor, Codex, ChatGPT and any other compatible client, so you configure memory once rather than per tool.

2. Auth that belongs to the user. OAuth-based connectors sign in as the person, so what an agent can read is bounded by what that person can already see.

3. Tools, not just text. The server exposes callable operations, so an agent can query memory mid-task rather than being handed a prompt-stuffed blob.

What it does not buy you, and this matters before you plan around it: MCP moves context, it does not create context. The protocol delivers whatever the server returns. Whether those facts are current, non-contradictory and permission-scoped is a property of the memory system behind the protocol, not of MCP itself. A connector will happily hand your agent last quarter's policy alongside this quarter's.

Setting up Claude Code

The fastest path. One command adds a remote HTTP MCP server:

```bash

claude mcp add --transport http sentra https://api.sentra.app/mcp/

```

Then open a Claude Code session and run /mcp once to complete sign-in and authorization. After that the tools are available in every session.

Verify it worked by asking for something only memory would know:

```

> What did we decide about the auth refactor?

```

If the answer cites a meeting or a thread rather than guessing, the connection is live.

Setting up Claude (web and desktop)

For an individual user, when an admin has already enabled the connector:

1. Open Customize in the Claude menu.

2. Find Sentra in the connector list and press Connect.

3. Press Allow on the Sentra authorization screen.

If Sentra is not in the list, add a custom web connector with two fields:

The org-admin setup, and the step everyone misses

If you are rolling this out to a team on a managed Claude plan, three steps, and the third one is the difference between a smooth rollout and a support queue:

1. Add the connector at the organization level. In Claude admin connectors, add a custom web connector with the same name and URL as above.

2. Connect as the admin yourself. Go to your personal connector settings and press Connect, then Allow. This step is required before step three is even visible.

3. Set default tool permission to Always allow. Open the connector's details, scroll to *Default restriction for unconfigured tools*, and set it to Always allow.

Skip step three and Claude asks every user to approve every memory tool in every new session, which teams reasonably interpret as the integration being broken.

Setting up the other clients

Codex (the CLI and IDE extension share one config file):

```bash

codex mcp add sentra --url https://api.sentra.app/mcp/

```

If this is your first MCP server in Codex, enable the client feature in ~/.codex/config.toml:

```toml

[features]

experimental_use_rmcp_client = true

[mcp_servers.sentra]

url = "https://api.sentra.app/mcp/"

```

Then run codex mcp login sentra.

Cursor uses a static config file and a bearer token rather than OAuth. Generate a key in Settings, API Access (it begins with sk_sentra_), then add to .cursor/mcp.json:

```json

{

"mcpServers": {

"sentra": {

"url": "https://api.sentra.app/mcp/",

"headers": {

"Authorization": "Bearer sk_sentra_YOUR_KEY_HERE"

}

}

}

}

```

ChatGPT: Settings, Connectors, Add custom connector, then enter https://api.sentra.app/mcp/ and approve on the Sentra consent screen.

VS Code, Windsurf, Zed and any client that only speaks stdio can bridge through mcp-remote:

```json

{

"mcpServers": {

"sentra": {

"command": "npx",

"args": ["-y", "mcp-remote", "https://api.sentra.app/mcp/"]

}

}

}

```

Anything else that accepts a server URL plus headers needs only two values: the URL above and Authorization: Bearer sk_sentra_....

Which auth method should you use?

Keys inherit the owning user's organization scope and visibility, so an agent acting for one person cannot read what that person cannot. Read endpoints allow 120 requests per minute per key, and exceeding that returns a 429 with a Retry-After header.

Troubleshooting the four failures you will actually hit

1. Claude keeps asking permission every session. The org-level default restriction is still unset. See step three above.

2. "Missing API key" or a 401. The key was revoked, expired, or the header is malformed. It must read exactly Authorization: Bearer sk_sentra_....

3. Connection or 404 errors. Check the trailing slash on https://api.sentra.app/mcp/, since some clients normalize URLs differently.

4. The agent connects but answers vaguely. Connection is not coverage. If the sources that hold the answer were never linked, memory has nothing to serve, and the fix is in the integrations rather than the MCP config.

FAQ

The decision rule

Use the OAuth connector wherever the client supports it, because per-user scoping is the whole security story. Reach for a key only where the client demands one, and store it like the credential it is. And once the wire is up, remember what MCP is not: getting the agent to your memory is the easy half, and the half that decides answer quality is whether the memory behind it knows which facts are still true.