OpenClaw MCP Tools: Connect Your AI to Any Service

What Is MCP?

Model Context Protocol (MCP) is an open standard created by Anthropic that defines how AI assistants communicate with external tools and data sources. Think of it as a universal plug format — any service that implements the MCP server spec can be connected to any MCP-capable AI client, including OpenClaw.

Before MCP, every AI integration was bespoke. Want your assistant to read a GitHub issue? Write a GitHub-specific integration. Want it to query a Postgres database? Write a Postgres-specific integration. Each connection required its own code, its own authentication flow, its own maintenance burden.

MCP standardizes the handshake. An MCP server exposes a set of tools (callable functions), resources (readable data), and prompts (templated interactions). An MCP client — like OpenClaw — discovers those capabilities and uses them through a consistent protocol. Write the server once; connect it to any compatible client.

MCP in One Line

MCP is to AI tools what USB is to hardware peripherals — one standard connector for everything.

How OpenClaw Uses MCP

OpenClaw acts as an MCP client. When you configure an MCP server, OpenClaw starts it as a subprocess (for stdio servers) or connects to it over HTTP (for remote servers). At session start, OpenClaw queries the server for its tool list, then makes those tools available to the AI model as callable functions.

The model can then invoke those tools during a conversation. If you ask OpenClaw to "open a GitHub issue for the bug we discussed," it calls the GitHub MCP server's create_issue tool. If you ask it to "query last week's orders," it calls the database MCP server's query tool. The plumbing is invisible — you just talk.

This integrates naturally with OpenClaw's skills system. Skills can wrap MCP servers, adding configuration templates, authentication helpers, and documentation so your AI knows when and how to use each connection.

Popular MCP Servers

The MCP ecosystem has grown rapidly since the spec was released. Here are the servers OpenClaw users connect most often:

🔧 Developer Tools
GitHub MCP: Read/write issues, PRs, commits, branches, and repos
GitLab MCP: Same for self-hosted GitLab instances
Filesystem MCP: Controlled read/write access to specific directories
Git MCP: Direct git operations — log, diff, status, commit

📊 Data & Databases
Postgres MCP: Run SQL queries against PostgreSQL databases
SQLite MCP: Query local SQLite databases
Google Sheets MCP: Read and write spreadsheet data
Airtable MCP: CRUD operations on Airtable bases

💬 Communication & Productivity
Slack MCP: Post messages, read channels, manage threads
Google Drive MCP: Browse, read, and create Drive files
Gmail MCP: Read, search, and send email
Linear MCP: Manage engineering issues and projects

🌐 Web & Search
Brave Search MCP: Web search without leaving your assistant
Puppeteer MCP: Control a browser — navigate, click, screenshot
Fetch MCP: Retrieve and parse web pages as markdown
Exa MCP: Neural semantic search across the web

Setting Up an MCP Server

OpenClaw configures MCP servers in your gateway config. Here's the general pattern, then a concrete GitHub example:

# openclaw.yaml — MCP server configuration
mcp:
  servers:
    github:
      command: npx
      args: ["-y", "@modelcontextprotocol/server-github"]
      env:
        GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_TOKEN}"
    postgres:
      command: npx
      args: ["-y", "@modelcontextprotocol/server-postgres"]
      env:
        DATABASE_URL: "${DB_URL}"
  

OpenClaw starts each listed server when the gateway boots. The servers run as child processes communicating via stdin/stdout (the stdio transport). For remote MCP servers running as HTTP services, use the url key instead of command:

mcp:
  servers:
    my-remote-tool:
      url: "https://my-tool.example.com/mcp"
      headers:
        Authorization: "Bearer ${MY_API_KEY}"
  

After saving, restart the OpenClaw gateway. On the next session, your AI will have access to all the tools the MCP server exposes. You can verify with the built-in mcporter skill — it lists active servers and lets you test individual tool calls.

For step-by-step VPS setup including MCP configuration, see the full install guide.

Real-World Examples

Theory is one thing. Here's what this looks like in practice when you're using OpenClaw day-to-day:

Code Review Workflow

With the GitHub MCP server connected, a conversation might go like this:

"Review the open PRs in my backend repo and flag any that have been waiting for review for over 48 hours."

OpenClaw calls list_pull_requests, filters by age, then posts a summary to your Telegram. No browser tab needed. Pair this with a n8n workflow to auto-assign reviewers and you have a lightweight code review pipeline.

Database Reporting

With a Postgres MCP server pointing at your analytics database:

"What were the top 5 pages by visits last week? Compare to the week before."

OpenClaw writes and runs the SQL, formats the comparison, and sends you the result. No BI tool required for quick sanity checks.

Incident Response

When something breaks at 2am, having Slack, GitHub, and your infrastructure MCP servers connected means your AI agent can:

Read the Slack alert thread for context
Check the GitHub commit history for recent changes
Post a status update to the ops channel
Open a tracking issue — all from a single natural-language request

Building Your Own MCP Server

The MCP spec is simple enough that building a custom server for your internal tools takes a few hours, not weeks. The official SDKs cover TypeScript, Python, and Kotlin. A minimal TypeScript server looks like this:

// my-tool-server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({ name: "my-tool", version: "1.0.0" });

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "get_status",
    description: "Returns service health status",
    inputSchema: { type: "object", properties: {} }
  }]
}));

server.setRequestHandler("tools/call", async (req) => {
  if (req.params.name === "get_status") {
    return { content: [{ type: "text", text: "All systems operational" }] };
  }
});

await server.connect(new StdioServerTransport());
  

Add this to your OpenClaw MCP config and your assistant can call get_status anytime. The real power comes from wrapping your actual internal APIs — deployment scripts, monitoring endpoints, internal databases — in this thin layer.

MCP vs OpenClaw Skills

OpenClaw has two extensibility systems: MCP servers and the skills system. They serve different purposes and work together.

When to Use MCP
Connecting to external services with existing MCP servers
Wrapping internal APIs for AI access
Data read/write operations against databases or file systems
Anything that benefits from a standardized protocol

When to Use Skills
Codifying how OpenClaw should approach a task (instructions + context)
Packaging workflow logic that combines multiple tools
Sharing reusable agent behaviors with the community via ClawHub
Lightweight integrations that don't need the full MCP protocol

In practice, the best setups use both. An MCP server provides raw access to a service; a skill wraps that access with intelligence — knowing when to use it, how to format the output, and how to chain multiple tools into a useful workflow.

For example, the n8n integration uses an MCP server to call n8n's API and a skill that tells OpenClaw when to trigger specific workflows based on conversational context.

The Big Picture

MCP is one of the most important developments in the self-hosted AI space. It means the ecosystem of AI-compatible tools grows independently of any single assistant or model provider. A GitHub MCP server built today works with OpenClaw, Claude Desktop, any future MCP-compatible client.

For people running private AI assistants on their own infrastructure, this matters a lot. You're not locked into a platform's approved integrations list. You connect what you need, control the authentication, and the assistant gains capabilities accordingly.

Combined with OpenClaw's persistent memory and scheduling system, MCP tools turn a conversational AI into something closer to a digital coworker — one that knows your tools, your codebase, and your workflows.

✓ Quick Summary
MCP is an open standard for connecting AI assistants to external services
OpenClaw acts as an MCP client — configure servers in openclaw.yaml
100+ community MCP servers cover GitHub, databases, Slack, search, and more
Build custom servers for internal tools in hours using official SDKs
Combine MCP servers with OpenClaw skills for intelligent, context-aware usage
All data flows through your infrastructure — no third-party relay

Ready to start? → Install OpenClaw on a VPS and configure your first MCP server in under an hour.