MCP servers explained: a beginner's guide

MCP is the cable between your AI assistant and the rest of your digital life. It is the reason Claude can read your calendar, query your usage data, or open a file on your machine. Here is what it actually is, in plain English, and how to install your first one.

If you have spent any time around Claude, Cursor, or the broader AI-assistant world in the last year, you have probably seen the letters MCP fly by. Three letters, no context. Someone posts a list of "great MCP servers" on Hacker News; somebody else replies with a JSON config you are supposed to paste into a file you have never heard of. The whole thing feels like it was written by people who already knew the answer.

This is the explanation that should have existed when you first saw the acronym.

What MCP actually stands for.

MCP is the Model Context Protocol. It was introduced by Anthropic in late 2024 as an open standard for connecting AI assistants to external tools and data. It is now supported by Claude Desktop, Cursor, Claude Code, Cline, and a growing list of other clients,including, increasingly, tools that have nothing to do with Anthropic at all.

The point of the protocol is to give every AI assistant the same way of asking the same question: "what tools do you have, and how do I call them?" Before MCP, every assistant had to write its own integrations for Google Drive, GitHub, Postgres, and so on. After MCP, anyone can publish a server that exposes a tool, and every MCP-aware assistant can use it.

The plug analogy.

The cleanest mental model is electrical plugs. Before standardized plug shapes, every appliance had to know how to attach to every kind of socket. Standardize the plug, and now any appliance works with any socket without either side needing to know about the other.

That is what MCP does for AI assistants. The "appliance" is your AI client (Claude Desktop, Cursor, etc.). The "socket" is an MCP server,a small program someone wrote that knows how to talk to some external thing (a database, an API, your calendar, your browsing history, your TokenEyez usage data). The protocol is the shape of the plug.

The three things an MCP server can expose.

Technically, an MCP server can offer three kinds of capability to the connected assistant. You can build a useful server with only one of them.

Tools:functions the AI can call. get_weather(city), search_github(repo, query), show_my_token_usage(week). Tools are the most common capability and the most powerful: the AI decides when to call them.
Resources:read-only data the AI can pull in. Files, database rows, the content of a webpage. Resources are good for documents you want the AI to reference.
Prompts:reusable prompt templates the user can invoke. Think of these as macros,saved scaffolds that drop in a structured prompt with one click.

Most servers in the wild today are tool-first. When somebody says "I installed the GitHub MCP server," they mean their AI assistant can now call functions like "search this repo" or "open this PR" directly inside a conversation.

How an MCP server actually runs.

A real surprise the first time you peek under the hood: most MCP servers are just small command-line programs. They run on your machine, talk to the AI client over stdin/stdout (yes, really), and exit when the client closes them.

A typical install flow is:

You install the server's package,usually via npm for Node-based servers or pip / uvx for Python ones.
You edit a config file in your AI client (for Claude Desktop, it's claude_desktop_config.json) and add a small block that tells it which command to run.
You restart the client. It launches the server in the background. The server tells the client what tools it offers. You start asking questions; the AI calls the tools when it wants to.

That is the whole loop. No web servers to host, no cloud accounts to create, no inbound network ports. Everything is local and stdio-driven. (Some servers offer an HTTP transport too, but stdio is the default and the easiest place to start.)

[screenshot: Claude Desktop "Search and tools" picker showing an installed MCP server with its available tools listed]

A worked example: installing the TokenEyez MCP server.

The fastest way to internalize how this works is to install one. Our own MCP server is a good first one because it is small, has a single clear purpose ("give Claude access to my usage data"), and is free.

Step 1:install the package.

From a terminal, run:

npm install -g tokeneyez

That installs the tokeneyez CLI globally. The CLI doubles as the MCP server,running it with no arguments puts it into MCP server mode; running it with subcommands gives you utilities like tokeneyez login and tokeneyez doctor.

Step 2:sign in.

tokeneyez login

That opens a browser tab, you click Authorize, and a session token gets written to ~/.tokeneyez/session.json. The MCP server reads from there.

Step 3:wire it into your AI client.

For Claude Desktop, open claude_desktop_config.json (the install page has the exact path for your OS) and add:

{
  "mcpServers": {
    "tokeneyez": {
      "command": "tokeneyez"
    }
  }
}

Restart Claude Desktop. You should now see the TokenEyez tools in the Search-and-tools picker.

Step 4:actually use it.

Ask Claude:

"How much did I spend on Opus this week?"

Claude figures out it should call the tool, calls it, reads back your numbers from the TokenEyez backend, and answers in plain English. No dashboard needed. The same pattern works in Cursor and Claude Code with a slightly different config block,full setup instructions live on the MCP install page.

3 mins

Realistic install time for your first MCP server, end to end, from "what is this acronym" to "Claude is reading data from a thing I just installed." It is a much shorter learning curve than the documentation suggests.

What MCP servers are good at.

Once you have one or two installed, the use cases compound. The strongest fit is anywhere your AI assistant already wants to reach for an external system. Some common categories:

Code and dev tooling:GitHub, GitLab, Postgres, SQLite, filesystem. Lets Claude or Cursor actually inspect your repos and queries instead of reasoning about them in the abstract.
Personal data:calendar, email, notes apps. The AI can read your schedule before drafting that follow-up email.
Observability and metrics:your own usage data (TokenEyez), analytics, logs, monitoring. "Why did spend spike last Tuesday?"
Search and retrieval:web search, internal wikis, document stores. Better grounded answers than the model's training data alone.

What MCP servers are not.

A couple of clarifications that save people time:

MCP is not a model. It is a protocol that sits between the model and tools. Claude, GPT, Gemini,none of them "are MCP." The model is the brain; MCP is the nervous system that lets the brain reach out and touch things.

MCP servers are not autonomous agents. They do not run on their own; they only do something when the connected AI client decides to call one of their tools, which only happens inside a conversation a user started. There is no "MCP server doing things in the background while you sleep",at least not in the basic protocol.

MCP is not Claude-only. It started at Anthropic but the spec is open. Cursor, Cline, OpenAI's newer tools, and a growing list of other clients support it. Building an MCP server future-proofs the integration across whichever assistant the user happens to prefer.

The risk you should know about.

One real concern: an MCP server is a program running on your machine that an AI can call. If the server is malicious, or even just badly written, it can do bad things,read files it shouldn't, hit network endpoints you didn't expect, leak data into a tool call. The standard advice is the same as for any open-source software you install on your dev machine:

Prefer servers from organizations you already trust.
Read the README and the manifest. What permissions does it want?
For do-it-yourself servers, glance at the source.
Pay attention to which tools your AI client surfaces and decline to confirm anything that looks off.

None of this is a reason to avoid MCP. It is a reason to install MCP servers the same way you install browser extensions,with a little caution and a preference for known sources.

Where to go from here.

Two concrete next steps. First, install one. Pick something low risk and useful,the TokenEyez server, the official filesystem server, the GitHub server. Three minutes, real result. Second, browse the public lists. The MCP community keeps directories of published servers; skim them and you'll quickly spot two or three that map directly to tools you already use.

The deeper point: MCP is the first time AI assistants have had a portable, shared way to reach into your actual tools and data. The assistants are going to get more useful at the rate that good servers get published,and you do not need to wait for vendor integrations to land. If something you want exists as an API, somebody probably already wrote, or will soon write, an MCP server that exposes it. The cable is standard now.

MCP servers explained: a beginner's guide.