OpenClaw with MCP: Connect Any Tool to Your AI Agent

Every AI agent framework eventually runs into the same problem: integrations. You build a GitHub integration, then someone needs Jira. You add Jira, and they need Linear. You add Linear, and they need Notion. Each integration is custom code that only works inside your framework. The wheel gets reinvented constantly.

MCP — the Model Context Protocol — was built to end that cycle. Released by Anthropic in late 2024 and now adopted across the industry, MCP is to AI tools what USB is to hardware: a single standard that lets any tool plug into any AI agent.

OpenClaw's skills system is MCP-compatible. You can plug any MCP server into your SOUL.md and your agent gains access to that tool instantly — no custom code, no framework-specific wrapper, no rebuilding integrations that already exist.

This guide covers what MCP is, why it matters in 2026, how OpenClaw implements it, and how to connect real MCP servers — GitHub, PostgreSQL, Brave Search, and more — to your agents.

What Is MCP?

MCP (Model Context Protocol) is an open standard that defines how AI agents communicate with external tools and data sources. It has two sides:

• MCP servers are small programs that expose tools and resources over the protocol. A GitHub MCP server exposes tools like list_pull_requests, create_issue, and read_file. A PostgreSQL MCP server exposes run_query, list_tables, and describe_schema.
• MCP clients are AI applications that consume those servers. OpenClaw is an MCP client. So is Claude Desktop, Cursor, Windsurf, and dozens of other tools.

The key insight is that an MCP server is written once and works everywhere. If the GitHub team publishes an official MCP server, every MCP-compatible AI tool gets GitHub integration automatically. No framework needs to build and maintain its own GitHub connector.

Think of it as the USB standard for AI tools. Before USB, every device needed a proprietary cable. After USB, you plug anything into anything. MCP does the same for AI integrations.

Why MCP Matters in 2026

MCP launched in late 2024 as a spec and a handful of reference implementations. By early 2026, it has become the de facto standard for AI tool integration. The adoption curve has been steep:

• All major frameworks now support MCP as a first-class integration method: LangGraph, AutoGen, CrewAI, Haystack, and OpenClaw all speak MCP.
• Major platforms have official MCP servers: GitHub, Notion, Linear, Stripe, Cloudflare, Sentry, Atlassian, and more have published verified servers.
• The npm ecosystem has exploded. The @modelcontextprotocol npm scope alone has dozens of servers. The community has published hundreds more.
• Claude Desktop and Cursor ship with MCP support out of the box, which has driven mainstream developer awareness.

For OpenClaw users, this means a rapidly growing library of pre-built tools you can plug into any agent without writing integration code. The work of connecting to GitHub, Slack, Postgres, or Brave Search has already been done — and it follows a standard you can rely on.

How OpenClaw Supports MCP

OpenClaw integrates MCP at the SOUL.md level. You declare MCP servers in the skills section of your agent configuration. The OpenClaw gateway starts each MCP server as a child process, establishes a connection over stdio, and makes the server's tools available to the agent alongside its built-in skills.

From the agent's perspective, MCP tools look identical to built-in skills. The agent does not know or care whether a tool came from an MCP server or a built-in integration. It simply sees a set of available tools and uses whichever one fits the task.

Here is what MCP configuration looks like in SOUL.md:

## Skills
- browser: Search the web
- mcp:
    server: npx @modelcontextprotocol/server-github
    env:
      GITHUB_TOKEN: YOUR_TOKEN
- mcp:
    server: npx @modelcontextprotocol/server-postgres
    env:
      POSTGRES_URL: YOUR_DB_URL

Each mcp: block specifies a server command and any environment variables the server needs (API keys, connection strings, tokens). The gateway handles starting, restarting, and shutting down the server process.

Step-by-Step: Adding Your First MCP Server

Let's walk through adding the GitHub MCP server to an OpenClaw agent. This server gives your agent the ability to read repositories, list pull requests, create issues, review code, and more.

