# What is an MCP server?

The Model Context Protocol (MCP) is an open standard for connecting AI applications to tools and data. An MCP server offers a list of tools, each with a name, a description and an input schema. A client such as Claude, ChatGPT or Cursor reads that list and lets the model call a tool when it needs one.

That is the short version. This guide explains the rest: why the protocol exists, which parts are involved, what happens during a tool call, how local and remote servers differ, how sign-in works, what to watch out for, and how to connect a server to the client you already use.

## Why MCP exists

Language models are good at reasoning and writing, but on their own they only know what was in their training data and what you paste into the conversation. To be useful at work they need to reach other systems: look something up, read a file, query a database, run a calculation or send a request.

Before MCP, every AI application built those connections in its own way. A tool written for one assistant did not work in another, and a company that wanted its service available in five AI apps had to build five integrations. With many apps and many services, the number of custom connections grows quickly.

MCP replaces that with one shared protocol. A service implements an MCP server once, and every application that speaks MCP can use it. An application implements MCP once, and it can connect to every server. The idea is similar to the Language Server Protocol, which lets one language server work in many code editors, and the MCP specification names it as an inspiration.

Anthropic introduced MCP in late 2024 as an open specification with open-source SDKs. It was adopted quickly by other AI companies and tool makers, and it is now developed as an open project under the Linux Foundation's Agentic AI Foundation. The specification is published at modelcontextprotocol.io and is versioned by date, so clients and servers can state which revision they speak.

## The three parts: host, client and server

The specification describes three roles.

- **The host** is the AI application you use: Claude Desktop, ChatGPT, an editor like Cursor or VS Code, or a command line agent such as Claude Code. It runs the model, shows the conversation and decides what the model may do.
- **The client** is the part of the host that talks to one server. A host that connects to three servers has three clients, one for each connection. In everyday use people say "MCP client" for the whole application, and that is usually fine.
- **The server** is the program that offers capabilities. It can be a small process on your laptop or a service on the internet. It does not run a model of its own; it waits for requests and answers them.

Messages between client and server use JSON-RPC 2.0, a simple format for requests and responses written in JSON. The model never talks to the server directly. It asks the host to call a tool, and the host's client sends the request.

## What a server offers

A server can offer three kinds of things. Most servers in use today focus on the first.

### Tools

Tools are functions the model can call. Each tool has:

- a **name**, such as `dns_lookup`
- a **description** in plain language that tells the model what the tool does and when to use it
- an **input schema**, written in JSON Schema, that defines the arguments, their types and which ones are required
- optionally an **output schema** that describes the shape of a structured result, and annotations that hint at behaviour

Tools are model-controlled: the model decides when to call one, based on the conversation. The specification recommends that a human stays in the loop, with clear indicators when a tool runs and the ability to deny a call.

### Resources

Resources are data the server makes available to read, such as files, records or documents, each identified by a URI. They give the model or the user context rather than performing an action. How a host presents them varies; some let you attach a resource to the conversation like a file.

### Prompts

Prompts are templates the server offers for the user to pick, such as a "review this pull request" workflow with a few arguments. They are user-controlled, and hosts often show them as slash commands or menu entries.

### What clients can offer back

The protocol also lets clients offer features to servers. The most important in the current specification is elicitation: a server can ask the user for missing information, such as a choice or a value, and the host shows that request in its own interface. Earlier revisions defined further client features, and support differs between hosts.

## How a tool call works, step by step

Here is what happens when you ask an assistant a question that needs a tool, for example "Which mail servers does example.com use?"

1. **The client learns the tools.** When you connect a server, the client sends a `tools/list` request. The server answers with its tools, their descriptions and their input schemas.
2. **The host gives the model the list.** The tool names, descriptions and schemas are added to what the model sees, alongside your message.
3. **The model picks a tool.** It reads your question, decides that a DNS lookup would answer it and produces a tool call with structured arguments that match the schema: the domain and the record type.
4. **The host checks and asks.** Depending on the host and your settings, it may show you the call and ask for approval before anything is sent.
5. **The client sends `tools/call`.** The request names the tool and carries the arguments.
6. **The server runs the tool.** It validates the input, does the work and returns a result.
7. **The result goes back to the model.** The host adds it to the conversation, and the model uses it to answer you. If it needs more, it may call another tool, or the same one again with different arguments.

