# Official Specification for the Model Context Protocol: Technical Reference and Implementation Guide

> Discover the official Model Context Protocol specification. Learn about the JSON-RPC communication standard, tool schemas, and authentication for MCP compliant servers and clients.

- Repository: [Frank Fiegel/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
- Tags: api-reference
- Published: 2026-09-02

---

**The official specification for the Model Context Protocol is maintained at [modelcontextprotocol.io](https://modelcontextprotocol.io/), which defines the JSON‑RPC‑based communication standard, tool schemas, and authentication requirements that all MCP‑compliant servers and clients must implement.**

The Model Context Protocol (MCP) standardizes how AI applications discover and invoke external tools through a unified interface. According to the `punkpeye/awesome-mcp-servers` repository, the authoritative technical reference for building compliant services resides at modelcontextprotocol.io, where developers can find complete documentation for implementing both MCP servers and clients.

## Where to Find the Official MCP Specification

The canonical documentation for MCP lives exclusively at **[modelcontextprotocol.io](https://modelcontextprotocol.io/)**. This site hosts the complete technical description of the protocol, including the JSON‑RPC communication layer, tool definition formats, authentication mechanisms, and error handling conventions.

In the `awesome-mcp-servers` repository, line 29 of [[`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md)](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md) explicitly links to this specification as the authoritative source. All servers listed in the repository must conform to the standards defined at this location to ensure interoperability with MCP clients.

## Core Components of the Specification

### JSON‑RPC 2.0 Communication Model

MCP uses a **JSON‑RPC 2.0** style request/response pattern for all interactions. Every message must include the standard JSON‑RPC fields: `jsonrpc` (version string), `id` (request identifier), `method` (operation name), and `params` (arguments object). This structure ensures that any compliant client can communicate with any MCP server using predictable patterns.

### Tool Definition Schema

The specification defines strict requirements for how servers expose their capabilities. Servers must implement the `tools/list` method to advertise available tools, including their parameter schemas, return types, and descriptions. This schema enables **dynamic discovery**, allowing clients to understand server capabilities at runtime without hardcoded dependencies.

### Authentication Mechanisms

The spec outlines required authentication protocols and security conventions for production MCP deployments. Implementers must follow these guidelines to ensure secure communication between clients and servers.

### Error Handling Conventions

MCP defines standardized error codes and response formats. All error responses must conform to the specification's conventions to ensure consistent behavior across different language implementations and server types.

## Implementation Examples

Below are minimal examples that demonstrate how to interact with an MCP server according to the official specification.

### Listing Available Tools (Python)

```python
import requests
import json

# MCP endpoint (replace with your server's URL)

MCP_URL = "https://example-mcp.com/mcp"

# The request conforms to the MCP spec: a JSON-RPC 2.0 call with method "tools/list"

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
}

response = requests.post(MCP_URL, json=payload)
tools = response.json()
print(json.dumps(tools, indent=2))

```

### Invoking a Tool (JavaScript)

```javascript
const fetch = require('node-fetch');

const MCP_URL = 'https://example-mcp.com/mcp';

async function callTool() {
  // 1️⃣ List tools to discover the tool name and parameters
  const listResp = await fetch(MCP_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'tools/list',
      params: {}
    })
  });
  const tools = await listResp.json();

  // Assume a tool named "weather/get" exists
  const invokeResp = await fetch(MCP_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 2,
      method: 'weather/get',
      params: { location: 'San Francisco, CA' }
    })
  });
  const weather = await invokeResp.json();
  console.log(weather);
}

callTool();

```

These snippets follow the *method* and *params* conventions defined in the MCP specification, demonstrating the required JSON‑RPC structure for both discovery and invocation phases.

## Key Repository Files Referencing the Specification

The `awesome-mcp-servers` repository contains several files that guide users toward the official specification:

- **[`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md)** — Provides the high‑level overview and links to the official MCP spec at line 29. This file categorizes the curated list of servers and emphasizes compliance requirements.
- **[`CONTRIBUTING.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/CONTRIBUTING.md)** — Contains guidelines for adding new MCP server entries, ensuring they conform to the official spec before inclusion in the list.
- **[`README-zh.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README-zh.md)** (and other localized READMEs) — Translations of the main README that preserve links to the MCP specification for non‑English readers.
- **`awesome-mcp-clients`** (linked repository) — A collection of client implementations that demonstrate how to consume MCP servers according to the specification.

## Summary

- The **official specification** is hosted exclusively at **modelcontextprotocol.io**.
- MCP uses **JSON‑RPC 2.0** for all client-server communications, requiring standard fields like `jsonrpc`, `id`, `method`, and `params`.
- Servers must implement the **`tools/list`** method to advertise capabilities per the specification's tool definition schema.
- The `awesome-mcp-servers` repository references the specification in **[`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md)** at line 29, establishing it as the authoritative source.
- Both **Python** and **JavaScript** implementations must follow the exact request/response structures defined in the spec to ensure interoperability.

## Frequently Asked Questions

### Where is the official Model Context Protocol specification documented?

The official specification is hosted at **modelcontextprotocol.io**. This site contains the complete technical documentation for the protocol's JSON‑RPC communication model, tool schemas, and authentication requirements. The `awesome-mcp-servers` repository explicitly references this URL in the introductory section of [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md) at line 29 as the authoritative source for all listed implementations.

### What communication protocol does MCP use?

MCP utilizes a **JSON‑RPC 2.0** style communication model. All requests must include standard JSON‑RPC fields including `jsonrpc`, `id`, `method`, and `params`, as demonstrated in the specification's method call conventions. This standardization allows any compliant client to interact with any MCP server using predictable request/response patterns without custom adapters.

### How do I discover available tools on an MCP server?

Clients must send a JSON‑RPC request with the method **`tools/list`** to retrieve the server's capabilities. According to the specification, this endpoint returns a structured list of available tools with their parameter schemas, enabling dynamic discovery and invocation without hardcoded dependencies. The response format is strictly defined to ensure consistent parsing across different programming languages.

### What files in the awesome-mcp-servers repository reference the official spec?

The primary reference appears in **[`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README.md)** at line 29, where the introductory documentation links to modelcontextprotocol.io. Additionally, **[`CONTRIBUTING.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/CONTRIBUTING.md)** provides guidelines ensuring new server submissions conform to the official specification, while localized READMEs like **[`README-zh.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/README-zh.md)** preserve these critical links for international contributors. The linked **`awesome-mcp-clients`** repository further demonstrates practical implementations of the spec.