MCP server vs client vs host vs agent vs RAG: the terms people mix up
Half the confusion about MCP is vocabulary. Here's each commonly-mixed-up pair, settled in a sentence, with the practical reason the distinction matters.
If you've found these terms blurring together, you're not being slow — people genuinely use them interchangeably, including people who should know better. Here's each pair, answer-first.
MCP server vs client
A server exposes tools; a client consumes them. The server is the program you install (a database wrapper, a GitHub connector). The client is the part inside your AI app that connects to it. You add servers; the client is already built into Claude/Cursor. When "tools aren't showing up", you're debugging the client's view of the server.
MCP server vs host
The host is the whole app plus the model; the client is just the protocol-speaking part inside it. Claude Desktop is the host; the MCP client is a component within it. This sounds pedantic until you hit the tool budget — it's enforced at the host level (the model choosing under load), not by any server.
MCP server vs MCP tool
A tool is one callable function; a server is the program that exposes a set of them. The average server ships ~12 tools. This is the distinction that trips up capacity planning: you don't run out of "servers", you run out of tools — Cursor degrades past ~40 active ones, which a handful of servers reaches fast.
MCP vs agent
An agent is the AI system that decides and acts; MCP is the standard it uses to reach tools. They're not alternatives — an agent uses MCP. If something is described as "an MCP server vs an agent", it's a category error: the server is a capability the agent can call, not a competing thing. Frameworks like the ones that build agents speak MCP as a client; they aren't MCP servers themselves.
MCP vs RAG
RAG retrieves documents to stuff into the prompt; MCP lets the model call live tools and actions. This is the most useful distinction to get right. RAG is read-only context injection — find relevant text, paste it in. MCP is interactive — the model can query, write, execute. They're complementary: you might use a RAG-style retrieval server over MCP. But "MCP vs RAG" frames them as rivals when they solve different halves of the problem.
MCP vs API
An API is the underlying service; an MCP server is a thin adapter that exposes that API to a model as standardized tools. Most servers are exactly this — a wrapper turning an existing API into MCP tools. We wrote a whole piece on MCP vs API because it's the question that most often hides a real decision (build a server vs call the API directly).
The one-line cheat sheet
- Host = the app + model (Claude Desktop)
- Client = the protocol plumbing inside the host
- Server = what you install; exposes tools
- Tool = one callable function on a server
- Agent = the deciding system; uses MCP
- RAG = retrieve-and-inject context (complementary to MCP)
- API = the underlying service a server wraps
Every one of these has a one-sentence definition page in the MCP glossary if you want to go deeper on any single term.