# What Is the Model Context Protocol (MCP)? A Complete Guide to Phase 13 of the AI Engineering Curriculum

> Understand the Model Context Protocol MCP, a standard for LLMs to interact with external tools. Explore its role in Phase 13 of the AI Engineering curriculum.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: deep-dive
- Published: 2026-06-20

---

**The Model Context Protocol (MCP) is an open-source, provider-agnostic standard that lets large language models discover, invoke, and exchange data with external tools via a JSON-RPC 2.0 client-server contract.**

The Model Context Protocol (MCP) has emerged as the industry standard for connecting AI agents to external tools and resources. In the `rohitg00/ai-engineering-from-scratch` repository, Phase 13 (also labeled "Tools & Protocols") provides a comprehensive, hands-on curriculum for mastering MCP from fundamental concepts to production deployment. This phase teaches you to build secure, discoverable MCP servers and clients using the official Python SDK and FastMCP framework.

## Understanding the Model Context Protocol (MCP) Standard

MCP is an open-source protocol first shipped by Anthropic in November 2024 and now stewarded by the Linux Foundation’s Agentic AI Foundation. It defines a client-server contract where an **agent (client)** queries a **tool server** for capabilities, then invokes tools via a standardized wire format.

### Core Architecture and Primitives

The protocol defines **six primitives** (three server-side, three client-side) according to the 2025-11-25 specification. These include `listTools`, `callTool`, and `streamResult`, alongside authentication, discovery, and error handling mechanisms. Servers expose capabilities through a `.well-known/mcp-capabilities` manifest, enabling a central registry to index available MCP servers for platform-wide discovery.

### Transport and Security Model

MCP defaults to **StreamableHTTP**, a stateless HTTP endpoint that streams JSON-RPC 2.0 responses, replacing earlier stdio-SSE transports. Security is enforced through **OAuth 2.1 scopes** with optional Open Policy Agent (OPA) policy gating. For example, destructive tools require `approved:by:human` scopes, while read-only operations may only need `read` permissions.

## How Phase 13 Teaches MCP Implementation

Phase 13 of the curriculum progresses through seven interconnected lessons that move from theory to production deployment. According to the source files in `phases/13-tools-and-protocols/`, learners implement real clients and servers rather than just reading documentation.

### Lesson 06: MCP Fundamentals

The curriculum begins with [`phases/13-tools-and-protocols/06-mcp-fundamentals/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/06-mcp-fundamentals/docs/en.md), which provides a concise historical overview of MCP, lists the six core primitives, and links to the official 2025-11-25 specification. This lesson establishes the theoretical foundation before writing any code.

### Lesson 09: MCP Transports

In [`phases/13-tools-and-protocols/09-mcp-transports/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/09-mcp-transports/docs/en.md), learners explore the evolution to StreamableHTTP transport. The lesson demonstrates how to issue a `listTools` request over HTTP and handle streaming responses, covering the wire protocol mechanics that underpin all MCP communication.

### Lesson 08: Building an MCP Client

[`phases/13-tools-and-protocols/08-building-an-mcp-client/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/08-building-an-mcp-client/docs/en.md) walks through constructing a production-ready client using the **Python SDK** (or TypeScript SDK). The lesson covers deserializing tool manifests, handling streaming responses, and enforcing OAuth 2.1 scope validation before executing remote tools.

### Lesson 07: Building an MCP Server

The server-side implementation is taught in [`phases/13-tools-and-protocols/07-building-an-mcp-server/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/07-building-an-mcp-server/docs/en.md) using the **FastMCP** framework. Learners expose tools such as a Postgres read-only API or an S3 list tool, wire JSON-RPC endpoints, and integrate OPA policy checks to enforce authorization at the tool level.

### Lessons 15 and 16: Security and Governance

Security receives dedicated coverage across two lessons. [`phases/13-tools-and-protocols/16-mcp-security-oauth-2-1/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/16-mcp-security-oauth-2-1/docs/en.md) details OAuth 2.1 scope design and implementation, while the tool-poisoning lesson explores threat models and mitigations against malicious tool definitions. Together, these lessons teach enterprise-grade authorization patterns.

### Lesson 17: Registries and Gateways

[`phases/13-tools-and-protocols/17-mcp-gateways-and-registries/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/17-mcp-gateways-and-registries/docs/en.md) introduces the registry pattern—a separate service that polls MCP servers for capability manifests and presents a discovery UI. This enables platform teams to manage and enable MCP servers across an organization.

### Lesson 13: Production Capstone

