Model Context Protocol (MCP)
MCPDefinition
An open standard protocol for connecting Claude to external tools and data sources. Defines a client-server architecture where MCP servers expose capabilities that MCP clients discover and use. Supports project-scoped (.mcp.json) and user-scoped configurations.
Example Usage
Configure MCP servers in .mcp.json with environment variable expansion for credentials: ${GITHUB_TOKEN}.
Why It Matters for the CCA-F Exam
MCP questions in the CCA-F exam test whether you can distinguish servers from clients from primitives, and whether you understand the scoping model (.mcp.json project-scoped vs. user-scoped). Expect scenario questions where you must choose the right primitive type for a given integration need, or identify which component (server vs. client) is responsible for a given behaviour.
In Depth
The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external tools and data sources. Before MCP, every team wired Claude to its APIs in a bespoke way — custom function schemas, custom error handling, custom auth plumbing. MCP standardises the contract so a single well-written server can plug into any compliant host without modification.
The Client-Server Model
MCP is built around a two-role architecture:
- An MCP Server is a process that exposes capabilities — tools, resources, or prompts — to whoever connects to it.
- An MCP Client is the host application (Claude Code, your custom agent) that connects to servers, discovers their capabilities, and orchestrates calls on behalf of the model.
The client initiates the session, completes an initialize handshake with each server, and then queries available capabilities. From that point, Claude can invoke any discovered capability without the developer writing bespoke glue code per integration.
Why MCP Exists
As the number of tools in an agentic system grows, the integration glue code grows even faster without a shared standard. MCP decouples *who builds the tool* from *who builds the client*. A community-built GitHub MCP server works in Claude Code, a custom chatbot, or any other compliant host — unchanged.
Transport & Configuration Overview
MCP supports two transport types. stdio runs the server as a local subprocess — right for developer tooling and single-user setups. Streamable HTTP runs the server as a network service — right for remote, shared, or multi-client deployments. In Claude Code, servers are registered in .mcp.json at the project root (project-scoped, committable) or in user-scoped config (per-developer). Environment variable expansion (${GITHUB_TOKEN}) keeps credentials out of version control.
Where to Go Next
This page covers the protocol overview only. For specifics, see:
- MCP Server — how to build and deploy a server, including code
- MCP Client — the client's gatekeeping and routing responsibilities
- MCP Tools (Primitive) — the model-controlled action primitive
- MCP Roots — filesystem scope and security boundaries
- StreamableHTTP Transport — transport mechanics and multi-client setup
How It Compares
| Feature | MCP (standard) | Custom tool_use integration |
|---|---|---|
| Portability | Any MCP-compliant host | Tied to one application |
| Discovery | Server advertises capabilities at runtime | Defined statically in code |
| Transports | stdio (local), Streamable HTTP (remote) | HTTP, SDK-specific |
| Config scoping | Project (.mcp.json) or user-scoped | Application-specific |
| Ecosystem | Growing library of community servers | Build everything yourself |
Frequently Asked Questions
Is MCP an Anthropic-only protocol?
No. MCP is an open standard. It was created by Anthropic and first adopted by Claude Code, but the spec is public and other AI clients and servers can implement it. Community MCP servers exist for GitHub, Slack, databases, and many other services.
What configuration file registers MCP servers in Claude Code?
`.mcp.json` at the project root registers project-scoped servers. User-scoped configuration covers servers available across all projects. Project-scoped config is preferred for team repos because it can be committed to version control.
How does MCP differ from just defining tools in the API messages array?
API tool_use is a per-request mechanism where you supply tool schemas inline. MCP is a persistent server process that manages its own lifecycle, can expose many tools, resources, and prompts, and allows the same capability to be reused across clients without redefining schemas each request.