Zum Hauptinhalt springen

MCP Servers

MCP (Model Context Protocol) is an open standard that lets AI coding tools connect to external services: file systems, databases, APIs, browsers, and more. Each MCP server exposes a set of tools the AI can call during a session, extending what it can do without you having to copy-paste content or context manually.

Claude Code has first-class MCP support. The same servers also work in Claude Desktop, Cursor, and any other MCP-compatible client.

How MCP works​

MCP follows a client-server model:

  • Server: a local process or remote service that exposes tools, resources, and prompts
  • Client: the AI tool (Claude Code, Claude Desktop, Cursor) that connects to the server and invokes its tools
  • Tools: callable functions the server exposes (e.g. search_web, query_database, screenshot)
  • Resources: data the server makes available as context (e.g. file trees, database schemas, API responses)

When you ask Claude to query a database, take a screenshot, or search the web, it calls the appropriate tool on the relevant MCP server. The server executes the action and returns the result directly into the conversation.

Servers can run locally (as a child process started by Claude Code) or remotely (connected via Server-Sent Events over HTTPS).

Configuring MCPs in Claude Code​

MCPs are defined in settings.json. Claude Code supports two levels:

LevelFileScope
Project.claude/settings.jsonThis project only, shared via git
User~/.claude/settings.jsonEvery project on your machine

Configuration format​

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@scope/package-name", "optional-arg"],
      "env": {
        "API_KEY": "your-key-here"
      }
    }
  }
}

For remote servers using Server-Sent Events:

{
  "mcpServers": {
    "remote-server": {
      "type": "sse",
      "url": "https://your-server/sse",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

Multiple servers can be configured together:

{
  "mcpServers": {
    "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/projects"] },
    "github":     { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." } },
    "brave-search": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-brave-search"], "env": { "BRAVE_API_KEY": "..." } }
  }
}

Verifying the connection​

After adding a server, confirm it loaded and see what tools it exposes:

/mcp

Claude Code lists all active servers and their available tools.

Ready-to-use MCP servers​

Copy any configuration block below into your settings.json under the mcpServers key. Each entry is also available as a downloadable JSON file.

Universal​

These servers are useful in almost any project regardless of stack or team size.

filesystem​

Download filesystem.json: read and write files outside the current project directory

Gives Claude access to arbitrary directories on your machine. Useful when you need it to read a config file, reference documentation, or write output to a location outside the project root.

{
  "filesystem": {
    "command": "npx",
    "args": [
      "-y",
      "@modelcontextprotocol/server-filesystem",
      "/Users/yourname/projects",
      "/Users/yourname/documents"
    ]
  }
}

Key tools: read_file, write_file, list_directory, move_file, search_files

memory​

Download memory.json: persistent knowledge graph that survives across sessions

Lets Claude store and recall facts, decisions, and notes between separate sessions. Useful for ongoing projects where you want it to remember architectural decisions, your personal preferences, or recurring context without re-explaining every time.

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

Key tools: create_entities, create_relations, search_nodes, open_nodes, add_observations

fetch​

Download fetch.json: HTTP requests and web page retrieval

Lets Claude fetch any URL and read the response: API documentation, a JSON endpoint, an HTML page, a raw file from GitHub. Useful when you want it to look something up without leaving the terminal.

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

Key tools: fetch (GET any URL, returns parsed text or raw content)

Code & version control​

For teams working with git and GitHub-hosted repositories.

git​

Download git.json: deep git history, blame, log, and diff operations (requires uv)

Extends Claude's git awareness beyond what it can run via Bash. Provides structured access to commit history, blame annotations, and diffs, which is more token-efficient than parsing raw git output.

Requires uv: pip install uv or brew install uv.

{
  "git": {
    "command": "uvx",
    "args": ["mcp-server-git", "--repository", "/path/to/your/repo"]
  }
}

Key tools: git_log, git_diff, git_blame, git_show, git_status, git_commit

github​

Download github.json: GitHub API access for issues, PRs, workflows, and repositories

Lets Claude read and create issues, review and comment on pull requests, trigger workflows, and search across repositories. Requires a GitHub personal access token with appropriate scopes.

{
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
    }
  }
}

Key tools: create_issue, list_issues, create_pull_request, list_pull_requests, get_file_contents, push_files, search_repositories, list_workflows

Token scopes needed: repo, workflow (add read:org for organization repositories).

Web & research​

For workflows that require fetching live information, scraping, or visual inspection of web pages.

Download brave-search.json: real-time web search via the Brave Search API

Gives Claude live web search without opening a browser. Useful for looking up library documentation, checking for breaking changes in recent releases, or researching unfamiliar APIs. Requires a free Brave Search API key.

{
  "brave-search": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-brave-search"],
    "env": {
      "BRAVE_API_KEY": "your_brave_api_key_here"
    }
  }
}

Key tools: brave_web_search (returns titles, URLs, and snippets), brave_local_search

puppeteer​

Download puppeteer.json: full browser automation and screenshot capture

Lets Claude control a Chromium browser: navigate to pages, take screenshots, click elements, fill forms, and extract content from JavaScript-rendered pages that plain HTTP fetching cannot read. Useful for visual debugging and testing.

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

Key tools: puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate, puppeteer_select

Databases​

For projects with relational databases. Both servers are read/write, so scope access to non-production databases or use read-only credentials when auditing.

sqlite​

Download sqlite.json: query and inspect local SQLite databases (requires uv)

Gives Claude direct access to a SQLite file. Useful for exploring a local development database, running ad-hoc queries, or generating migrations without switching to another tool.

Requires uv: pip install uv or brew install uv.

{
  "sqlite": {
    "command": "uvx",
    "args": ["mcp-server-sqlite", "--db-path", "/path/to/your/database.db"]
  }
}