A simplified `tools/call` request looks like this. The tool name and arguments are illustrative, and the current specification adds a few metadata fields to each message that are left out in both examples.

```json
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "dns_lookup",
    "arguments": {
      "domain": "example.com",
      "type": "MX"
    }
  }
}
```

The server answers with a result. Text content is the most common, and a tool can also return images, audio, links to resources or structured data that matches its output schema.

```json
{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "MX records for example.com: 10 mail.example.com"
      }
    ],
    "isError": false
  }
}
```

### Two kinds of errors

The specification separates two kinds of failure. A protocol error, such as an unknown tool name or a malformed request, comes back as a standard JSON-RPC error. A tool execution error, such as an invalid date or a lookup that failed, comes back as a normal result with `isError` set to true and a message that explains the problem. The second kind is meant for the model: a clear message lets it correct its arguments and try again.

### Why exact tools matter

Models guess when they do not know. Ask one for the SSL certificate expiry of a site, the WHOIS record of a domain or the byte size of a converted image, and it may produce a plausible but wrong answer. A tool returns the real value. With tools, the model spends its effort on understanding the task and explaining the result, and leaves the exact work to code.

## Local and remote servers

The specification defines two standard transports, the ways messages travel between client and server.

### Local servers over stdio

A local server runs on your own machine. The host starts it as a separate process and talks to it over standard input and output, one JSON-RPC message per line. This suits tools that need your files, your local database or programs installed on your computer.

Local servers need installation: a runtime such as Node.js or Python, the server package and a configuration entry in your host. Credentials, if any, usually come from environment variables. The server runs with your user's permissions, which is both its power and its risk.

### Remote servers over Streamable HTTP

A remote server runs on the internet. The client sends each message as an HTTP POST to one endpoint URL, and the server replies with a JSON response or a stream of events for that request. This transport is called Streamable HTTP. It replaced an older HTTP plus Server-Sent Events transport from earlier revisions, which some clients still support for older servers.

A remote server needs no installation. You add its URL to your client and sign in. It works the same in a desktop app, a web app, an editor and a command line agent, and it is updated by its provider without any action from you.

### Which kind to use

Use a local server when the tool needs something only your machine has, such as your files or a local service. Use a remote server for everything that lives on the internet anyway, such as lookups, conversions and APIs, and whenever you want the same tools in several clients without installing anything. Clients that only support local servers can still reach a remote one through a small bridge such as mcp-remote, which runs locally and forwards messages to the URL.

## Authentication

A local server inherits your machine's trust. A remote server needs to know who is calling it, and MCP clients use one of two ways to prove it. Our post on [OAuth or API key](/blog/oauth-or-api-key/) covers the choice in more detail.

### OAuth for connectors

For HTTP servers, the specification builds authorization on OAuth 2.1. When a client connects without a token, the server answers that sign-in is required and points to metadata that tells the client where to authorize. The client opens a sign-in page in your browser, you approve the connection once, and the client receives an access token that it sends with every request. Tokens are issued for that specific server, and the server must reject tokens meant for anything else.

Connectors in Claude and ChatGPT work this way. You never paste a secret into the client, and you can revoke the connection from either side.

### API keys and bearer tokens

Editors and command line agents such as Claude Code, Cursor and the Gemini CLI are usually configured through a file or a single command. There an API key is simpler: you create a key in your account with the server's provider and send it in the `Authorization` header, as `Bearer` followed by the key. Treat that key like a password. Keep it out of shared repositories and replace it if it leaks.

## Which clients support MCP

Support has spread across most AI tools that people use for work. Among them:

