# Client setup

> Config for Claude Code, the Claude chat apps, Gemini CLI, Antigravity, Codex CLI, Cursor, VS Code, and anything else.

Find your client below and copy its block - the URL field name differs between clients, and Antigravity connects through a bridge.

| Client | Config file | URL field | Auth |
|---|---|---|---|
| **Claude Code** - incl. the Code tab of Claude Desktop | `.mcp.json` / `~/.claude.json` | `url` + `"type":"http"` | Built-in OAuth |
| **Claude Desktop - Chat tab** · **Cowork tab** · **claude.ai** | UI only - Connectors | URL field in dialog | Built-in OAuth |
| **Gemini CLI** | `~/.gemini/settings.json` | `httpUrl` | Built-in OAuth |
| **Antigravity** | `~/.gemini/config/mcp_config.json` | `command` → `mcp-remote` | Via bridge |
| **Codex CLI** | `~/.codex/config.toml` | `url` | Built-in OAuth |
| **Cursor** | `~/.cursor/mcp.json` | `url` | Built-in OAuth |
| **VS Code** (Copilot) | `.vscode/mcp.json` | `url`, under `servers` | Built-in OAuth |
| **Other clients** | whatever it uses for stdio | `command` → `mcp-remote` | Via bridge |

Chat and Cowork can't send larger files or images - [what works where](/mcp/overview#what-you-need-and-what-works-where).

<Note>
  **After adding the server, start a new session.** Clients read their server list at startup, so a server added mid-conversation will not appear. Restart the CLI, or quit and reopen the desktop app - closing the window is not enough.
</Note>

### Claude Code

Add the server. Use `--scope user` so it follows you into every project; drop the flag to keep it to the current directory.

```bash
claude mcp add --transport http copyleaks_app --scope user https://extensions.copyleaks.com/mcp
```

Start Claude Code, run `/mcp`, pick **copyleaks_app**, and sign in. The browser round-trip stores a token in your OS keychain - you will not be asked again until it expires.

Or sign in without a session: `claude mcp login copyleaks_app`. If the browser does not open, open the printed URL yourself. On a headless machine or over SSH, add `--no-browser` and paste the full redirect URL back at the prompt - over SSH, connect with `ssh -t` so the paste prompt works.

Confirm:

```bash
claude mcp list
claude mcp get copyleaks_app
```

A healthy server reports **✔ Connected**. **! Needs authentication** means the sign-in did not complete. **⏸ Pending approval** means a committed `.mcp.json` entry has not been approved on this machine yet - run `/mcp` and approve it.

**Sharing it with a team** - add it to `.mcp.json` at the project root and commit that file. Each teammate approves the server once and signs in with their own Copyleaks account; no credentials travel in the file.

```json
{
  "mcpServers": {
    "copyleaks_app": {
      "type": "http",
      "url": "https://extensions.copyleaks.com/mcp"
    }
  }
}
```

<Warning>
  **A `url` with no `type` is silently skipped**

  A JSON entry with a `url` and no `type` is read as a local command and skipped, with the message `MCP server "copyleaks_app" has a "url" but no "type"`. Config blocks written for other clients routinely omit it. **Always add `"type": "http"`.**
</Warning>

### The Claude Chat and Cowork tabs, and claude.ai

The Chat and Cowork tabs of Claude Desktop, and claude.ai, reach remote MCP servers as **custom connectors**. There is no `claude_desktop_config.json` entry for this - that file handles locally installed servers only.

1. Open **Customize → Connectors**.
2. Press **+**, then **Add custom connector**.
3. Paste `https://extensions.copyleaks.com/mcp` and leave **Advanced settings** untouched - the server registers the client for you.
4. Press **Add**, then **Connect**, and approve the permissions the sign-in page requests.

Connectors follow your Claude account, so one added on the web also appears in the desktop app's Chat and Cowork tabs.

<Note>
  **Team and Enterprise workspaces** - an Owner adds the connector once under **Organization settings → Connectors**. Every member then connects it from their own **Customize → Connectors** and signs in as themselves. The organization-level entry publishes the server; it does not share a session or a Copyleaks account.
