Skip to main content

Best Claude Code MCP Servers to Install First (2026): Starter Picks by Workflow

Start with GitHub for remote PR and issue context, Context7 for version-specific docs, Playwright for browser exploration, or Sentry for recurring incident work. Add the one capability your existing tools lack, and check a relevant returned result before adding another server.

LaoZhang AI TeamPublishedUpdated 11 min read
On this page
Claude Code integrations for repository work, library documentation, browser checks, and production incidents

The best first MCP server for Claude Code is the one that supplies information or actions your current workflow is missing. Choose GitHub for remote PR and issue context, Context7 for version-specific library documentation, Playwright for browser exploration, or Sentry for recurring production incident work. If your built-in tools, an existing connector, or an authorized CLI already does the job, use that first.

These are conditional starter recommendations based on the providers' documented capabilities, rather than a performance ranking. The setup instructions below reflect documentation checked on October 7, 2026. They are reader instructions; we did not install these servers or authenticate service accounts to produce this guide.

Which MCP server should you install first?

Start with a task you repeat. “Read this PR's latest discussion” is a better reason to add an integration than “give Claude more tools.” The first task also gives you a concrete way to check whether setup worked.

Your missing capabilityFirst candidateMaintainer or operatorWhat a useful first result contains
Current remote issues and pull requestsGitHub MCP serverGitHubThe requested repository, PR or issue identifier, and relevant current content
Documentation for the library version in your projectContext7UpstashA matching library/version and documentation that answers the implementation question
Inspecting a browser flow or reproducing visible UI behaviorPlaywright MCPMicrosoftThe requested page and an observed state, snapshot, or screenshot relevant to the task
Investigating errors already tracked in productionSentry MCPSentryThe correct organization/project, issue reference, and relevant event details

The provider documentation explains the prerequisites for GitHub, Context7, Playwright, and Sentry. A maintained provider implementation is a more useful starting point than an old package name copied from a directory. Several original reference servers, including GitHub and Sentry samples, are now in the MCP project's archived list; that does not mean the providers' own current servers are archived.

Before installing, check the alternative you already have. Claude Code can work with local files and shell commands without an MCP server. An existing authorized GitHub CLI workflow can read PR information with gh pr view. Context7 and Playwright also document CLI and Skills options. MCP is useful when you want their tools available through Claude's tool interface; it is not a requirement for every external request.

Choose GitHub for remote PR context, Context7 for version-specific docs, Playwright for browser checks, or Sentry for incident investigation, and verify the returned evidence.

Context7: start here when the missing piece is library documentation

Choose Context7 when a library's current APIs or your installed version matter to the answer. Its MCP tools resolve a library identifier and query its documentation. Ask for the version actually used in your project; a result for a different major version can be accurate documentation and still be wrong for your code. Context7's README documents both tools and version-specific use.

For an interactive Claude Code session, the current hosted plugin is a straightforward option. Inside Claude Code, run these as two separate commands:

/plugin marketplace add upstash/context7
/plugin install context7@context7-marketplace

Restart Claude Code, open /mcp, select Context7, and complete its browser sign-in. This plugin uses a hosted MCP server and does not require local Node.js, npm, or npx. It does not read CONTEXT7_API_KEY; adding that variable will not complete the plugin's sign-in. These steps and conditions come from the Context7 Claude Code guide.

Then ask a bounded question using the package and version in your project. For example:

Use Context7 to find the documented method for canceling a query in the installed version of TanStack Query. First identify the library and version you are querying, then give the relevant method and documentation reference. Do not change files.

This is an example request, not a recorded result. Check that Claude used Context7's resolve-library-id and query-docs tools, or queried an already known valid library identifier, and that the returned material matches the requested version. A plausible answer without a matching tool result does not show that the integration supplied it. Coverage and relevance still need checking; retrieving documentation does not guarantee correct generated code.

For headless, SSH, or CI use, follow the provider's key-based setup instead of relying on interactive plugin sign-in. The manual HTTP endpoint at https://mcp.context7.com/mcp uses a Bearer service key; the separately documented OAuth endpoint is https://mcp.context7.com/mcp/oauth. Stdio uses API-key authentication. Choose one route for the environment you use, rather than configuring the plugin, manual MCP server, and CLI together. Context7's client configurations distinguish these routes.

GitHub: add it for remote PR and issue context

Choose GitHub MCP when reading current repository discussions through Claude's tool interface would improve your recurring work. If your existing authorized gh workflow already supplies the needed PR details, you can keep using it.

For a shared repository configuration, merge the following entry into the root .mcp.json. Do not overwrite other entries. This example exposes read tools for issues and pull requests:

json
{
  "mcpServers": {
    "github-read": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${GITHUB_MCP_PAT}",
        "X-MCP-Toolsets": "issues,pull_requests",
        "X-MCP-Readonly": "true"
      }
    }
  }
}

