References: Model Context Protocol

Source material

Source curriculum (structural mirror, cited as further study):
• Anthropic Academy (https://anthropic.skilljar.com/):
    "Introduction to Model Context Protocol" + "MCP Advanced Topics"
    (developer-focused courses)
  License: Anthropic Academy course content is account-gated;
    Clawdemy structurally mirrors the Academy's lesson progression
    as inspiration and cites it as further study. Every substantive
    claim in this lesson is verifiable against the public Anthropic
    documentation and the open MCP specification.

Primary public-doc anchors (every substantive claim verified against):
• Anthropic, "MCP connector" (the Messages API integration)
  https://platform.claude.com/docs/en/agents-and-tools/mcp-connector
• modelcontextprotocol.io home, "What is the Model Context Protocol?"
  (the open standard's introduction)
  https://modelcontextprotocol.io/
• MCP specification, Authorization section (OAuth flow)
  https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization
• Anthropic, "Tool reference" (the directory of Anthropic-provided
   tools that the decision frame compares against)
  https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference
• Anthropic, "Tool search tool" (defer_loading + tool_search,
   the pairing this lesson cross-references)
  https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool

Verbatim claims sourced from the public docs and spec:
• "Claude's Model Context Protocol (MCP) connector feature enables you
   to connect to remote MCP servers directly from the Messages API
   without a separate MCP client" (mcp-connector docs page, opener)
• "MCP (Model Context Protocol) is an open-source standard for
   connecting AI applications to external systems"
   (modelcontextprotocol.io home)
• "Think of MCP like a USB-C port for AI applications. Just as USB-C
   provides a standardized way to connect electronic devices, MCP
   provides a standardized way to connect AI applications to external
   systems" (modelcontextprotocol.io home)
• Beta header: anthropic-beta: mcp-client-2025-11-20 (current);
   mcp-client-2025-04-04 deprecated (mcp-connector docs, Note)
• "This feature is not eligible for Zero Data Retention (ZDR). Data
   is retained according to the feature's standard retention policy"
   (mcp-connector docs, Note)
• "Use the mcp_servers API parameter when you have remote servers
   accessible by URL and only need tool support. Use the client-side
   helpers when you need local servers, prompts, resources, or more
   control over the connection with the base SDK" (mcp-connector docs)

Required attribution: "Based on the structure of the Anthropic Academy
  'Introduction to Model Context Protocol' and 'MCP Advanced Topics'
  courses (https://anthropic.skilljar.com/). This lesson is an
  independent structural mirror in original prose; every substantive
  claim is verified against the public Anthropic Claude documentation
  at https://platform.claude.com/docs/ and the open Model Context
  Protocol specification at https://modelcontextprotocol.io/.
  Anthropic does not endorse it."

Read this next

• Anthropic, “MCP connector”. The canonical reference for the Messages API integration: the full mcp_servers and mcp_toolset shape, all configuration patterns, the response block reference, the migration guide from the deprecated beta version.
• modelcontextprotocol.io. The open standard’s home: the architecture diagrams, the spec, the ecosystem of MCP servers and hosts. Start here if you want to author your own MCP server.
• Anthropic, “Tool reference”. The directory of every Anthropic-provided tool with current model compatibility; the comparison set for the decision frame between L5 (Anthropic-provided) and L6 (third-party via MCP).

Going deeper

A short, durable list. Each link is a specific next step inside Track 22.

• Lesson 7 of this track, “Prompt caching and context management.” Where tool definitions across the L4 + L5 + L6 layers become cacheable, where cache_control on the mcp_toolset attaches into the caching system, and where long-session compaction handles the accumulated mcp_tool_result blocks.
• Lesson 8 of this track, “From single call to agent loop.” Where the per-step tool capability set the loop has access to is the union of custom (L4), server + Anthropic-schema (L5), and MCP (L6) tools. The denylist-destructive-tools discipline from this lesson becomes load-bearing in the agent setting.
• Lesson 9 of this track, “Six effective-agent patterns.” Where the choice between read-only allowlist and full-set-behind-human-confirm becomes a design decision per pattern (especially for the autonomous-agent and orchestrator-workers patterns).

Adjacent tracks (the natural next destinations)

• Track 20 (AI Agents and Tool Use): pick this if you want the full track-level depth on agent design, especially around tool isolation, sandboxing, and the security disciplines (allowlist vs denylist; human-confirm-before-state-changes) this lesson sketches at the connector-configuration layer.
• Track 21 (LLM Ops and Production): pick this if you want the provider-agnostic view of evaluation and observability for tool-using applications. The eval-set discipline from there applies directly to MCP tool calls: measure whether each connected MCP server earns its cost on your workload.

Where this connects inside the track

The third tool layer the rest of T22 builds on top of:

• Lesson 1 (first call): the iterate-the-content-array discipline now extends to mcp_tool_use and mcp_tool_result. Same array; more block types.
• Lesson 2 (production patterns): the stop_reason dispatch already covers end_turn, max_tokens, stop_sequence, tool_use, and (from L5) pause_turn; MCP calls do not introduce a new stop reason but do produce assistant turns with new block types to surface.
• Lesson 3 (model selection): the effort dial affects ALL tokens including MCP tool-definition tokens and tool-result content; the same per-MTok pricing applies.
• Lesson 4 (custom client tools): the path you choose when the tool’s code is yours and not exposed as MCP.
• Lesson 5 (server tools + Anthropic-schema clients + tool_search): the path you choose when Anthropic already provides the capability; defer_loading and tool_search pair with the MCP toolset’s per-tool defer_loading for large multi-server catalogs.
• Lesson 7 (next, prompt caching): cuts the repeated cost of tool definitions across all three tool layers; the cache_control field on the mcp_toolset is the seam.
• Lesson 8 onward (agent loop): the per-step tool inventory the loop has access to is the union of L4, L5, and L6 tools.
• Lesson 12 (shipping): the per-server cost tracking in the usage object is what production cost monitoring surfaces; the eval-set discipline measures whether each MCP server earns its cost.