One of the most underutilized features of Claude Code is its ability to integrate with external tools through MCP (Model Context Protocol) servers. Think of MCPs as a bridge between Claude and the tools you already use — Google Drive, GitHub, Slack, Stripe, databases, and dozens more.

Once you understand MCPs, your Claude Code experience transforms from isolated conversations into a connected toolkit that can read your files, execute commands, query databases, and integrate with your entire technology stack.

What Are MCP Servers?

MCP (Model Context Protocol) is a standard protocol that lets Claude Code communicate with external tools. Instead of Claude being isolated, it can now:

Read files from your computer or cloud storage
Execute code and scripts
Query databases directly
Call APIs without writing boilerplate
Automate workflows across your tools

An MCP server is a small program that bridges Claude to a specific tool. For example:

GitHub MCP lets Claude read repos, create branches, make commits
Google Drive MCP lets Claude access your files, create spreadsheets, update docs
Stripe MCP lets Claude check payments, create customers, manage subscriptions
Database MCP lets Claude query PostgreSQL, execute migrations, debug issues

When you activate an MCP server, all its capabilities become available as tools Claude can invoke.

Popular MCP Servers and What They Do

Development & Code

GitHub: Read/write repos, create PRs, manage issues
GitLab: Same as GitHub but for GitLab instances
Browserbase: Web scraping and page interaction
Shell: Execute bash commands directly

Data & Analytics

Google Drive: Read/write docs, sheets, presentations
Google Sheets: Advanced spreadsheet operations
SQL Database: Query PostgreSQL, MySQL, SQLite
BigQuery: Data warehouse queries and analysis
Stripe: Payment processing, customer management

Communication

Slack: Send messages, create channels, read conversations
Gmail: Read emails, send messages, manage labels
Notion: Read/write pages and databases
Linear: Issue tracking and project management

Business & Productivity

Salesforce: CRM data access and updates
HubSpot: Marketing, sales, and customer data
Jira: Issue tracking and project management
Asana: Task management and project coordination

Cloud & Infrastructure

AWS: EC2, S3, Lambda, and other services
Google Cloud: Run functions, access storage, manage resources
Vercel: Deploy and manage edge functions
Fly.io: Container deployment and management

How MCP Servers Work: The Architecture

You: "Claude, check my GitHub repos and summarize PRs waiting for review"
        ↓
Claude Code receives request
        ↓
Claude recognizes GitHub MCP is available
        ↓
Claude invokes: github.list_open_pull_requests()
        ↓
GitHub MCP Server makes authenticated API call to GitHub
        ↓
MCP Server returns: [PR list with metadata]
        ↓
Claude processes and responds with summary

The key: Claude doesn’t need to know how to call GitHub’s API. The MCP server handles authentication, error handling, and response formatting. Claude just invokes the right tool.

Installing Your First MCP Server

Step 1: Check Your Current MCPs

Claude Code stores MCP configurations in ~/.claude.json (global) and .mcp.json files (per-project). See what’s already installed:

cat ~/.claude.json | grep -A 20 "mcpServers"

Step 2: Add an MCP Server

Example: Add the GitHub MCP

Edit ~/.claude.json:

