What Is an MCP Server? A Plain-English Guide, With a Free One to Try

If you build AI agents, you have probably seen three letters everywhere this year: MCP. Tool vendors advertise MCP support, desktop AI apps have settings pages for MCP servers, and job posts ask for MCP experience. Yet a surprising number of builders are still fuzzy on what an MCP server actually is and why it matters. This guide explains the idea in plain English, shows what happens on the wire, and walks through connecting a real, free MCP server: the one that powers Agent Toolbox.

The problem MCP solves

A language model on its own can only produce text. To be useful as an agent, it needs to do things: search a database, read a file, call an API, run a calculation. Every major model API supports this through tool calling, sometimes called function calling. You describe a tool with a name, a description, and a JSON Schema for its inputs, and the model can respond with a request to call it. Your code runs the tool and sends the result back. Both Anthropic's tool use documentation and OpenAI's function calling guide describe this same basic round trip.

The trouble is that each integration used to be hand-built. If you wanted your agent to talk to a ticketing system, a code repository, and a calendar, you wrote three custom connectors, and if you switched AI apps you often wrote them again. When Anthropic introduced the protocol on November 25, 2024, it described exactly this pain: every new data source required its own custom implementation, which made connected systems hard to scale. MCP was offered as a universal, open standard that replaces those fragmented integrations with a single protocol.

Clients, servers, and a shared language

The cleanest way to picture MCP is the USB comparison people often use. A USB device does not need to know what brand of laptop it is plugged into, and the laptop does not need a custom driver for every mouse. Both sides agree on a standard. In MCP, the AI application (Claude Desktop, Cursor, an IDE, or your own agent code) acts as the client, and the thing that provides capabilities is the server. An MCP server can wrap anything: a local folder, a SaaS API, a database, or a set of utility functions.

Under the hood, MCP messages are JSON-RPC 2.0, a simple request-and-response format that has been around for years. According to the MCP specification's transport section, the protocol defines two standard ways to carry those messages. With stdio, the client launches the server as a local subprocess and they talk over standard input and output; this is how most desktop integrations work. With Streamable HTTP, the server is a web endpoint that the client sends HTTP requests to; this is how remote, hosted servers work, and it is what Agent Toolbox uses.

What a conversation with a server looks like

A session starts with a handshake. The client sends an initialize request saying which protocol version it speaks, and the server replies with its own name, version, and capabilities. Once that is done, the client can ask what tools exist by calling the method tools/list. The server answers with an array of tools, each with a name, a human-readable description, and an inputSchema written in JSON Schema. The client passes those definitions to the model. When the model decides it needs one, the client sends tools/call with the tool name and arguments, and the server returns the result as content the model can read.

Notice what this means in practice. The model never talks to the server directly, and the server never sees your conversation. The client sits in the middle, deciding what to expose and when. That separation is a large part of why MCP has caught on: tool authors write a server once, and it works with any client that speaks the protocol. The full details, including other capabilities such as resources and prompts, are in the official specification and the project's introduction.

Meet the Agent Toolbox MCP server

Agent Toolbox runs a small, stateless MCP server over Streamable HTTP at https://agenttoolbox.net/api/mcp. It exposes four tools today, and they mirror the free web tools on this site.

estimate_tokens estimates the token count and US dollar cost of a piece of text across current frontier models, using list prices we verify against official provider pages. An agent can use it to sanity-check a prompt before sending it to an expensive model, or to report its own spend.

convert_schema takes a JSON Schema and converts it into tool definitions for the OpenAI, Anthropic, and MCP formats. This is handy for agents that generate or refactor other tools.

mcp_config generates an mcpServers configuration block, the JSON snippet that desktop clients use to register a server.

search_directory searches the Agent Toolbox directory of tools for AI agent builders, so an agent can look up options such as vector databases, evaluation frameworks, or other MCP servers.

Connecting it in a few minutes

Most desktop clients read a JSON configuration with an mcpServers object. For a remote server, the entry can be as short as this:

{
  "mcpServers": {
    "agenttoolbox": { "url": "https://agenttoolbox.net/api/mcp" }
  }
}

The exact file location and field names differ a little between clients, which is why we built the free MCP Server Config Generator. Pick your client, paste the server details, and it produces the block for you.

If you would rather see the protocol with your own eyes, you can talk to the server with nothing but curl. This request asks for the list of tools:

curl -s https://agenttoolbox.net/api/mcp \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

The response is a JSON-RPC result containing the four tools and their input schemas. Change the method to tools/call and add params with a name and arguments, and you have made the same call a model-driven client would make. Doing this once by hand is the fastest way we know to demystify MCP.

Free and Pro access

All of the web tools on Agent Toolbox are free, and the API and MCP server have a free tier with a rate limit. Builders who need higher volume can upgrade to Pro for $19 a month or $190 a year; details are on the pricing page and the developer docs. The server itself runs the tools deterministically: it does not call a language model, and it does not store the text you send it.

When you should build your own server

Using other people's servers is the easy part. The more interesting question is when to write your own. A good rule of thumb is that if you have written the same tool integration twice for two different agents or apps, it belongs in an MCP server. The official SDKs, linked from the MCP introduction, handle the protocol details so that you mostly write ordinary functions with schemas. Keep each tool narrow, write descriptions as if explaining the tool to a new colleague, and validate inputs strictly, because a model will eventually send you something strange.

Security deserves real attention. An MCP server is code that an AI system can trigger, so treat its permissions the way you would treat any service account. Expose read-only operations where possible, require confirmation for anything destructive, and be careful with servers from unknown sources, since tool descriptions and results flow straight into the model's context.

The takeaway

MCP is not magic. It is a shared, open format for describing tools and carrying calls to them, built on plain JSON-RPC and either local pipes or HTTP. That modesty is its strength. Write a capability once, and every compatible agent can use it. If you want a low-stakes place to start, point your client at the Agent Toolbox server and ask your agent what tools it can see.

Sources

Anthropic, "Introducing the Model Context Protocol" (Nov 25, 2024): https://www.anthropic.com/news/model-context-protocol. MCP specification (2025-06-18) and transports: https://modelcontextprotocol.io/specification/2025-06-18. MCP introduction: https://modelcontextprotocol.io/introduction. Anthropic tool use overview and OpenAI function calling guide, linked above.