Model Context Protocol

MCPs: Give
superpowers to Claude Code

Connect Claude Code to your favorite tools (GitHub, Slack, Gmail, databases) and turn it into an all-powerful assistant that acts in your real environment.

6 guides

Explore MCPs in depth

From theory to practice, each guide covers an essential aspect of MCPs. Follow them in order or jump straight to the one you need.

Concept

What is an MCP?

The Model Context Protocol is the universal adapter between Claude Code and the rest of the digital world.

The simple analogy

Imagine Claude Code is a versatile expert locked in a room. It is brilliant, but it cannot touch anything outside that room. MCPs are universal plugs that you connect between Claude and your tools: your mailbox, your source code, your databases, your browser...

Each MCP opens a new door. Without MCPs, Claude Code can only read and write local files. With MCPs, it can send a Slack message, create a GitHub pull request, run a SQL query, and much more. All from the terminal.

Without MCP

Claude Code reads and writes local files. Powerful, but isolated.

+ MCP

You plug in adapters that connect Claude to your services.

Result

An assistant that acts in your real environment, not just in a chat.

Architecture

How does it work?

The MCP acts as a standardized bridge between Claude Code and external services.

You

"Show me the open GitHub issues"

Claude Code

Understands your request and calls the right MCP

MCP Server

Translates the request into API calls

External service

GitHub, Slack, Gmail, DB...

Standard protocol

MCP is an open protocol created by Anthropic. Each MCP server exposes a set of tools that Claude Code can call automatically. You don't need to write code, just configure the connection.
Installation

How to install an MCP?

Three simple steps to connect a new service to Claude Code.

1

Open the Claude Code configuration

MCPs are configured in the settings.json file of Claude Code. You can edit it directly or use the dedicated command.

Terminalbash
# Open the configuration via Claude Code
claude mcp add <mcp-name> -- <command> <args>


# Or manually edit the configuration file
# ~/.claude/settings.json (global configuration)
# .claude/settings.json  (per-project configuration)
2

Add the MCP in settings.json

Each MCP is declared in the mcpServers section. Here is the typical structure:

~/.claude/settings.jsonjson
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/your/folder"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Token security

Never commit your tokens to a Git repository. Use environment variables or a secret manager for sensitive information. Prefer the global configuration (~/.claude/settings.json) for personal tokens.
3

Verify that the MCP is active

Restart Claude Code and verify that the MCP tools are available. Claude Code automatically detects configured MCPs at startup.

Terminalbash
# List configured MCPs
claude mcp list


# Test an MCP by asking Claude to use it
claude "List the files in my project folder"

Tip

If an MCP does not connect, check that the command (npx, uvx, etc.) is installed and accessible in your PATH. You can also check the logs with claude mcp logs.
Recommendations

Essential MCPs

Our selection of the best MCP servers to get started and go further with Claude Code.

Beginner

Filesystem

Read and write files, explore directories, search content. The basic tool to interact with your file system.

Organize, analyze and transform your local files

Intermediate

GitHub

Manage pull requests, issues, search code, check CI/CD workflows. Essential for developers.

Automate the management of your repositories

Intermediate

PostgreSQL / SQLite

Query your databases directly from Claude Code. Execute SQL queries, analyze schemas, export results.

Explore and analyze your data without leaving the terminal

Advanced

Puppeteer / Playwright

Automate a web browser: take screenshots, fill forms, scrape pages, test interfaces.

E2E testing, web scraping and browser automation

Beginner

Slack

Read and send messages, manage channels, search history. Connect your team communication to Claude.

Automate notifications and team monitoring

Beginner

Gmail

Read, search and sort your emails. Create drafts, analyze conversations, extract key information.

Save time on managing your emails

Tutorial

Your first MCP workflow

Install and use the Filesystem MCP in 5 minutes to discover the power of MCPs.

1

Install the Filesystem MCP

The Filesystem MCP is the simplest to start with. It allows Claude Code to read and manipulate files in a folder you choose.

Terminalbash
# Add the Filesystem MCP in one command
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /home/your-user/projects
2

Verify the configuration

Make sure the MCP is properly registered in your configuration.

Terminalbash
claude mcp list


# Expected result:
# filesystem: connected
#   Tools: read_file, write_file, list_directory, search_files, ...
3

Use the MCP in a conversation

Launch Claude Code and ask it to use the files. It will automatically detect the Filesystem MCP and use it.

Terminalbash
# Launch Claude Code
claude


# Then ask for example:
> List all TypeScript files in my projects folder
> and give me a summary of each file.


# Claude will automatically:
# 1. Use list_directory to explore the folder
# 2. Use read_file to read each .ts file
# 3. Provide you with a structured summary
4

Go further

Combine multiple MCPs to create powerful workflows. For example, use Filesystem + GitHub to analyze a local project and automatically create a pull request.

~/.claude/settings.jsonjson
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/home/your-user/projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-..."
      }
    }
  }
}

Concrete workflow

Try: "Analyze the files modified this week in my project, create a pull request with a summary of changes, and send a Slack notification to the team." Claude Code will chain the three MCPs automatically.
Best practices

Getting the most out of MCPs

Principle of least privilege

Only grant each MCP the permissions it needs. Limit folders accessible to the Filesystem MCP, use tokens with restricted scopes for GitHub.

Per-project configuration

Use the .claude/settings.json file at the root of each project for specific MCPs. Reserve the global config (~/.claude/settings.json) for universal MCPs.

Combine MCPs

True power emerges when Claude chains multiple MCPs in the same workflow. Filesystem + GitHub + Slack = complete automation.

Document your configurations

Add a CLAUDE.md file at the root of your projects to explain which MCPs are used and why. Claude Code will read it automatically.

Limitations to know

MCPs execute real actions (sending messages, creating files, API requests). Claude Code will always ask for confirmation before executing a sensitive action. Do not disable this protection with --dangerously-skip-permissions in production.

Continue your learning

MCPs are just one piece of the puzzle. Discover Skills to teach custom behaviors to Claude Code, and master advanced prompting for exceptional results.

Discover SkillsMaster prompting