What Are MCP Servers? A Guide for Claude Code Developers

8/11/2025

What Are MCP Servers & Why Do You Seriously Need Them for Claude Code?

Alright, let's talk about something that's been buzzing around in developer circles lately: MCP servers & Claude Code. If you've heard the term "MCP server" & your mind immediately went to some new kind of dedicated hardware you have to buy, or maybe something related to Minecraft... take a deep breath. It's not that at all.

Honestly, the term is a bit of a curveball. In this context, MCP has nothing to do with Microsoft certifications or building blocky worlds. It stands for Model Context Protocol, & it's the secret sauce that transforms Anthropic's AI coding assistant, Claude Code, from a pretty smart tool into an absolute powerhouse.

Think of it this way: Claude Code on its own is like a brilliant programmer who's locked in a room with just a computer & a compiler. They can write amazing code, but they can't check bug reports, pull the latest designs, or submit their finished work. MCP servers are the key that unlocks the door & connects that programmer to the entire outside world of tools & services they need to actually get work done.

It's a complete game-changer for how you interact with an AI assistant. We're moving beyond simple question-&-answer sessions & into a world where your AI can become a proactive member of your development team.

So, What is the Model Context Protocol (MCP) REALLY?

At its heart, the Model Context Protocol is an open-source standard created by Anthropic. Its entire purpose is to be a universal language, a standard way for AI models like Claude to talk to external tools, data sources, & APIs.

It’s like a universal adapter for your AI. You know how you can get a travel plug that lets you plug your US-based laptop into a European wall socket? MCP does that, but for software. It creates a standardized bridge so that Claude Code can connect to & interact with hundreds of different services that weren't originally designed to speak "AI language."

The ecosystem has three main parts, which is pretty straightforward:

The Host: This is the application making the requests, like Claude Code or other AI-powered editors.
The Client: This is the middleman that manages the communication between the host & the servers.
The Server: This is the actual tool or service you want to connect to. It could be GitHub, your project management software, a database, or even your own local file system.

So, an "MCP Server" isn't a physical box. It's a piece of software that "serves" up the functionality of another tool in a way that Claude can understand & use. It exposes specific functions, turning passive data sources into active tools.

Why This is a HUGE Deal for Developers

Okay, so it's a protocol. Cool. But why should you, a developer with deadlines to meet, actually care? Because this is where the magic happens. Connecting Claude Code to MCP servers elevates it from a simple code generator to a true AI development assistant that can automate tedious tasks & streamline your entire workflow.

With MCP servers hooked up, you can ask Claude Code to do things that sound like they're straight out of science fiction:

Integrate with Issue Trackers: "Hey Claude, look at JIRA ticket ENG-4521. Implement the feature described in there, & then create a new pull request for it on GitHub."
Analyze Live Data: "Check Sentry for any new errors related to the feature from ENG-4521 & see what Statsig says about its usage."
Query Databases Directly: "Can you pull the emails of 10 random users from our Postgres database who have used the new feature?"
Work with Design Tools: "Update the standard email template using the new Figma designs that were just posted in the #design Slack channel."
Automate Entire Workflows: "Draft personalized emails in Gmail inviting those 10 users to a feedback session about the new feature."

Do you see what's happening here? The AI is no longer just a passive tool waiting for you to copy & paste code. It's reaching out into the very same tools you use every day—Jira, GitHub, Sentry, Slack, Figma, your databases—& taking action. It’s about giving the AI context & capability.

This means less context-switching for you. No more bouncing between ten different browser tabs to track an issue, review code, check for errors, & manage your projects. You can stay in your terminal, in your flow state, & delegate those tasks to your AI assistant. Tom Moor, the Head of Engineering at Linear, put it perfectly when talking about their MCP integration: "Fewer tabs, less copy-paste. Better software, faster.”

The Two Flavors of MCP Servers: Remote vs. Local

Not all MCP servers are created equal. They generally fall into two categories, & which one you use depends on your needs.

1. Remote MCP Servers

These are the easiest to get started with & are likely what most people will use. A remote MCP server is one that's hosted & managed by a third-party vendor. Companies like Sentry, Asana, Atlassian, & ClickUp run their own MCP servers that you can connect to.

The Upsides:

Zero Maintenance: This is the big one. The vendor handles all the setup, updates, scaling, & making sure the server is always available. You just add the server's URL to your Claude Code configuration, and that's it.
Secure & Simple Authentication: They use native OAuth 2.0 support. This means you log in once through a secure browser pop-up, & Claude Code handles the rest. No messing around with storing API keys or credentials in plain text files. Your authentication tokens are stored securely & refreshed automatically.
Growing Ecosystem: More & more companies are building their own MCP servers, so the list of available integrations is constantly growing.

