MCP (Model Context Protocol) is an open source standard that lets Claude Code plug into external tools and data: your GitHub, your database, a browser, your Sentry. Without MCP, Claude only knows your code. With an MCP server connected, it reads your issues, queries your database, and acts on those systems directly, instead of working from whatever you paste into the chat by hand. In practice, you add a server with the claude mcp add command, and Claude Code can connect to hundreds of tools listed in the official directory. This guide covers what MCP is, how to add and configure a server, which servers are worth it when you're building an MVP solo, how to build your own, and the trap almost everyone falls into.
What is MCP (Model Context Protocol)?
MCP is a standard plug between Claude and the rest of your stack. The Model Context Protocol is an open standard for integrations between an AI and tools: any service that exposes an MCP server can be connected to Claude Code, and Claude then gains access to its functions.
The analogy that works: MCP is to AI what USB is to hardware. Before USB, every device had its own proprietary connector. After it, one port handled everything. MCP plays the same role: a single format to connect Claude to GitHub, a PostgreSQL database, a browser, or your monitoring tool, without reinventing the integration each time.
The signal that you need a server is simple: as soon as you catch yourself copying data from another tool into the chat (an issue, a log, a database row), an MCP could do that job for you. Once connected, Claude reads and acts on that system live. You go from "let me copy-paste the JIRA ticket" to "implement the feature described in ticket ENG-4521 and open a PR on GitHub." The difference is substantial: Claude works on the real, up-to-date data instead of your rough summary of it.
What this unlocks once you've connected a server or two: implementing a feature described in a ticket and then opening the PR, analyzing your monitoring data, querying your database to pull a list of users, integrating the latest Figma designs, automating email drafts. These are all tasks where Claude used to stop being useful because it couldn't reach the data.
One distinction that matters for founders: MCP and skills do different jobs. A skill tells Claude how to do something (a procedure). An MCP gives it access to something (a tool, some data). You'll need both, for different reasons.
MCP provides the connection. Zo Computer can provide the persistent computer that hosts the files, services, and agent around that connection.
How to add and configure an MCP server in Claude Code
Adding an MCP server to Claude Code takes one command: claude mcp add. What changes is the connection type. Three of them matter.
Remote HTTP server (recommended). This is the most common case for a cloud service. You provide a name and a URL:
claude mcp add --transport http notion https://mcp.notion.com/mcp
If the server requires authentication, you pass a token in a header:
claude mcp add --transport http secure-api https://api.example.com/mcp \
--header "Authorization: Bearer your-token"
Local stdio server. For a tool that runs as a process on your machine. The double dash -- separates Claude's options from the command that launches the server:
claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \
-- npx -y airtable-mcp-server
SSE server. The older remote transport, now deprecated. If a service still offers it, use its HTTP version when one exists.
Many remote servers use OAuth rather than a hardcoded token: the first time you use one, Claude Code starts the sign-in, stores the token, and refreshes it on its own. If a session eventually rejects it, the /mcp panel offers to re-authenticate you. So for these services, you don't have to manage tokens by hand.
To find reliable servers, browse the official connector directory at claude.ai/directory: these are reviewed servers, and you add them with the same claude mcp add command. One security warning you can't skip: make sure you trust every server before you connect it. A server that fetches external content can expose you to prompt injection. Only connect MCP servers you know and trust, and leave the rest alone however curious you are.
Project vs global scope: where to configure what
This is the question that trips everyone up. When you add a server, you choose a scope, and that scope decides who sees the server and where its config is stored. There are three options.
| Scope | Loads in | Shared with the team | Stored in |
|---|---|---|---|
| local (default) | This project only | No, private | ~/.claude.json |
| project | This project only | Yes, via git | .mcp.json at the root |
| user | All your projects | No, private | ~/.claude.json |
The founder logic:
- local: your default. A personal or experimental server, or one with credentials you definitely don't want to commit. It follows only you, on this project.
- project: when the whole team needs the same tools. The server is written to a
.mcp.jsonfile at the root, which you commit. Everyone gets the config when they clone. For security, Claude Code asks for approval before using a project server. - user: a server you want everywhere, across all your projects (your knowledge base, your research tool). Private, but global to your machine.
You set the scope with --scope (or -s):
claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp
Checking that an MCP server is running
An added server is useless until it's connected. Three commands to check:
claude mcp list # list all configured servers
claude mcp get github # details for a specific server
claude mcp remove github # remove a server
Inside Claude Code, type /mcp: the panel shows each connected server along with its number of tools. If a project server is waiting for your approval, it shows up as ⏸ Pending approval in claude mcp list: run claude interactively to approve it. A simple habit before assuming "it works": open /mcp and check that the server is green and actually exposes tools.
A note on reliability: if a remote (HTTP) server disconnects mid-session, Claude Code tries to reconnect on its own, several times, with a delay that grows after each attempt. The server shows as pending in /mcp in the meantime. Local (stdio) servers aren't restarted automatically: if one goes down, you have to restart it yourself. Knowing this saves you from chasing a bug when the connection is simply coming back.
Essential MCP servers for building your MVP
You can connect hundreds of servers. But when you're building an MVP on your own, the smart move is to connect four or five that eliminate your daily back-and-forth. Here they are, from a founder-developer's point of view.
GitHub, Playwright, Supabase, database
GitHub. The highest payoff. Claude reads your issues, opens PRs, and works on your repos without you leaving the terminal. The GitHub server authenticates with a personal access token that you generate in your GitHub settings, scoped to the relevant repositories, and then pass in a header. The result: "implement issue #42 and open a PR" takes one sentence instead of a morning.
Your database. An MCP server connected to your PostgreSQL (or to Supabase, which offers one) lets Claude query your real data. "Find the last 10 users who turned on this feature" becomes a query Claude writes and runs, instead of you opening a SQL client. For a founder who needs to understand usage without being a data analyst, that's a huge shortcut.
Playwright. A server that gives Claude control of a real browser. It can test a user flow, fill out a form, or check that a page renders. Letting Claude click through your app to confirm a flow works replaces the QA pass you don't have time for.
Monitoring. A server like Sentry lets Claude read your production errors directly. "Look at this week's Sentry errors and tell me which one affects the most users": you go from manual triage to a diagnosis in one sentence.
Your docs and communication. A Notion or Slack server lets Claude read your specs and discussion threads where they live. Founders spend a good chunk of their day retyping context that already exists somewhere, and these servers remove that step. Claude goes straight to the source.
The rule: every server you connect should kill a round trip you already make ten times a day. If you never copy data out of a tool, it doesn't need an MCP. Four well-chosen servers (your code, your database, your test browser, your monitoring) cover most of what an MVP needs. Add the rest the day a concrete need shows up.
Building your own MCP server
No existing server covers your homegrown internal tool? Write one. An MCP server is a program that exposes functions according to the protocol, and Claude connects to it like any other.
There are two paths. The first is by hand: the protocol documentation at modelcontextprotocol.io covers the fundamentals (how to declare your tools, handle authentication, and test). The second is faster and more approachable: let Claude generate the skeleton for you. Claude Code has an official plugin for this.
/plugin install mcp-server-dev@claude-plugins-official
Then, in the session:
/mcp-server-dev:build-mcp-server
Claude asks about your use case and generates a server structure, either remote over HTTP or local over stdio. You start from a working base instead of a blank page. For a founder who isn't a protocol specialist, that's the difference between getting started and giving up on the first page of docs.
A practical detail if your local server needs to read files from your project: Claude Code passes it the project's root path in an environment variable (CLAUDE_PROJECT_DIR), which your code can read directly. Your server can then resolve its paths without depending on the current working directory, which avoids a classic bug when writing your first stdio server. Start small: a server that exposes a single useful function beats an ambitious one you never finish.
Pitfalls to avoid (too many MCP servers hurt results)
The most common pitfall is what separates a setup that helps Claude from one that slows it down. When you discover MCP, the natural reflex is to connect it to everything. That's a mistake.
Every server you connect adds its tools to what Claude has to consider. Historically, the more servers you added, the more you bloated the context, and the more Claude had to sort through dozens of tools, most of them irrelevant to the task at hand. Claude Code now reduces that cost with tool search, enabled by default on recent models: tool definitions are loaded only on demand, so adding a server barely touches your context window. The cost is smaller, but it's still there. The practical limit is still your context budget, and one measurable constraint remains: MCP tool output triggers a warning above 10,000 tokens and is capped at 25,000 by default. A query that pulls back an entire table can get truncated.
The discipline to keep, in three points:
- Only connect what you actually use. An MCP connected "just in case" is context Claude drags around for no benefit.
- Scope precisely. A personal server goes in local, a team server in project. Don't put something in user if you only use it on one project.
- Watch out for overly broad queries. Asking a database MCP to return everything runs into the output cap. Keep the query focused.
Three tools you reach for without thinking beat fifteen you have to hunt for.
Further reading
FAQ
What is MCP in Claude Code?
MCP (Model Context Protocol) is an open source standard that connects Claude Code to external tools and data: GitHub, a database, a browser, a monitoring tool. Once an MCP server is connected, Claude reads and acts on those systems directly, instead of working from what you copy into the chat. You add a server with the claude mcp add command.
How do I add an MCP server in Claude Code?
Use claude mcp add. For a remote server: claude mcp add --transport http <name> <url>. For a local server: claude mcp add <name> -- <command>. You can pass an authentication token with --header and choose the scope with --scope (local, project, or user). Browse reviewed connectors at claude.ai/directory.
Where is an MCP server's configuration stored?
It depends on the scope. A local server (the default) and a user server are stored in ~/.claude.json and stay private. A project server is written to a .mcp.json file at the project root, designed to be committed and shared with the team via git. Always check a server's status with claude mcp list or the /mcp panel.
What are the best MCP servers for a founder?
The highest-payoff ones when building an MVP: GitHub (issues, PRs, repos), a server for your database (query your real data), Playwright (drive a browser for testing), and a monitoring tool like Sentry (read your production errors). The rule: only connect servers that eliminate a round trip you already make every day.
Is it risky to connect too many MCP servers?
Yes, to a degree. Every server adds tools Claude has to consider, and even though tool search limits the impact on context, MCP tool output is capped at 25,000 tokens by default. An unknown server can also expose you to prompt injection. Only connect what you use, and only trust verified servers.
