Theory
Your agent knows how to read and write code. But by default, it can't query your database, search your Notion workspace, open a GitHub issue, check a Jira ticket, or browse the web. Every time you need something from outside the codebase, you copy it manually, paste it into the chat, and hope the context holds. MCP fixes this.
What MCP is, in plain terms
Model Context Protocol is an open standard, released by Anthropic and now widely adopted, that lets AI assistants connect to external tools and data sources in a consistent way. Instead of every tool vendor building a custom integration for every AI assistant, MCP defines one interface that works across tools.
From a usage perspective: you install an MCP server for a tool you use (GitHub, Jira, Postgres, Slack, a web browser), connect it to your AI assistant, and the agent gains the ability to call that tool autonomously when a task requires it. You don't have to paste anything manually. The agent figures out when to reach for the right tool and does it as part of its normal workflow.
The practical difference it makes
Without MCP, a typical workflow looks like this: you ask the agent to fix a bug, it asks you for the error logs, you go to your monitoring tool, copy the relevant lines, paste them back, and the agent finally has what it needs. You're the copy-paste bridge.
With an MCP server for your monitoring tool connected, the same workflow looks like: you ask the agent to fix a bug, it queries the logs directly, correlates them with the code, and proposes a fix. You weren't the bridge.
This is the shift MCP enables: the agent stops waiting for you to hand-feed it information and starts going to get what it needs.
What MCP servers exist
There are already hundreds of MCP servers available, covering most of the tools engineers use daily:
- Developer tools: GitHub (read issues, PRs, code), GitLab, Linear, Jira
- Databases: Postgres, MySQL, SQLite (run queries against your actual data)
- Search and docs: Brave Search, Context7 (up-to-date library docs), Exa
- Productivity: Notion, Google Drive, Slack
- Browser: Playwright, Puppeteer (the agent can actually navigate pages)
- Cloud: AWS, Cloudflare
- Utilities: Filesystem (extended access), memory servers, fetch (retrieve any URL)
You can browse the full registry at mcp.so or through the registries maintained by Anthropic and the community on GitHub.
How to connect an MCP server to your tool
The setup is straightforward. In Cursor you add MCP servers through the settings UI or by editing .cursor/mcp.json. In VS Code/Copilot you edit .vscode/mcp.json. In Claude Code you run claude mcp add. Most servers are either an npm package you run with npx or a Python package you run with uvx, so no global installation is needed.
A typical entry in a config file looks like:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"
}
}
}
}
Once connected, the tools from that server show up in the agent's available tool list. When you give the agent a task, it decides autonomously which tools to call and in what order. You don't need to tell it "go look at GitHub": if the task involves a GitHub issue, it will.
A note on trust
Every MCP server you connect expands what the agent can do in the world. A database server means the agent can run queries (and potentially destructive ones). A filesystem server means it can read and write files outside your project directory. Be deliberate about which servers you enable and what permissions you grant them. This is covered in more depth in the next section on MCP security.
Practice
Run this in a repository you already know, not a toy project. The point is to feel where the practice helps and where it gets in the way on code that has history.
The goal of this exercise is hands-on: pick two MCP servers that connect to tools you actually use at work, install them, and observe the difference they make.
Step 1: Choose two servers worth having
Browse mcp.so or the Awesome MCP Servers list and identify two servers relevant to your daily work. Some good starting points:
- GitHub MCP if you use GitHub for issues and PRs
- Context7 if you regularly look up library documentation
- Postgres or SQLite MCP if you work with a local or dev database
- Brave Search or Fetch if you want the agent to be able to look things up on the web
- Linear or Jira MCP if your team tracks work there
Pick ones where you currently find yourself manually copying information into the chat.
Step 2: Install and connect them
Follow the setup instructions for your tool (Cursor, VS Code, or Claude Code). Verify they're connected by asking the agent something simple that requires the server: "List my open GitHub issues" or "What's the latest version of [library] and what changed in it?"
Step 3: Run a real task with them active
Pick a real task from your current work that involves one of the connected tools. Don't tell the agent to use the MCP server: just describe the task naturally and let it figure out what to call. Observe:
- Did it reach for the MCP tool without being told?
- What did it retrieve, and was it accurate?
- How many manual copy-paste steps did you not have to do?
Step 4: Compare with and without
Run the same task without the MCP server active (disable it temporarily in your config). Note how the interaction changes: what does the agent ask you for? How many extra steps do you need?
Reflect:
- Which server had the biggest impact on your workflow?
- Are there other tools you use daily that you'd want an MCP server for?
- Did the agent ever call a tool when you didn't expect it to? Was that useful or surprising?