# How to Set Up OpenClaw MCP Server

Connect OpenClaw to Fastio's hosted MCP server for consolidated tools covering files, sharing, and AI. Connect directly over HTTP or SSE with your scoped API key.

This guide covers prerequisites, setup steps, testing, and troubleshooting. It also explains what MCP is and how OpenClaw connects to MCP servers.

Source: https://fast.io/resources/openclaw-mcp-setup/
Last reviewed: 2026-02-17

## What is MCP and how does OpenClaw use it?

Model Context Protocol (MCP) is an open standard for connecting AI models to external tools and services. It lets agents call into storage systems, APIs, databases, and custom tools using a consistent interface. Anthropic published the spec, but any vendor or developer can build an MCP server against it.

OpenClaw is an open-source local AI assistant that runs on your machine. It works alongside messaging apps like WhatsApp, Telegram, and Discord, and adds capabilities through skills from [ClawHub](https://clawhub.ai/). When you install an MCP skill, OpenClaw registers those tools and can call them during agent execution.

You can connect OpenClaw to any MCP server. There are community servers for databases, code execution, browser automation, and more. Fastio's hosted MCP server at [mcp.fast.io](/storage-for-agents/) is one option, focused on file storage and collaboration. It exposes a consolidated MCP toolset covering workspaces, file operations, sharing, AI chat, and cloud imports.

The Fastio [ClawHub skill](https://fast.io/storage-for-openclaw/) (`dbalve/fast-io`) installs and registers those tools with a single command, with no config files and no environment variables. It's a good fit if you want cloud storage with built-in RAG and don't want to host anything yourself.

### What Fastio's MCP server provides

- **Hosted server**: No self-hosting. Connect via `https://mcp.fast.io/mcp`.

- **Zero local install**: Connect with a URL to access Fastio's consolidated toolset.

## Prerequisites

Before setting up OpenClaw with any MCP server, you need a working OpenClaw instance.

**Runtime:**
- Node.js 24 recommended. Node 22 LTS (22.16+) still supported.
- Install OpenClaw: `npm install -g openclaw@latest`
- Then run `openclaw onboard --install-daemon` to configure your LLM and messaging channels.

**LLM backend:**
- An API key for your preferred provider: Anthropic, OpenAI, Google, or a local model via Ollama.
- OpenClaw prompts for this during onboarding.

**For Fastio specifically:**
- No account needed upfront. The first tool call triggers browser-based OAuth and creates your account.
- There is no permanent free tier. To run an organization, start a 14-day trial (a credit card is required) or take a subscription. Storage and seats come with the plan, and included credits cover AI work.

## Step-by-step setup with Fastio

This covers connecting OpenClaw to Fastio's remote MCP server. Fastio requires no local package installation or containerization.

**Step 1: Install OpenClaw**
```
npm install -g openclaw@latest
openclaw onboard --install-daemon
```
Follow the prompts to set your LLM provider and optional messaging channels.

**Step 2: Connect to Fastio Remote MCP Server**
Add Fastio's remote MCP URL to your OpenClaw configuration:
```json
{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_KEY"
      }
    }
  }
}
```
You can also connect using legacy SSE at `https://mcp.fast.io/sse`.

**Step 3: Authenticate with Fastio**
Create an account at [Fastio](https://fast.io) and obtain a long-lived, scoped API key from your organization settings. Fastio also supports PKCE browser login for supervised sessions.

## Testing the integration

Run through these checks to confirm the setup works end to end.

1. **Basic file operations:**
  

```
   "Create workspace 'test-mcp'. Upload note 'hello.md' with content 'OpenClaw MCP test.' List contents."
  

```
   You should get a workspace ID, a node ID for the file, and a confirmation. Browse to [app.Fastio](https://app.fast.io/) to see it.

2. **RAG query:**
  

```
   "Enable intelligence on 'test-mcp'. Query: summarize workspace contents."
  

```
   With intelligence mode on, uploaded files get indexed. The response should cite 'hello.md'.

3. **Share creation:**
  

```
   "Create a send share in 'test-mcp' for the root folder. Set password 'test123', return the public link."
  

```
   You'll get a share ID and a branded link you can open in a browser.

4. **URL import:**
  

```
   "Import https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf to 'test-mcp'."
  

```
   Should return an import job ID and a node ID once complete.

5. **File lock:**
  

```
   "Acquire lock on 'hello.md'. List locks. Release it."
  

```
   You should see a lock token appear and then clear.

Node IDs look like `f3jm5-zqzfx-...`. Check `openclaw logs` if anything returns an error.

## Workflow examples

Here are some things you can do once the integration is running.

**Attachment archiving:**
```
"Save recent WhatsApp attachments to 'WhatsApp Archive'. Create subfolders /images, /docs, /audio and sort by type."
```
OpenClaw creates the workspace, uploads files, organizes into folders. The result is browsable at [app.Fastio](https://app.fast.io/).

**Document Q&A:**
Upload contracts or research PDFs to a workspace and enable intelligence mode.
```
"Enable intelligence on 'contracts'. Find all indemnity clauses across contracts, cite sources."
```
The built-in RAG pipeline indexes files and returns citations with page references once Intelligence is enabled.

**Client data room:**
```
"In 'Q4-reports', create a send share for root. Brand with client logo, password-protect, expire in 30 days."
```
Produces a share link with file previews. Audit logs track views.

**Multi-agent coordination:**
```
"Invite agent@example.com to 'team-project' as member. Review version history and audit log."
```
Fastio's file version history with restore and append-only audit logs track concurrent human and agent changes safely.

**Ownership handoff:**
```
"Create transfer token for my org. Generate claim link."
```
A human claims the workspace via the link and can upgrade the plan. The agent keeps admin access.

### Ownership transfer

If an agent builds out a workspace for a client, the agent can transfer ownership without losing access:
1. Create agent account, org, and workspace via MCP tools.
2. Configure files, shares, and intelligence mode.
3. Call the `org` tool with action `transfer-token-create` to get a 72-hour token.
4. Share the claim URL: `https://go.fast.io/claim?token={token}`.
5. Human claims; agent keeps admin privileges.

This is also the workaround when the agent hits credit limits (402 errors): transfer to a human account so they can upgrade. See [agent guide](/storage-for-agents/).

## Troubleshooting

**Auth fails or token expired:**
Run `openclaw logout`, then try "Use Fastio" again. PKCE handles OAuth. If the browser tab gets stuck, disable any extensions blocking popups and copy the auth code manually.

**Credit limits (402 error):**
Included credits refresh with your billing period. Monitor with `auth status`. If you're hitting limits mid-workflow, overage runs $10 per 100,000 credits, or transfer the org to a human account so they can move up a plan at /pricing/.

**Tool errors:**
Run `openclaw doctor` for diagnostics. Check `openclaw logs` for specifics. If a skill seems outdated, run `openclaw update` or reinstall with `npx clawhub@latest install dbalve/fast-io`.

**No workspaces visible:**
Run `org discover-external` to find workspaces you've been invited to. Check `auth status` to confirm scopes.

**RAG not working:**
Confirm intelligence mode is enabled (`workspace update intelligence=true`). Files need to reach `ai_state: ready`, which you can check with `storage details`. Large files take a minute to index.

**Upload fails:**
Use a resumable upload for large files so a dropped connection resumes instead of restarting. Storage comes out of your plan allowance rather than your credits, so an upload failure is almost never a credit problem.

**Still stuck:**
Check the [Fastio MCP docs](/storage-for-agents/) or the [OpenClaw community](https://openclaw.ai/).

## Frequently asked questions

### How do I set up MCP in OpenClaw?

Add Fastio's remote MCP endpoint (`https://mcp.fast.io/mcp`) to your OpenClaw configuration with a scoped API key. OpenClaw connects over Streamable HTTP or SSE with zero local installation.

### What are the prerequisites for OpenClaw MCP?

Node.js 24 (or Node 22.16+ LTS), OpenClaw installed, an LLM API key, and a Fastio account with an API key from organization settings.

### What tools does Fastio's MCP server provide?

Fastio exposes a consolidated MCP toolset covering authentication, organizations, workspaces, storage, version history, branded shares, AI chat, and anchored comments.

### Is Fastio free for OpenClaw agents?

No. Creating an account is free, but running an organization requires a 14-day trial, which needs a credit card, or a subscription. Storage and seats come with the plan, and included credits cover AI work such as chat, ingestion, and agent runs.

### How do I handle credit limits?

Included credits refresh with your billing period, and overage is billed at $10 per 100,000 credits. If an agent hits limits mid-workflow, you can let overage cover it, transfer org ownership to a human account so they can move up a plan, or wait for the refresh.

### Can OpenClaw share files externally?

Yes. The `share` tool supports send, receive, and exchange share types with optional passwords, branding, and expiry dates.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.