Each developer must supply their own GITHUB_MCP_PAT to the process launching Claude Code, with access to the required repositories and operations. The file contains a variable reference, not a token to commit. GitHub's Claude Code CLI guide documents PAT authentication for the hosted server; remote OAuth support depends on the host integration. The local Docker OAuth route is a separate choice.

Start Claude Code in that repository. In an interactive CLI session, approve the project server when prompted, then inspect /mcp. Verify that the intended read tools are available: unknown toolset names can be ignored, so the written filter alone is insufficient. Read-tool filtering also does not reduce a token's underlying privileges. See GitHub's remote server configuration.

For a first read, give one accessible PR URL and request its title, state, and relevant review discussion, without posting a comment. Check the GitHub-labeled tool result for the same repository and PR number. If access fails, inspect credential and repository authorization before adding more tools or expanding permissions.

Playwright: add it for browser exploration and visible behavior

Choose Playwright MCP when Claude needs to inspect page state through browser tools across an exploratory session. Microsoft also offers a CLI and Skills approach for coding agents; an existing browser integration may already satisfy your task. The Playwright MCP README describes these alternatives and the MCP server's accessibility snapshots.

The local package requires Node.js 18 or newer. For a personal trial limited to the current project, register the stdio server from a terminal outside Claude Code:

bash
claude mcp add --transport stdio --scope local playwright -- npx -y @playwright/mcp@latest --isolated

The -- separates Claude's configuration options from the server command and arguments. local controls who sees the configuration; stdio controls how Claude starts and communicates with the process. The package may be downloaded when started. Anthropic's MCP instructions document this command structure.

Here, --isolated selects a browser context whose storage is lost when it closes. That is useful for a clean public-page check. The default persistent profile retains browser state, and concurrent clients can conflict over a profile. Isolated mode is not a security boundary; Microsoft's documentation explicitly says MCP itself is not one. Select logged-in browser access only when the task requires it and you have authorized it.

Restart Claude Code and inspect /mcp for Playwright's status and tools. Begin with a public page or a development page you control. A useful request might be:

Open the specified page, inspect whether its primary navigation is visible, and capture a screenshot. Report the page URL and the observed navigation labels. Do not sign in, submit forms, or change account settings.

Check the actual browser tool calls, page state, and screenshot returned. A screenshot establishes what was visible at that moment; it does not by itself prove that a checkout, API request, or database update succeeded. For a more complex flow, define the expected result before asking the browser to act.

Sentry: add it when you already investigate production incidents

Sentry is a useful first integration for an on-call workflow that already depends on its error data. It has less immediate value if your work rarely involves production incidents.

For a personal current-project configuration, run this from the terminal outside Claude Code:

bash
claude mcp add --transport http --scope local sentry https://mcp.sentry.dev/mcp

Restart Claude Code, open /mcp, select Sentry, and complete OAuth with the appropriate account. Sentry also documents URLs scoped to an organization and project, such as https://mcp.sentry.dev/mcp/your-org/your-project. These routes default tools to the selected project and hide unnecessary discovery tools; they do not replace account authorization. Use your real organization and project slugs if choosing that route. Sentry's hosted MCP documentation explains the endpoint and scoping.

Start with one issue you are permitted to investigate. Request its issue reference, affected release or time window where available, and a small relevant event sample. Compare the returned organization, project, and issue identifier with the incident you intended to inspect. Reading an error can inform a diagnosis; it is not proof that a proposed code change fixes the error.

HTTP, stdio, and scope: choose them separately

HTTP is the recommended transport for suitable hosted servers. Stdio starts a local process such as Playwright's package. SSE is deprecated, though older SSE-only integrations still exist; current Claude Code documentation describes HTTP-first automatic SSE fallback starting with version 2.1.265. Use the current provider and Claude Code transport instructions for your installed version rather than copying an old SSE command.

Scope answers a different question:

Claude Code CLI scopeConfiguration locationSuitable use
local, the defaultProject-specific entry in your private ~/.claude.jsonYour integration for this project
projectRepository root .mcp.jsonShared server configuration, with each person supplying their own access
userPrivate top-level entry in ~/.claude.jsonYour integration across projects

A remote HTTP server can have local scope, and a local stdio process can have user scope. In the CLI, same-name local entries take precedence over project entries, then user entries; the chosen entry replaces the lower-priority entry rather than merging fields. Managed configuration can also affect the result. These are CLI configuration rules, not a promise that every Desktop or cloud session behaves identically.

For project JSON, use the mcpServers wrapper shown above and an explicit "type": "http" for a URL server. By contrast, claude mcp add-json takes one server entry without that outer wrapper. Missing environment variables can leave unresolved literal values and produce warnings; check the service-specific variable instead of assuming the JSON parser will reject the file immediately.

