10 MCP Servers That Turn OpenClaw Into a Superagent (Setup Guide Included)

#Your Agent Is Only as Powerful as Its Tools

Out of the box, OpenClaw can browse the web, run shell commands, manage files, and control your browser. That's already a lot. But what if your agent could query your Postgres database directly? Or create GitHub issues? Or search your company's Slack history?

That's what MCP (Model Context Protocol) servers unlock. Each MCP server is a small program that exposes a specific set of tools — read a database, manage files, interact with an API — over a standardized protocol. Your OpenClaw agent connects to these servers and gains their capabilities automatically. No custom code required.

The MCP ecosystem has exploded since Anthropic open-sourced the protocol in late 2024. There are now over 1,200 published servers. Here are the 10 most useful ones for OpenClaw users, with exact config examples you can paste into your openclaw.json today.

#How MCP Works in OpenClaw

OpenClaw has native MCP client support built on @modelcontextprotocol/sdk. You declare MCP servers in your openclaw.json config, and the Gateway spawns each server process on startup. The agent discovers the server's tools automatically and can call them during any conversation.

Here's the basic structure:

// ~/.openclaw/openclaw.json
{
  agents: {
    list: [
      {
        id: "main",
        mcp: {
          servers: [
            {
              name: "my-server",
              command: "npx",
              args: ["-y", "@some-org/mcp-server"],
              env: {
                API_KEY: "your-key-here",
              },
            },
          ],
        },
      },
    ],
  },
}

Each server entry needs a name, a command to launch it, and optional args and env. The transport defaults to stdio — the agent communicates with the server over stdin/stdout. That's it.

Now let's get to the servers.

#1. Filesystem — @modelcontextprotocol/server-filesystem

The most fundamental MCP server. Gives your agent structured access to read, write, search, and manage files on the local filesystem. Unlike OpenClaw's built-in exec tool (which can already do file ops), the filesystem MCP server provides dedicated, granular tools with directory scoping for safety.

{
  name: "filesystem",
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"],
}

The path argument restricts access to that directory tree. Your agent can't escape it. Good for giving access to a specific project without exposing your whole machine.

Best for: Agents that manage codebases, organize documents, or work with local data files.

#2. GitHub — @modelcontextprotocol/server-github

Create issues, open PRs, search repos, read file contents, manage branches — all from natural language. This is one of the most popular MCP servers in the ecosystem for a reason.

{
  name: "github",
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-github"],
  env: {
    GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_xxxxxxxxxxxxxxxxxxxx",
  },
}

Best for: Developer workflows. "Open an issue for that bug we discussed." "What PRs are open on the main branch?" "Create a branch and push a fix."

#3. Postgres — @modelcontextprotocol/server-postgres

Direct SQL access to your PostgreSQL database. Your agent can query tables, inspect schemas, and pull data — all through natural conversation.

{
  name: "postgres",
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost:5432/mydb"],
}

Best for: Data analysis, reporting, debugging. "How many users signed up this week?" "Show me the top 10 orders by revenue."

#4. Slack — @anthropic/mcp-server-slack

Search messages, read channels, post updates, and manage your Slack workspace. Pairs perfectly with OpenClaw's existing Slack channel integration — the channel handles conversation, while the MCP server gives your agent deeper workspace access.

{
  name: "slack",
  command: "npx",
  args: ["-y", "@anthropic/mcp-server-slack"],
  env: {
    SLACK_BOT_TOKEN: "xoxb-your-token",
    SLACK_TEAM_ID: "T01234567",
  },
}

Best for: Searching conversation history, cross-referencing discussions, posting summaries to channels.

#5. Notion — @notionhq/mcp

Official Notion MCP server. Search pages, read content, create new pages, update databases — the full Notion API exposed as MCP tools.

{
  name: "notion",
  command: "npx",
  args: ["-y", "@notionhq/mcp"],
  env: {
    NOTION_API_KEY: "ntn_xxxxxxxxxxxxx",
  },
}

Best for: Knowledge management. "Find my meeting notes from last Tuesday." "Add a new item to the product roadmap database." "Summarize everything in the Q1 planning page."

#6. Google Drive — @anthropic/mcp-server-gdrive

Search, read, and export files from Google Drive. Supports Docs, Sheets, Slides, and raw files. Your agent can find and summarize documents without you opening a browser.

{
  name: "gdrive",
  command: "npx",
  args: ["-y", "@anthropic/mcp-server-gdrive"],
  env: {
    GOOGLE_CLIENT_ID: "your-client-id",
    GOOGLE_CLIENT_SECRET: "your-client-secret",
  },
}