The phase culminates in [`phases/13-tools-and-protocols/13-mcp-server-with-registry/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/13-mcp-server-with-registry/docs/en.md), where learners assemble a production-grade MCP server behind a load balancer. This capstone integrates OAuth 2.1 scopes, OPA gating, and a registry for enterprise-wide discovery, representing the full "learn-by-doing" approach of the curriculum.

## Practical MCP Implementation Examples

The repository includes working code examples that demonstrate the client-server contract in action.

### Listing Tools with a Python Client

This minimal client from [`phases/13-tools-and-protocols/08-building-an-mcp-client/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/08-building-an-mcp-client/docs/en.md) demonstrates how to query a server for available tools using JSON-RPC 2.0 over HTTP:

```python
import json, requests

def list_tools(endpoint: str, token: str):
    payload = {
        "jsonrpc": "2.0",
        "method": "listTools",
        "params": {},
        "id": 1
    }
    headers = {"Authorization": f"Bearer {token}"}
    resp = requests.post(endpoint, json=payload, headers=headers, stream=True)
    for line in resp.iter_lines():
        if line:
            print(json.loads(line))

```

### Building a FastMCP Server

The following server implementation from [`phases/13-tools-and-protocols/07-building-an-mcp-server/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/07-building-an-mcp-server/code/main.py) exposes a read-only Postgres tool using the FastMCP framework:

```python
from fastmcp import MCPServer, Tool

def query_postgres(sql: str) -> str:
    # (implementation omitted for brevity)

    return "result rows …"

server = MCPServer(transport="streamable_http", auth="oauth2")
server.register_tool(
    Tool(name="postgres_query",
         description="Read‑only SQL query against a PostgreSQL DB",
         parameters={"type": "object",
                     "properties": {"sql": {"type": "string"}}},
         fn=query_postgres,
         scopes=["postgres:read"])
)
server.start()

```

### Enforcing Security with OPA Policies

To prevent unauthorized destructive operations, [`phases/13-tools-and-protocols/16-mcp-security-oauth-2-1/code/main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/16-mcp-security-oauth-2-1/code/main.py) includes OPA (Open Policy Agent) policies that gate tool access based on OAuth scopes:

```rego
package mcp.authorization

allow {
    input.scope == "approved:by:human"
}
allow {
    not destructive_tool
    input.scope == "read"
}
destructive_tool {
    input.tool in {"jira_create", "linear_create", "postgres_write"}
}

```

## Summary

- **Model Context Protocol (MCP)** is an open-standard JSON-RPC 2.0 protocol for LLM-to-tool communication, now maintained by the Linux Foundation.
- **Phase 13** of the `rohitg00/ai-engineering-from-scratch` curriculum provides a complete learning path from fundamental concepts to production deployment.
- Learners implement **FastMCP servers** and **Python SDK clients** with real authentication, authorization, and transport handling.
- The curriculum covers **StreamableHTTP** transport, **OAuth 2.1** security, and **OPA policy** gating for enterprise use cases.
- A **registry pattern** enables organization-wide discovery of MCP servers through capability manifests.

## Frequently Asked Questions

### What makes MCP different from traditional REST API integration?

**MCP provides a standardized discovery mechanism and client-server contract specifically designed for AI agents.** Unlike ad-hoc REST integrations, MCP servers expose a `.well-known/mcp-capabilities` manifest that allows clients to dynamically discover available tools, their schemas, and required authentication scopes. This eliminates the need for hard-coded API endpoints and enables the ecosystem of tools used by Claude Desktop, ChatGPT, and Cursor.

### How does MCP handle authentication and authorization?

**MCP uses OAuth 2.1 for authentication and supports fine-grained scope-based authorization.** According to [`phases/13-tools-and-protocols/16-mcp-security-oauth-2-1/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/16-mcp-security-oauth-2-1/docs/en.md), tools can declare required scopes (e.g., `postgres:read` or `approved:by:human`), and the server validates these tokens before execution. Additionally, OPA policies can enforce complex governance rules, such as blocking destructive operations unless explicitly approved by a human operator.

### What transport protocol should I use for MCP servers?

**You should use StreamableHTTP, the default stateless transport defined in the 2025-11-25 specification.** As taught in [`phases/13-tools-and-protocols/09-mcp-transports/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/09-mcp-transports/docs/en.md), StreamableHTTP replaces earlier stdio and SSE transports by providing a scalable, HTTP-based endpoint that supports streaming JSON-RPC responses. This works better with load balancers and cloud-native deployments than the older transport methods.

### How do I discover available MCP servers in an enterprise environment?

**Deploy a registry service that indexes server capabilities.** Lesson 17 in Phase 13 ([`phases/13-tools-and-protocols/17-mcp-gateways-and-registries/docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/17-mcp-gateways-and-registries/docs/en.md)) demonstrates building a registry that polls MCP servers for their manifests and exposes a UI or API for discovery. This pattern allows platform teams to centrally manage which tools are available to different agents while maintaining security through the gateway layer.