</Note>

#### Cowork

1. Open the **Cowork** tab and **choose a folder** - Cowork reads and writes only inside folders you share.
2. Describe the job in one message: *"Scan every `.docx` in this folder that changed since yesterday with my Client Reports profile, and write a summary to `originality-check.md`."*
3. To repeat it, save it as a **scheduled task**. A task that needs a folder on your computer runs on your computer, so the desktop app has to be open when it fires; a task that only reads past scans can run in the cloud with the app closed.

### Gemini CLI

```bash
gemini mcp add --transport http --scope user copyleaks_app https://extensions.copyleaks.com/mcp
```

Or write it into `~/.gemini/settings.json` (user scope) or `.gemini/settings.json` (project scope), which also lets you name the permissions you want and set a timeout:

```json
{
  "mcpServers": {
    "copyleaks_app": {
      "httpUrl": "https://extensions.copyleaks.com/mcp",
      "oauth": {
        "enabled": true,
        "scopes": ["scans:read", "scans:run", "profiles:read", "profiles:write", "account:read", "offline_access"]
      },
      "timeout": 30000
    }
  }
}
```

<Warning>
  **`httpUrl`, not `url`**

  In Gemini CLI, `url` means SSE and `httpUrl` means Streamable HTTP. Using `url` here makes the client open an SSE connection the server does not serve, and the failure looks like a network problem rather than a config mistake.
</Warning>

Verify with `/mcp`. `--trust` skips tool confirmations for writes too - use it only with read-only permissions.

### Antigravity

Antigravity keeps MCP configuration in `mcp_config.json` - globally at `~/.gemini/config/mcp_config.json`, or per-project at `.agents/mcp_config.json`. Connect Copyleaks through the `mcp-remote` bridge ([Anything else](#anything-else)), which needs Node.js installed:

```json
{
  "mcpServers": {
    "copyleaks_app": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://extensions.copyleaks.com/mcp",
        "--static-oauth-client-info",
        "{\"client_id\": \"mcp-copyleaks.com\"}"
      ]
    }
  }
}
```

Copy the block as it is, including the last two lines - they tell the bridge which Copyleaks sign-in client to use.

### Codex CLI

Codex reads MCP servers from `~/.codex/config.toml`. The table key becomes the server name, so use underscores rather than hyphens.

```toml
[mcp_servers.copyleaks_app]
url = "https://extensions.copyleaks.com/mcp"
auth = "oauth"
scopes = ["scans:read", "scans:run", "profiles:read", "profiles:write", "account:read", "offline_access"]
startup_timeout_sec = 30
tool_timeout_sec = 120
```

Then complete the sign-in once:

```bash
codex mcp login copyleaks_app
```

<Tip>
  Codex accepts the smallest tool replies of any client listed here. On a document with very many matched sources, ask for a narrower view - one match type, one source type, or a minimum matched-word count - rather than everything at once.
</Tip>

### Cursor and VS Code

Cursor infers the transport from the URL, so a remote server needs nothing but the address:

```json
{
  "mcpServers": {
    "copyleaks_app": {
      "url": "https://extensions.copyleaks.com/mcp"
    }
  }
}
```

Global config lives at `~/.cursor/mcp.json`, per-project at `.cursor/mcp.json`.

**VS Code with GitHub Copilot** follows the same shape in `.vscode/mcp.json`, under a `servers` key rather than `mcpServers`. Add the server through **MCP: Add Server → HTTP** and let the editor write the file, which avoids guessing the current schema.

### Anything else

Plenty of MCP clients still speak only stdio. Bridge them with `mcp-remote`, which runs locally, handles the OAuth sign-in in your browser, and proxies the session to the remote endpoint. Any client that can launch a command can use it.

```json
{
  "mcpServers": {
    "copyleaks_app": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://extensions.copyleaks.com/mcp"]
    }
  }
}
```

Treat the bridge as a compatibility shim, not a default. It caches its own sign-in under `~/.mcp-auth`.