Step 1: Create or Open Your Agent

If you do not have an agent yet, create one. If you have an existing agent, open its SOUL.md file.

# Create a new agent
openclaw agents add github-assistant

# Navigate to its workspace
cd ~/.openclaw/agents/github-assistant/

Step 2: Get a GitHub Personal Access Token

The GitHub MCP server needs a token to authenticate. Go to GitHub Settings → Developer settings → Personal access tokens → Fine-grained tokens and create a token with the permissions your agent needs: repository read/write, issues, pull requests.

Step 3: Add the MCP Server to SOUL.md

Open your agent's SOUL.md and add the MCP skills section. Here is a complete example for a GitHub assistant agent:

# SOUL.md — GitHub Assistant

## Identity
You are a GitHub Assistant. You help developers manage repositories, review pull requests, triage issues, and understand codebases. You have direct access to GitHub via MCP tools.

## Behavior
- When asked about a repository, use your GitHub tools to fetch real data — do not guess
- For pull request reviews, read the diff and provide specific, actionable feedback
- When creating issues, ask for title and description before submitting

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-github
    env:
      GITHUB_TOKEN: ghp_YOUR_TOKEN_HERE

## Channels
- telegram

Step 4: Start the Gateway

Start or restart the OpenClaw gateway. It will read your SOUL.md, see the MCP server declaration, and start the GitHub MCP server as a subprocess.

# Start the gateway
openclaw gateway start

# Or restart if it's already running
openclaw gateway restart

# Verify the MCP server is connected
openclaw gateway status

Step 5: Test Your Agent

Send a message to your agent that requires GitHub access. If the MCP server is connected correctly, the agent will use its GitHub tools to fetch real data.

# Ask the agent about a repository
openclaw agent --agent github-assistant \
  --message "List the open pull requests in mergisi/awesome-openclaw-agents"

# Ask for a code review
openclaw agent --agent github-assistant \
  --message "Review PR #47 in mergisi/awesome-openclaw-agents and summarize the changes"

# Create an issue
openclaw agent --agent github-assistant \
  --message "Create an issue in mergisi/awesome-openclaw-agents titled 'Add MCP skill templates'"

Popular MCP Servers for OpenClaw

The MCP ecosystem has a server for almost every developer tool. Here are the most useful ones to add to OpenClaw agents, with the exact SOUL.md configuration for each.

GitHub

Repository management, pull request reviews, issue triage, code search, and file reading. The most widely used MCP server by far.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-github
    env:
      GITHUB_TOKEN: YOUR_GITHUB_PAT

Tools exposed: list_repos, get_file_contents, list_pull_requests, create_issue, search_code, get_pull_request, and more.

PostgreSQL

Run SQL queries, inspect schemas, and analyze data from a PostgreSQL database. Perfect for analytics agents and data pipeline monitoring.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-postgres
    env:
      POSTGRES_URL: postgresql://user:pass@host:5432/dbname

Tools exposed: query, list_tables, describe_table. The server is read-only by default for safety.

SQLite

Same as PostgreSQL but for local SQLite databases. Great for personal agents, log analysis, and offline workflows.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-sqlite
    env:
      SQLITE_DB_PATH: /path/to/your/database.db

Brave Search

Web search via Brave's Search API. Returns structured results with titles, URLs, and descriptions. Better privacy than Google and widely used in production MCP setups.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-brave-search
    env:
      BRAVE_API_KEY: YOUR_BRAVE_API_KEY

Get a free API key at brave.com/search/api. The free tier covers 2,000 queries per month — enough for most agent workloads.

Filesystem

Read and write files on the local filesystem. Useful when you want controlled file access beyond OpenClaw's built-in file skill. You specify which directories are accessible.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-filesystem /Users/me/projects /Users/me/documents

The paths after the server command are the allowed directories. The server refuses requests to access anything outside those paths.

Puppeteer

