OpenClaw MCP Tools: Give Your Personal AI 10,000+ Real-World Tools

OpenClaw — the open-source personal AI assistant with over 340,000 GitHub stars — now supports MCP. That means it can connect to any MCP server and use external tools as first-class capabilities. Your personal AI can go from answering questions to actually doing things across your services.

We've been watching OpenClaw's growth since late 2025. It runs on your hardware, works with Claude, GPT-4, Gemini, DeepSeek, and local models through Ollama, and connects to 20+ messaging platforms — WhatsApp, Telegram, Discord, Slack, Signal, iMessage. It already had 3,200+ skills on ClawHub. What it didn't have was a standardized way to reach the services those skills talked about.

MCP changes that. And MCPBundles makes it trivial.

What Changed: OpenClaw Gets MCP

OpenClaw historically ran as a Node.js gateway that routed messages between your messaging apps and your AI model. Skills — community-built automation scripts — extended what the AI could do, but each skill had to implement its own API integrations, handle its own authentication, and manage its own error handling. Every skill was an island.

MCP replaces that with a standard protocol. Instead of every skill reinventing API access, OpenClaw connects to MCP servers that expose tools through a unified interface. The AI model discovers what tools are available, understands their parameters, and calls them directly.

OpenClaw supports MCP in two directions:

• As an MCP client — connect to external MCP servers (like MCPBundles) and use their tools
• As an MCP server — expose its own conversations and tools to other MCP-compatible clients via openclaw mcp serve

The client direction is what matters for getting real work done. Connect OpenClaw to MCPBundles and your personal AI gains access to 10,000+ tools across 500+ services — Stripe, HubSpot, Gmail, Postgres, Ahrefs, PostHog, and everything else your team uses.

Three Ways to Connect

There are three approaches to connecting OpenClaw to MCPBundles. Each serves a different use case, and you can combine them.

Option 1: Native MCP Config (Simplest)

As of v2026.3.13, OpenClaw has built-in support for remote MCP servers via streamable HTTP. No plugins needed — just add MCPBundles to your ~/.openclaw/openclaw.json:

{
  "mcp": {
    "servers": {
      "mcpbundles": {
        "url": "https://mcp.mcpbundles.com/hub/mcp",
        "headers": {
          "Authorization": "Bearer mb_your_api_key_here"
        }
      }
    }
  }
}

Restart the gateway:

openclaw gateway restart

That's it. OpenClaw connects to MCPBundles on startup, discovers tools via tools/list, and the AI model can call them like any built-in capability. Run openclaw mcp list to confirm your tools are loaded.

This is the fastest path. Three lines of config, one restart, and your personal AI has access to every service you've connected in your MCPBundles workspace.

Option 2: MCP Bridge Plugin (Advanced Control)

If you're connecting multiple MCP servers and want finer control over tool namespacing and token efficiency, the openclaw-mcp-bridge plugin adds features the native config doesn't have yet.

Install the plugin:

openclaw plugins install @aiwerk/openclaw-mcp-bridge

Configure it in ~/.openclaw/openclaw.json:

{
  "plugins": {
    "entries": {
      "openclaw-mcp-bridge": {
        "enabled": true,
        "config": {
          "mode": "router",
          "servers": [
            {
              "name": "mcpbundles",
              "url": "https://mcp.mcpbundles.com/hub/mcp",
              "prefix": "mcpb",
              "tokenFile": "/path/to/mcpbundles-api-key"
            }
          ]
        }
      }
    }
  }
}

The two things that matter here:

mode: "router" — This is important for MCPBundles. In direct mode, every tool gets registered individually in the AI's tool list. With hundreds of tools available, that bloats the context and wastes tokens. Router mode exposes a single mcp meta-tool that the AI uses to discover and call tools on demand. It saves roughly 99% of tool tokens compared to direct registration. Use direct mode only if you're connecting a single bundle with a handful of tools.

prefix: "mcpb" — Namespaces tool names to avoid collisions with other MCP servers. A tool called list-invoices becomes mcpb_list-invoices.

The tokenFile field points to a file containing your MCPBundles API key (create one from your workspace settings). Using a file keeps the key out of your config.

openclaw gateway restart

Option 3: MCPBundles CLI (Terminal Access)

OpenClaw has a terminal. The MCPBundles CLI works in any terminal. That means the same workflow that works in Claude Code, Cursor, and Windsurf works in OpenClaw too.

Install and connect:

pip install mcpbundles
mcpbundles connect my_workspace

From this point on, OpenClaw's AI model can discover and call tools through shell commands:

mcpbundles tools --bundle stripe
mcpbundles call search-customers-a3f --bundle stripe -- query="acme"
mcpbundles search "invoice"

The AI writes and runs these commands itself. You ask "check if acme-corp has any overdue invoices in Stripe" in natural language — on WhatsApp, Telegram, or wherever you talk to your OpenClaw — and the AI figures out which commands to run.

For multi-service workflows, the CLI provides a Python execution sandbox:

mcpbundles exec "
customers = await list_customers(bundle='stripe', limit=10)
for c in customers['data']:
    contact = await search_contacts(bundle='hubspot-crm', query=c['email'])
    print(c['email'], len(contact.get('results', [])), 'HubSpot matches')
"

Every enabled tool is available as an async Python function. The AI writes the script, the CLI handles auth and execution.

When to Use Which

	Native Config	MCP Bridge Plugin	MCPBundles CLI
Setup	3 lines in openclaw.json	Plugin install + JSON config	pip install mcpbundles
How it works	Tools in AI's tool list	Tools via router or direct	AI runs shell commands
Token efficiency	All tools registered	Router mode saves ~99%	No tool registration overhead
Cross-service	One tool call at a time	One tool call at a time	exec chains calls in Python
Best for	Single MCP server, quick start	Multiple MCP servers, large catalogs	Multi-tool workflows, exploration

For most users starting out: native config. It takes 30 seconds and covers the common case.

If you're connecting MCPBundles alongside other MCP servers (your own services, Postgres, GitHub): bridge plugin with router mode. The namespacing and token efficiency pay for themselves immediately.

If you want the AI to chain calls across services in a single script — pulling Stripe data, cross-referencing HubSpot, and emailing results through Gmail: CLI. The exec sandbox is the only option that lets the AI compose multi-service workflows in one shot.

You can use all three simultaneously. Native config or bridge for your most-used services, the CLI for ad-hoc exploration and complex cross-service workflows.

What OpenClaw Can Do With MCPBundles

Once connected, your personal AI goes from "let me look that up for you" to actually doing the work:

From WhatsApp: "What were our Stripe payments this week? Summarize by customer."

From Telegram: "Check if john@acme.com has a HubSpot contact and what deal stage they're in."

From Discord: "Query our PostHog analytics for the signup funnel conversion rate this month."

From Slack: "Search Google Search Console for our top 10 pages by clicks and cross-reference with Ahrefs domain rating."

From iMessage: "Send a summary email via Gmail to the team with yesterday's key metrics from Plausible."

The AI model handles tool discovery, parameter construction, and result interpretation. It doesn't matter which messaging platform you're using — OpenClaw routes the request to the right model, the model calls the right tools, and the answer comes back in the same conversation.

This is the unlock. OpenClaw already gave you a personal AI you could talk to from anywhere. MCP + MCPBundles gives that AI the ability to reach into your actual business systems and get real answers.

What Services Are Available?

MCPBundles connects OpenClaw to 10,000+ tools across 500+ providers:

Category	Services	What Your AI Can Do
Payments & Billing	Stripe, Chargebee, Recurly	Search customers, list invoices, check subscriptions
CRM	HubSpot, Attio, Salesforce, Close	Search contacts, update deals, pull pipeline data
Databases	PostgreSQL, MySQL, Supabase	Run parameterized queries, explore schemas
Email	Gmail, SendGrid, Fastmail	Send emails, search inbox, manage campaigns
Analytics	PostHog, Plausible, Google Analytics	Query events, get funnel data, track metrics
SEO	Google Search Console, Ahrefs	Rankings, indexing status, keyword research
Developer Tools	GitHub, Linear, Sentry	Issues, PRs, error tracking
Project Management	Asana, Notion, Monday.com	Tasks, documents, boards
Cloud	AWS, Cloudflare, Vercel	DNS, deployments, infrastructure
Finance	QuickBooks, Xero, Brex	Invoices, expenses, reconciliation

Browse the full catalog at mcpbundles.com/providers.

Every service is pre-authenticated through your MCPBundles workspace. Your team connects services once — OAuth, API keys, whatever the service needs — and from that point on, every OpenClaw session gets access automatically. The AI never asks you for a token.

Skills and Tools: Better Together

OpenClaw's community has built 3,200+ skills on ClawHub — structured playbooks that tell the AI how to approach a task. Think of them as recipes: step-by-step procedures, quality gates, formatting rules, escalation logic. Skills are great at defining workflows, but they can't reach outside systems on their own.