The Downside:

You're reliant on the vendor to maintain the service. If their server goes down, your integration stops working.

Connecting is usually a simple one-line command, something like:

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

2. Local MCP Servers

For those who want more control or need to interact with things on their own machine, there are local MCP servers. The perfect example of this is the File System MCP Server.

This is a server you run on your own computer. Once it's active, it gives Claude Code the ability to read, write, & edit files directly on your local machine.

The Upsides:

Total Control: You control the server. It's running on your hardware.
Local Access: It's INCREDIBLY powerful for tasks like project-wide refactoring, analyzing log files, or quickly scaffolding out new components based on a prompt.
Offline Capability: Since it's local, it can work without an internet connection (though Claude Code itself still needs one).

The Downsides:

Manual Setup: You have to set it up yourself. This usually involves cloning a Git repository, installing some dependencies, & running the server process.
You're Responsible: You have to manage it, keep it updated, & make sure it's running when you need it.

The power of a local file system server can't be overstated. Some users have found that for pure coding tasks, using Claude with a file system MCP can be just as effective, if not more so, than using the specialized Claude Code client, because it can directly manipulate the code on your machine.

How Businesses Can Leverage This (And Where Arsturn Fits In)

Now, let's zoom out from the individual developer experience & think about this from a business perspective. The core idea here is using AI to create seamless, automated communication between different systems. This isn't just a developer productivity tool; it's a model for the future of business automation.

Think about customer service. Right now, many businesses struggle with disconnected systems. A customer chats with a bot on the website, which then creates a ticket in a helpdesk system, which a human agent then has to look up in the CRM to get the customer's history. It's a clunky, manual process.

This is exactly the kind of "context-switching" problem that MCP is designed to solve for developers. The same principle applies to customer interactions. You want an AI that can communicate across all your business systems in real-time.

This is where conversational AI platforms come into the picture. For instance, a platform like Arsturn helps businesses build no-code AI chatbots that are trained on their own data. This is key. The AI isn't just spitting out generic answers; it's providing personalized, context-aware responses based on your company's knowledge base, product documentation, & policies.

Imagine a customer service chatbot built with Arsturn that doesn't just answer questions. Imagine it can:

Check the real-time status of an order by querying your fulfillment database.
Create a support ticket in your helpdesk system if it can't solve the problem.
Update the customer's contact information in your CRM.
Proactively offer a discount code from your marketing platform if it detects frustration.

This is the business equivalent of what MCP servers do for Claude Code. They provide the connective tissue, the "protocol," that allows an AI to interact with various business tools to provide a seamless, intelligent experience. By building an AI chatbot with Arsturn, you’re essentially creating a specialized "MCP server" for your customer-facing operations. It helps businesses build meaningful connections with their audience through these personalized chatbots, boosting conversions & providing instant, 24/7 support without the heavy manual lifting.

Getting Started: Security & Collaboration

Anthropic has thankfully put some thought into the security & collaboration aspects of MCP.

For security, you're always in control. Claude Code will prompt you for approval before it uses a server from a project for the first time. You have to give it permission to act. For particularly powerful or sensitive operations, this is a crucial safeguard. For example, one custom GitHub server for Claude Code requires you to manually run the CLI with a

--dangerously-skip-permissions

flag just once to accept the terms, acknowledging the power you're unleashing.

For collaboration, MCP supports project-scoped servers. You can define your team's MCP server configurations in a file called

.mcp.json

and check it into your Git repository. This is HUGE. It means every developer on the team automatically gets access to the same set of tools & integrations when they pull the project. No more "it works on my machine" problems because someone forgot to install the right plugin. It ensures consistency & gets new team members up to speed instantly.

The Bottom Line

So, what are MCP servers & why do you need them for Claude Code?

They're not hardware. They are the essential software bridges that connect Claude Code to the outside world. They are what make it possible for the AI to do real, practical work for you—from managing your Jira board to debugging production issues in Sentry.

You need them because they fundamentally change your relationship with the AI. They transform it from a "code completion" utility into a proactive development partner. They allow you to automate the boring stuff, reduce the mental load of switching between a dozen different tools, & ultimately, help you write better software faster.

The world of AI is moving at a breakneck pace, but this feels like a truly significant step forward. It’s about more than just generating code; it’s about integrating intelligence directly into the fabric of our daily workflows.

Hope this was helpful & cleared up some of the confusion. Let me know what you think. What are some of the first MCP servers you're going to try out?