If your AI team has more than one agent, you have already paid the N×M integration tax. Every agent re-implements lookup_customer, every team writes its own search_knowledge_base, and the day someone changes the CRM API, ten different codebases break in subtly different ways. The Model Context Protocol (MCP) is Anthropic's open standard for ending that tax. It separates what a tool does from which agent uses it, and as of the 2026 specification revision, it does so over stateless HTTP transports that scale on ordinary load balancers. This guide walks through why MCP exists, what changed in 2026, and the architectural decisions tested on the Claude Certified Architect (CCA-F) and NVIDIA NCP-AAI exams.
Hands-on first
This article pairs with our hands-on MCP lab. If you learn faster by typing than reading, skip to building a real MCP server in 40 minutes, then come back here for the architecture context. Ready to test yourself? Preporato's CCA-F practice tests include 6 full-length exams with an explanation for every option, and the free CCA-F sample questions lets you try 20 questions first.
Stand up an MCP server in 40 minutes
Feel the protocol work end-to-end (stdio server, LangChain client, hybrid MCP+native tool agent) before you commit to architectural decisions.
Why MCP Exists: The N×M Problem
Every LLM agent needs tools. Look up a user. Query a database. Call an API. Without a standard, every team writes the same tools differently:
With 10 agents and 20 tools, that is 200 implementations to maintain, test, and keep in sync. A CRM pricing change ripples through all of them. A new field becomes a coordinated release across ten teams. This is the integration tax you pay every day in a multi-agent organisation.
What MCP changes
MCP flips the relationship. Write each tool once as an MCP server. Any MCP-compatible client (Claude Desktop, Claude Code, Cursor, LangChain, OpenAI Agents SDK, raw Anthropic API) can use it:
The math is the same shape as REST APIs versus per-client integrations: standardise the contract, write the implementation once, plug new clients in without glue code.
The MCP cost model
| Approach | 10 agents × 20 tools | Add an 11th agent | Change one tool |
|---|---|---|---|
| Per-agent tool reimplementation (N×M) | 200 implementations | +20 implementations | 10 codebases change |
| MCP servers (N+M) | 30 implementations (10 clients + 20 tools) | +1 client config | 1 codebase changes |
Try 15 CCA-F practice questions free
They come from the CCA-F practice tests, and each option shows its explanation once you answer.
- 6 timed practice exams
- Every answer explained
- A score for each domain
- $19.99 one-time
What Changed in 2026
MCP shipped in late 2024 and the protocol evolved fast. If you are studying from material older than April 2026, expect drift on these three points.
MCP 2026 changes (verified June 2026)
- Stateless protocol core. The 2026-07-28 specification revision (release candidate now public) makes MCP stateless at the protocol layer. Sessions no longer require sticky load balancing; horizontal scaling works on ordinary HTTP infrastructure.
- Streamable HTTP replaces HTTP+SSE. SSE is deprecated for new remote servers. Existing SSE servers still work; new code should default to Streamable HTTP.
- Server discovery metadata. Servers can now publish a manifest a registry or crawler can read without opening a session. This unblocks the public MCP registry initiative.
- Model releases do not change MCP. Claude Fable 5 (released June 9, 2026, the new tier above Opus) connects to MCP servers exactly like Opus and Sonnet do. The protocol is model-agnostic, so transport and architecture answers on the exams never depend on which Claude model is in play.
The three transports you need to know
| Transport | Use case | 2026 status |
|---|---|---|
| stdio | Local tools, subprocess-spawned servers (Claude Desktop, Claude Code) | Stable. Default for local. |
| Streamable HTTP | Remote shared servers, multi-tenant deployments | The 2026 standard. Stateless, single endpoint, supports POST and GET. |
| HTTP+SSE | Existing remote deployments from 2024-2025 | Deprecated. Backwards-compatible but no new features. |
The exam tests transport selection directly. The rule of thumb: stdio for anything spawned locally by the client, Streamable HTTP for anything you would deploy behind a load balancer.
What an MCP Server Exposes
A server exposes three primitive types. Understanding which to use when is the most common exam question after transport selection.
| Primitive | What it is | When to use it | LangChain analog |
|---|---|---|---|
| Tools | Functions the LLM can call | Anything that takes input and produces output, or has side effects | @tool |
| Resources | Read-only data exposed at file-like URIs | Documents, configuration, KB entries with stable identifiers | A RAG document with a fixed ID |
| Prompts | Reusable prompt templates parameterized by client | Workflow templates the user picks from a menu | ChatPromptTemplate |
The schema for each is derived from the function signature in your server code. Parameter types become the input schema, return types become the output type, docstrings become the description the LLM reads when deciding whether to call the tool. The decorator pattern in FastMCP (the high-level Python SDK) mirrors @tool in LangChain:
from fastmcp import FastMCP
mcp = FastMCP("acme-support")
@mcp.tool
def check_account(email: str) -> str:
"""Look up a customer account by email."""
# ...
return f"Account for {email}: Pro plan, active"
if __name__ == "__main__":
mcp.run() # defaults to stdio transport
Tool descriptions are prompts
This is the part nobody writes down explicitly. The docstring on your tool is read by the LLM at decision time. Vague docstrings cause tool-selection errors. The exam tests this with scenarios like "an agent with 22 tools has 60% tool-selection accuracy, what changes?" The first-order fix is almost never "use a smarter model"; it is "write more discriminating tool descriptions" or "split the tool surface across subagents."
When to Use MCP vs Anthropic Skills vs Native @tool
This decision shows up across both CCA-F (Domain 2: Tool Design & MCP Integration, 18%) and NCP-AAI (Agent Development, 15%). The exam wants a defensible rule, not vibes.
MCP vs Skills vs native @tool
| Approach | Best when | Avoid when |
|---|---|---|
| Native @tool / @function_call | Tool is single-team, single-agent, lives in the same repo as the agent | More than one agent or team needs it |
| Anthropic Skills | Workflow is Claude-specific, model-controlled, and benefits from prompt + tool packaging | You need cross-vendor portability or non-Claude clients |
| MCP server | Tool is reused across agents, teams, or vendors. Implementation owned by a platform team | Tool is one-off, single-caller, and standing up a server adds more overhead than it saves |
The CCA-F exam has a recurring scenario shape: "Team A built an agent with three tools. Team B wants to use two of those tools in a different agent. What is the correct architectural change?" The right answer is almost always "extract the shared tools into an MCP server." It is not "copy the code into Team B's repo." It is not "ask Team A to maintain a Python package." MCP is the explicitly-correct answer pattern for cross-team tool sharing.
Three questions from the CCA-F practice tests
Your wire-transfer agent must screen each recipient against a sanctions list before calling execute_transfer, and the system prompt says so firmly. In red-team tests, about 1 in 300 transfers skipped screening when the requester stressed urgency ("the CEO needs this in 10 minutes"). Compliance requires screening on every transfer, with no exceptions. What is the most reliable change?
[object Object]
Correct. A programmatic prerequisite looks at recorded state, which no amount of urgency in the conversation can change: the transfer tool refuses to run unless a passing screen for the same recipient is recorded, and returns an error telling the agent to screen first.
A. The final decision still rests on Claude reconciling two outputs, so the same urgency framing can tip it toward approving.
B. Forcing a tool on each turn breaks normal conversation, is not supported on every model and still does not tie the screening result to the recipient being paid.
C. Stronger wording and examples lower the skip rate, but they keep screening in the model's hands, which is what urgency framing exploits. A zero-tolerance rule needs enforcement outside the model.
Your coordinator receives the research subagent's findings, then dispatches the report-writing subagent with the prompt "Using the research above, write the client report." The reports regularly contradict the findings, for example citing a 12% market decline that the research had shown was 3%. What is the most likely root cause?
[object Object]
Correct. A subagent starts with the prompt it is given and nothing else; it does not see the coordinator's conversation. "The research above" points at nothing, so the writer fills the gap from general knowledge. Pass the findings, with sources, in the report agent's prompt.
A. Different snapshots would not explain a report contradicting findings it had been given. The writer never had them.
B. max_tokens limits the length of the response and has no effect on what the prompt can carry.
D. The coordinator had the findings before it dispatched the writer. The problem is what it put in the writer's prompt.
Your returns agent has 22 tools, from lookup_order and check_inventory to generate_label and schedule_pickup. It often picks the wrong tool and calls tools out of order, such as generate_label before process_return. Most conversations move through clear phases: identify the order, decide the remedy, carry it out. What is the primary architectural improvement?
[object Object]
Correct. Workflow-level tools, such as a process_return that also generates the label, remove sequencing mistakes inside a workflow, and exposing the tools for the current phase alone keeps each choice small.
A. Hard-coding each step turns the agent into a script that breaks on cases the orchestrator did not anticipate, and forced tool choice is not available on every model.
B. Examples help with common paths but grow with each new request type and still leave the model choosing among 22 tools.
D. Better descriptions help selection at the margin, but 22 overlapping choices remain, and descriptions do not enforce order.
Full CCA-F set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsArchitecture Patterns That Show Up on the Exam
Pattern 1: Platform team owns the MCP server
The most common production pattern. A central platform team owns one or more MCP servers. Agent teams consume them. Schema changes go through the platform team. New tools land in one place. This is the architecture the CCA-F exam expects you to recommend for cross-team scenarios.
Pattern 2: Hybrid agents (MCP + native tools)
Agents do not have to choose. A LangChain or LangGraph agent can mount MCP tools as first-class tools alongside native @tool definitions. The exam tests this: "When should an agent use MCP tools versus its own?" The answer: native for agent-specific logic, MCP for shared infrastructure. Mix them in the same tools=[] list.
Pattern 3: Sub-agent dispatch with MCP
When tool count grows past ~15-20, tool-selection accuracy degrades. The exam-tested fix is sub-agent dispatch: a coordinator routes to specialist sub-agents, each of which sees only its own focused tool surface. MCP servers slot in naturally because each sub-agent can mount only the MCP servers relevant to its domain.
From theory to working agents
The MCP lab walks you through all three patterns above with running code.
Build an MCP Tool Server & Connect a LangChain Agent
Build a Model Context Protocol server that exposes your company's tools and data, then connect a LangChain agent to it and see how MCP decouples tools from agents.
Build an AI Agent 3 Ways: ReAct vs Tool Calling vs Plan-and-Execute
Build the same SaaS support agent three ways, as ReAct, direct tool calling and plan-and-execute, then compare speed, reasoning quality and reliability to learn when each fits.
Build a Multi-Agent Supervisor with LangGraph
Build a supervisor agent that routes queries to specialist agents, the core orchestration pattern the NCP-AAI exam tests.
The Exam Angles (CCA-F + NCP-AAI)
The same MCP concepts appear with different framing in both exams.
Claude Certified Architect (CCA-F), Domain 2: Tool Design & MCP Integration (18%)
- Transport selection (stdio vs Streamable HTTP) for given deployment shapes
.mcp.jsonconfiguration placement (project-level vs user-level vs directory-level)- Tool description quality and its effect on selection accuracy
- MCP vs Anthropic Skills vs native
@tooldecision criteria - Error handling: structured errors,
isRetryableflags, idempotency
NVIDIA NCP-AAI, Agent Architecture & Design (15%) + Agent Development (15%)
- Why standardized protocols matter at multi-agent scale (the N×M argument)
- Tool architecture: separation of tool implementation from agent reasoning
- Cross-framework interop (Claude Desktop, LangChain, OpenAI Agents SDK speaking MCP)
- When to introduce MCP as part of an agent platform
If you have not built an MCP server end-to-end, both exams will feel abstract on these questions. The lab below fixes that.
Read the protocol, then build one
Practice questions teach the rules. The lab makes the protocol muscle memory by walking you through a real server end-to-end.
Browse all labsFrequently Asked Questions
Next Steps
If you are preparing for either CCA-F or NCP-AAI, the fastest way to make these concepts stick is to build a server. Read the protocol, then write 50 lines of FastMCP, then connect a LangChain agent to it. The exam tests pattern recognition; the lab makes the patterns muscle memory.
Open the MCP lab
Stand up a server, connect a client, build a hybrid MCP+native agent. ~40 minutes, all in your browser.
Sources:
![Model Context Protocol (MCP) Architecture Guide: From N×M to N+M [2026]](/og-preporato.jpg)