Model Context Protocol (MCP)

MCP is an open standard developed by Anthropic for connecting AI agents to external data sources, tools, and services. It provides a standardized way for agents to interact with the world beyond their training data.

Contents

• How MCP Works
• Key Concepts
• Quick Start: Add an MCP Server
• Popular MCP Servers
• Filesystem
• Git
• GitHub
• PostgreSQL
• SQLite
• Slack
• Web / Brave Search
• Puppeteer
• Playwright
• Memory
• AgentMemory
• Sequential Thinking
• Time
• Context Mode
• Context7
• DuckDuckGo
• Android MCP
• Chrome DevTools
• Tools Supporting MCP
• Best Practices
• Troubleshooting

MCP Servers Quick Reference

How MCP Works

The Agent (Layer 1) sends requests through its built-in MCP Client (Layer 2), which communicates with MCP Servers (Layer 3) that connect to real external services — filesystems, APIs, databases.

Key Concepts

Quick Start: Add an MCP Server

To add an MCP server to your agent, add it to your agent's configuration:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token"
      }
    }
  }
}

Then restart your agent and the new tools will be available automatically.

Popular MCP Servers

Most servers follow a similar pattern:

1. Install the server (usually via npm or docker)
2. Configure in your agent's mcpServers config
3. Restart your agent to detect new tools

Filesystem MCP Server

Official server from Anthropic's MCP repository. Provides safe read/write access to local files and directories.

• GitHub: modelcontextprotocol/servers — src/filesystem
• npm: @modelcontextprotocol/server-filesystem

npx -y @modelcontextprotocol/server-filesystem

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"],
      "env": {
        "ALLOWED_DIRECTORIES": "/path/to/your/project"
      }
    }
  }
}

Git MCP Server

Official Git server from Anthropic's MCP repository. Provides tools for reading, searching, and analyzing Git repositories — commit history, branches, diffs, file status.

• GitHub: modelcontextprotocol/servers — src/git
• Package: mcp-server-git (pip/uvx)

uvx mcp-server-git

{
  "mcpServers": {
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git"]
    }
  }
}

• Commit history: Read commit messages, authors, dates
• Branch listing: List and inspect branches
• File diff: Show diffs between commits
• Status check: Current repo status (modified, staged files)

GitHub MCP Server

Two options available — the official server from GitHub and the Anthropic MCP version.

• GitHub: github/github-mcp-server
• Install: Clone the repo directly or use Docker

• GitHub: modelcontextprotocol/servers — src/github
• npm: @modelcontextprotocol/server-github ✅ (exists, v2025.4.8)
• Also available: github-mcp-server (community, v1.8.7), @fre4x/github (community, v1.1.0)

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your-token-here"
      }
    }
  }
}

{
  "mcpServers": {
    "github": {
      "url": "https://api.anthropic.com/v1/mcp/github"
    }
  }
}

• Token not found: Ensure GITHUB_TOKEN is set and valid
• 403 Forbidden: Check token scopes (needs repo permission)
• Rate limited: GitHub has API rate limits (5000 req/hour for authenticated users)

PostgreSQL MCP Server

Provides read-only access to PostgreSQL databases. Good for querying schemas, running migrations, and database introspection.

npx -y @modelcontextprotocol/server-postgres

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/mydb"
      }
    }
  }
}

• Schema introspection: Agent can read table structures, columns, types
• Query execution: Run SELECT queries safely (read-only)
• Transaction safety: No write operations prevent data corruption

SQLite MCP Server

> ⚠️ Note: The npm package @modelcontextprotocol/server-sqlite does not exist (confirmed 404 — never published on npm). Use one of the community alternatives below.

Provides read/write access to SQLite databases. Good for local development, prototyping, and data inspection.

npx -y @easy-mcps/sqlite-mcp-server

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@easy-mcps/sqlite-mcp-server"]
    }
  }
}

• Full SQL access: SELECT, INSERT, UPDATE, DELETE
• Schema inspection: Read table structures, indexes, triggers
• Transaction support: BEGIN/COMMIT transactions

Slack MCP Server

Provides access to Slack channels, messages, and threads. Good for team communication workflows.