You'll need to complete OAuth setup on first run. The server will prompt you through it.

Best for: Document retrieval, research, pulling data from shared drives.

#7. Brave Search — @anthropic/mcp-server-brave-search

OpenClaw already has built-in web search via the Brave API. But the MCP server version gives you a standalone, swappable search tool that any MCP-compatible client can use — and it keeps your search config portable.

{
  name: "brave-search",
  command: "npx",
  args: ["-y", "@anthropic/mcp-server-brave-search"],
  env: {
    BRAVE_API_KEY: "BSA_xxxxxxxxxxxxx",
  },
}

Best for: If you want search as an MCP tool rather than a built-in, or you're running multiple agents with different search configs.

#8. Puppeteer — @anthropic/mcp-server-puppeteer

Headless browser automation. Navigate pages, take screenshots, click elements, fill forms, extract content. Complements OpenClaw's built-in browser tool with a lighter-weight alternative for scripted automation.

{
  name: "puppeteer",
  command: "npx",
  args: ["-y", "@anthropic/mcp-server-puppeteer"],
}

Best for: Web scraping, form filling, testing, screenshot-based monitoring.

#9. SQLite — @modelcontextprotocol/server-sqlite

Lightweight database access for SQLite files. Perfect for working with local databases, app data stores, or quick data analysis on .db files.

{
  name: "sqlite",
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/database.db"],
}

Best for: Analyzing local databases, app prototyping, working with exported data.

#10. Memory — @modelcontextprotocol/server-memory

A persistent key-value knowledge graph that your agent can read and write to across sessions. Think of it as giving your agent a structured long-term memory beyond OpenClaw's workspace files.

{
  name: "memory",
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-memory"],
}

Best for: Storing structured facts, preferences, and relationships that your agent should remember. "Remember that our deploy target is us-east-1." "What do you know about Project Atlas?"

#Putting It All Together

Here's what a real multi-server config looks like in practice. You can combine as many servers as you need:

// ~/.openclaw/openclaw.json
{
  agents: {
    list: [
      {
        id: "main",
        mcp: {
          servers: [
            {
              name: "github",
              command: "npx",
              args: ["-y", "@modelcontextprotocol/server-github"],
              env: { GITHUB_PERSONAL_ACCESS_TOKEN: "ghp_xxx" },
            },
            {
              name: "postgres",
              command: "npx",
              args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://readonly@localhost/prod"],
            },
            {
              name: "notion",
              command: "npx",
              args: ["-y", "@notionhq/mcp"],
              env: { NOTION_API_KEY: "ntn_xxx" },
            },
            {
              name: "filesystem",
              command: "npx",
              args: ["-y", "@modelcontextprotocol/server-filesystem", "~/projects"],
            },
          ],
        },
      },
    ],
  },
}

After saving, restart the gateway:

openclaw gateway restart

OpenClaw hot-reloads most config changes, but MCP server additions typically need a restart to spawn the new processes.

#Troubleshooting Tips

Server won't connect? Check that the npm package exists and installs cleanly:

npx -y @modelcontextprotocol/server-github --help

Tools not showing up? Run openclaw doctor to check MCP server status. If a server crashes on startup (bad credentials, missing deps), it won't register its tools.

Too many tools? Each MCP server adds tools to your agent's context. If you connect 10 servers with 5 tools each, that's 50 extra tools in the system prompt. This can increase token usage and slow down tool selection. Only connect what you actually use.

Environment variables not working? Remember OpenClaw's priority: env vars > config file > defaults. If you set GITHUB_PERSONAL_ACCESS_TOKEN both in openclaw.json and as a system env var, the system env var wins.

#Security Considerations

MCP servers run as local processes with whatever permissions you give them. A few rules:

1. Use read-only credentials for databases unless your agent genuinely needs write access.
2. Scope filesystem access to specific directories. Don't pass / as the path.
3. Rotate tokens regularly. Treat MCP server env vars like any other secret.
4. Audit server packages before installing. Stick to official @modelcontextprotocol/* and @anthropic/* servers, or well-known community servers with active maintenance.
5. Use openclaw doctor regularly — it flags MCP servers with known vulnerabilities.

#What's Next

The MCP ecosystem is moving fast. New servers ship weekly — for everything from email (Gmail, Outlook) to cloud infrastructure (AWS, GCP) to specialized tools (Figma, Linear, Jira). The MCP Registry is the canonical directory.

The real power isn't any single server. It's the composability. An agent that can query your database, check your GitHub PRs, search Slack history, and update Notion — all in one conversation — is qualitatively different from one that just chats.

That's what turns OpenClaw from an assistant into a superagent. And it takes about 5 minutes to set up.