- **Chat assistants:** Claude on the web, desktop and mobile, and ChatGPT through custom connectors in developer mode, depending on plan and workspace settings.
- **Code editors:** Cursor, VS Code with GitHub Copilot, Windsurf and other AI editors.
- **Command line agents:** Claude Code, the Gemini CLI and the Codex CLI.
- **Frameworks and self-hosted interfaces:** agent SDKs from the major model providers and many open-source chat interfaces.

Clients differ in what they implement. Nearly all support tools, fewer show resources and prompts, and remote sign-in options vary. If a feature matters to you, check your client's documentation. The [clients overview](/clients/) lists the ones we have tested with MultitaskAI.

## Security and trust

MCP makes it easy to give a model new abilities, which also makes it easy to give it the wrong ones. The specification is clear that tools represent code execution and that users must consent to what is shared and done. In practice:

- **Only connect servers you trust.** A server sees every argument the model sends to it. A malicious one can return text designed to steer the model, or ask for data it has no reason to need.
- **Treat tool descriptions as claims.** A description or annotation saying a tool is read-only is information from the server, not a guarantee. The specification tells clients to treat annotations as untrusted unless the server is trusted.
- **Keep approvals on for actions.** Many hosts ask before a tool runs. Leave that on for tools that change things, such as sending mail or writing files, and only allow automatic runs for tools you understand.
- **Grant narrow access.** When an OAuth sign-in asks for scopes, grant what the task needs. Use separate API keys for separate machines so you can revoke one without breaking the others.
- **Think about data.** Whatever the model passes to a tool leaves the conversation and reaches the server. Do not let it send confidential documents to a tool that only needs a domain name.
- **Watch for prompt injection.** Content a tool fetches, such as a web page, can contain instructions aimed at the model. A careful host and a careful model help, but the risk grows with every powerful tool you combine.

## Common use cases

- **Developer utilities:** formatting and repairing JSON, testing regular expressions, encoding and decoding, generating hashes and checking HTTP headers, right inside the editor or terminal agent.
- **Domains and infrastructure:** DNS records, WHOIS data and SSL certificates for debugging a launch or an outage.
- **SEO and web checks:** meta tags, page structure and other on-page checks without leaving the conversation.
- **Conversions and calculations:** units, dates, time zones, currencies and finance or health calculations, where a model's mental arithmetic is not good enough.
- **Images and files:** resizing, converting or inspecting images as part of a larger task.
- **Company systems:** issue trackers, databases, documentation and internal APIs, usually through servers the company runs itself.
- **Agents that work in steps:** a coding or research agent that checks its own work with tools as it goes.

## Connecting a remote server

The details differ by client, but the pattern is the same: give the client the server's URL and a way to sign in. At a high level:

- **Claude:** open Settings, then Connectors, add a custom connector with the URL and sign in when Claude asks. Connectors added on the web also appear in Claude Desktop and the mobile apps. See the [Claude guide](/docs/claude.md).
- **ChatGPT:** turn on developer mode in the connector settings, create a connector with the URL, choose OAuth and sign in. See the [ChatGPT guide](/docs/chatgpt.md).
- **Claude Code:** run `claude mcp add` with the HTTP transport, the URL and your API key as a header, then check the connection with `/mcp`. See the [Claude Code guide](/docs/claude-code.md).
- **Cursor:** add the server's URL and an `Authorization` header to `mcp.json`, then make sure it is enabled in Cursor's MCP settings. See the [Cursor guide](/docs/cursor.md).
- **Gemini CLI:** add the server to `settings.json` with its HTTP URL and header, or use `gemini mcp add`. See the [Gemini CLI guide](/docs/gemini-cli.md).

After connecting, ask the model to list its tools or try a simple task. If nothing appears, check the URL, the transport type and the key first, because those three cause most failed connections. The [setup guides](/docs.md) cover every client step by step.

## Limits and pitfalls