npx -y @modelcontextprotocol/server-slack

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_TOKEN": "xoxb-your-token-here",
        "SLACK_TEAM_ID": "T1234567890"
      }
    }
  }
}

• "not_in_channel" error: Bot needs to be invited to the channel first
• Rate limiting: Slack has API limits for team workspaces

Web Search / Brave Search MCP Server

Provides internet search and web page fetching capabilities.

npx -y @modelcontextprotocol/server-brave-search

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "optional-api-key-here"
      }
    }
  }
}

• Web search: Query Brave Search API
• Page fetching: Extract content from URLs
• HTML-to-text: Convert web pages to readable text

Puppeteer MCP Server

Provides headless browser automation capabilities. Supports web scraping, testing, and web interaction.

• GitHub: code-craka/puppeteer-mcp
• MCP Servers listing: mcpservers.org/servers/code-craka/puppeteer-mcp

npx -y @modelcontextprotocol/server-puppeteer

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

• Page navigation: Visit URLs, navigate within pages
• Screenshot capture: Take screenshots as base64
• JavaScript execution: Run custom scripts in browser context
• PDF generation: Save pages as PDF documents
• Network monitoring: Intercept and inspect network requests

Playwright MCP Server

Microsoft's Playwright-based MCP server for browser automation. More feature-rich than Puppeteer — supports multiple browsers, network mocking, and accessibility snapshots.

• GitHub: microsoft/playwright-mcp

npx -y @playwright/mcp

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp"]
    }
  }
}

• Multi-browser: Chromium, Firefox, WebKit support
• Accessibility snapshots: Read page structure via a11y tree
• Network mocking: Intercept and modify network requests
• Screenshot & PDF: Capture page states
• Element interaction: Click, type, navigate — any web action

Memory MCP Server

Provides persistent memory storage across agent sessions. Good for long-running agents and context persistence.

• GitHub: modelcontextprotocol/servers — src/memory
• npm: @modelcontextprotocol/server-memory

npx -y @modelcontextprotocol/server-memory

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"],
      "env": {
        "MEMORY_BACKEND_URL": "your-backend-url"
      }
    }
  }
}

• Persistent storage: Memory survives agent restarts
• Session-scoped: Different agents have separate memory
• Search: Retrieve memories by key or content
• Namespaces: Organize memories by project or topic

AgentMemory MCP Server

> 🏆 #1 persistent memory for AI coding agents — 95.2% retrieval R@5, 92% fewer tokens vs competitors, 53 MCP tools.

AgentMemory provides persistent, cross-session memory for coding agents. Built on the iii engine, it features confidence scoring, lifecycle management, knowledge graphs, and hybrid semantic + keyword search.

• GitHub: rohitg00/agentmemory
• npm: @agentmemory/agentmemory (server), @agentmemory/mcp (MCP shim)
• License: Apache-2.0
• Language: TypeScript

# Install the memory server (one-time)
npm install -g @agentmemory/agentmemory

Start the memory server in a separate terminal
agentmemory

The MCP server is auto-available via the shim package

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["-y", "@agentmemory/mcp"],
      "env": {
        "AGENTMEMORY_URL": "http://localhost:3111"
      }
    }
  }
}

Sequential Thinking MCP Server

Enhances agent reasoning with structured thinking chains. Good for complex problem solving and step-by-step analysis.

• GitHub: modelcontextprotocol/servers — src/sequentialthinking
• npm: @modelcontextprotocol/server-sequential-thinking

npx -y @modelcontextprotocol/server-sequential-thinking

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

• Thinking chains: Agent shows step-by-step reasoning
• Tree visualization: See decision paths
• Context management: Track what information is considered
• Debug mode: Inspect internal reasoning process

Time MCP Server

Official Time server from Anthropic's MCP repository. Provides current time and timezone information for agents.

• GitHub: modelcontextprotocol/servers — src/time
• Package: mcp-server-time (pip/uvx)

uvx mcp-server-time

{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": ["mcp-server-time"]
    }
  }
}

• Current time: Get current time in specified timezone
• Timezone conversion: Convert between timezones
• Date calculations: Add/subtract time, get day of week

