Before MCP, connecting an assistant to a data source meant writing an integration for that assistant. Connect to Postgres for Claude, write one thing. Connect to Postgres for Cursor, write another. Connect to Postgres for your own agent, write a third. The integrations were the same work repeated per client.
MCP standardises the seam. The server exposes tools, resources, and prompts over a JSON-RPC protocol; the client — any client — speaks that protocol. Write the Postgres server once and every compatible client can use it.
The three things a server can expose
**Tools** are functions the model can call: `query(sql)`, `list_tables()`. They take arguments and return results. This is what people mean by "MCP server" most of the time.
**Resources** are readable content addressed by URI: a file, a record, a document. The model reads them rather than calling them.
**Prompts** are reusable templates the server offers. Useful in theory, rarely used in practice.
Transports, briefly
A server talks to a client over a transport. Two matter: **stdio**, where the client launches the server as a subprocess and they speak over stdin/stdout, and **HTTP**, where the server is a service with a URL.
stdio is what almost every local server uses, which is why installation instructions look like `npx -y some-package` — that command is the client launching the process. When a server "will not start", it is usually because the client cannot run that command: wrong path, missing runtime, or a package that no longer exists.
What MCP is not
It is not a marketplace, and it does not make a server safe. A server that can delete files will delete files whether or not it speaks JSON-RPC. The protocol standardises the connector, not the permissions — those are still decided by what token, role, or filesystem path you hand over.
Where to go next
If you just want to use one: install your first server. If something is broken: debugging a server that will not start. If you want to build one, start by reading how to choose a server — the differences between servers tell you what the protocol leaves to the implementer.