What Is an MCP Server? MCP in AI Explained, and How to Use It

You have probably seen "MCP" in an announcement from Claude, ChatGPT or a software vendor. Behind the acronym is a simple idea: give the AI standard access to your tools, so it works on your data instead of whatever you copy and paste into it.

I start with the definition, then how it works, examples of useful MCP servers and the steps to add one to Claude, with a command generator so you avoid syntax errors.

What is MCP in AI? The simple definition

MCP stands for Model Context Protocol. It is an open standard that describes how an artificial intelligence application connects to external systems: files, a database, a search engine, business software.

The official documentation uses an image I always reuse in meetings: MCP is a USB-C port for AI applications. Before USB-C, every device had its own cable. Before MCP, every connection between an assistant and a service was coded by hand, once per assistant and once per service. With MCP, a service publishes a server, and every compatible assistant knows how to use it.

In practice, an AI connected through MCP can search your Notion pages, query your Google Analytics data, drive a browser or launch a Screaming Frog crawl, then answer you based on what it just found. It goes from an assistant that writes to an assistant that looks things up and takes action.

Where does MCP come from, and who governs it?

Anthropic, the company behind Claude, released MCP in November 2024. Most of the industry then adopted the protocol: when it was transferred in December 2025, the official announcement cited support from ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot and Visual Studio Code, more than 10,000 active servers and 97 million monthly SDK downloads.

That transfer happened on December 9, 2025: Anthropic handed MCP over to the Agentic AI Foundation, a fund hosted by the Linux Foundation and co-founded with Block and OpenAI. Decisions on the specification are still made by its maintainers, based on public proposals from the community. For a business, this answers the lock-in objection: adopting MCP does not mean betting on a single vendor.

MCP, AI and LLM: what is the difference?

The three terms refer to different layers. The LLM (large language model) is the engine that understands and writes: Claude, GPT, Gemini. The AI application is the software you work in with it: the Claude app, ChatGPT, Claude Code, Cursor. MCP is the cable that connects that application to your tools.

So MCP does not make the model smarter. It gives it access to information and actions it did not have. An average model that is well connected to your data often answers better than an excellent model working blind.

MCP vs API: what is the difference?

An API is a service's programmatic entry point, specific to each vendor. An MCP server usually relies on that API, but presents it in a common format, with a name, a description the model can read and a parameter schema for each tool. MCP does not replace the API: it makes it usable by any compatible AI, without adapter code written for each assistant.

The gain is simple arithmetic. Connecting five assistants to ten services used to take fifty integrations, each one to write and maintain. With MCP, ten servers are enough, and all five assistants can read them.

What is an MCP server?

An MCP server is the program that links the AI to a service. It announces what it can do, receives the AI's requests, runs them against the service (an API, a database, files) and sends back the result. The word "server" sounds more intimidating than it is: it is often a small program of a few hundred lines.

There are two kinds:

• A local server runs on your computer. The AI application launches it itself and talks to it through standard input and output (the stdio transport). That is the case for a server that reads your files or drives installed software, such as Screaming Frog.
• A remote server is hosted by the service vendor and reached through an HTTPS address (the Streamable HTTP transport). Notion, Stripe and Sentry publish their own: nothing to install, you just connect your account.

In Claude, a remote server added from the interface is called a connector. An MCP connector is nothing more than a remote MCP server declared in your account.

How MCP works: client, server, tools and resources

The three roles: host, client and server

The architecture separates three roles, and mixing them up is the most common mistake.

• The host is the AI application itself: Claude Desktop, Claude Code, Visual Studio Code. It coordinates everything.
• The client is the component that holds the connection to a server. The host creates one per server: three servers connected, three clients.
• The server is the program that provides the context, whether it runs on your machine or at the other end of the network.

None of the three needs to know the other in advance. A server written for your internal tool works with Claude today and with another assistant tomorrow, without a single extra line of code. That is the whole point of a standard.

What a server exposes: tools, resources and prompts

A server can offer three types of elements, which the specification calls primitives.

• Tools are executable functions: query a database, call an API, write a file. This is what the model triggers.
• Resources are data you can look up: the contents of a file, a record, a database schema. This is what the model reads.
• Prompts are reusable interaction templates: a procedure to follow, examples. This is what frames the model.

The rule I apply: if the AI needs to act, it is a tool. If it needs to know, it is a resource. If it needs to proceed in a certain way, it is a prompt. In practice, most public servers mainly expose tools, and the quality of the experience depends on them.

In the other direction, the client can offer features to the server. The main one is elicitation: the server asks the user for a clarification or a confirmation along the way.

What happens when you ask a question

1. Discovery. The client asks the server for its capabilities, then for its list of tools (tools/list): for each one, a name, a description and a JSON schema of its parameters.
2. Choice. The model reads those descriptions and decides whether one of the tools serves your request. All it knows about a tool is what is written in its description.
3. Approval. Depending on your settings, the application asks for your permission before running the tool.
4. Call. The client sends the request (tools/call) with parameters that match the schema, and the server runs it against the service.
5. Response. The result comes back into the conversation. The model continues its reasoning, and may call another tool.

The practical consequence: the quality of tool descriptions matters as much as the code. A poorly described tool will never be called at the right moment.

The technical details in one paragraph

Messages use JSON-RPC 2.0, whatever the transport. Since the 2026-07-28 version of the specification, the protocol is stateless: each request carries its version and the client's capabilities, and the server publishes its own through a mandatory discovery request (server/discover). Over the HTTP transport, authentication relies on the usual web mechanisms (token, API key, header), and the specification recommends OAuth to obtain tokens.