MCP tools are the inverse. They give the AI the ability to call external services, but they don't know how to use them well. A raw Stripe tool can list invoices, but it doesn't know that PaymentIntents replaced the Charges API, that IDs start with pi_, or that idempotency keys prevent duplicate charges.

MCPBundles provides both — and makes the skills accessible through the protocol itself. Every MCPBundles MCP server includes a get_skills tool that returns the domain knowledge for any bundle. The AI calls get_skills before its first interaction with a service and gets back structured context about the data model, naming conventions, common mistakes, and best practices. No manual setup — the AI reads the manual as part of its normal tool discovery flow.

When your OpenClaw calls get_skills for the Stripe bundle, it learns:

• PaymentIntents replaced the Charges API — use pi_ IDs, not ch_
• Price is immutable — create a new Price, then update the Subscription
• Use idempotency keys for any create/upsert to enable safe retries

For HubSpot, it learns that property names are internal (firstname, not "First Name"), associations are directional, and deals require a pipeline_id. For PostgreSQL, it learns to use parameterized reads, wrap destructive operations in transactions, and that dry-run previews exist for risky updates. Every major service has one of these.

If you're using the MCPBundles CLI, mcpbundles init generates a skill file — a markdown document that captures the full discovery-to-execution workflow for your workspace. AI agents that support skill files (and OpenClaw does, natively) read it automatically and know how to use the tools from the first interaction. The skill file tells the AI: here are your bundles, here's how to discover tools, here's how to call them, and here's how to fetch domain knowledge before acting. It's the bridge between OpenClaw's skill system and MCPBundles' tool catalog.

This is the difference between an AI that fumbles through API docs and one that gets it right on the first try. OpenClaw skills define the workflow. MCPBundles provides the tools, the domain expertise via get_skills, and the initialization via mcpbundles init. Together, your personal AI can handle real tasks without the trial-and-error that makes most AI tool use feel unreliable.

Security: Your AI Never Sees Your Credentials

This is the part that matters most if you're self-hosting OpenClaw and connecting it to production services.

The typical approach to giving an AI access to Stripe or HubSpot is to paste an API key into a config file or environment variable on the machine running the AI. That means your credentials sit on the same hardware as your AI model, your conversation history, and whatever plugins you've installed. If any of those are compromised, your API keys go with them.

MCPBundles separates credentials from the AI entirely. Here's how the layers work:

OpenClaw (your hardware) — runs the AI model, stores your conversations, manages your messaging platform connections. The only MCPBundles credential it holds is a single API key scoped to your workspace. It never sees a Stripe secret key, a HubSpot OAuth token, or a database password.

MCPBundles (cloud) — stores and manages all service credentials. API keys are encrypted at rest. OAuth tokens are obtained through browser-based authorization flows that MCPBundles handles end-to-end — the AI model is never involved in the OAuth handshake and never receives the access token. When the AI calls a tool, the request goes through MCPBundles, which injects the right credentials server-side before forwarding to the service.

The services (Stripe, HubSpot, etc.) — receive authenticated requests from MCPBundles, not from your OpenClaw instance. They never see your AI or your conversations.

The AI model — whether it's Claude, GPT-4, or a local Llama running via Ollama — sees tool names, parameters, and results. It never sees credentials, tokens, or secrets. It can't leak what it doesn't have.

For OAuth services specifically, this is a significant advantage. Setting up OAuth for HubSpot or Google typically means registering a client application, handling redirect URIs, managing token refresh, and storing tokens securely. MCPBundles handles all of that. You click through an OAuth flow once in the MCPBundles dashboard, and the tool works from that point on — token refresh, scope management, and revocation all happen server-side, invisible to the AI.

This separation also means you can revoke access to any service instantly from the MCPBundles dashboard without touching your OpenClaw setup. Disable a bundle, and the tools disappear from the AI's available set on the next request. No config changes, no gateway restart.

Why This Matters for Personal AI

The personal AI assistant space has been stuck in a frustrating pattern: impressive demos, limited real utility. You could ask your AI to summarize an article or draft an email, but the moment you needed it to interact with a real service — check a payment, update a CRM record, query a database — you were back to opening dashboards and copy-pasting data.

OpenClaw broke the first barrier by making the AI persistent and reachable from anywhere. MCP breaks the second barrier by giving it a standardized way to use tools. MCPBundles removes the third barrier — the months of work it takes to build, authenticate, and maintain integrations with hundreds of services. And the security model means you get all of this without putting your credentials on your AI's machine.