- **Too many tools can confuse the model.** Every connected tool adds names and descriptions to what the model reads. Connecting many servers at once costs context and can lead to wrong choices. Turn off servers you do not need for a task.
- **Good descriptions matter.** The model only knows what the description tells it. Servers with vague descriptions get called at the wrong time or with the wrong arguments.
- **Name collisions.** Two servers can offer tools with the same name. Clients handle this differently, so if a call goes to the wrong place, check for duplicates.
- **Clients are not identical.** A server that works in one client may need different configuration in another, and some clients only support part of the protocol.
- **Models differ in tool use.** Some models call tools eagerly and well, others need a nudge such as "use the DNS tool for this". Smaller local models are often weaker at it.
- **Latency and limits.** Each call is a network round trip, and servers enforce rate limits or quotas. An agent that loops on a tool can use up a daily allowance quickly.
- **The protocol evolves.** New revisions add and change features. Well-maintained clients and servers handle older revisions, but expect occasional differences while support catches up.

## One endpoint, many tools

MultitaskAI is a remote MCP server with 166 exact tools behind one endpoint, across text, web development, images, units, dates and time, domains, SEO, finance and health: DNS, WHOIS and SSL lookups, JSON repair, regex testing, conversions, image resizing and more. It speaks Streamable HTTP and works with Claude, ChatGPT, Claude Code, Cursor, VS Code, Windsurf, Gemini CLI, Codex CLI and any other MCP client over HTTP.

Connectors in Claude and ChatGPT sign in with OAuth, and editors and command line agents send an API key in the `Authorization` header. Every signed-in account gets 100 free requests a day, reset at midnight UTC. MultitaskAI Pro removes the limit for €9 a month; see [pricing](/pricing/). The old MultitaskAI chat app is retired.

- [Browse the tools](/tools/)
- [Read the setup guides](/docs.md)

## Glossary

- **MCP (Model Context Protocol):** the open standard for connecting AI applications to tools and data.
- **Host:** the AI application you use, which runs the model and manages connections.
- **Client:** the part of the host that holds one connection to one server.
- **Server:** a program that offers tools, resources or prompts over MCP.
- **Tool:** a function the model can call, defined by a name, a description and an input schema.
- **Resource:** data a server makes available to read, identified by a URI.
- **Prompt:** a reusable template a server offers for users to pick.
- **Elicitation:** a server asking the user for missing input through the client.
- **JSON-RPC 2.0:** the request and response format MCP messages use.
- **JSON Schema:** the format that describes a tool's arguments and, optionally, its output.
- **stdio:** the transport for local servers, using a process's standard input and output.
- **Streamable HTTP:** the transport for remote servers, using HTTP requests to one endpoint.
- **OAuth:** the sign-in standard connectors use to get an access token for a remote server.
- **Bearer token:** a token or API key sent in the `Authorization` header to prove who is calling.
- **Connector:** the name Claude and ChatGPT use for a connected remote MCP server.

## Frequently asked questions

### Is MCP only for Claude?

No. Anthropic introduced it, but it is an open standard now developed under the Linux Foundation, and ChatGPT, Cursor, VS Code, the Gemini CLI, the Codex CLI and many other clients support it.

### Do I need to be a developer to use an MCP server?

Not for a remote one. In Claude or ChatGPT you paste a URL and sign in. Local servers and command line clients take a little more setup, such as editing a configuration file.

### What is the difference between an MCP server and an API?

An API is built for programs that know its endpoints in advance. An MCP server describes its tools in a way a model can read and choose from at run time, through one protocol that every MCP client understands. Many MCP servers call ordinary APIs behind the scenes.

### Does the MCP server see my whole conversation?

No. A server receives the requests the client sends it, such as a tool name and its arguments. It does not see the rest of the conversation unless the model puts that text into the arguments.

### Can an MCP server run a model of its own?

It can, but it does not have to, and most do not. A typical server runs ordinary code and returns results. The model stays in the host.

### Are MCP servers safe?

As safe as the server and the permissions you give it. Connect servers from providers you trust, keep approvals on for tools that change things, and do not let the model send data a tool does not need.

### How many servers can I connect at once?

Clients allow several, but each one adds tools for the model to consider. A few focused servers usually work better than many overlapping ones.

### Does MultitaskAI cost money?

Every signed-in account gets 100 free requests a day, reset at midnight UTC. MultitaskAI Pro removes the daily limit for €9 a month. See [pricing](/pricing/).
