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

# Connect Your AI App to the Docs MCP Server

> Connect Claude, Cursor, VS Code, Codex, or your own agent to the Hello Clever docs MCP server so it answers from our live documentation instead of guessing.

Hello Clever hosts a Model Context Protocol (MCP) server for this documentation site. Connect it to your AI coding assistant and it can search and read every published page while it answers you, API reference and OpenAPI specs included.

Why it helps: without the MCP server, your assistant is working from memory. It might invent an endpoint that does not exist, reach for a field name from an older version, or mix Hello Clever up with another payment provider. Once you connect it, it checks the current page before it answers, so you spend less time correcting it.

Setup takes a minute or two, and there is nothing to install. The server is free, public, read-only, and needs no API key.

<Note>
  So you know which server this is: it reads our published documentation and nothing else. It is not an API into your Hello Clever account, so it cannot see your merchant data, balances, or transactions. If you want answers about your own payment data, [Clever AI](/clever-ai/tutorials) in the Merchant Portal is the tool for that.
</Note>

## Server details

Everything you need to set it up:

| Property       | Value                                                          |
| -------------- | -------------------------------------------------------------- |
| Server URL     | `https://docs.helloclever.co/mcp`                              |
| Transport      | HTTP (streamable)                                              |
| Authentication | None. The server is public.                                    |
| Access         | Read-only                                                      |
| Discovery      | `https://docs.helloclever.co/.well-known/mcp`                  |
| Server card    | `https://docs.helloclever.co/.well-known/mcp/server-card.json` |

The server introduces itself as `Hello Clever`. Use the URL exactly as it appears above: there is no separate host, port, or `npx` package to install.

## What your AI app gets

### Tools

Three of them, and your assistant chooses between them on its own.

<CardGroup cols={3}>
  <Card title="Search" icon="magnifying-glass">
    Searches the whole site and hands back matching snippets with page titles and links. Great for broad or conceptual questions like "how do I authenticate".

    `search_hello_clever`
  </Card>

  <Card title="Read the docs" icon="folder-tree">
    Reads the docs as a virtual read-only filesystem using `ls`, `tree`, `rg`, `cat`, `head`, and `jq`. Handy for exact keyword matches, browsing the structure, or pulling up a full page.

    `query_docs_filesystem_hello_clever`
  </Card>

  <Card title="Submit feedback" icon="flag">
    Sends a documentation problem back to our docs team: a page that is wrong, outdated, incomplete, or has an example that does not work.

    `submit_feedback`
  </Card>
</CardGroup>

A typical run searches first, then reads the most promising pages in full.

<Warning>
  The name of the second tool sounds alarming, so to be clear: `query_docs_filesystem_hello_clever` never touches your machine. It runs against an in-memory copy of the published documentation on our side, with no network access, no write access, and no visibility into your local files.
</Warning>

### Resources

You also get a `helloclever` skill file, exposed as an MCP resource. If the tools give your assistant access to the content, the skill tells it how to use that content: which flows apply to payins and payouts, how to configure webhooks, and how to test in sandbox. Clients that support MCP resources pick it up automatically once you connect, so there is nothing extra to install.

### What it covers

Everything in our published navigation, in every language the site ships:

* Getting Started, Platform Overview, payment concepts, and Clever Concepts
* Merchant Portal and Clever AI guides
* Platform integrations such as Shopify, WooCommerce, Magento, and Xero
* The full API Reference, including the v1, v2, Payment Gateway 3, Card, and Cashback OpenAPI specs
* Security and compliance pages

## Connect from the docs site

<div style="position:relative;height:0;width:100%;overflow:hidden;z-index:99999;border-radius:6px;box-sizing:border-box;padding-bottom:calc(57.38916256% + 32px)">
  <iframe src="https://www.guidejar.com/embed/65961f38-4f24-4a18-a76d-65534e073943?type=1&controls=on&skipIntro=false" width="100%" height="100%" style="position:absolute;inset:0" allowfullscreen frameborder="0" />
</div>

If you would rather not touch a config file, start here.

