What is MCP? The Model Context Protocol, explained

MCP, the Model Context Protocol, is an open standard that lets an AI model use tools and read data that live outside it, through one shared interface. Anthropic released it in November 2024 and it does for AI applications roughly what USB-C did for hardware: one port instead of a different cable for every device. A model that speaks MCP can use any MCP server, and a server anyone writes works in every MCP client.

What problem does MCP solve?

Before MCP, every connection between a model and a tool had to be built twice: once against the tool's API, once against the framework calling it. With five applications and twenty tools that is a hundred integrations, and none of them transfer when you switch either side. MCP turns that multiplication into addition.

The pain was not theoretical. Teams wrote the same Postgres connector for their chat app, their IDE plugin and their internal agent, each in a different shape. Tool descriptions were tuned per model. Credentials were pasted into environment variables in three places. When a new framework showed up, the work started over, and nothing you had built for one vendor came with you.

How does MCP work?

MCP is a client-server protocol that speaks JSON-RPC 2.0. There are three roles. A host is the AI application you use, like Claude or an IDE. A client lives inside the host and holds exactly one connection. A server is a small program that exposes capabilities over that connection.

What a server exposes

Servers offer three kinds of capability, and the split is about who is in control of each one.

• Tools are functions the model can decide to call. Each has a name, a description and a JSON Schema for its arguments. Sending an email, running a query, scraping a page.
• Resources are read-only data the application chooses to load, addressed by URI. A file, a database table, the current git diff. The host decides what goes into context, not the model.
• Prompts are templates a person invokes on purpose, usually surfaced as slash commands. A server can ship the exact wording that gets the best out of its own tools.

A tool definition is small enough to read at a glance. This is what the client hands the model:

{
  "name": "search_web",
  "description": "Search the live web and return ranked results.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "limit":  { "type": "integer", "default": 10 }
    },
    "required": ["query"]
  }
}

What the client gives back

The traffic is not one way. A server can ask the host for a model completion through sampling, which means a server can use AI without holding an API key of its own. It can ask the user a question mid-run through elicitation, added in the June 2025 revision. And the host can tell a server which directories or URLs it is allowed to touch, through roots.

How the two ends connect

Local servers run as a subprocess and talk over stdio, which is why they are configured with a command instead of a URL. Remote servers are an HTTPS endpoint using streamable HTTP, which replaced the older HTTP plus SSE transport in the March 2025 revision, and they authenticate with OAuth 2.1. That second half matters more than it sounds: it is the difference between a server you install and a server you sign in to.

Why did MCP win?

MCP won because it was open, it was first, and the alternative was nothing. There was no competing standard for tool access, and the labs whose models everyone was already calling adopted it within months of each other. Once three of them shipped support, writing anything else stopped making sense.

• November 2024. Anthropic open-sources the spec with SDKs and a set of reference servers.
• March 2025. OpenAI adopts MCP across its Agents SDK and desktop app. The 2025-03-26 revision adds streamable HTTP and an OAuth-based authorization flow.
• April to May 2025. Google confirms support for Gemini, and Microsoft ships it in Copilot Studio and Windows.
• June 2025. The next revision adds elicitation, structured tool output and resource links.
• Late 2025. Stewardship of the spec moves to open governance under the Linux Foundation, so no single vendor owns it.

Under two years in, there are thousands of community servers, official ones from most large SaaS vendors, and a registry to find them. The interesting consequence is not the count. It is that building an integration is now an afternoon of work that pays off in every client at once.

MCP vs function calling: what is the difference?

Function calling is how a model asks for something to run. MCP is how that something gets connected. They are layers rather than rivals: the client hands the model tool definitions, the model emits a function call, and the client turns that into a tools/call over MCP.

So keep function calling for the three-line helper only your app will ever call. Reach for MCP the moment a second client wants the same capability, or the moment you want somebody else's.

How do you connect your first MCP server?

Connecting a remote server takes a URL and about a minute. In Claude you add it as a custom connector in settings. In Claude Code you add four lines to a .mcp.json file, or run a single command. Nothing gets installed either way.

Add it to Claude as a custom connector

1. Open settings, then connectors.
2. Choose add custom connector and paste the server URL, for example https://mcp.usegoro.ai/mcp.
3. Complete the sign in the server asks for. That is the OAuth flow.
4. Start a chat and open the tools menu. Everything the server exposes is listed there, and you can switch individual tools off.

Custom connectors are a paid-plan feature, and on team plans an admin can install one for the whole organization so nobody repeats the setup.

Add it to Claude Code

A .mcp.json file in the project root is the version you want, because it is checked into the repo and every teammate gets the same tools on their next run.

{
  "mcpServers": {
    "goro": {
      "type": "http",
      "url": "https://mcp.usegoro.ai/mcp"
    }
  }
}

Or skip the file and let the CLI write it:

$ claude mcp add --transport http goro https://mcp.usegoro.ai/mcp

Then run /mcp inside a session to see connection status and authenticate. If a server is reachable but shows no tools, it almost always means the sign in did not finish.

A local server, for contrast

Local servers get a command instead of a URL, because the host starts them as a subprocess and talks to them over stdio.

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

That difference is the whole practical split in MCP. Local servers are great for your own machine and terrible to share. Remote servers are the ones a team can actually standardize on. If your next question is what to plug in first, the guide to giving Claude real-time web data walks through live search, and web scraping for AI agents covers pulling structured data out of sites that have no API.

Where Goro fits

You do not need us to use MCP. Most people start with a local filesystem server or the official one their SaaS vendor ships, and that is the right first move. This section is here because the honest answer to "which server should I add" depends on how many you are about to add.

Goro is one remote MCP server that fronts a catalog of real-world tools: social platform data, scraping, search, people and company enrichment, media generation. Your agent connects once, discovers what is available, sees the price of a call before it runs it, and pays out of a single balance. The alternative shape is twenty servers, twenty accounts and twenty invoices, which is fine at two and miserable at twenty.

The tradeoff is real. A gateway is an extra hop, and a server written by the vendor of the thing you are calling will always know that thing better than a gateway does. What you get back is not holding twenty vendor relationships to answer one question, and one bill instead of twenty. You can read the whole catalog, prices included, on the tools pages, and how the balance is funded on the pricing page.