MCP in one picture: servers, primitives and transports
A plain-English, visual explanation of the Model Context Protocol: tools, resources and prompts, stdio versus Streamable HTTP, and securing shared servers.
In 30 seconds
MCP is a protocol that connects applications like Claude Code to external capabilities through servers.
Servers expose tools (actions), resources (readable data) and prompts (templates).
Local servers use stdio; shared remote servers use Streamable HTTP with per-user authentication.
Least privilege still applies: give agents only the servers and credentials they need.
Same protocol, two transports. Local servers are launched by the client; shared servers run remotely and must authenticate each user.
What MCP is for
Without a standard, every integration — an issue tracker, a database, a documentation site — needs custom glue for every AI application. The Model Context Protocol defines one way for a client (such as Claude Code or your own agent) to discover what a server offers and call it. Build the server once and any MCP client can use it.
The three primitives
Tools are actions the model can invoke, like creating a ticket or running a query. Resources are data the client can read into context, like a file or a record. Prompts are reusable templates a server provides. Most exam questions focus on tools, but knowing the difference helps you spot distractors that swap them.
Choosing a transport
stdio fits servers that run on the same machine as the client. The client launches the server as a subprocess and talks over standard input and output; nothing listens on the network. This is the natural choice for access to a developer's local files or tools.
Streamable HTTP fits shared servers that many users reach over the network — company documentation, a central data service. That makes authentication and per-user authorization essential: each person should see only what they are entitled to, not whatever one shared admin key allows.
Sharing MCP in a team
In Claude Code, servers the whole project needs go in a project-scoped .mcp.json committed to the repository. Credentials come from environment variables or each user's own sign-in — never written into the file.
Security in one line: treat tool results as untrusted input. A fetched web page can contain instructions; least privilege is what stops them from mattering.
Part of Domain 2: Tool Design & MCP Integration (18% of the exam). Explanations are our own, checked against Anthropic's documentation on November 22, 2026.
Common traps
Trap
Why it fails
Do this instead
Running a local-only server over the network
Adds exposure and a service to manage
Use stdio for local servers
One admin key for a shared server
Everyone gets admin access
Authenticate and authorise per user
API token committed in .mcp.json
Leaks the secret to everyone with repo access
Use environment variables or user auth
Check yourself
Two original practice questions on this lesson. Try them before opening the answers.
Check yourself 1
Scenario: Developer productivity with Claude
Your team needs an MCP server that runs locally next to each developer's Claude Code to access their local files. Which transport is the natural fit?
A. Streamable HTTP, exposed on the office network so every machine can reach it
B. stdio, with the client launching the server as a local subprocess
C. Streamable HTTP on a public URL, protected by a shared API key
D. Streamable HTTP on a loopback port on each developer's own machine
Show answer and explanation
Answer: B. The stdio transport is designed for local servers: the client starts the server process and communicates over standard input and output, with nothing exposed on a network and no separate process to keep running. HTTP-based transport is for remote, shared servers; even bound to loopback it adds a listening service and its lifecycle for no benefit, and network exposure needs proper authentication.
Check yourself 2
Scenario: Developer productivity with Claude
A central MCP server provides access to company documentation for hundreds of users. Which transport and design considerations apply? Choose two.
A. Use the HTTP-based (Streamable HTTP) transport for remote clients
B. Require company SSO, then give every signed-in user the full corpus
C. Use stdio, with each user running a local copy holding the admin key
D. Skip authentication because the documentation is internal-only data
E. Authenticate users and authorize access per user, not via one admin key
Show answer and explanation
Answer: A and E. Shared remote servers use the HTTP-based transport and must handle authentication and per-user authorization, so each person sees only what they are entitled to. Distributing an admin key to local copies or skipping auth for "internal" data widens the attack surface, and SSO alone authenticates people without limiting what each one may read.