Understanding the Model Context Protocol (MCP) for Developers

The Model Context Protocol (MCP) is an open standard that defines how AI assistants connect to external tools, data sources, and services. If you are working with AI-powered developer tools — IDEs, coding assistants, agent frameworks — you will encounter MCP vocabulary increasingly often. Understanding the terminology precisely will help you read documentation, participate in technical discussions, and build integrations confidently.

This guide explains the core MCP concepts and the English vocabulary used to describe them, with examples from real developer contexts.

What Is MCP?

MCP stands for Model Context Protocol. It was introduced by Anthropic in November 2024 and defines a standardised way for large language models (LLMs) to interact with the outside world. Before MCP, every AI tool integration was bespoke — each company built its own way to connect an LLM to a database, a file system, or an API. MCP provides a shared vocabulary and a shared wire format for these connections.

The key insight behind MCP is the client–server architecture. An AI assistant (the MCP client) can connect to one or more MCP servers, each of which exposes capabilities — tools, resources, or prompts. The client can discover what each server offers and call those capabilities at runtime.

Core Vocabulary

MCP Server

An MCP server is a process that exposes capabilities to an AI client. It could be a lightweight local process or a remote service. Servers are responsible for:

• Declaring what they offer (tools, resources, prompts)
• Handling requests from the client
• Returning results in a structured format

Common usage: “I’m building an MCP server that wraps our internal Jira API so that Claude can query tickets directly.”

MCP Client

An MCP client is the AI-side component that connects to MCP servers. In practice, the client is often embedded in an AI assistant like Claude Desktop, Cursor, or a custom agent. The client:

• Discovers available servers
• Negotiates capabilities during a handshake
• Invokes tools and fetches resources as needed

Common usage: “The MCP client sends a tool call request, and the server responds with the result.”

Tools

Tools in MCP are functions that the AI can call to perform actions. They are the most commonly discussed capability. A tool has:

• A name (e.g., search_codebase, run_query)
• A description that the LLM reads to understand what the tool does
• An input schema (usually JSON Schema) defining the parameters

Common usage: “We’ve exposed a get_pull_request tool on our GitHub MCP server. The model can call it with a PR number and get back the diff and review comments.”

Key collocations with “tool”:

• invoke a tool — call a tool by sending a request
• register a tool — make a tool available on the server
• tool call — the act of the LLM requesting a tool execution
• tool result — the data returned after the tool runs

Resources

Resources are read-only data that MCP servers can expose. Unlike tools (which perform actions), resources represent content — files, database records, API responses — that the AI can read as context.

Common usage: “The MCP server exposes the project’s README as a resource. When the model needs context about the project structure, it fetches the resource rather than calling a tool.”

• expose a resource — make data available via MCP
• fetch a resource — read resource content
• resource URI — the identifier for a specific resource (e.g., file:///project/README.md)

Prompts

Prompts in MCP are reusable, parameterised message templates that servers can expose. They allow server developers to pre-author prompt patterns that clients can use consistently.

Common usage: “The server exposes a code_review prompt that takes a file path as a parameter and returns a structured prompt asking the model to review it according to our coding standards.”

Sampling

Sampling is an advanced MCP capability where the server can request the client (the AI) to generate text. This enables servers to incorporate LLM reasoning into their own workflows — a server-side pattern rather than just responding to AI requests.

Common usage: “The server uses sampling to ask the model to classify the severity of an error before returning the tool result.”

Transport and Connection Vocabulary

MCP servers communicate with clients over a transport layer. Two transports are common:

• stdio transport — the server runs as a local subprocess, and the client communicates via standard input/output. Simple, widely supported.
• HTTP + SSE transport — the server runs as a web service. The client sends HTTP requests and receives responses via Server-Sent Events (SSE) for streaming.

Key phrases:

• “This MCP server uses stdio transport — you launch it as a child process.”
• “For remote servers, we use the HTTP transport with SSE for streaming responses.”
• Handshake — the initial exchange where client and server negotiate protocol version and capabilities

Practical Vocabulary in Context

Here is how MCP vocabulary appears in a real team conversation:

“We’ve written an MCP server that exposes three tools: list_deployments, get_deployment_logs, and rollback_deployment. The server connects to our internal deployment API. Once the MCP server is registered in Claude Desktop, engineers can ask Claude to fetch the logs for a failing deployment and it will invoke the tool automatically.”

“One thing to watch out for: tool descriptions matter a lot. If the description is ambiguous, the model may invoke the wrong tool or pass incorrect parameters. Write descriptions as if you’re documenting a function for a developer who has never seen your codebase.”

Key Vocabulary Summary

• MCP — Model Context Protocol, a standard for AI-to-tool connectivity
• MCP server — a process that exposes tools, resources, or prompts
• MCP client — the AI-side component that connects to servers
• Tool — a callable function the AI can invoke
• Resource — read-only data the AI can fetch for context
• Prompt — a reusable, parameterised message template
• Sampling — a server requesting text generation from the AI
• Handshake — the capability negotiation step when client and server connect
• stdio transport — communication via standard input/output (local)
• SSE — Server-Sent Events, used for streaming in HTTP transport

MCP is evolving quickly, but its core vocabulary is stable. Mastering these terms will help you read the official specification, contribute to MCP server projects, and discuss AI tooling with colleagues in precise, professional English.