Context Mode MCP Server

An MCP server that enables context-aware agent behaviors with mode switching for different development scenarios.

• GitHub: mksglu/context-mode

npx -y context-mode

{
  "mcpServers": {
    "context-mode": {
      "command": "npx",
      "args": ["-y", "context-mode"]
    }
  }
}

• Mode switching: Toggle between development, review, debug modes
• Context awareness: Provides contextual prompts based on mode
• Workflow integration: Adapts agent behavior to current task

Context7 MCP Server

A context-aware MCP server by Upstash that provides relevant context from external sources to AI agents.

• GitHub: upstash/context7

npx @upstash/context7-mcp --api-key YOUR_API_KEY

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["@upstash/context7-mcp", "--api-key", "your-api-key-here"]
    }
  }
}

• External context: Fetch relevant context from external sources
• RAG integration: Retrieve-augment-generate pipeline
• Knowledge injection: Provide agents with up-to-date external information

DuckDuckGo MCP Server

Provides privacy-focused web search capabilities through DuckDuckGo search engine.

• GitHub: nickclyde/duckduckgo-mcp-server
• npm: duckduckgo-mcp-server

npx duckduckgo-mcp-server

{
  "mcpServers": {
    "duckduckgo": {
      "command": "npx",
      "args": ["duckduckgo-mcp-server"]
    }
  }
}

• Web search: Query DuckDuckGo search engine
• Privacy: No tracking, no API key required
• Instant answers: Get direct answers where available

Android MCP Server

Enables AI agents to interact with Android devices — take screenshots, tap, type, and automate Android UI.

• GitHub: CursorTouch/Android-MCP

uvx --python 3.13 android-mcp

# Connect device via USB/Wi-Fi
adb devices

{
  "mcpServers": {
    "android": {
      "command": "uvx",
      "args": ["--python", "3.13", "android-mcp"]
    }
  }
}

• Screen capture: Read device screen content
• UI interaction: Tap, swipe, type on device
• App control: Launch/kill apps, read notifications
• Automation: Script Android workflows

Chrome DevTools MCP Server

Lets coding agents control and inspect a live Chrome browser — reliable automation, in-depth debugging, and performance analysis via Chrome DevTools.

• GitHub: ChromeDevTools/chrome-devtools-mcp
• npm: chrome-devtools-mcp

npx -y chrome-devtools-mcp@latest

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest"]
    }
  }
}

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest", "--slim", "--headless"]
    }
  }
}

• Performance insights: Record traces, extract actionable performance data (uses Chrome CrUX API for field data)
• Advanced debugging: Analyze network requests, capture screenshots, inspect console with source-mapped stack traces
• Reliable automation: Built on Puppeteer — automatically waits for action results
• Usage statistics: Collected by default; opt-out with --no-usage-statistics flag or CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS env var

Tools Supporting MCP

Best Practices

Troubleshooting

Related

• AI Tools Index — Full tools reference including MCP support
• Tools — AI coding agents and assistants compared
• AI Editors — AI-powered editors comparison
• Skills — Agent skills explained

Sources

• api-anthropic-com-v1-mcp-github
• api-slack-com-apps
• github-com-chromedevtools-chrome-devtools-mcp
• github-com-code-craka-puppeteer-mcp
• github-com-cursortouch-android-mcp
• github-com-github-github-mcp-server
• github-com-iii-hq-iii
• github-com-microsoft-playwright-mcp
• github-com-mksglu-context-mode
• github-com-modelcontextprotocol-servers-blob-main-src-memory-readme-md
• github-com-modelcontextprotocol-servers-tree-main-src-filesystem
• github-com-modelcontextprotocol-servers-tree-main-src-git
• github-com-modelcontextprotocol-servers-tree-main-src-github
• github-com-modelcontextprotocol-servers-tree-main-src-sequentialthinking
• github-com-modelcontextprotocol-servers-tree-main-src-time
• github-com-nickclyde-duckduckgo-mcp-server
• github-com-rohitg00-agentmemory
• github-com-settings-tokens
• github-com-upstash-context7
• mcpservers-org-servers-code-craka-puppeteer-mcp