Claude Code MCP servers — the complete guide for 2026

According to Yandex.Wordstat, the "claude code mcp" cluster gets 1,411 monthly searches (claude code mcp servers 884, generic claude code mcp 1,411). The trend is growing fast: +609% YoY since July 2025 (from 44 to 312 weekly searches). Competition is low — there is no comprehensive English-language article about MCP servers for Claude Code.

MCP (Model Context Protocol) is Anthropic's open standard that lets Claude Code (and Claude Desktop) connect to external systems: GitHub, Notion, Slack, Linear, Figma, PostgreSQL, Brave Search, the filesystem, and hundreds of others. Every MCP server adds new "tools" to Claude Code, and the model can call them just like the built-in tools (Read, Write, Bash).

In this article — the complete guide: what MCP is, how the client-server architecture works, how to install MCP servers in Claude Code and Claude Desktop through LiteAI, the 10 most useful MCP servers with examples, security and FAQ.

What is MCP (Model Context Protocol) in plain language

MCP is an open protocol (analogous to LSP for AI agents) that Anthropic shipped in November 2024. The idea is simple: an AI model should be able to call external tools in a standard way, without custom integrations for each service.

Before MCP, integrating Claude Code with GitHub meant writing a custom wrapper that Claude called through Bash (gh api …), or using an MCP server like @modelcontextprotocol/server-github. After MCP this became a standard:

User → Claude Code → MCP Client → MCP Server (GitHub/Notion/Slack/...) → External API
                                         ↑
                            stdio / SSE / HTTP

What this gives a developer:

• A single way to connect. One format for all tools. No more custom wrappers.
• Ready-made servers. Hundreds of MCP servers for popular services: GitHub, Notion, Linear, Figma, Postgres, Brave Search, Filesystem, Playwright, Context7.
• Custom servers. You can write your own MCP server in 50 lines of Python/Node code.
• Security. All calls go through an isolated process with an explicit allowlist of permissions.

MCP architecture: client-server

MCP runs on a client-server model:

Component	Role	Examples
MCP Client (host)	The host application where the AI model lives	Claude Code, Claude Desktop, Cursor, Continue, Cline, Zed
MCP Server	A service that exposes tools/resources to the AI	@modelcontextprotocol/server-github, playwright-mcp, filesystem-mcp
Transport	The communication channel between client and server	stdio (local), SSE (HTTP), HTTP + JSON-RPC

How this works in practice:

1. Claude Code reads ~/.claude/settings.json or .mcp.json and sees the list of MCP servers.
2. On startup the CLI launches each server as a child process (for stdio) or connects over HTTP.
3. The server registers its tools (for example, github.createPR, notion.search, slack.postMessage).
4. When you write "create a PR with these changes and notify the team on Slack", Claude Code understands that it needs the GitHub MCP and Slack MCP and calls the corresponding tools.
5. The results return to the model and it continues reasoning.

How to install an MCP server in Claude Code

There are 3 ways.

Method 1: claude mcp add (recommended)

The simplest path is Claude Code's built-in CLI command:

# GitHub MCP (needs a Personal Access Token)
claude mcp add github \
  --command npx \
  --args "-y @modelcontextprotocol/server-github" \
  --env GITHUB_PERSONAL_ACCESS_TOKEN=ghp_your_token

# Filesystem MCP
claude mcp add filesystem \
  --command npx \
  --args "-y @modelcontextprotocol/server-filesystem" \
  --args "/Users/me/projects"

After claude mcp add, Claude Code restarts the MCP client and connects the servers. Verify status:

claude mcp list

Method 2: ~/.claude/settings.json

Global configuration for all projects:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}

Method 3: .mcp.json in the project root

Local configuration for a specific project (commit it to git):

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

The 10 most useful MCP servers in 2026

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

What it does: Claude Code can read issues, make PRs, review code, search repositories, create releases.

Install:

claude mcp add github \
  --command npx \
  --args "-y @modelcontextprotocol/server-github" \
  --env GITHUB_PERSONAL_ACCESS_TOKEN=ghp_...

Real scenario:

"Read issue #234, find the relevant code, fix the bug, create a PR with tests and add the bug label."

Claude Code:

1. Reads the issue via mcp__github__get_issue.
2. Searches the code (Grep, Glob).
3. Makes changes.
4. Creates a PR via mcp__github__create_pull_request.
5. Adds the label via mcp__github__add_issue_labels.

Useful tools: get_issue, create_issue, create_pull_request, search_repositories, get_file_contents, list_commits, create_release.

2. Filesystem MCP (@modelcontextprotocol/server-filesystem)

What it does: Claude Code gets structured access to files outside the current project.

Install:

claude mcp add filesystem \
  --command npx \
  --args "-y @modelcontextprotocol/server-filesystem" \
  --args "/Users/me/notes" \
  --args "/Users/me/work"

Real scenario:

"Find my note about Redis pub/sub in ~/notes and add an example with LiteAI Chat to the architecture section of ~/work/api-design.md"

3. Notion MCP (@modelcontextprotocol/server-notion)

What it does: Read and write Notion pages, search the workspace, create databases.

Install:

claude mcp add notion \
  --command npx \
  --args "-y @modelcontextprotocol/server-notion" \
  --env NOTION_TOKEN=secret_...

Real scenario:

"Find the architecture page in Notion, add a section about MCP integrations and stamp it with today's date"

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

What it does: Read channels, send messages, react.

Install:

claude mcp add slack \
  --command npx \
  --args "-y @modelcontextprotocol/server-slack" \
  --env SLACK_BOT_TOKEN=xoxb-...

Real scenario:

"When CI fails, post a message to #dev-alerts with the link to the failing workflow"

5. Linear MCP (@modelcontextprotocol/server-linear)

What it does: Manage Linear tasks (create, update, comment).

6. Figma MCP (@modelcontextprotocol/server-figma)

What it does: Read Figma files, export components, extract tokens.

Real scenario:

"Read the design in Figma, create a Button React + Tailwind component, and pull styles from Figma Tokens"

7. Playwright MCP (@microsoft/playwright-mcp)

What it does: Claude Code controls a browser via Playwright: opens pages, clicks, fills forms, takes screenshots.

Real scenario:

"Open staging.liteai.tech, navigate to /pricing, verify all prices are displayed correctly, take a screenshot"

8. PostgreSQL MCP (@modelcontextprotocol/server-postgres)

What it does: Safe access to a PostgreSQL database (read-only by default).

Real scenario:

"Find all users whose last_seen_at is more than 30 days ago and generate a SQL migration to archive them"

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

What it does: Search the web through the Brave Search API.

Real scenario:

"Check whether Anthropic Sonnet 4.7 is out — if it is, update our CLAUDE.md with the changelog"

10. Context7 MCP (@upstash/context7-mcp)

What it does: Up-to-date library documentation (upstash, react, next.js, etc.) — Claude Code does not "invent" APIs but pulls fresh docs.

Real scenario:

"Update our code for Next.js 15 — fetch the Context7 docs for the current App Router API"

MCP in Claude Desktop

Claude Desktop (Anthropic's standalone app) also supports MCP. The config lives in:

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

Example config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/notes"]
    }
  }
}

Access through LiteAI: Claude Desktop uses the same ANTHROPIC_BASE_URL=https://api.liteai.tech/anthropic as Claude Code. Details — in «Claude Desktop on Windows and macOS».

MCP security: what to know

MCP servers are executable code on your machine. Every MCP server you launch has access to:

• Files in the allowed scope (for Filesystem MCP).
• External APIs on your behalf (for GitHub/Slack/Notion MCP).
• Network traffic (for HTTP servers).

5 security rules:

1. Only install MCP servers from trusted sources. Official — Anthropic and Microsoft on npm. Unofficial — read the source on GitHub before running.
2. Use read-only tokens where possible. GitHub PAT with minimal scopes (only repo:read instead of full access).
3. Filesystem MCP — narrow scope. Don't give access to all of /Users/me, only the needed subdirectories.
4. PostgreSQL MCP — read-only by default. Don't enable write without a clear reason.
5. Log the calls. Claude Code writes MCP calls to a log — periodically review what your servers are doing.

MCP through LiteAI

LiteAI is fully compatible with MCP — the LiteAI proxy transparently passes tool-calls from Claude Code to Anthropic and back. On the Anthropic side MCP is supported natively, so you don't need to change your MCP configuration when using LiteAI — only ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN.

export ANTHROPIC_BASE_URL="https://api.liteai.tech/anthropic"
export ANTHROPIC_AUTH_TOKEN="sk-bf-..."
export ANTHROPIC_MODEL="claude-opus-4-8"
claude mcp add github --command npx --args "-y @modelcontextprotocol/server-github" \
  --env GITHUB_PERSONAL_ACCESS_TOKEN=ghp_...

MCP servers run as local processes on your machine and talk to Claude Code over stdio, while Claude Code talks to LiteAI over HTTP. The architecture is the same as when connecting directly to Anthropic.

FAQ

What is Claude Code MCP?

MCP (Model Context Protocol) is Anthropic's open standard that lets Claude Code connect to external systems (GitHub, Notion, Slack, Linear, Figma, PostgreSQL, Brave Search, and hundreds of others). Each MCP server adds new "tools" to Claude Code, and the model can call them automatically.

Which Claude Code MCP servers are most useful?

Top 10: GitHub (PR/issues), Filesystem (files outside the project), Notion (notes), Slack (notifications), Linear (tasks), Figma (design → code), Playwright (e2e tests through the browser), PostgreSQL (read-only SQL), Brave Search (web search), Context7 (current documentation).

How do I install an MCP server in Claude Code?

Through claude mcp add <name> --command <cmd> --args ... --env KEY=VALUE. Or via ~/.claude/settings.json for global configuration, or via .mcp.json in the project root for local.

Does MCP work through LiteAI?

Yes. LiteAI is fully compatible with MCP — the proxy passes tool-calls to Anthropic and back without changes. You only configure ANTHROPIC_BASE_URL=https://api.liteai.tech/anthropic, everything else works as with direct Anthropic.

Are Claude Code MCP servers safe?

MCP servers are executable code. Use only verified packages (Anthropic, Microsoft), grant minimum scopes, review logs periodically.

How much does MCP cost?

The protocol itself is free. MCP servers are open-source. You pay only for Claude tokens consumed by tool calls. Through LiteAI — 30 ₽/M flat.

Can I write my own MCP server?

Yes. In ~50 lines of Python (with the mcp package) or Node.js. Anthropic provides SDKs for Python, TypeScript, Go, Rust, Java, Kotlin, C#.

Bottom line

MCP servers turn Claude Code from "AI chat in the terminal" into a full-fledged agent that can:

• create PRs on GitHub;
• post to Slack;
• read and write to Notion;
• drive a browser via Playwright;
• run SQL queries against Postgres;
• look up current documentation.

All of this works through LiteAI at 30 ₽/M flat — no VPN, no foreign cards, paid in rubles.

Start by installing GitHub MCP and Filesystem MCP — these two are the most useful for everyday work. As needs grow, add Notion, Slack, PostgreSQL.