# MCP servers for Claude Code: the nine worth adding, and which ones a team should share

> The nine MCP servers worth adding to Claude Code, with each vendor's own install command, the right scope for each, and which belong in a shared .mcp.json.

Source: https://baalda.com/blog/best-mcp-servers-for-claude-code
Site: Baalda, https://baalda.com
Published: 2026-11-10

**Short answer.** The best MCP servers for Claude Code reach the systems your work lives in: GitHub, Linear, Sentry, a database such as Supabase, Playwright for a browser, Context7 for library docs, and a notes server such as Baalda for what the team writes down. On a team, share the ones that sign each person in as themselves and keep personal tools at user scope.

The best MCP servers for Claude Code are the ones that reach the systems your work already lives in: GitHub for code, Linear for issues, Sentry for errors, your database, a browser, current library docs, and the notes your team writes things down in. Nine are worth knowing, and for a team the more useful question is which of them belong in the repo for everyone and which stay on one laptop.

Every round-up ranking for this query lists a dozen servers for one developer and stops at the install line. That is the easy half. Once a server goes into a shared `.mcp.json`, it runs for every person who clones the repo, as whoever they authenticate as, and whatever it learns ends up somewhere. This post gives the nine, the exact commands from each vendor's own page, and a plain answer on which to share.

## Which MCP servers are worth adding to Claude Code?

| Server | What Claude can reach | How it connects | Share it in the repo? |
|---|---|---|---|
| GitHub | Repos, issues, pull requests | Remote HTTP, a personal access token | Yes, with the token in an environment variable |
| Linear | Issues, projects, comments | Remote HTTP, OAuth | Yes |
| Sentry | Errors, performance, issue triage | Remote HTTP, OAuth | Yes |
| Supabase | Projects, SQL queries | Remote HTTP, OAuth | Yes, pinned to one project and read-only |
| Notion | Workspace pages | Remote HTTP, OAuth | If the team already lives in Notion |
| Figma | Design files | Remote HTTP, sign-in | Only for people who work from designs |
| Playwright | A real browser | Local stdio | No, keep it at user scope |
| Context7 | Current docs for libraries | Remote HTTP, an API key | No, keep it at user scope |
| Baalda | The team's markdown notes | Remote HTTP, a token per person | Yes, with the token in an environment variable |

The pattern in the last column is simple. A server that authenticates each person as themselves is safe to share, because the shared file holds only a URL. A server that is about your own way of working (a browser, a docs lookup) belongs to you, not the project.

## How do you add an MCP server to Claude Code?

Remote servers use HTTP, which Anthropic's [Claude Code MCP docs](https://code.claude.com/docs/en/mcp) call the recommended option. The pattern is `claude mcp add --transport http <name> <url>`. Local servers run as a command after a `--`, and everything after it is passed to the server untouched.

These are the commands as each vendor publishes them, checked on 10 November 2026:

```bash
claude mcp add --transport http linear-server https://mcp.linear.app/mcp
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
claude mcp add --transport http notion https://mcp.notion.com/mcp
claude mcp add --transport http figma https://mcp.figma.com/mcp
claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp"
claude mcp add playwright npx @playwright/mcp@latest
```

GitHub's own [installation guide](https://github.com/github/github-mcp-server/blob/main/docs/installation-guides/install-claude.md) uses `claude mcp add-json` for Claude Code 2.1.1 and newer, with the URL `https://api.githubcopilot.com/mcp` and your token in an `Authorization: Bearer` header. Sentry's URL also takes an organisation and project slug on the end if you want to narrow it. Context7 is a remote server at `https://mcp.context7.com/mcp` with an API key, and its README points to `npx ctx7 setup --claude` for a guided install rather than printing a `claude mcp add` line.

After adding, `/mcp` inside a session walks you through OAuth in the browser, and `claude mcp list` shows each server as connected, needing authentication, or failed.

## Which scope should each server use?

Claude Code has three scopes, and the default is the one teams most often get wrong.

- **local**, the default, is stored in `~/.claude.json` and loads only in the project you ran the command from.
- **project** writes `.mcp.json` in the repo root and is shared with everyone through version control.
- **user** is also stored in `~/.claude.json`, and loads in all your projects.

Figure: Servers that sign in each person as themselves go in the repo's .mcp.json. Personal tools stay in ~/.claude.json.

The OAuth servers (Linear, Sentry, Notion, Supabase) are the easy case for project scope: the file holds a URL and each teammate signs in through `/mcp` as themselves. Supabase's [own setup page](https://supabase.com/docs/guides/getting-started/mcp) suggests project scope and adds two parameters worth using in a shared file. `?project_ref=<id>` limits the server to one project and drops the account-level tools, and `?read_only=true` runs queries as a read-only Postgres user. The same page warns that the server "runs with your developer permissions", so on a team those two parameters are not optional.