<Steps>
  <Step title="Open the menu">
    At the top right of any page on this site, select the arrow next to the **Copy page** button.
  </Step>

  <Step title="Pick your option">
    **Copy MCP Server** puts `https://docs.helloclever.co/mcp` on your clipboard, ready to paste into your client. **Connect to Cursor** installs it in Cursor for you in one click.
  </Step>
</Steps>

The same menu is handy even without the MCP server. **Open in ChatGPT** and **Open in Claude** start a conversation about the page you are reading, and **Copy page** and **View as Markdown** give you that page as plain Markdown to paste anywhere you like.

## Connect your AI app

Pick your tool below.

<Tabs>
  <Tab title="Claude Code">
    One command in your terminal:

    ```bash theme={null}
    claude mcp add --transport http hello-clever https://docs.helloclever.co/mcp
    ```

    Add `--scope project` if you would like to commit the server to your repository's `.mcp.json` and share it with your team, or `--scope user` to have it available in every project on your machine.

    To confirm, run `/mcp` inside Claude Code. You should see the server listed as connected.
  </Tab>

  <Tab title="Claude web and desktop">
    <Steps>
      <Step title="Open connector settings">
        Head to the [Connectors](https://claude.ai/settings/connectors) page in your Claude settings.
      </Step>

      <Step title="Add a custom connector">
        Select **Add custom connector**, then enter:

        * Name: `Hello Clever Docs`
        * URL: `https://docs.helloclever.co/mcp`
      </Step>

      <Step title="Save it">
        Select **Add**.
      </Step>

      <Step title="Use it in a chat">
        Select the attachments button (the plus icon) in any conversation, then select **Hello Clever Docs**.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cursor">
    The quickest way is **Connect to Cursor**, in the menu behind the **Copy page** button at the top of this page. If you prefer to set it up yourself:

    <Steps>
      <Step title="Open MCP settings">
        Press <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> on Windows), search for `Open MCP settings`, then select **Add custom MCP**. This opens `mcp.json`.
      </Step>

      <Step title="Add the server">
        ```json mcp.json theme={null}
        {
          "mcpServers": {
            "hello-clever": {
              "url": "https://docs.helloclever.co/mcp"
            }
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="VS Code">
    Create `.vscode/mcp.json` in your project:

    ```json .vscode/mcp.json theme={null}
    {
      "servers": {
        "hello-clever": {
          "type": "http",
          "url": "https://docs.helloclever.co/mcp"
        }
      }
    }
    ```

    Commit the file and everyone working in the repository gets the server too.
  </Tab>

  <Tab title="Codex">
    Add the server to `~/.codex/config.toml`:

    ```toml ~/.codex/config.toml theme={null}
    [mcp_servers.hello-clever]
    url = "https://docs.helloclever.co/mcp"
    ```
  </Tab>

  <Tab title="Other clients">
    Most other agents accept the URL through the `add-mcp` helper, which writes the right config for whichever client you pick:

    ```bash theme={null}
    npx add-mcp https://docs.helloclever.co/mcp
    ```

    Not seeing your client? Add it by hand wherever it keeps remote MCP servers. All it needs is the HTTP transport and the URL `https://docs.helloclever.co/mcp`. No headers, no credentials.
  </Tab>
</Tabs>

## Check that it worked

Ask your assistant something our docs answer precisely and the open web does not. Any of these make a good test:

* *Using the Hello Clever docs MCP, what fields does a PayTo agreement need?*
* *Search the Hello Clever docs for the difference between a Payments Account and a Treasury Account.*
* *Read the v2 Payin endpoint from the Hello Clever docs and write me a curl request.*

If the answer comes back with page links to `docs.helloclever.co`, you are connected. If it stays vague and cites nothing, it is still working from memory: check that the server shows as connected in your client, then try again.

## Call the server from your own code

Building your own integration? Any MCP client library can talk to the server. To try it from a terminal first, send a JSON-RPC `initialize` call:

<CodeGroup>
  ```bash Initialize theme={null}
  curl -X POST https://docs.helloclever.co/mcp \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json, text/event-stream' \
    -d '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "initialize",
      "params": {
        "protocolVersion": "2025-06-18",
        "capabilities": {},
        "clientInfo": {"name": "my-integration", "version": "1.0.0"}
      }
    }'
  ```

  ```bash List tools theme={null}
  curl -X POST https://docs.helloclever.co/mcp \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json, text/event-stream' \
    -d '{"jsonrpc": "2.0", "id": 2, "method": "tools/list"}'
  ```

  ```bash Run a search theme={null}
  curl -X POST https://docs.helloclever.co/mcp \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json, text/event-stream' \
    -d '{
      "jsonrpc": "2.0",
      "id": 3,
      "method": "tools/call",
      "params": {
        "name": "search_hello_clever",
        "arguments": {"query": "PayTo agreement"}
      }
    }'
  ```
</CodeGroup>

Two things worth knowing. Responses come back as server-sent events, so keep `text/event-stream` in your `Accept` header. And the search tool takes an optional `language` parameter, for example `"language": "ja"`, if you want results from the Japanese pages. It defaults to `en`.

## Rate limits

These limits keep the server available for everyone. Normal interactive use will not come close to them.

| Scope                           | Limit                    |
| ------------------------------- | ------------------------ |
| Per user (IP address)           | 5,000 requests per hour  |
| Search, per site                | 10,000 requests per hour |
| Query docs filesystem, per site | 10,000 requests per hour |

If you do go over, the server returns `429 Too Many Requests`. Back off and retry: limits reset on a rolling hourly window, so you will not be locked out for long.

## If something goes wrong

<AccordionGroup>
  <Accordion title="The server will not connect">
    Check the URL is exactly `https://docs.helloclever.co/mcp`, with no trailing slash and nothing after it. Then check your client is set to the HTTP transport rather than stdio or SSE. One thing that is not a problem: a `405` response if you open that URL in a browser. The endpoint only answers `POST`, so that is expected.
  </Accordion>

  <Accordion title="My client is asking for an API key or an OAuth login">
    It should not need one. The server is public and takes no credentials. If your client insists on a token, leave the field blank or choose the "no authentication" option.
  </Accordion>

  <Accordion title="It connects, but never seems to use the tools">
    Some clients only reach for MCP tools when the question clearly calls for them. Try naming the source in your prompt, for example "search the Hello Clever docs for...". In Claude web and desktop, also check the connector is selected through the attachments button for that conversation.
  </Accordion>

  <Accordion title="I am getting answers from the old documentation">
    The server indexes this site only. Anything on `legacy-docs.helloclever.co` is outside the index, so answers citing it are coming from your model's training data or a web search rather than from us.
  </Accordion>

  <Accordion title="A page my assistant quoted is wrong">
    Please tell us. Ask your assistant to use the `submit_feedback` tool with the page path and a description of the problem, and it reaches our docs team directly.
  </Accordion>
</AccordionGroup>

## Security and privacy

Connecting the server is low risk. Here are the specifics:

* The server is read-only. The only tool that sends anything back to us is `submit_feedback`, and all it sends is the page path and the feedback text your assistant supplies.
* It serves published documentation. None of it is account-specific, so connecting it exposes none of your data to us.
* Your prompts stay with your AI provider. Only the search queries and file commands your assistant issues reach our documentation server.
* Adding the server to a shared config file such as `.mcp.json` or `.vscode/mcp.json` is safe to commit. There are no secrets in it.

For how we handle data more broadly, see [How we handle data](/platform-overview/compliance/how-handle-data) and [API security](/security/api-security).

## Where to go next

* [Choosing an integration](/integrations/choosing-integration): pick your integration path before you start building
* [Integration keys](/integration-keys): the credentials your code needs, which the MCP server never handles
* [API overview](/api/overview) and [Authentication](/api/authentication): the reference pages your assistant will read most often
* [Clever AI tutorials](/clever-ai/tutorials): the AI built into the Merchant Portal, which does read your payment data


## Related topics

- [Hello Clever Developer Documentation](/index.md)
- [Shopify Connector](/clever-ai/shopify-connector.md)
- [Choose the Right Hello Clever Integration](/integrations/choosing-integration.md)