The Plain-English MCP Glossary: 30 Terms Explained
MCP comes with a pile of jargon: hosts, transports, elicitation, federation. This MCP glossary explains 30 of the most common MCP terms in plain English, two or three sentences each, grouped by theme so you can skim straight to the part you need. No prior knowledge assumed, no jargon used before it has been defined.
The basics: the protocol and the players
MCP. Short for Model Context Protocol, an open standard for connecting AI agents to tools and data. Introduced by Anthropic in late 2024, it replaced a mess of one-off integrations with a single plug shape: any compliant agent can use any compliant server. Think USB for AI tools.
Agent. An AI system that does things instead of just answering. It reads your request, decides which tools to call, calls them, and works with the results, looping until the task is done. A chat window is not an agent; a chat window that files the ticket for you is.
Host. The application you actually run: Claude Desktop, an IDE, or your own agent runtime. The host owns the conversation with the model and decides which MCP servers to connect and what the model is allowed to do with them.
Client. The protocol component inside the host that holds one connection to one MCP server. A host with five servers runs five clients. You rarely see clients directly; they are plumbing, and the terms host and client get sloppily swapped in casual writing.
Server. A program that exposes tools, resources, and prompts over MCP so agents can use them. It can be a small process on your laptop or a hosted service on the web. We wrote a full explainer on [what an MCP server is](/blog/what-is-an-mcp-server) if you want the long version.
What a server exposes
The next five terms describe what you actually get when you connect a server. There is a deeper walkthrough in our post on [tools, resources, and prompts](/blog/mcp-tools-resources-prompts).
Tool. An action the agent can invoke: search a catalog, send a message, create an invoice. Tools are the workhorse of MCP, and most servers are mostly tools. Each call is a structured request from the agent and a structured result back.
Tool schema. The machine-readable description of a tool: its name, what it does, and the exact parameters it accepts. Schemas are what let a model call tools correctly instead of guessing. They also cost money, because the model reads every connected schema at the start of a session: 150 tools at an average of 350 tokens per schema is about 52,500 tokens before your first word.
Resource. Read-only data a server offers, like a file, a record, or a log. Tools do things; resources are things to read. The host decides which resources actually get pulled into the model's context.
Prompt. A reusable prompt template the server ships, often with slots to fill in. It lets a server say "here is the best way to ask me for this" instead of hoping every user phrases it well.
Function calling. The model-level feature where an LLM outputs a structured function request instead of prose. MCP builds on top of it: function calling is the model's raw ability, MCP is the standard wiring that delivers tool definitions to the model and routes the calls back.
How messages travel
Transport. The channel a client and server talk over. MCP defines the messages; the transport defines how they physically move. The two standard options are stdio and Streamable HTTP.
stdio. Standard input and output: the host launches the server as a local process and pipes messages to it directly. Simple and private, but the server has to run on your machine, with everything that implies about installing and updating it.
Streamable HTTP. The transport for remote MCP servers: ordinary HTTP requests, with the option of streamed responses. It is what lets a server live at a URL, like https://mcp.tulimoa.com/mcp, and serve many users without anyone installing anything.
Stateless protocol. A design where each request carries everything the server needs, so the server keeps nothing in memory between calls. Streamable HTTP permits stateless MCP servers, which is why they deploy so well on serverless platforms. Mind the trap: a stateless server does not mean your agent remembers anything. It means the server does not have to.
Sampling. A server asking the client's model to generate text on the server's behalf. It lets a server use LLM reasoning mid-task without shipping its own model or holding its own API key. The host stays in control and can refuse.
Elicitation. A server pausing mid-operation to ask the human for structured input: a missing value, a choice, a confirmation. It turns guess-and-hope flows into an explicit question at the moment the answer is needed.
MCP v2. The second major revision of the protocol, finalized in late July 2026. It tightens the rules around auth and session lifecycle, and servers can run dual-era, speaking v2 while older clients keep working. Our plain-English guide to [what changed in MCP v2](/blog/what-is-mcp-v2) has the details.
Tokens, context, and memory
Token. The unit models read, write, and bill in: a short chunk of text, roughly three quarters of an English word. Every schema, message, and tool result is measured in tokens, which is why "how much does this add to context" is a money question, not a pedantic one.
Context window. The maximum number of tokens a model can consider at once. Your prompt, the tool schemas, the results, and the whole conversation history all compete for that space. When it fills up, something gets dropped or compressed, and the agent forgets.
RAG. Retrieval-Augmented Generation: fetching relevant documents at question time and placing them in front of the model. RAG solves "the model has never read our documents". It complements MCP rather than competing with it; plenty of MCP tools are RAG pipelines behind a schema.
Memory layer. A persistence layer that keeps facts, decisions, and IDs alive across sessions and context resets, then hands them back when they matter. Without one, an agent re-fetches and re-derives what it already knew, and you pay tokens for every repeat. Tulimoa's gateway ships with a memory layer built in; fewer repeats is the entire pitch.
Checkpoint. A saved snapshot of an agent's plan and progress mid-task, so the state survives a crash or a context compaction. On the Tulimoa gateway, checkpoint is one of the memory tools alongside remember, recall, and set_goal, and memory tools never cost credits.
Access, trust, and infrastructure
OAuth. The standard way to grant limited access without handing over a password: you approve once, the service receives a scoped token, and you can revoke it any time. Remote MCP servers use OAuth so an agent can act as you without ever seeing your credentials.
DCR. Dynamic Client Registration, an OAuth extension that lets a client register itself with an authorization server automatically, with no human creating an app in a console first. It matters for MCP because agents constantly meet servers that nobody pre-configured.
Credential vault. Encrypted storage for the secrets behind your connected tools: OAuth tokens, API keys. A good vault encrypts each secret separately, uses it only at the moment of a call, and never shows it to the model. It is the difference between connecting a tool and pasting an API key into a prompt.
Audit trail. A record of every call an agent made: which tool, when, on whose behalf, with what outcome. When an agent does something surprising, the audit trail is how you find out what actually ran. If a vendor cannot show you one, that is also an answer.
Gateway. A service that sits between your agent and many MCP servers: one endpoint to connect, with auth, routing, and policy handled in one place. Instead of configuring ten servers in every host, you configure the gateway once. The full explainer on [what an MCP gateway does](/blog/what-is-an-mcp-gateway) goes deeper.
Federation. The gateway move of merging many servers' tool catalogs into one namespaced list. Your agent sees github__create_issue and crm__find_contact side by side, and the gateway routes each call to the right backend without the agent knowing or caring where it lives.
Registry. A machine-readable index of MCP servers that clients and tooling can query programmatically: names, versions, endpoints. Think of a package manager's index, but for servers instead of libraries.
Directory. A human-curated catalog of servers and agent-ready tools, built for browsing and judging quality rather than machine lookup. A registry answers "resolve this name"; a directory answers "what is worth connecting?". Our [free curated directory](/discover) is one, browsable on the web and over MCP.
What to read after this MCP glossary
Thirty definitions are a map, not the territory. If you are starting from zero, the three linked explainers above are the reading order we would pick: server first, then gateway, then MCP v2.
Bookmark this page too. MCP terminology keeps moving, and we will keep this list current as the spec does. And if you hit a term in the wild that is missing here, tell us at hello@tulimoa.com. A glossary that stops growing is just a museum.