Awesome MCP Servers for Claude Desktop Cowork

One of the defining innovations of Claude Cowork is the Model Context Protocol (MCP). MCP allows you to extend Claude's intelligence by connecting it to external data sources and execution engines via secure, standardized APIs.

Instead of writing custom scripts for every tool, you can plug in community-maintained MCP servers. This guide curates the absolute best open-source MCP servers for productivity and development, providing instant setup codes for your claude_desktop_config.json.

Table of Contents

  1. What is an MCP Server?
  2. Top 5 Open-Source MCP Servers
  3. Example Combined Configuration
  4. Best Practices for Running MCPs

What is an MCP Server?

An MCP Server is a local or remote process that exposes a set of "Tools" and "Resources" to Claude.

When configured, Claude Desktop detects these tools at startup and automatically routes relevant user requests to them. For example, if you ask Claude, "Read my Google Calendar to find open slots today", Claude calls the Google Calendar MCP server to fetch the data.

Top 5 Open-Source MCP Servers

Here are the most useful, battle-tested MCP servers you should configure today:

1. File System MCP (@modelcontextprotocol/server-filesystem)

Allows Claude to read, write, edit, and traverse files on your computer inside allowed directories.

  • Why use it: This is the default backbone of Cowork's file manipulation abilities.
  • Configuration:
"filesystem": {
  "command": "npx",
  "args": [
    "-y",
    "@modelcontextprotocol/server-filesystem",
    "C:\\Users\\YourUsername\\Desktop",
    "C:\\Users\\YourUsername\\Downloads"
  ]
}

2. GitHub MCP (@modelcontextprotocol/server-github)

Allows Claude to view repositories, create issues, search code, commit edits, and manage pull requests.

  • Why use it: Ideal for developers who want Claude to manage version control and PR pipelines autonomously.
  • Configuration (Requires a GitHub Personal Access Token):
"github": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": {
    "GITHUB_PERSONAL_ACCESS_TOKEN": "your_github_token_here"
  }
}

3. SQLite Database MCP (@modelcontextprotocol/server-sqlite)

Grants Claude standard SQL query capabilities to inspect, update, and create local database files.

  • Why use it: Excellent for analyzing local databases, extracting metrics, and generating reports from local business datasets.
  • Configuration:
"sqlite": {
  "command": "npx",
  "args": [
    "-y",
    "@modelcontextprotocol/server-sqlite",
    "--db-path",
    "C:\\Users\\YourUsername\\ClaudeWork\\analytics.db"
  ]
}

4. Brave Search MCP (@modelcontextprotocol/server-brave-search)

Connects Claude to Brave's web search API to query current search results, URLs, and summaries.

  • Why use it: Keeps Claude updated with real-time web facts, avoiding hallucination on current news or document links.
  • Configuration (Requires a Brave Search API key):
"brave-search": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-brave-search"],
  "env": {
    "BRAVE_API_KEY": "your_brave_api_key_here"
  }
}

5. Puppeteer Web Scraper MCP (@modelcontextprotocol/server-puppeteer)

Allows Claude to open local headless browser windows to scrape page text, take screenshots of sites, and click elements.

  • Why use it: Essential for complex web data collection or automated testing.
  • Configuration:
"puppeteer": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
}

6. Google Drive MCP (@modelcontextprotocol/server-google-drive)

Lets Claude search, read, and list files in your Google Drive, including Docs and Sheets exported to text.

  • Why use it: Useful when your source documents live in Drive rather than on a local disk, which is common for collaborative teams.
  • Configuration (Requires OAuth client credentials from Google Cloud Console):
"google-drive": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-google-drive"],
  "env": {
    "GOOGLE_CLIENT_ID": "your_client_id",
    "GOOGLE_CLIENT_SECRET": "your_client_secret"
  }
}

7. Slack MCP (@modelcontextprotocol/server-slack)

Lets Claude list channels, read recent messages, and post updates to a channel on your behalf.

  • Why use it: Handy for status reporting. A Cowork task can post its own completion summary into a project channel when it finishes.
  • Configuration (Requires a Slack bot token):
"slack": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-slack"],
  "env": {
    "SLACK_BOT_TOKEN": "xoxb-your-bot-token"
  }
}

8. Memory MCP (@modelcontextprotocol/server-memory)

A simple key-value memory store that persists across Cowork sessions, so Claude can recall facts, preferences, and project context without you repeating them.

  • Why use it: Useful for long-running projects where Claude needs to remember decisions, naming conventions, or style rules between sessions.
  • Configuration:
"memory": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-memory"]
}

How to Configure MCP Servers in Claude Cowork

Adding an MCP server to Claude Desktop takes a few minutes. Follow these steps for each server you want to enable.

Step 1: Locate the config file

Claude Desktop reads MCP server definitions from a single JSON file.

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