Examples of useful MCP servers

Thousands of servers exist, of very uneven quality. The ones in the table are published by the service vendor or by the MCP project itself, which is my first selection criterion.

On the SEO side, note one gap: as far as I know, Google has not published an official server for Search Console. Community servers exist, and you should read their code or their permissions before trusting them with your properties. I have gathered other uses of AI for search engine optimization in Claude for SEO.

For a complete, step-by-step case, I have detailed how to install the Screaming Frog MCP server in Claude, with the settings and the first-crawl trap.

Where to find more MCP servers

• The project's official registry, registry.modelcontextprotocol.io, which lists published servers.
• The project's reference servers repository on GitHub (modelcontextprotocol/servers), useful to see what a clean server looks like.
• Claude's connector directory, where servers from the major vendors can be added in a few clicks.
• Your software's documentation: more and more vendors describe their MCP server and how to install it there.

Claude MCP: how to add an MCP server to Claude

The steps depend on where you use Claude. The server stays the same, only the way you declare it changes.

In Claude (web and app): add a connector

1. Open the connector settings: Customize > Connectors on the Pro and Max plans.
2. Click + Add, then Add custom connector, and paste the remote server's address, for example https://mcp.notion.com/mcp.
3. If the vendor gave you one, enter the OAuth client ID and secret in the advanced settings, confirm, then connect your account.
4. In a conversation, turn the connector on or off from the tools menu in the input box.

Three limits to know. The free plan allows only one custom connector. On the Team and Enterprise plans, only workspace owners add connectors, and members then connect to them. Finally, Claude reaches the server from Anthropic's infrastructure, not from your computer: a server that only listens on localhost cannot be reached this way.

In Claude Desktop: extension or config file

For a local server, there are two methods. The simplest is the extension: a .mcpb file provided by the vendor, installed from Settings > Extensions. That is the method Screaming Frog documents.

The other one goes through the config file. In the app settings, open Developer > Edit Config: Claude opens claude_desktop_config.json, stored in ~/Library/Application Support/Claude/ on macOS and in %APPDATA%\Claude\ on Windows. Declare the server there:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/Documents/allowed-folder"
      ]
    }
  }
}

Then quit Claude completely, not just the window, and reopen it. Forgetting this step explains most "invisible" servers. The server then appears in the list of connectors, from the add button in the input box.

In Claude Code: the claude mcp add command

Claude Code is configured from the command line. If the tool is not on your machine yet, first follow my tutorial to install Claude Code. Three forms cover almost every case:

# Remote server (HTTP)
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Local server (stdio): everything after -- is the server command
claude mcp add --transport stdio playwright -- npx @playwright/mcp@latest

# Local server with an environment variable, for all your projects
claude mcp add --transport stdio --scope user analytics-mcp -e "GOOGLE_PROJECT_ID=your-project" -- pipx run analytics-mcp

The --scope option decides where the configuration is stored:

• local, the default: this project, for you only.
• project: a .mcp.json file at the project root, shared with the team through git.
• user: all your projects, on your machine.

After that, claude mcp list shows the declared servers, claude mcp remove name removes one, and the /mcp command, inside a session, shows their status and starts the OAuth connection when a server requires it.

To get the syntax right, the generator below writes the Claude Code command and the JSON block from a few fields. Start from a known server or describe your own.

Security: the risks of an MCP server

MCP gives the AI hands. That is the whole point, and it is also where the risks lie. The protocol's security documentation and Claude's documentation agree on four points.

• A local server runs with your permissions. A filesystem server can read and modify everything you can read and modify. Limit it to the folders it needs, and never run an install command you do not understand.
• Prompt injection. A server that fetches external content (a web page, a ticket, an email) can bring hidden instructions into the conversation that hijack the model. The Claude Code documentation is clear on this: make sure you trust each server before connecting it.
• Overly broad permissions. The protocol's best practices recommend starting with minimal permissions and widening them only when an action requires it. A token that opens everything exposes everything if it leaks.
• Unverified connectors. Anthropic says it plainly about custom connectors: they connect Claude to services Anthropic has not verified. Read every tool approval request.

MCP, skills and agents: who does what?

These three notions come up together and complement each other. MCP provides the access: it plugs the AI into a tool. A skill provides the method: a folder of instructions and scripts that Claude loads when a task calls for it, for example your audit procedure. An agent chains the two autonomously to reach a goal.

An SEO example: the Screaming Frog MCP server can launch a crawl and produce an export, while an audit skill says which exports to request and how to prioritize the issues. To write your own, see my guide to Claude Skills, and for the next step, the method to build an AI agent.

Should you build your own MCP server?

Rarely as a first step. Start by connecting an existing server and live with it for two weeks: the list of what you missed becomes the spec for your first server.

Writing a server pays off when the same connection has to serve several times: several assistants, several teams, or several months. Official SDKs exist in the main languages, and the protocol is not the hard part. The real question is choosing which tools to expose, and how far to go.

My advice fits in one sentence: two well-named, well-described tools beat a server that mirrors an entire API. Faced with fifty tools, a model chooses badly, and every tool definition takes up room in its context window. This is the kind of project I take on in an AI automation engagement, when a business tool needs to become accessible to Claude.

Written by

Anthony Courtin

SEO, GEO & AI automation consultant

I help small businesses and independent professionals with their visibility (Google, ChatGPT, Perplexity) and with real-world use of AI at work. I train teams in-house and help them rethink their processes. Everything I write here, I use with clients.

Follow me on LinkedIn My YouTube channel (in French)