Key tools: read_query (SELECT), write_query (INSERT, UPDATE, DELETE), create_table, list_tables, describe_table

postgres​

Download postgres.json: read-only access to a PostgreSQL database

Lets Claude inspect schemas, run SELECT queries, and reason about your data model. The official server runs in read-only mode by default, making it safe to point at a staging or production replica.

{
  "postgres": {
    "command": "npx",
    "args": [
      "-y",
      "@modelcontextprotocol/server-postgres",
      "postgresql://localhost:5432/your_database"
    ]
  }
}

Replace the connection string with your actual database URL. To use credentials separately: postgresql://user:password@host:port/database

Key tools: query (read-only SQL), list_tables, describe_table

Productivity & collaboration​

For teams using project management, documentation, and communication tools alongside their code.

notion​

Download notion.json: read and write Notion pages, databases, and blocks

Lets Claude read your Notion documentation and write new pages or database entries. Useful for keeping technical specs, ADRs, or meeting notes in sync with code changes. Requires a Notion integration token with access to the relevant pages.

{
  "notion": {
    "command": "npx",
    "args": ["-y", "@notionhq/notion-mcp-server"],
    "env": {
      "OPENAPI_MCP_HEADERS": "{\"Authorization\": \"Bearer ntn_your_token_here\", \"Notion-Version\": \"2022-06-28\"}"
    }
  }
}

Key tools: notion_retrieve_page, notion_query_database, notion_create_page, notion_update_block, notion_search

slack​

Download slack.json: post messages, read channels, and look up user information

Lets Claude read recent messages in channels and post updates. Useful for posting deployment summaries, PR notifications, or standup notes without leaving the terminal. Requires a Slack app with channels:read, chat:write, and users:read scopes.

{
  "slack": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-slack"],
    "env": {
      "SLACK_BOT_TOKEN": "xoxb-your-bot-token",
      "SLACK_TEAM_ID": "T0000000000"
    }
  }
}

Key tools: slack_post_message, slack_list_channels, slack_get_channel_history, slack_reply_to_thread, slack_get_users

linear​

Download linear.json: create and update Linear issues and cycles

Lets Claude create issues directly from code review findings, update issue status as work progresses, and look up what is planned in the current cycle. Requires a Linear API key.

{
  "linear": {
    "command": "npx",
    "args": ["-y", "linear-mcp-server"],
    "env": {
      "LINEAR_API_KEY": "lin_api_your_key_here"
    }
  }
}

Key tools: create_issue, update_issue, list_issues, get_issue, list_teams, list_cycles

google-drive​

Download google-drive.json: search and read files from Google Drive

Lets Claude search for and read documents, spreadsheets, and other files stored in Google Drive. Useful when your team keeps specs or runbooks in Drive alongside code. Requires a GCP OAuth2 credentials file and initial browser-based authorization.

{
  "google-drive": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-gdrive"],
    "env": {
      "GDRIVE_CREDENTIALS_PATH": "/path/to/gcp-credentials.json",
      "GDRIVE_TOKEN_PATH": "/path/to/token.json"
    }
  }
}

Follow the setup guide to create a GCP project, enable the Drive API, and generate credentials.

Key tools: search, read_file

DevOps & infrastructure​

For teams managing containers, CI pipelines, and cloud resources alongside their application code.

docker​

Download docker.json: manage containers, images, volumes, and networks via the Docker socket

Lets Claude list running containers, inspect logs, start and stop services, and manage images. Useful for debugging container issues, generating Compose files, or automating local environment setup.

Requires Docker Desktop or Docker Engine running locally.

{
  "docker": {
    "command": "npx",
    "args": ["-y", "@docker/mcp-server"]
  }
}

Key tools: list_containers, inspect_container, container_logs, run_container, stop_container, list_images, pull_image, list_volumes

MCP support in other tools​

MCP is an open standard. While Claude Code was the first major AI coding tool to support it, most others have added support.

ToolMCP supportConfiguration locationNotes
Claude CodeFull, stable.claude/settings.jsonFirst-class; multi-server, stdio and SSE
Claude DesktopFull, stableclaude_desktop_config.jsonSame servers, different config file path
CursorYes (experimental)Cursor settings UI or mcp.jsonSupports stdio and SSE; enable in Settings > MCP
Gemini CLIYessettings.jsonGrowing server compatibility
Codex CLIPartialCLI flags or config fileTool call compatibility varies by server
VS Code + CopilotYes (GitHub Copilot agent mode)mcp.json in workspace or user settingsSupported in agent mode only

Using MCP with Claude Desktop​

Claude Desktop uses the same server packages but a different config file:

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

The format is identical to Claude Code's settings.json. You can share MCP server configs between the two.

Using MCP with Cursor​

In Cursor, go to Settings > MCP and add server configurations through the UI, or place an mcp.json file in your project root:

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

Not all MCP tools map cleanly to Cursor's agent model. Servers that expose many tools can slow down Cursor's context loading; prefer targeted single-purpose servers.

Tips​

  • Scope filesystem access carefully. Only pass the directories the server actually needs. Giving access to / is a security risk if a prompt injection attack ever reaches Claude.
  • Use project-level config for team servers. Commit .claude/settings.json with servers that every team member should have (GitHub, Linear, your database). Leave personal credentials out: use environment variables or .env files that are gitignored.
  • Check /mcp after adding a server. It confirms the server started and shows which tools are available. If a server fails to start, Claude Code shows the error there.
  • Prefer read-only credentials for database servers. Create a dedicated read-only database user for MCP access, especially for staging or production replicas.
  • Start with one or two servers. Each server adds to Claude's context about available tools. Adding a dozen servers at once can make it harder for Claude to pick the right tool. Add servers as you need them.