The result: you talk to your AI on WhatsApp, it checks Stripe, updates HubSpot, queries your database, and sends you a summary. All authenticated. All auditable. All through one platform — and your credentials never leave MCPBundles.

Getting Started

Native Config (fastest — recommended for most users)

Add this to ~/.openclaw/openclaw.json:

{
  "mcp": {
    "servers": {
      "mcpbundles": {
        "url": "https://mcp.mcpbundles.com/hub/mcp",
        "headers": { "Authorization": "Bearer mb_your_api_key_here" }
      }
    }
  }
}

Then restart: openclaw gateway restart. Done.

Bridge Plugin (recommended for multiple MCP servers)

openclaw plugins install @aiwerk/openclaw-mcp-bridge

Add MCPBundles as a server in the plugin config with mode: "router", restart the gateway, and your tools are live with minimal token overhead.

CLI (recommended for multi-service workflows)

pip install mcpbundles
mcpbundles connect my_workspace

Your OpenClaw can now discover and call any tool through shell commands, and chain calls across services with mcpbundles exec.

Next Steps

• Browse available tools: mcpbundles.com/tools — search across 10,000+ tools
• See all providers: mcpbundles.com/providers — every connected service
• Learn about MCP: What is MCP? — the protocol that makes this work
• CLI documentation: CLI setup guide — full reference
• OpenClaw docs: docs.openclaw.ai — OpenClaw setup and configuration

Troubleshooting

A few things that can trip you up:

Tools not showing up after config change. OpenClaw loads MCP server configs at gateway startup. After editing openclaw.json, always run openclaw gateway restart. Then confirm with openclaw mcp list — you should see your MCPBundles tools in the output.

Tool call timeouts. MCPBundles tools that query large datasets (database queries, analytics exports) can take longer than OpenClaw's default timeout. Increase it:

openclaw config set mcp.toolCallTimeout 60000

That sets a 60-second timeout. The default is often too short for production API calls that involve pagination or aggregation.

Gateway token issues. If you see auth errors on gateway startup, the config key changed in recent versions from gateway.token to gateway.auth.token. Run openclaw doctor — it catches this and most other config problems automatically.

"Connection refused" errors. This means the MCP server URL isn't reachable from your OpenClaw host. For MCPBundles, make sure your machine has outbound HTTPS access to mcp.mcpbundles.com. If you're running OpenClaw on a VPS or Raspberry Pi behind a restrictive firewall, port 443 outbound needs to be open.

Running diagnostics. When something isn't working, this sequence covers most issues:

openclaw status
openclaw gateway status
openclaw doctor
openclaw mcp list

openclaw doctor is the single most useful command — it validates your config, checks connectivity, and reports version mismatches.

Frequently Asked Questions

How do I connect OpenClaw to MCPBundles?

Three ways. Simplest: add MCPBundles as a remote server in openclaw.json under mcp.servers with your API key — three lines of config, one gateway restart. For multiple MCP servers: install the @aiwerk/openclaw-mcp-bridge plugin with router mode for token efficiency. For multi-service workflows: install the MCPBundles CLI with pip install mcpbundles. All three give your AI access to the same 10,000+ tools.

Does OpenClaw support remote MCP servers natively?

Yes, since v2026.3.13. Add a url and headers to mcp.servers in your openclaw.json and OpenClaw connects via streamable HTTP. For more advanced setups (tool namespacing, router mode), the openclaw-mcp-bridge plugin adds features on top of native support.

Can I use OpenClaw with MCPBundles from WhatsApp or Telegram?

Yes. OpenClaw connects to 20+ messaging platforms. Once MCPBundles tools are connected (via the bridge plugin or CLI), the AI can call them regardless of which platform you're messaging from. Ask about a Stripe customer from WhatsApp, get the answer in the same chat.

What AI models work with OpenClaw and MCPBundles?

OpenClaw supports Claude, GPT-4, Gemini, DeepSeek, and local models via Ollama. All of them can use MCP tools through the bridge plugin. The CLI works with any model that has terminal access.

Can the AI model see my API keys or OAuth tokens?

No. MCPBundles injects credentials server-side when forwarding tool calls to services. The AI model only sees tool names, parameters, and results — never secrets. OAuth flows happen in your browser through the MCPBundles dashboard; the AI is never involved in the authorization handshake. You can revoke access to any service instantly from the dashboard without touching your OpenClaw config.

Does the MCPBundles CLI work with other AI agents too?

Yes. The same CLI, same commands, same workflow works in Claude Code, Cursor, Windsurf, OpenClaw, or any agent with terminal access.