Skip to content

Model Context Protocol (MCP)

  • Agents
  • Asked often
  • About 1 h 30 min to learn
  • 5 vetted resources
Build a plan that includes this

What this topic covers

MCP is an open protocol that lets an AI application (the host) plug into external programs (servers) through a standard JSON-RPC interface, so one integration works across many clients. A host spins up one client per server; servers expose tools (model-invoked actions), resources (app-selected read-only context) and prompts (user-invoked templates). Interviews ask you to contrast MCP with plain function calling, explain the host/client/server split and the two transports (stdio vs streamable HTTP), say who controls each primitive, and discuss consent and security for tool execution. The spec moves fast: the 2026-07-28 revision made the protocol stateless with a discover request and deprecated sampling, so be ready to say what changed.

Builds on

You’re ready when you can

What interviewers check, from the resources below.

  • Explain why a host creates one client per server and what each role is responsible for
  • Compare stdio and streamable HTTP transports and say when you would pick each
  • Describe a tools/list → tools/call exchange and what a tool definition contains
  • State who controls tools, resources and prompts (model, application, user)
  • Say what the 2026-07-28 revision changed (stateless requests, server/discover, sampling deprecated) and why that matters for server authors
  • Explain the M×N integration problem and how a shared protocol turns it into M+N
  • Distinguish host from client without using the words interchangeably
  • Map a concrete feature of a coding assistant onto tool, resource and prompt
  • Decide for a given capability whether it should be a tool, a resource or a prompt, and justify by who controls it
  • Name three ways an application keeps a human in control of model-invoked tools

What to study, in order

Each link opened and checked by hand; the date says when.

  1. Start here

    Architecture overview (opens in a new tab)

    Model Context Protocol docs · Model Context Protocol contributors · 35 min · Free · checked 21 Oct 2026

    Why
    This is the page an interviewer has in mind when they ask “so how does MCP actually work”; it gives you the host/client/server split, the two layers and real JSON-RPC messages to describe.
    What to read
    Read “Concepts of MCP”: “Participants”, “Layers” (data layer, transport layer) and “Data Layer Protocol” (“Statelessness and discovery”, “Primitives”, “Notifications”). Then walk steps 1–3 of “Example” (discovery, tool discovery, tool execution).
    What to skip
    Step 4 of the example (subscriptions and notifications) and the “Scope” list of sub-projects, unless you are interviewing for a platform team that builds clients.

  2. Free alternative

    Key Concepts and Terminology (opens in a new tab)

    Hugging Face MCP Course · Hugging Face · 15 min · Free · checked 21 Oct 2026

    Why
    Gives you the one-line pitch for MCP (M×N integrations become M+N) and a clean host/client/server glossary; enough for the “why does MCP exist” question without reading protocol detail.
    What to read
    Read “The Integration Problem” (both the M×N and M+N parts) and “Core MCP Terminology” (“Components”, “Capabilities”).
    What to skip
    Nothing on this page, but note it still lists sampling as a live primitive; the 2026-07-28 spec deprecated it, so say so if asked.

  3. Go deeper

    Understanding MCP servers (opens in a new tab)

    Model Context Protocol docs · Model Context Protocol contributors · 30 min · Free · checked 21 Oct 2026

    Why
    Design questions (“how would you expose our internal API to an agent?”) are really questions about choosing tools vs resources vs prompts and where human approval sits; this page is the spec's own answer.
    What to read
    Read “Core Server Features” including the “Tools”, “Resources” and “Prompts” sections with each “User Interaction Model”, then “Bringing Servers Together” for the multi-server flow.
    What to skip
    “Parameter Completion” and the resource-template URI examples; nice to know, rarely asked.

  4. Go deeper

    MCP Python SDK (opens in a new tab)

    GitHub · modelcontextprotocol · 30 min · Free · checked 22 Oct 2026

    Why
    Having written a working MCP server, not just read the spec, is what lets you answer follow-ups about tools versus resources, transports and where the schema comes from.
    What to read
    Follow the README’s “A server in 15 lines” (docs_src/index/tutorial001.py): one tool and one templated resource, opened with uv run mcp dev server.py in the MCP Inspector. Then do “A client in 10 lines”: serve it over streamable HTTP and call the tool from the Client.
    What to skip
    Skip the contributing guide and the SDK’s lower-level server internals; the docs site’s advanced pages can wait.

  5. Go deeper

    Model Context Protocol servers (opens in a new tab)

    GitHub · modelcontextprotocol · 40 min · Free · checked 22 Oct 2026

    Why
    The official reference servers show what a well-behaved MCP server looks like, including how it limits what the model can touch. That is the part interviewers push on once you say “just expose it over MCP”.
    What to read
    Read the README’s “Reference Servers” list. Then read src/filesystem/README.md (“Directory Access Control”, “How It Works”, “Tools” and “Tool annotations”) and src/filesystem/path-validation.ts. Skim src/everything/README.md as the server that exercises every protocol feature. Note how the filesystem README separates 2025-era clients from the 2026-07-28 protocol.
    What to skip
    Skip the archived servers, the per-client config snippets (Claude Desktop, VS Code, Docker) and the releasing docs.

Companies that test Agents most

Put Model Context Protocol (MCP) in your plan

Tell us your interview date and hours a day; it lands on the right day, in the right order.

Build my plan