Browser automation via Puppeteer. Navigate pages, take screenshots, fill forms, and extract content from JavaScript-rendered sites. Complements OpenClaw's built-in browser skill with a different automation backend.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-puppeteer

Tools exposed: navigate, screenshot, click, fill, evaluate, get_content.

Slack

Read and send Slack messages, list channels, search messages, and manage notifications. Combine with OpenClaw's built-in Slack channel to get both inbound (from Slack) and outbound (to Slack via MCP) capabilities.

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-slack
    env:
      SLACK_BOT_TOKEN: xoxb-YOUR-BOT-TOKEN
      SLACK_TEAM_ID: YOUR_TEAM_ID

Real-World Example: SEO Research Agent

Here is a complete SOUL.md for an SEO research agent that combines GitHub MCP (for storing reports) and Brave Search MCP (for live web research). This is the kind of agent that used to require custom integration code for each tool.

# SOUL.md — SEO Research Agent

## Identity
You are an SEO research specialist. You analyze keywords, study competitor content, identify ranking opportunities, and produce actionable reports. You use web search to find current data and GitHub to store and version your research.

## Behavior
- Always search the web before making claims about keyword trends or competitor rankings
- Store research reports as markdown files in the GitHub repository
- Structure reports with: executive summary, keyword analysis, competitor landscape, recommendations
- When asked to research a topic, ask: target market, competitors to include, and report depth (quick vs. deep)

## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-brave-search
    env:
      BRAVE_API_KEY: YOUR_BRAVE_API_KEY
- mcp:
    server: npx -y @modelcontextprotocol/server-github
    env:
      GITHUB_TOKEN: YOUR_GITHUB_PAT

## Channels
- telegram
- slack

With this configuration, the agent can run a full SEO research workflow from a single Telegram message: search for competitors, analyze keyword patterns, draft a report, and commit it to a GitHub repository — all without any custom glue code.

Interacting with the SEO Agent

# Trigger a research session via CLI
openclaw agent --agent seo-researcher \
  --message "Research 'openclaw alternatives 2026'. Check top 5 Google results, analyze their content structure, and save a report to my seo-reports GitHub repo."

# From Telegram — just message the bot:
# "Research 'mcp server guide 2026' and compare the top 3 results"

# The agent will:
# 1. Use Brave Search MCP to query the web
# 2. Read competitor pages using Brave's content extraction
# 3. Analyze structure, word count, headings, and key topics
# 4. Draft a markdown report
# 5. Use GitHub MCP to commit the report to the repo

MCP vs. OpenClaw Built-in Skills

OpenClaw ships with built-in skills for the most common tasks: web search, file management, shell commands, API requests, browser automation, and code execution. MCP servers extend this further. Here is when to use each:

Use Built-in Skills When...

• You need zero setup: Built-in skills work immediately after installing OpenClaw. No npm packages, no tokens, no external processes.
• The task is general-purpose: File reads, shell commands, HTTP requests, and basic web search are covered by built-ins. MCP is overkill for these.
• You are running on a resource-constrained machine: Each MCP server is a separate process. Built-in skills run in-process with lower overhead.
• You want simplicity: Fewer moving parts means fewer things to debug. Start with built-ins and add MCP servers as you need deeper integrations.

Use MCP Servers When...

• You need deep service integration: GitHub's MCP server exposes 30+ tools. Replicating that with the built-in API skill would require dozens of custom functions.
• You want interoperability: If you use Claude Desktop, Cursor, or other MCP-compatible tools alongside OpenClaw, your MCP servers work across all of them.
• The integration already exists: Before building anything custom, check if an MCP server exists for your tool. It probably does.
• You need structured tool schemas: MCP servers expose typed tool definitions with parameters and return types, which helps the model use them correctly.

Using Both Together

The most powerful setup combines both. Built-in skills handle general tasks; MCP servers handle specific integrations. This agent uses built-in browser for general web scraping and MCP servers for structured service integrations:

