# Connect an AI assistant (MCP) (/docs/guides/mcp)



Connect your assistant to eReader Relay to find feeds, save articles to an existing reading list,
or send a blog post to one of your devices. The assistant works with the account you approve and
uses your usual plan allowances and delivery limits.

You can also [import reports and documents](/docs/guides/documents) containing Markdown, HTML tables,
supplied images, and chart data. Relay can turn them into an EPUB for your library or devices.

## Connection settings [#connection-settings]

Open [Account → Connected apps](https://ereaderrelay.com/connections) in Relay to find your server URL
and manage approved applications.

| Setting                                                  | Value                                                      |
| -------------------------------------------------------- | ---------------------------------------------------------- |
| Name                                                     | `eReader Relay`                                            |
| Server URL                                               | `https://ereaderrelay.com/mcp`                             |
| Transport                                                | Streamable HTTP (sometimes labelled HTTP or Remote)        |
| Authentication                                           | OAuth — sign in to Relay in the browser and approve access |
| Bearer token, token environment variable, custom headers | Leave empty                                                |
| OAuth client ID and client secret                        | Leave empty; the client registers automatically            |

Use the full URL including `/mcp`. No API key or locally installed Relay server is needed.
If you are testing a preview, copy the URL from **Connected apps on that preview** and use a distinct
name such as `eReader Relay Preview`. Preview and production data and authorizations are separate;
connecting to production requires signing in again.

## Choose your app [#choose-your-app]

These instructions were checked against the linked official client documentation on 29 September 2026.
Menus and availability depend on your installed version, account, and workspace policy. The common
[MCP standard](https://modelcontextprotocol.io/docs/2026-07-28/getting-started/intro) defines how clients
connect; each app provides its own setup interface.

### ChatGPT on the web [#chatgpt-on-the-web]

1. In ChatGPT settings, open **Security and login** and enable **Developer mode**, if available.
2. Open [Plugins](https://chatgpt.com/plugins) and use the **plus** button to add a connection.
3. Name it **eReader Relay**, add a description such as “Manage my reading lists and send articles to my eReader”, and enter the server URL above.
4. Use OAuth when an authentication choice appears. Leave optional client credentials empty.
5. Create the connection, sign in to Relay, approve the requested access, and review the discovered tools.
6. Start a new conversation and select the connection from the tools menu.

If you cannot add a custom connection, check your workspace's developer-mode policy with its admin.
Web connections are configured separately from local desktop MCP settings.

[Official ChatGPT connection guide](https://developers.openai.com/plugins/deploy/connect-chatgpt)

### Codex and ChatGPT desktop [#codex-and-chatgpt-desktop]

In versions with **Plugins → MCPs**, choose **Add → Connect to a custom MCP**. Other versions expose
**Settings → MCP servers → Add server**. Enter the connection settings above, save, then select
**Authenticate** when prompted. Complete Relay's sign-in and consent screen. Restart the connection
or app if requested and start a new task.

For Codex CLI:

```sh
codex mcp add ereader-relay --url https://ereaderrelay.com/mcp
codex mcp login ereader-relay
codex mcp list
```

Alternatively, add this to `~/.codex/config.toml`, then run the login command:

```toml
[mcp_servers.ereader-relay]
url = "https://ereaderrelay.com/mcp"
```

The desktop app, Codex CLI, and Codex IDE extension share this configuration on the same Codex host.
ChatGPT web does not read this local file. Use `/mcp` in Codex to check the available tools.

[Official desktop and Codex MCP guide](https://learn.chatgpt.com/docs/extend/mcp)

### Claude web and Claude Desktop [#claude-web-and-claude-desktop]

1. Open **Customize → Connectors**.
2. Use **+ → Add custom connector** and enter Relay's server URL.
3. Leave advanced OAuth credentials empty and choose **Add**.
4. Connect the new entry, sign in to Relay, and approve access.
5. Enable the connector in the conversation's tools menu.

Use a remote custom connector for Relay. Team and Enterprise workspaces may need an owner to add
the connector first; each person then connects their own Relay account.

[Official Claude remote connector guide](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp)

### Claude Code [#claude-code]

Register Relay for your user account:

```sh
claude mcp add --transport http --scope user ereader-relay https://ereaderrelay.com/mcp
```

Open Claude Code, run `/mcp`, select **ereader-relay**, and authenticate in the browser. Newer releases
also support `claude mcp login ereader-relay` directly from your terminal. Finish Relay's consent
screen and check that the tools appear in `/mcp`.

[Official Claude Code MCP guide](https://code.claude.com/docs/en/mcp)

### OpenCode [#opencode]

For **OpenCode V2**, add and authenticate the server:

```sh
opencode mcp add ereader-relay --global --url https://ereaderrelay.com/mcp
opencode mcp auth ereader-relay
opencode mcp list
```

You can also run `/mcps` inside OpenCode and select Relay to sign in. OAuth is enabled by default.

If configuring V2 by hand, merge this entry into your `opencode.jsonc`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "servers": {
      "ereader-relay": {
        "type": "remote",
        "url": "https://ereaderrelay.com/mcp"
      }
    }
  }
}
```

**OpenCode V1** places the `ereader-relay` entry directly inside `mcp`, without the `servers` wrapper.
After saving, use `opencode mcp auth ereader-relay` to sign in. Keep OAuth enabled in either version.

[Official OpenCode V2 guide](https://opencode.ai/v2/docs/mcp-servers/) ·
[OpenCode V1 guide](https://opencode.ai/docs/mcp-servers/)

### Cursor [#cursor]

Merge this entry into `~/.cursor/mcp.json` for personal use, or `.cursor/mcp.json` for a project:

```json
{
  "mcpServers": {
    "ereader-relay": {
      "url": "https://ereaderrelay.com/mcp"
    }
  }
}
```

Save and restart Cursor. Open **Customize → MCPs** (or MCP settings in older versions), connect
Relay, and complete the browser authentication prompt. Make sure its tools are enabled for Agent.

[Official Cursor MCP guide](https://cursor.com/help/customization/mcp)

### VS Code with GitHub Copilot [#vs-code-with-github-copilot]

Run **MCP: Add Server** from the Command Palette, choose an HTTP server, and enter Relay's URL.
Choose a name and whether to save it for your user or workspace. Start the server and complete
the trust and browser sign-in prompts.

For a workspace, the equivalent `.vscode/mcp.json` entry is:

```json
{
  "servers": {
    "ereader-relay": {
      "type": "http",
      "url": "https://ereaderrelay.com/mcp"
    }
  }
}
```

Use **MCP: List Servers** to inspect the connection, then enable Relay's tools in Copilot Chat's
tool picker. Preserve any existing server entries when editing configuration files.

[Official VS Code MCP guide](https://code.visualstudio.com/docs/agent-customization/mcp-servers)

## Check the connection [#check-the-connection]

Start with a request that only reads your account:

> Use eReader Relay to show my reading lists, devices, and remaining plan allowances.

Check that the returned account and list names are yours. Then try:

* “Find the RSS feed for [https://blog.cloudflare.com](https://blog.cloudflare.com) and add it to my Weekly Tech reading list.”
* “Save this article to my Weekend reading list: \[article URL].”
* “Send this blog post to my Kindle now: \[article URL].”
* “Check the status of that delivery.”

Create the reading list and register its device in Relay first. Use their actual names so the
assistant can select the intended destination. A send request queues preparation and delivery;
ask for its status afterward. Email accepted by the delivery provider does not confirm that your
physical device has downloaded it.

## Newsletters and subscriptions [#newsletters-and-subscriptions]

The assistant can prepare a private subscription inbox and add an observed newsletter sender to
a reading list. You may still need to enter that address on the publisher's website, solve a CAPTCHA,
or confirm the subscription. A sender becomes available after its first email arrives.

MCP does not purchase paid newsletter subscriptions or change your Relay billing plan. Open Relay's
[billing page](https://ereaderrelay.com/billing) to manage your plan. See
[Subscription inboxes](/docs/guides/subscription-inboxes) for the full newsletter workflow.

## Permissions and disconnecting [#permissions-and-disconnecting]

Relay asks you to approve read, write, and send access. The connected assistant can only operate on
your account, and your source, inbox, article, and delivery allowances still apply. Your assistant
may ask for an additional confirmation before making changes or sending an article.

To revoke access, open **Account → Connected apps** in Relay and select **Disconnect** beside the
application. Remove or disable the connection in the assistant too. Reconnecting requires a new
authorization.

## Troubleshooting [#troubleshooting]

| Symptom                                             | What to check                                                                                                                                                                    |
| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Connected, but the assistant cannot see tools       | Start a new conversation or task, enable Relay in the tool picker, and refresh or restart the MCP connection.                                                                    |
| Authentication fails or loops                       | Use the complete `/mcp` URL, remove manually entered token/header settings, and authenticate again. Check that you are signing in to the intended preview or production account. |
| Server appears unavailable when opened as a website | `/mcp` is a protocol endpoint, not a web page. Test it through the assistant's MCP connection.                                                                                   |
| A client only offers STDIO or API keys              | Use a client with remote Streamable HTTP and OAuth support. Relay does not issue a static API key for this connection.                                                           |
| Access was revoked or expired                       | Reconnect and approve access again.                                                                                                                                              |
| A plan or rate limit is reported                    | Follow the returned explanation. Wait before retrying rate limits; review your plan for allowance limits.                                                                        |
| No feed found for a website                         | Some sites do not publish RSS or Atom. Supply a known feed URL or save individual articles instead.                                                                              |
| A tool fails after adding or removing settings      | Update the client, refresh its tool catalog, and consult its linked official guide.                                                                                              |

The guides above describe each client's documented connection flow. Client versions and workspace
restrictions can affect compatibility; a client appearing here is not a promise that every release
has been tested with Relay.
