Claude Code is good at the work in front of it: the files in your repo, the command you just ran, the error in your terminal. What it can’t see, by default, is everything that lives _around_ the code — the plan you wrote last week, the decision from Tuesday’s meeting, the spec that explains _why_ a function exists at all. That context usually lives in a different tool, and the way you get it into the model is by copying and pasting.

The Model Context Protocol (MCP) exists to end that copy-paste tax. This guide shows you how to connect Claude Code to your Integrity workspace over MCP so the assistant can search, read, and query your workspace directly — no export, no paste, no losing the thread.

## What MCP is, briefly

MCP is an open standard for connecting AI applications to external systems. The protocol’s own docs put it well: it’s “a USB-C port for AI applications” — a standardized way to plug an assistant into your data sources, tools, and workflows instead of building a bespoke integration for every pair.

The shape is simple. There’s a **client** (here, Claude Code) and a **server** (here, Integrity). The server exposes a set of capabilities — in MCP’s vocabulary, _tools_, _resources_, and _prompts_ — and the client calls them on your behalf. When Claude Code needs to know something that lives in your workspace, it asks the Integrity server, gets a structured answer back, and works from that instead of from whatever you happened to paste into the chat.

You don’t have to build any of this. Integrity ships the MCP server. Claude Code ships the client. Your job is to introduce them.

## The one-command connection

Everything you need lives in Integrity’s **Settings → Connections**. Generate a key there — it’s a bearer token that carries your workspace and your identity, so there’s no separate account to link and no per-workspace URL to juggle. The same screen shows you a ready-to-paste snippet for Claude Code.

The command is a single line:

```bash
claude mcp add --transport http integrity https://api.app.integrity.sh/mcp \
  --header "Authorization: Bearer YOUR_KEY"
```

That’s the whole setup. Three things are worth noticing:

- `--transport http` tells Claude Code this is a **remote HTTP server**. Anthropic’s docs call HTTP the recommended option for remote MCP servers — “the most widely supported transport for cloud-based services” — and it’s the one Integrity uses. (Claude Code also supports the older SSE transport, now deprecated, and local `stdio` servers for tools that run as processes on your machine — neither applies here.)
- `integrity` is just the local name Claude Code will use for the connection. Call it whatever you like.
- The `--header` flag passes your bearer key. Because the key encodes your workspace, that single header is all the authentication the server needs.

Run it, and Claude Code registers the server. Type `/mcp` inside a session to confirm it connected and to see the tools it picked up. If you ever want to inspect or remove it, `claude mcp list` and `claude mcp get integrity` show you what’s configured.

### Choosing where the connection lives

Claude Code stores MCP servers in one of three scopes, and you pick with `--scope`:

- **`local`** (the default) — available only to you, only in the current project.
- **`project`** — written to a `.mcp.json` file that you commit, so everyone on the repo gets the same server. Teammates are prompted to approve it before it activates.
- **`user`** — available to you across all your projects.

If your team all works out of one Integrity workspace, `--scope project` is the natural fit for the _endpoint_ — commit the server definition so nobody has to hunt for the URL. Keep the **key** itself a per-person secret, though: it carries your identity, so it belongs in a local, untracked settings file, not in the shared `.mcp.json`.

## What Claude Code can do once it’s connected

Here’s where Integrity’s model does something specific. In most tools, “connect your workspace” means “let the AI read a pile of documents.” In Integrity, everything is a **node in one tree** — a line, a heading, a task, a canvas card, a document, a recorded meeting are all the same kind of thing. So when Claude Code reaches into your workspace over MCP, it isn’t parsing exported files. It’s navigating the same structure you navigate.

The Integrity server exposes tools that map directly onto how you already move through your workspace:

- **Search** across the whole tree — find the node where a decision, a name, or a phrase lives.
- **Read the outline** of a branch — get the shape of a section without pulling every word.
- **Read a node** and its subtree — the full content under any heading, task, or document.
- **Query your supertag databases** — because tagging a node turns it into a row you can view as a board, table, or timeline, Claude Code can ask structured questions against those views: which tasks are open, which items are tagged for this release, what’s on the roadmap.

The practical effect is that your prompts get shorter and truer. Instead of pasting last week’s plan into the chat and hoping you grabbed the right version, you say: _“Read the migration plan node and tell me which steps we haven’t shipped.”_ Instead of describing your data model from memory, you say: _“Query the Bugs supertag and list everything still marked open.”_ Claude Code goes and reads the actual node — the current one — and answers from that.

Meetings are the same node type, which means they’re reachable too. A meeting you recorded — with its clean AI-written notes attached — is a node Claude Code can pull up when you say _“what did we decide about auth in the standup?”_ The thread from the room to the terminal stays intact.

That’s the whole point of Integrity’s tagline, _keep the thread_: the context doesn’t fragment across tools, so the assistant working in your terminal is looking at the same tree you are.

## A note on trust

MCP hands an assistant real reach into your systems, and that’s worth respecting. Anthropic’s own guidance is to verify you trust a server before connecting it, and to be aware that any server which fetches external content can expose you to prompt-injection risk. Connecting your _own_ Integrity workspace to your _own_ Claude Code is the low-risk end of that spectrum — you control both sides, and the bearer key scopes access to your workspace. Still, treat the key like any credential: keep it out of committed files, and rotate it from Settings if it leaks.

## Where to go next

If you have Claude Code installed and an Integrity workspace, you’re about ninety seconds from the assistant reading your tree: generate a key in **Settings → Connections**, paste the one-line command, and type `/mcp` to confirm. From there, the interesting part isn’t the setup — it’s that “what did we decide” and “what’s still open” stop being questions you answer by hand and start being questions you delegate.

For plans, workspace details, and how the rest of Integrity fits together, see [integrity.sh](/content/site-root.html).

## Frequently asked

### Do I need to write any code to connect Claude Code to Integrity?

No. You generate a key in Integrity's Connections settings and run a single `claude mcp add` command. There is no server to host and no code to write — Integrity runs the MCP server for you, and Claude Code is the client.

### Where does Claude Code store the connection, and can my whole team share it?

Claude Code stores MCP servers in one of three scopes: `local` (just you, current project — the default), `project` (checked into `.mcp.json` and shared with everyone on the repo), or `user` (available to you across every project). Pick the scope with the `--scope` flag. Because your key carries your workspace and identity, share the endpoint via `project` scope but keep the key itself a per-person secret.

### What can Claude Code actually see once it's connected?

It sees whatever the MCP tools expose: search across your tree, the outline of a branch, a single node and its subtree, and queries against your supertag databases. It reads your workspace the way you'd navigate it — as nodes — rather than as exported files.

### Is MCP an Anthropic-only thing?

No. The Model Context Protocol is an open standard, and the same Integrity endpoint works with other MCP clients too — Claude Desktop, Codex CLI, and any other MCP client. Claude Code is just the one this guide walks through.

Keep the thread — try Integrity.