Giving Claude (or any agent) a paperwork tool
Most MCP servers give an assistant a fixed menu of tools: one per action, hand-maintained, drifting out of sync with the real API the moment something changes. CloudRaker's MCP server does something different: it exposes exactly two tools, built live from the API's own OpenAPI spec, and lets the agent write and run real code against the full platform through them. Point Claude, ChatGPT, or Codex at it, and any of them can search the API surface, generate a call, and parse, extract, redact, fill, and sign a document, with a human approval step it waits on rather than guesses past.
Two tools, not fifty
The server fronts the CloudRaker gateway and exposes the entire API through Code Mode, two tools derived straight from the live OpenAPI spec:
search— finds the operations relevant to whatever the agent's trying to do.execute— runs generated TypeScript against the gateway to do it.
Because both tools are built from the live spec rather than hand-written per endpoint, the MCP server always covers the full API automatically; there's no per-endpoint tool to fall out of date. When CloudRaker ships a new capability, it shows up here without anyone touching the MCP server itself.
The generated code runs in an isolated worker with no outbound network of its own. The real gateway call happens on the host, with your bearer token injected there, so the credential never enters the code-execution sandbox, and generated code has no way to see or leak it.
Connecting it
The server lives at https://mcp.cloudraker.com, and it accepts two kinds of credential:
- An organization API key, sent as a Bearer token — the same key you'd use with the SDKs. Simplest path, works everywhere.
- OAuth 2.0, for clients that support it — discovered automatically, with an interactive sign-in and no manual token handling. This is what claude.ai's custom connectors use.
For Claude Code:
claude mcp add --transport http cloudraker https://mcp.cloudraker.com \
--header "Authorization: Bearer $CLOUDRAKER_API_KEY"
Or in .mcp.json:
{
"mcpServers": {
"cloudraker": {
"type": "http",
"url": "https://mcp.cloudraker.com",
"headers": { "Authorization": "Bearer <organization API key>" }
}
}
}
For claude.ai or Claude Desktop, add a custom connector pointed at https://mcp.cloudraker.com; it discovers the OAuth flow on its own, with no token to copy anywhere.
Since MCP is an open standard, ChatGPT and Codex connect the same way in principle (same URL, same bearer-token header), though the exact steps for adding a custom MCP connector differ by client, so check each platform's own MCP setup docs for the specific UI flow. The API-key header path works as a reliable fallback anywhere OAuth discovery isn't supported.
There's also a second MCP server, https://docs.cloudraker.com/_mcp/server, for querying CloudRaker's documentation directly instead of fetching pages. Different job, same pattern.
What it looks like in practice
Once connected, you don't write API calls; you describe the task:
Here's a signed vendor contract as a PDF. Pull out the term length, payment terms, and renewal notice period, redact the signatory's personal details, and route it for compliance sign-off.
Behind the scenes, the agent uses search to find the relevant operations (extract, redact, and an agent run for the approval step), then execute to generate and run the code against the gateway: an extraction call against an inferred or provided schema, a redaction pass, and an agent run that pauses at a needs_approval state until a person signs off. Ask for citations and you get page-and-region evidence back for every field, the same grounding you'd get calling the API directly.
That pause is the point. CloudRaker's agent runs are a separate surface from the six core verbs: a versioned, multi-step workflow that includes a sign-off gate. A queued or needs_approval run doesn't proceed on its own; it sits there until a human resolves it. An agent driving this over MCP inherits that same discipline. It can carry a document most of the way to done, then it stops and waits, instead of skipping the step a human was supposed to check.
Why the pause matters
Most "AI does paperwork" demos stop at extraction: the model reads a document and tells you what's in it. Getting a document finished (filled, approved, signed) usually still goes through a person by hand, because the tools that could automate it don't expose an approval step an agent can respect.
That's the gap the two-tool, Code Mode design and the built-in approval gate are both solving for: not just letting an agent read a document, but letting it drive the whole pipeline and know exactly where it's required to stop.
Try it
Connect CloudRaker's MCP server to Claude, ChatGPT, or Codex and hand it a real document from your own workflow: a contract, a claim, a form. Ask it to extract, redact, and route something for approval, and watch it actually wait at the sign-off step.