The token servers need one more step. GitHub's guide says to keep the token out of the file and to gitignore `.mcp.json` and `.env`. The alternative, if you want the file in the repo, is that Claude Code expands `${VAR}` inside `url` and `headers`, so the checked-in file can name the variable and each person exports their own token.

## Will nine servers fill up Claude's context?

Less than the round-ups suggest. Their "context bloat" warnings mostly leave out how Claude Code now loads tools. Anthropic's docs now say tool search is on by default for Opus 4, Sonnet 4, Haiku 4.5 and later models: at session start only tool names and server instructions load, and a tool's full definition arrives when Claude goes looking for it. The docs put it plainly: "Claude Code doesn't impose a fixed per-server tool cap; the practical limit is your context window budget."

Figure: At session start Claude sees each server's tool names. The full definition of a tool loads only when it is called.

What still costs you is output. Claude Code warns when one tool result passes 10,000 tokens and cuts it at 25,000 by default. You can raise the cap with `MAX_MCP_OUTPUT_TOKENS`, but a server that returns a whole Sentry event or a full table dump is a sign to narrow the query, not to raise the limit.

## Where does what Claude learns end up?

This is the server the lists leave out. GitHub, Linear and Sentry let Claude read and act on the work. None of them is a place for what the team figures out along the way: why the retry limit is three, which customer the flaky test belongs to, what was decided in Tuesday's call. Claude Code's automatic memory is kept in files under one person's home folder, so the next teammate's session starts without it.

Baalda is a notes app where that layer is plain markdown files the whole team edits together, and its MCP server lets Claude read and write those same files. You mint a token in **Vault Settings → MCP**, and it is scoped to one person inside one vault. Then:

```bash
claude mcp add --transport http baalda http://localhost:3010/api/mcp \
  --header "Authorization: Bearer mcp_your_token_here"
```

That URL is a server on your own machine. The managed service is `https://api.baalda.com/api/mcp`, and a self-hosted one is your own address plus `/api/mcp`. In a shared `.mcp.json`, put `Bearer ${BAALDA_MCP_TOKEN}` in the header and let each person export their own.

The token is the reason it belongs in the shared file. A call to `read_note` or `search_notes` acts as the person who minted the token, so Claude reaches what that person can reach under Baalda's per-folder and per-note permissions, and nothing more. When it calls `edit_note` or `append_note`, the change goes through the same sync engine as a keystroke, so a teammate with that note open sees the text arrive. [What an MCP server for team notes needs](/blog/mcp-server-team-notes) covers the identity model in full, and the [setup docs](/docs/mcp-setup) have the endpoint details. If you are one person with a local vault, you may not need the server at all, as [Claude Code as a second brain](/blog/claude-code-second-brain) explains.

## Where Baalda is the wrong pick

Baalda is a notes server, not a replacement for any other row in the table. It does not reach your code, your issues or your errors. Its search matches words, not meaning, so a note that says "retries" will not turn up for "backoff". And if your team's writing already lives in Notion and works, Notion's server is the shorter path.

## What should you check before installing any of them?

Every server you add shares one model's context with the others, so a server that returns poisoned text can steer Claude into misusing another server's write tools. Install from the vendor's own page, prefer OAuth over pasted tokens, scope database servers to read-only, and give the servers that write (GitHub, Linear, Baalda) the narrowest identity that does the job. [Is MCP safe?](/blog/is-mcp-safe) goes through the risks one by one.

## FAQ

### What are the best MCP servers for Claude Code?

For most teams: GitHub for code and pull requests, Linear for issues, Sentry for errors, Supabase or another database server, Playwright for driving a browser, Context7 for current library docs, and a notes server such as Baalda for decisions and context the team writes down. Notion and Figma are worth adding if your team already works in them.

### How do I add an MCP server to Claude Code?

For a remote server, run `claude mcp add --transport http <name> <url>`, for example `claude mcp add --transport http linear-server https://mcp.linear.app/mcp`. For a local one, put the command after `--`, as in `claude mcp add playwright npx @playwright/mcp@latest`. Then run `/mcp` in a session to sign in, and `claude mcp list` to check each server connected.

### Should MCP servers go in .mcp.json or ~/.claude.json?

`.mcp.json` in the repo root is project scope and is shared with everyone who clones the repo. `~/.claude.json` holds both local scope, the default, and user scope. Put servers that sign each person in with OAuth, or that read a token from an environment variable, in `.mcp.json`. Keep personal tools such as a browser or a docs lookup at user scope.

### Do lots of MCP servers slow Claude Code down or eat context?

Much less than they used to. Anthropic's docs say tool search is on by default for Opus 4, Sonnet 4, Haiku 4.5 and later, so only tool names and server instructions load at session start. Tool output still counts: Claude Code warns above 10,000 tokens and caps a result at 25,000 by default, which `MAX_MCP_OUTPUT_TOKENS` can raise.