{
  "mcpServers": {
    "github": {
      "command": "uvx",
      "args": ["mcp-server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Get your GitHub token:

Go to github.com/settings/tokens
Generate new token (classic)
Scopes: repo, read:org
Copy token to your config

Step 3: Restart Claude Code

MCP servers are loaded when Claude Code starts. After updating ~/.claude.json, restart to apply changes.

Step 4: Verify It Works

Try asking Claude Code a GitHub question:

Check my GitHub profile and list my top 5 repositories by stars.

If configured correctly, Claude will use the GitHub MCP to fetch your repos.

Setting Up Multiple MCPs

For active development, you’ll want several MCPs running simultaneously. Here’s a typical setup for a developer:

{
  "mcpServers": {
    "github": {
      "command": "uvx",
      "args": ["mcp-server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "google-drive": {
      "command": "uvx",
      "args": ["mcp-server-google-drive"],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/credentials.json"
      }
    },
    "stripe": {
      "command": "uvx",
      "args": ["mcp-server-stripe"],
      "env": {
        "STRIPE_API_KEY": "sk_live_..."
      }
    },
    "postgres": {
      "command": "node",
      "args": ["~/.mcp-servers/postgres-mcp.js"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/db"
      }
    }
  }
}

MCP Configuration Best Practices

1. Use Environment Variables for Secrets

Never hardcode API keys. Use environment variables:

"env": {
  "STRIPE_API_KEY": "$STRIPE_API_KEY"  // Reads from .env file
}

Create a .env file (never commit this):

export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_..."
export STRIPE_API_KEY="sk_live_..."
export DATABASE_URL="postgresql://..."

Load it before starting Claude Code:

source .env
# Now start Claude Code

2. Project-Specific MCPs

Not every project needs every MCP. Use project-level configs:

# In your project root, create .mcp.json
{
  "mcpServers": {
    "github": { ... },
    "stripe": { ... }
  }
}

Claude Code loads .mcp.json from the current project directory, so you only have access to the tools you need.

3. Test MCP Connections

When you add a new MCP, test it immediately:

Tell me about the MCP servers I have available.

Claude will list all available MCPs. If your new one isn’t listed, check:

# Verify the config syntax
cat ~/.claude.json | python -m json.tool

# Check if the MCP command is in PATH
which uvx
which node

Real-World Examples

Example 1: Automated Weekly Report

Use the GitHub MCP to:
1. Get all merged PRs from the last 7 days
2. Use the Google Drive MCP to create a new Google Doc
3. Write a summary report of changes
4. Use the Slack MCP to post the link to #engineering

Claude executes all of this with a single request, invoking three MCPs sequentially.

Example 2: Database Query and Analysis

Query my PostgreSQL database (use the Postgres MCP):
SELECT * FROM users WHERE created_at > NOW() - INTERVAL '7 days'

Then analyze the results and create a visualization using Google Sheets.

Example 3: GitHub Issue Auto-Triaging

Using the GitHub MCP, find all open issues in my repo with:
- No assignee
- Priority label "high"

Then create a summary and use Slack MCP to notify @engineering-leads

Troubleshooting MCPs

MCP not appearing in available tools?

Check ~/.claude.json syntax (python -m json.tool to validate)
Restart Claude Code after updating config
Verify the command is in PATH (which uvx, which node)

Authentication errors?

Ensure API keys are correct
Check token expiration (especially GitHub personal access tokens)
Verify the token has required scopes
Check permissions on credentials files

MCP crashes or hangs?

Check MCP server logs (if available)
Try running the MCP command directly to debug
Reduce the number of MCPs if resource-constrained
File an issue with the MCP maintainer

Creating Your Own MCP Server

Once you’re comfortable with existing MCPs, you can build custom ones for your unique tools. MCP servers are simple Node.js programs.

Basic template:

// my-custom-mcp.js
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",
});

// Define a tool
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "get_status",
      description: "Check status of my system",
      inputSchema: {
        type: "object",
        properties: {
          component: {
            type: "string",
            description: "Component to check",
          },
        },
      },
    },
  ],
}));

// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_status") {
    return {
      content: [{ type: "text", text: "All systems operational" }],
    };
  }
  throw new Error("Unknown tool");
});

const transport = new StdioServerTransport();
await server.connect(transport);

{
  "mcpServers": {
    "my-tool": {
      "command": "node",
      "args": ["/path/to/my-custom-mcp.js"]
    }
  }
}

Performance Considerations

Each MCP server adds to startup time and memory usage. Best practices:

Only load what you use: Disable MCPs for inactive projects
Use project-level configs: Keep .mcp.json lean
Batch requests: Instead of calling an MCP 10 times, batch the operation
Cache results: If asking the same question, Claude caches MCP results

The MCP Ecosystem is Growing

New MCPs are released regularly. Check for them at:

mcp.run: Directory of public MCPs
GitHub: Search mcp-server-* for community projects
Anthropic: Official MCPs maintained by Anthropic

Conclusion

MCP servers turn Claude Code from a conversational AI into an integrated agent that can access your entire technology stack. Start with 2-3 MCPs that match your primary tools (GitHub + Google Drive for writers, Stripe + PostgreSQL for SaaS builders, Salesforce + HubSpot for sales teams).

Once you’re comfortable, add more. And when you encounter a tool without an MCP, you know you can build one yourself.

The best part? You’re no longer switching between applications. Everything flows through Claude Code.

The Complete Guide to MCP Servers for Claude Code