> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enrichley.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Setup

> Connect Enrichley MCP to Claude Code, Cursor, and MCP Inspector.

Connect the Enrichley MCP server to your AI assistant in a couple of minutes. You will need an Enrichley account on a paid plan.

## Prerequisites

* An Enrichley paid plan ([sign up](https://app.enrichley.io/sign-up)).
* An AI client that supports remote MCP servers with OAuth (Claude Code, Cursor, VS Code, or Codex).

## MCP endpoint

Use this URL wherever your client asks for the MCP server URL:

```text theme={null}
https://mcp.enrichley.io/mcp
```

## Client setup

<Tabs>
  <Tab title="Claude Code">
    Add the server with the Claude Code CLI:

    ```sh theme={null}
    claude mcp add --transport http enrichley https://mcp.enrichley.io/mcp
    ```

    Then open Claude Code and run:

    ```text theme={null}
    /mcp
    ```

    Follow the browser prompt to sign in to your Enrichley account and authorize the requested scopes. Claude Code stores and refreshes the OAuth token on your machine.

    **Scope options**

    Pass `--scope` to control where the server is available and where the config is stored:

    | Flag                      | Scope                | Config file                 |
    | ------------------------- | -------------------- | --------------------------- |
    | `--scope local` (default) | Current project only | `~/.claude.json`            |
    | `--scope project`         | Shared with team     | `.mcp.json` in project root |
    | `--scope user`            | All your projects    | `~/.claude.json`            |

    Example — share with your team via the project-level config:

    ```sh theme={null}
    claude mcp add --scope project --transport http enrichley https://mcp.enrichley.io/mcp
    ```

    Each teammate still completes the OAuth flow with their own Enrichley account.

    **Alternative — add via JSON**

    ```sh theme={null}
    claude mcp add-json enrichley '{"type":"http","url":"https://mcp.enrichley.io/mcp"}'
    ```

    **Project-local `.mcp.json`**

    If you prefer to commit the config directly, drop this in your repo root:

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "type": "http",
          "url": "https://mcp.enrichley.io/mcp",
          "oauth": {
            "scopes": "account.read validation.run"
          }
        }
      }
    }
    ```

    Use the `/mcp` menu in Claude Code to clear authentication or reconnect.
  </Tab>

  <Tab title="Cursor">
    Add the Enrichley server to your Cursor MCP configuration.

    **File:** `.cursor/mcp.json` (project-level) or `~/.cursor/mcp.json` (global)

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    <Steps>
      <Step title="Create or edit the config file">
        Open `.cursor/mcp.json` in your project root, or `~/.cursor/mcp.json` for all projects.
      </Step>

      <Step title="Paste the config above">
        Save the file.
      </Step>

      <Step title="Restart Cursor">
        Restart Cursor, enable the Enrichley server in the MCP/tools panel, and complete the OAuth browser flow when prompted.
      </Step>
    </Steps>

    <Tip>
      Use the project-level config (`.cursor/mcp.json`) to scope Enrichley to a single repo. Use the global config (`~/.cursor/mcp.json`) to make it available everywhere.
    </Tip>
  </Tab>

  <Tab title="VS Code">
    VS Code's built-in MCP client supports remote HTTP servers with OAuth.

    **File:** `.vscode/mcp.json` (workspace) or open the user `mcp.json` via `Cmd+Shift+P` → **MCP: Open User Configuration**

    ```json theme={null}
    {
      "servers": {
        "enrichley": {
          "type": "http",
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    <Steps>
      <Step title="Create the config file">
        Add `.vscode/mcp.json` to your workspace, or open the user-level file via the command palette.
      </Step>

      <Step title="Paste the config above">
        Save the file. VS Code picks up MCP server changes automatically.
      </Step>

      <Step title="Authorize the server">
        Run **MCP: List Servers** from the command palette, select `enrichley`, and complete the browser sign-in.
      </Step>
    </Steps>

    <Note>
      VS Code uses `"servers"` (not `"mcpServers"`) and requires `"type": "http"` for remote servers.
    </Note>
  </Tab>

  <Tab title="Codex">
    The OpenAI Codex CLI supports remote streamable HTTP MCP servers with OAuth.

    **Quick install** — register the server, then complete the OAuth login:

    ```sh theme={null}
    codex mcp add enrichley \
      --url https://mcp.enrichley.io/mcp \
      --scopes account.read,validation.run
    codex mcp login enrichley
    ```

    `codex mcp login` opens your browser to sign in to Enrichley and authorize the requested scopes. After it completes, run `codex mcp list` to confirm the server is connected.

    **Manual config**

    Edit `~/.codex/config.toml` (user-level) or `.codex/config.toml` in your project root (project-level, trusted projects only):

    ```toml theme={null}
    [mcp_servers.enrichley]
    url = "https://mcp.enrichley.io/mcp"
    scopes = ["account.read", "validation.run"]
    ```

    After saving, run `codex mcp login enrichley` to complete the OAuth flow.

    <Note>
      If you run multiple OAuth-protected MCP servers and need a fixed callback port (for example, behind a corporate proxy), set `mcp_oauth_callback_port` at the top level of `~/.codex/config.toml`. Otherwise Codex picks an ephemeral port automatically.
    </Note>
  </Tab>
</Tabs>

<Tip>
  Need to test the server outside of an AI client? See [Debugging with MCP Inspector](/mcp/troubleshooting#debugging-with-mcp-inspector).
</Tip>

## More clients

Beyond the four clients above, the Enrichley MCP server has been validated against these additional MCP-compatible clients. Pick your client below for setup details.

<AccordionGroup>
  <Accordion title="Amazon Q Developer CLI">
    Amazon Q Developer CLI supports remote HTTP MCP servers with OAuth.

    **Config file:** `~/.aws/amazonq/mcp.json` (global) or `.amazonq/mcp.json` (workspace)

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "type": "http",
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    After saving, start a Q CLI session with an agent that includes this server. Run `/mcp` — Q CLI will mark the server as "not yet loaded" and provide an authorization URL. Open it in your browser, sign in to Enrichley, and authorize the requested scopes.
  </Accordion>

  <Accordion title="Cline (VS Code extension)">
    Cline supports remote HTTP MCP servers via the `streamableHttp` transport, including OAuth.

    Open the Cline panel → **Configure** → **Configure MCP Servers**, and add:

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "type": "streamableHttp",
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    On first connect, Cline displays an OAuth URL in VS Code. Click it to complete sign-in in your browser. Cline stores credentials securely and reconnects automatically when you reload.
  </Accordion>

  <Accordion title="Gemini CLI">
    Gemini CLI supports remote HTTP MCP servers with OAuth via auto-discovery.

    **Config file:** `~/.gemini/settings.json` (user) or `.gemini/settings.json` (project)

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    Gemini CLI auto-detects HTTP transport, falls back to SSE if needed, and discovers the OAuth flow from the server's protected-resource metadata. On first use it opens your browser for sign-in.
  </Accordion>

  <Accordion title="JetBrains IDEs (AI Assistant 2025.2+)">
    JetBrains AI Assistant supports remote MCP servers with OAuth 2.1 + PKCE in version 2025.2 and newer.

    Open **Settings → Tools → AI Assistant → Model Context Protocol (MCP)** and add a new server, or edit the JSON config directly:

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    When you first invoke an Enrichley tool, the IDE opens your browser to complete the OAuth flow. Tokens are stored and refreshed automatically.

    <Note>
      Requires AI Assistant 2025.2 or newer for full OAuth + Streamable HTTP support.
    </Note>
  </Accordion>

  <Accordion title="Roo Code (workaround required)">
    Roo Code's native `streamable-http` transport does not yet trigger OAuth flows reliably on a 401 challenge ([tracked in Issue #8119](https://github.com/RooCodeInc/Roo-Code/issues/8119)). Until that ships, use [`mcp-remote`](https://github.com/geelen/mcp-remote) as a local stdio bridge — it handles OAuth on Roo Code's behalf.

    Open Roo Code's MCP settings and add:

    ```json theme={null}
    {
      "mcpServers": {
        "enrichley": {
          "command": "npx",
          "args": [
            "-y",
            "mcp-remote",
            "https://mcp.enrichley.io/mcp"
          ]
        }
      }
    }
    ```

    `mcp-remote` opens your browser for OAuth on first run and caches tokens locally. Once Roo Code adds native OAuth 2.1 support, you can switch to a direct HTTP config.
  </Accordion>

  <Accordion title="Zed">
    Zed supports remote HTTP MCP servers with OAuth. Note that Zed uses **`context_servers`** in its config (not `mcpServers`).

    Open Zed's settings (`Cmd+,` on macOS) and add:

    ```json theme={null}
    {
      "context_servers": {
        "enrichley": {
          "url": "https://mcp.enrichley.io/mcp"
        }
      }
    }
    ```

    When no `Authorization` header is configured, Zed initiates the standard MCP OAuth flow on first use.

    <Warning>
      There are open reports of Zed's OAuth flow not always triggering reliably ([Issue #43162](https://github.com/zed-industries/zed/issues/43162)). If you hit this, fall back to [`mcp-remote`](https://github.com/geelen/mcp-remote) as a stdio bridge.
    </Warning>
  </Accordion>
</AccordionGroup>

### Not currently supported

<Warning>
  **GitHub Copilot Coding Agent** cannot be used with the Enrichley MCP server. Per [GitHub's documentation](https://docs.github.com/en/copilot/concepts/agents/coding-agent/mcp-and-coding-agent), the Copilot cloud agent does not support remote MCP servers that use OAuth for authentication. We will revisit this when GitHub adds OAuth support.
</Warning>

### Other MCP-compatible clients

The Enrichley MCP server works with any client that implements **Streamable HTTP transport with OAuth 2.1 + PKCE**. If your client meets that bar, point it at:

```text theme={null}
https://mcp.enrichley.io/mcp
```

<Note>
  Static-API-key client configurations (using a header field like `x-api-key`) are **not** supported. The Enrichley MCP server requires OAuth.
</Note>

If you get it working with a client we haven't documented, let us know at [support@enrichley.io](mailto:support@enrichley.io) and we'll add it.

## Verify the connection

Ask your AI assistant:

> *"Check my Enrichley credit balance."*

Your assistant should call the `enrichley_get_account_status` tool and return your remaining credits and current rate-limit window. This call is free — it does not consume credits.

If it works, you're done. If not, see [Troubleshooting](/mcp/troubleshooting).

## Next steps

<CardGroup cols={2}>
  <Card title="Tools Reference" icon="wrench" href="/mcp/tools">
    See what each tool returns and how credits are counted.
  </Card>

  <Card title="Authentication" icon="key" href="/mcp/authentication">
    Learn how authorization works and how to disconnect.
  </Card>
</CardGroup>