If the file does not exist, create it with an empty mcpServers object:

{
  "mcpServers": {}
}

Step 2: Add the server block

Open the file in a text editor. Inside mcpServers, add a key for each server using the configuration snippets above. The key name (for example "github") is just a label you choose; it does not need to match the package name.

Step 3: Provide credentials

For servers that need a token or API key, fill in the env values. Never commit this file to version control with real secrets. Use environment variable expansion or a local secrets manager if your team shares the config template.

Step 4: Restart Claude Desktop

MCP servers are loaded at startup. After editing the config, fully quit Claude Desktop (not just close the window) and relaunch it. On macOS, use Cmd-Q; on Windows, right-click the tray icon and select Quit.

Step 5: Verify the server loaded

Open a new chat and ask Claude: "Which MCP tools are available right now?" Claude will list the detected tools grouped by server. If a server is missing from the list, check the next section.

Troubleshooting MCP Connection Issues

When an MCP server fails to load, Claude Desktop usually surfaces a generic "server failed to start" message. Here is a diagnostic checklist that resolves the large majority of problems.

  • Confirm Node is installed. All the servers above run via npx, which requires Node.js 18 or newer. Run node --version in a terminal. If it prints nothing or an older version, install the current LTS from nodejs.org and restart Claude Desktop.
  • Test the server manually. Copy the command and args from your config and run them in a terminal: 
    npx -y @modelcontextprotocol/server-filesystem /Users/you/Cowork
    If the server starts and waits for input, the package works. If it errors, the error message is usually clearer than the one Claude Desktop shows.
  • Check the config JSON syntax. A trailing comma or missing brace will invalidate the whole file. Paste the file contents into a JSON linter (jsonlint.com) to catch syntax errors fast.
  • Verify token permissions. For GitHub, the token needs repo and read:org scopes. For Slack, the bot token needs chat:write and channels:read. A token with the wrong scopes will load but fail at call time with a 403 or "insufficient permissions" error.
  • Check the working directory. The filesystem server only sees directories listed in its args. If Claude says it cannot find a file, confirm the path in the config matches the actual folder. On Windows, use double backslashes (C:\\Users\\...) in JSON.
  • Read the log file. Claude Desktop writes MCP startup logs to:
    • macOS: ~/Library/Logs/Claude/mcp.log
    • Windows: %APPDATA%\Claude\Logs\mcp.log Open the log and search for the server name. The final lines usually contain the real error.
  • Watch for port conflicts. Some servers bind a local port. If another process already holds that port, the server will exit. Run lsof -i :PORT (macOS) or netstat -ano | findstr :PORT (Windows) to check.

Security Best Practices for MCP

MCP servers run locally with whatever permissions your user account has. That makes them convenient, and also dangerous if configured carelessly.

  • Scope filesystem access tightly. Only list directories Claude needs. Avoid passing your home directory or root. A misbehaving prompt could otherwise read or move sensitive files.
  • Use least-privilege tokens. For GitHub, prefer a fine-grained personal access token scoped to specific repositories rather than a classic token with full repo access. For Slack, create a dedicated bot user with access only to the channels it needs.
  • Keep tokens out of version control. Add claude_desktop_config.json to your .gitignore if you keep dotfiles in a repo. Share a redacted template instead.
  • Prefer official packages. Stick to @modelcontextprotocol/* packages and well-known community servers. A random npm package with a similar name could be malicious. Check the publisher and download count before installing.
  • Audit the tools a server exposes. After adding a server, ask Claude to list its tools. If a server exposes a "run shell command" tool and you did not expect that, remove the server or find a narrower alternative.
  • Rotate credentials regularly. Treat MCP tokens like any other production secret. Rotate every 90 days and revoke immediately if you suspect a leak.
  • Run untrusted servers in a container. If you want to try a community server you do not fully trust, run it inside Docker and pass a bind-mounted directory instead of host paths. This limits what a compromised server can reach.

Example Combined Configuration

To run multiple servers, group them in your claude_desktop_config.json under the mcpServers object:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\YourUsername\\ClaudeWork"]
    },
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "C:\\Users\\YourUsername\\ClaudeWork\\db.sqlite"]
    }
  }
}

Best Practices for Running MCPs

  • Avoid Globally Installed Packages: Use npx -y to run the servers. This automatically downloads the latest version at launch without polluting your global node modules library.
  • Manage Node Environment: Make sure your local terminal has a valid node installation on its environment PATH. If you get a connection failure, test the npx command in your terminal first.
  • Scope File Access: Only list directories you actually intend to read/write under the filesystem args. Do not pass root directories like / or C:\ as this is a safety hazard.

Last updated: June 15, 2026

This article is part of CoworkHow.com, an independent resource for Claude Cowork users. We are not affiliated with Anthropic.