## Skills
- browser: Navigate and extract content from web pages
- file: Read and write local files
- mcp:
    server: npx -y @modelcontextprotocol/server-github
    env:
      GITHUB_TOKEN: YOUR_TOKEN
- mcp:
    server: npx -y @modelcontextprotocol/server-brave-search
    env:
      BRAVE_API_KEY: YOUR_KEY
- mcp:
    server: npx -y @modelcontextprotocol/server-slack
    env:
      SLACK_BOT_TOKEN: YOUR_TOKEN
      SLACK_TEAM_ID: YOUR_ID

The MCP Ecosystem in 2026

The MCP server ecosystem has grown faster than anyone expected. Here is where to find servers and how to evaluate them.

Official Sources

• modelcontextprotocol.io — The official MCP website with documentation, the spec, and a curated server registry.
• npm: @modelcontextprotocol — Anthropic's reference implementations. These are production-quality, well-maintained, and tested. Start here.
• github.com/modelcontextprotocol/servers — The reference server repository with implementations for filesystem, GitHub, GitLab, Google Drive, Slack, PostgreSQL, SQLite, Brave Search, Puppeteer, and more.

Community Sources

• awesome-mcp-servers on GitHub — A community-curated list of hundreds of MCP servers. Covers everything from Stripe to Obsidian to Home Assistant.
• npm search: "mcp-server-" — Many community servers follow this naming convention. Search npm for your tool plus "mcp-server" and you will often find something.

Evaluating a Server Before You Use It

Before giving an MCP server access to sensitive credentials, check:

• Is it published by the official organization (e.g., @modelcontextprotocol)?
• Does the GitHub repository have recent commits and open issues being addressed?
• Does the README clearly document what permissions the server requests?
• Can you run it locally and inspect the source before deploying? All MCP servers in the reference implementation are open source.

Troubleshooting MCP in OpenClaw

MCP servers are separate processes, which means there are a few more failure modes than built-in skills. Here are the most common issues and how to fix them.

MCP Server Fails to Start

Check that Node.js is installed on the machine running the gateway. Most MCP servers usenpx, which requires Node.js 18 or later.

# Check Node.js version
node --version   # Should be v18.0.0 or higher

# Test the MCP server command directly
npx -y @modelcontextprotocol/server-github

# Check OpenClaw gateway logs
openclaw gateway logs --tail 50

Tools Not Available to Agent

If the server starts but the agent cannot see its tools, the most common cause is a SOUL.md formatting error. YAML is indent-sensitive. Make sure the mcp: block is correctly indented under the - list item.

# Correct indentation
## Skills
- mcp:
    server: npx -y @modelcontextprotocol/server-github
    env:
      GITHUB_TOKEN: YOUR_TOKEN

# Wrong — will not parse correctly
## Skills
- mcp:
  server: npx -y @modelcontextprotocol/server-github
  env:
    GITHUB_TOKEN: YOUR_TOKEN

Authentication Errors

If the server starts but returns authentication errors, verify your token is correct and has the right permissions. Tokens in SOUL.md are passed as environment variables to the MCP server process — check that they are not accidentally quoted or truncated.

# Verify your GitHub token works directly
curl -H "Authorization: Bearer YOUR_TOKEN" \
  https://api.github.com/user

What to Build Next

MCP turns every OpenClaw agent from a general-purpose assistant into a specialist with real access to real systems. A GitHub agent can actually read your code. A database agent can actually query your data. A search agent can actually fetch current information from the web.

The pattern is always the same: find the MCP server for your tool, add it to SOUL.md, tell the agent what it can do, and start working. No custom integration code required.

If you want a starting point, the awesome-openclaw-agents repository has agent templates that already include MCP configurations for common setups. Fork one, swap in your credentials, and you have a production-ready agent in minutes.

Or browse the CrewClaw gallery for pre-configured agents with tested MCP integrations and deploy one directly to your machine.