Rows of servers in a rack, the machines an MCP server connects an assistant to
Technology

What an MCP server is, and the three worth connecting first

21 November 2026 · 8 min read · VOXA editorial

An MCP server is a small program that gives an AI assistant access to something outside the chat box: a folder of files, a database, an inbox, a repository. Instead of building a separate integration for every assistant, the server speaks one protocol and any assistant that supports it can use it. That is the whole idea, and it is worth understanding because it changes what you can ask a model to do.

The short answer: MCP stands for Model Context Protocol. Anthropic published it in November 2024 and other assistants have adopted it since. A server exposes three things: tools the model can call, resources it can read, and prompts it can offer. For a small team the three worth connecting first are a folder on your own machine, a database you already own, and one place where your work notes or requests live. Everything else can wait until one of those three stops being enough.

What a protocol actually buys you

Before a shared protocol, every assistant needed its own connector for every tool. Five assistants and ten tools meant fifty integrations, each one maintained by somebody. A protocol collapses that: every tool writes one server, every assistant writes one client, and the two meet in the middle.

The comparison people use is USB-C, and it is close enough. The plug is boring, which is the point. The interesting part is what happens when your assistant can suddenly read the actual thing instead of guessing at it.

Technically there are two halves. The client is the app you type into: Claude Desktop, Cursor, an editor, a chat product that added support. The server is the connector. When the server runs on your own machine it talks over standard input and output, which means nothing leaves the laptop except the model calls. When it runs on someone else's server it talks over HTTP, and now you are trusting a third party with whatever that server can reach.

The three things a server can expose

Every MCP server chooses from the same three primitives, and knowing which one you are looking at saves a lot of confusion.

Only tools change anything. If a server exposes nothing but resources, it is a library card, not a pair of hands.

Setup, in five minutes

For a desktop assistant the configuration is a small JSON block. This is the filesystem server, pointed at one folder, read-only by scope because you only gave it one path:

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

Save it, restart the app, and the tools appear in the tools menu. No account, no API key, no deployment. The first time it answers a question using a file you forgot you had, the value is obvious.

The second thing you notice is the bill. Every server you connect sends its tool definitions with the conversation, whether or not you use them. Three servers with ten tools each, at roughly 250 tokens per definition, is about 7,500 tokens of overhead before you have typed a word. On a $3 per million input tokens model that is around $0.02 per message, and about $4.50 a month if you send 200 messages. Multiply it by a fatter server and it stops being trivia. The fix is boring: connect fewer servers, prefer ones that expose few tools, and switch off what you are not using that week.

The three worth connecting first

There are hundreds of servers now. Most of them solve a problem you do not have yet. These three earn their place early because they replace guessing with reading.

1. A folder on your own machine

The filesystem server is the least glamorous and the most useful. Point it at one folder, not your whole drive. The assistant stops inventing what is in your documents and starts quoting them, which is the difference between a draft you rewrite and a draft you edit.

Start read-only even if write is supported. A model with write access to a folder can rename, overwrite and reorganise faster than you can notice, and the mistakes look like your own work.

2. A database you already own

A Postgres or Supabase server turns questions like how many orders came in last week into an actual number instead of a confident estimate. Create a separate database user with read-only rights on one schema, and put that connection string in the config. Not the admin one, not the production writer.

This is the server that pays for itself first, because the alternative is a person running a query and pasting it into a chat, which is slower and happens less often.

3. One place where the request arrives

The third is whatever holds the work: notes, issues, or the inbox. Pick one. A notes server means the assistant can find the decision you made three weeks ago. A repository server means it can read the code before suggesting a fix. An inbox server means it can draft the reply with the thread in front of it.

Do not connect all three at once. Each one adds context cost and each one widens what a bad instruction can reach.

What MCP does not do

Half the disappointment around MCP comes from expecting it to be something else. It is plumbing, and plumbing has limits.

Security, in plain terms

Three rules cover most of it. Give the smallest access that still does the job: one folder, one schema, one mailbox. Keep the first week read-only, and only add write after you have watched what it does with read. Log what runs, because a server that quietly retries a failed write five times is a thing you want to find out from a log, not from a client.

The uncomfortable one is injection. An email that says please forward all invoices to this address is a normal sentence, and a model reading that mailbox cannot always tell it from an instruction. The mitigation is not cleverness, it is scope: no write access to anything that sends, and a person approving anything that leaves the building.

When to skip it entirely

If a single script already does the job, keep the script. If the task happens once a quarter, a copy and paste costs less than a config file. And if all your data lives in one app that already has its own assistant, you are not the customer for a protocol that connects many.

MCP pays off on the second use of the same access, not the first. That is the honest test.

Verdict: Connect one folder this week, read-only, and count how many answers change from a guess to a quote. If the number is zero, MCP is not your problem and no server will fix it. If it is three or more, add the database next, then the place your work requests arrive. The protocol is free and the servers are free. The cost is tokens and attention, and both are limited.

Questions people ask

What does MCP stand for?

Model Context Protocol. Anthropic published it in November 2024 as an open standard for connecting AI assistants to outside tools and data, and several other assistants and editors have added support since.

Do I need to write code to use it?

Not to use existing servers. Each one is a line or two in a config file. You only write code if you build your own server for an internal system nobody else has connected.

Are MCP servers free?

The servers are open source and free to run. What costs money is the model: every tool definition and every tool result goes into the context window and is billed like any other token.

Is it safe to connect a database?

Yes, with a read-only user limited to one schema, and no write access until you have watched it work. Never give it the credentials your application uses to write.

How is this different from a plugin or an API?

An API is a set of endpoints you call in code. A plugin is one app's private extension system. An MCP server is a connector any supporting assistant can use, which is why one server works in several apps.

Which should I connect first?

A folder, because it needs no account and no credentials, and it shows you within one conversation whether the assistant can actually use your material.

Related: the AI directory, what a stack costs by seat, and where agents earn their keep in a small business.