Project servers normally require first-use approval in interactive CLI sessions. Noninteractive -p, Agent SDK, and cloud execution have different loading behavior. A checked-in configuration does not share credentials or grant permission to perform every operation it exposes. Anthropic's MCP reference documents those conditions.

Configuration choices for personal access and shared project integrations

How to tell whether your first MCP actually works

Check three things in order: the configuration, the connection and available tools, then a useful returned result. “Added” only confirms that configuration was written.

From the terminal, you can inspect registered servers:

bash
claude mcp list
claude mcp get github-read

Replace github-read with the name you registered. Inside Claude Code, /mcp shows server status, authentication, and available tools. The Claude Code quickstart explains this distinction between registration and a working tool call.

What you seeNext check
Server missingCurrent project, scope, server name, and configuration location
Pending approval or disabledThe applicable approval or enablement state in this session
Needs authenticationThe provider's OAuth flow or dedicated service credential
Failed or connection errorTyped HTTP entry, endpoint, or stdio executable and prerequisites, as appropriate
Connected but required tools absentTool discovery result, provider filters, and account access
Tools available but the answer is unsupportedA matching completed tool call and relevant returned content

Cached discovery and a connection badge do not prove that the latest request reached the service. For the final check, use one bounded task from the selection table. Require the identifier, version, page state, or issue data that makes the result relevant. Keep errors visible instead of treating a fluent answer as a substitute for a failed read.

Once the integration supplies that result, use it for your recurring work before adding another. Modern Claude Code supports deferred tool definitions through tool search under documented model and provider conditions, so server count is not a reliable measure of context use or speed. Results and accumulated conversation still matter. If setup works but sessions become crowded, continue with diagnosing MCP tool load and large results. If you need to expose your own internal service, use the separate guide to choosing and building an internal API tool integration.

FAQ

Are these MCP servers free?

There is no single fee schedule for MCP integrations. An open source package does not make its service account, hosting, or model usage free. Check the plan and limits for the provider you choose; Context7, for example, distinguishes authentication and higher-limit access in its documentation. Do not assume a directory's “free” label covers the whole workflow.

Does Claude Code need a filesystem MCP server?

Claude Code already has local file and shell capabilities, so you do not need an extra filesystem server just to work on the current checkout. Add a server when it supplies a capability or permitted data source the existing tools lack. The Claude Code quickstart distinguishes built-in tools from additional MCP tools.

Will my claude.ai connectors appear automatically in Claude Code?

Only under the applicable authentication and session conditions. The CLI's connector import requires an active claude.ai subscription credential and appropriate authorization; API-key or third-party-provider authentication does not automatically fetch those connectors. Desktop and cloud delivery have their own conditions. Check the connector section of the MCP reference and the tools actually available in your session before adding a duplicate server.

How many MCP servers should I add?

Start with the integration needed for one recurring task, verify the result, and add another when a separate need appears. There is no documented universal server count that guarantees speed. Tool search behavior depends on the model, provider, and configuration; it does not remove the need to request focused outputs.

Are Skills a substitute for MCP?

Sometimes they are an alternative way to finish the same task. A Skill can guide Claude to use an existing external CLI, while MCP exposes tools through a protocol. Context7 and Playwright document both approaches in their respective READMEs. Neither instructions nor a configured server supply missing service authorization. Choose the approach your task and environment support.

Sources12

External pages this guide links to, in the order they appear. Last updated Oct 7, 2026.

  1. 1.GitHubgithub.com/github/github-mcp-server
  2. 2.Context7github.com/upstash/context7
  3. 3.Playwrightgithub.com/microsoft/playwright-mcp
  4. 4.Sentrymcp.sentry.dev
  5. 5.MCP project's archived listgithub.com/modelcontextprotocol/servers
  6. 6.gh pr viewcli.github.com/manual/gh_pr_view
  7. 7.Context7 Claude Code guidecontext7.com/docs/clients/claude-code
  8. 8.Context7's client configurationscontext7.com/docs/resources/all-clients
  9. 9.Claude Code CLI guidegithub.com/github/github-mcp-server/blob/main/docs/installation-guides/install-claude.md
  10. 10.remote server configurationgithub.com/github/github-mcp-server/blob/main/docs/remote-server.md
  11. 11.Anthropic's MCP instructionscode.claude.com/docs/en/mcp
  12. 12.Claude Code quickstartcode.claude.com/docs/en/mcp-quickstart
More in Claude Code
Choosing bundled, official, and project-specific Claude Code skills for the work at hand
Claude Code

Best Claude Code Skills to Use First: Picks by Workflow

Use /code-review to look for bugs, /simplify to clean up changed code, and an official skill when design, browser testing, or document work needs a more specific method. Install for the right scope, then check discovery and a real task result.

12 min