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

# MCP servers

> Give the Reintersect agent tools from a remote MCP server: one an admin adds by URL, or one your app serves.

> Reintersect apps are in developer preview. Names and limits can still change before general
> release.

The Reintersect agent can call tools on remote MCP servers that speak Streamable HTTP. A workspace
gets an MCP server in one of two ways:

| Kind | Who sets it up | How |
| - | - | - |
| Custom | A workspace admin | **Settings → Workspace → Integrations → Add MCP server**, then the server's URL. No app code involved. |
| App-served | You, in code | `.addMcp(handler, { auth })` on your app. Reintersect serves the handler at your app's `/mcp` path, and the manifest lists the server so admins see it on the consent screen. |

Both kinds follow the same tool snapshot, allowlist and approval rules.

## Serve MCP from your app

```ts src/app.ts theme={null}
import { createReintersectApp } from "@reintersect/sdk/app";
import { mcpServer } from "./mcp";

export const app = createReintersectApp({ name: "Launchpad", slug: "launchpad" })
  .addBlock(DeploymentCard)
  .addMcp(mcpServer, { auth: "oauth" });
```

`addMcp` takes any fetch-style MCP handler: a function `(request, extra?) => Response`, or an object
with such a `fetch` method. See [Server handlers](/mcp/servers). An app has at most one MCP server.

| Hosting | URL of the server |
| - | - |
| Reintersect-hosted | `https://<slug>.reintersect.app/mcp` |
| Self-hosted | `/mcp` under the root of your `endpoint`, such as `https://launchpad.example.com/api/mcp` for the endpoint `https://launchpad.example.com/api/reintersect` |

The manifest records that URL and the `auth` mode. A deploy is refused with `mcp-host-unverified` when
the URL's host isn't covered by one of the app's [verified domains](/references/domain-verification);
private apps, and hosted apps serving MCP on their own `<slug>.reintersect.app` host, are exempt.
Adding or changing the server changes the app's access, so installs wait for an admin to approve the
new version.

## Tools

When a server is added, Reintersect connects with an admin's credentials, lists the server's tools
and stores a snapshot: names, descriptions, input schemas and annotations. The admin chooses which
tools members can use. Tools the admin leaves out are never offered to the agent.

Each tool the agent sees is named `mcp_<server>__<tool>`, at most 64 characters, so two servers with a
`search` tool don't collide. Tool descriptions and results are passed to the model as data from
that server, never as instructions.

### Approval

| Tool | What happens when the agent calls it |
| - | - |
| Annotated `readOnlyHint: true` and `openWorldHint: false` | Runs without asking. |
| Anything else, including read-only tools without `openWorldHint` | The agent shows an approval card with the tool and its arguments, and runs it only after the member who started the turn approves. |

Admins can override each tool in the server's settings: ask first, always ask, or run without asking.
The circle agent, which runs without a member watching, only gets tools that run without asking.

### When the tool list changes

Reintersect refreshes the snapshot when the server's cache hint (`ttlMs`) expires and when a call
fails because a tool no longer exists or the cached view is out of date. A new tool, or a tool that
loses `readOnlyHint`, is held until an admin reviews it.

## Asking the member for input

When a tool needs more input mid-call (an MCP `elicitation/create` form request), the agent shows the
form in the chat to the member who started the turn. Reintersect sends the answers back and retries
the call, up to three rounds, within 15 minutes. Requests whose fields look like they ask for a
password, token or other secret are refused, and messages are capped at 500 characters. The circle
agent can't answer input requests.

## What your server receives

Tool calls arrive as normal MCP requests with the member's credential. See
[Authentication](/mcp/authentication) for how that credential is obtained. Don't trust anything in
the request's `_meta` for authorization; use the verified token.

## Protocol support

Reintersect's MCP client is the official TypeScript client, and connects to servers on the current
protocol revision and earlier ones that support Streamable HTTP. Every request to a server goes
through Reintersect's SSRF guard: private, loopback and link-local addresses are refused.

MCP Apps, the `ui://` resources that render inside an iframe, aren't supported, and tool results
can't carry blocks. To show interactive UI, give the agent an
[insert tool](/agents#inserting-blocks) by making a block `insertable`.

## Next steps

<Columns cols={2}>
  <Card title="Authentication" icon="key" href="/mcp/authentication">
    Bring your own OAuth, or let Reintersect sign each call.
  </Card>

  <Card title="Server handlers" icon="plug" href="/mcp/servers">
    Mount the official SDK or any fetch-style handler with addMcp.
  </Card>

  <Card title="Agents" icon="bot" href="/agents">
    How the agent reads, inserts and acts on blocks.
  </Card>
</Columns>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.