rust-mcp-schema 2.0.0

Type-safe implementation of the Model Context Protocol in Rust, designed to reduce errors and accelerate development with powerful utilities.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

<p align="center">
  <img width="200" src="./assets/rust-mcp-schema.png" alt="Description" width="300">
</p>

# Model Context Protocol (MCP) Schema for Rust

[<img alt="crates.io" src="https://img.shields.io/crates/v/rust-mcp-schema?style=for-the-badge&logo=rust&color=FE965D" height="22">](https://crates.io/crates/rust-mcp-schema)
[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-rust_mcp_schema-0ECDAB?style=for-the-badge&logo=docs.rs" height="22">](https://docs.rs/rust-mcp-schema/latest/rust_mcp_schema)
[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/rust-mcp-stack/rust-mcp-schema/ci.yml?style=for-the-badge" height="22">
](https://github.com/rust-mcp-stack/rust-mcp-schema/actions/workflows/ci.yml)

A type-safe Rust implementation of the official Model Context Protocol (MCP) schema, supporting all official MCP Protocol versions:

- `2026-07-28` (default)
- `2025-11-25`
- `2025-06-18`
- `2025-03-26`
- `2024-11-05`
- `draft`

The MCP schemas in this repository are [automatically generated](#how-are-schemas-generated) from the official Model Context Protocol, ensuring they are always up-to-date and aligned with the latest official specifications.

---

**Note:** This crate **only** provides an implementation of the MCP schema.

<img align="top" src="assets/rust-mcp-stack-icon.png" width="24" style="border-radius:0.2rem;"> If you are looking for a high-performance, asynchronous toolkit for building MCP servers and clients, checkout [rust-mcp-sdk](https://crates.io/crates/rust-mcp-sdk).
Focus on your app's logic while [rust-mcp-sdk](https://crates.io/crates/rust-mcp-sdk) takes care of the rest!

---

## Contents:

- [Features](#features)
- [How can this crate be used?](#how-can-this-crate-be-used)

- [Schema Versions](#schema-versions)
  - [How to switch between different schema versions?](#how-to-switch-between-different-schema-versions)
  - [How are Schemas generated?](#how-are-schemas-generated)
- [What is `schema_utils`?](#what-is-schema_utils)
- [What does the schema_utils do?](#what-does-the-schema_utils-do)
- [Usage Examples](#usage-examples)
  - [Detecting a CallToolRequest Message on an MCP Server](#detecting-a-calltoolrequest-message-on-an-mcp-server)
  - [Creating a CallToolResult Response on an MCP Server](#creating-a-calltoolresult-response-on-an-mcp-server)
  - [Detecting a CallToolResult Response Message in an MCP Client](#detecting-a-calltoolresult-response-message-in-an-mcp-client)
- [Usage Examples (Without Utilizing schema_utils)](#usage-examples-without-utilizing-schema_utils)

  - [Detecting a CallToolRequest Message on an MCP Server (without schema_utils)](#detecting-a-calltoolrequest-message-on-an-mcp-server-without-schema_utils)

- [Contributing](CONTRIBUTING.md)

## Features

- 🧩 Type-safe implementation of the MCP protocol specification.
- 💎 Auto-generated schemas are always synchronized with the official schema specifications.
- 📜 Includes all official released versions : `2026-07-28`, `2025-11-25`, `2025-06-18`, `2025-03-26`, `2024-11-05` and `draft` version for early adoption.
- 🛠 Complimentary schema utility module (schema_utils) to boost productivity and ensure development integrity.

## How can this crate be used?

This Crate provides Rust implementation of the official Model Context Protocol (MCP) schema.

Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you’re building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need.

This crate includes the schema with `serialization` / `deserialization` support via serde_json, along with a minimal implementation of the necessary traits for structs and enums. This helps in creating and using various MCP messages such as requests, responses, notifications, and errors.

This crate could be used for developing an **MCP Server** or **MCP Client** in Rust.
For more information on the MCP architecture, refer to the [official documentation](https://spec.modelcontextprotocol.io/specification).

---

<img align="top" src="assets/rust-mcp-stack-icon.png" width="24" style="border-radius:0.2rem;"> Check out [rust-mcp-sdk](https://crates.io/crates/rust-mcp-sdk) , a high-performance, asynchronous toolkit for building MCP servers and clients which is based on `rust-mcp-schema`. Focus on your app's logic while [rust-mcp-sdk](https://crates.io/crates/rust-mcp-sdk) takes care of the rest!

---

## Schema Versions

This repository provides all official released versions the schema , including draft version, enabling you to prepare and adapt your applications ahead of upcoming official schema releases.

- [2026-07-28](src/generated_schema/2026_07_28) (default)
- [2025-11-25](src/generated_schema/2025_11_25)
- [2025-06-18](src/generated_schema/2025_06_18)
- [2025-03-26](src/generated_schema/2025_03_26)
- [2024-11-05](src/generated_schema/2024_11_05)
- [draft](src/generated_schema/draft)

### How to switch between different schema versions?

By default, the latest version of the MCP Protocol schema is enabled.

Each schema version has a corresponding Cargo feature that can be enabled in your project's Cargo.toml.

Multiple schema versions may be enabled concurrently if needed. Non-default versions are available under explicitly named modules, for example:

- rust_mcp_schema::mcp_2025_06_18
- rust_mcp_schema::mcp_2025_11_25

> 📌 Note: the three most recent schemas (`2026_07_28`, `2025_11_25` and `draft`) are also re-exported at the crate root and are therefore **mutually exclusive** — enable at most one of them at a time. Older versions (`2025_06_18`, `2025_03_26`, `2024_11_05`) are module-only and can be combined with any one of them.

Example: enable `2025-06-18` version of the schema:

<!-- x-release-please-start-version -->

```toml
# Cargo.toml
rust-mcp-schema = { version: 2.0.0 , default-features = false, features=["2025_06_18"] }
```

Example: enable `draft`` version of the schema :

```toml
#Cargo.toml
rust-mcp-schema = { version: 2.0.0 , default-features = false, features=["draft"] }
```

<!-- x-release-please-end -->

## How are Schemas generated?

Schemas are generated from the official `schema.ts` and `schema.json` files available in the original [Model Context Protocol (MCP) repository](https://github.com/modelcontextprotocol/specification/tree/main/schema).

Using a customized version of [typify](https://github.com/oxidecomputer/typify), along with additional pre-processing and post-processing steps, the schema specifications are transformed into Rust code.

### 📌 Note

> The code used to generate schemas from `schema.ts` and `schema.json` is not included in this repository. However, I am considering making it available as a CLI tool in the future, allowing developers to generate MCP schemas as Rust code that can be directly integrated into their projects.

## What is `schema_utils`?

The Rust implementations of the MCP schemas in this crate are automatically generated from the official MCP GitHub repository.

[mcp_schema.rs](src/generated_schema/2026_07_28/mcp_schema.rs) provides all the core structures and enums with serialization/deserialization support, allowing you to use them as needed and extend their functionality.

To streamline development, improve compile-time type checking, and reduce the potential for errors, we’ve implemented utility types and functions that offer more strongly-typed objects and implementations, all without modifying the originally generated schema.

Please refer to [schema_utils.rs](src/generated_schema/2026_07_28/schema_utils.rs) for more details.

### 📌 Note

> Using schema_utils is optional. It is enabled by default through the schema_utils Cargo feature and can be used from `rust_mcp_schema::schema_utils`.

> If you prefer not to use schema_utils, you can directly work with the enums and structs provided in [mcp_schema.rs](src/generated_schema/2026_07_28/mcp_schema.rs), adapting them to your needs and creating your own utility types and functions around them.

Visit [Usage Examples (Without `Using schema_utils`)](#usage-examples-without-utilizing-schema_utils) to see an alternative approach.

### What does the schema_utils do?

The official schema defines a unified `JsonrpcMessage` type that encompasses all messages and notifications within the MCP protocol.

To enhance type safety and usability, `schema_utils` divides JsonrpcMessage into two distinct categories: `ClientMessage` and `ServerMessage`. Each category includes the relevant types for both standard and custom messages.

Please refer to [schema_utils.rs](src/generated_schema/2026_07_28/schema_utils.rs) and the [Usage Examples](usage-examples) section for more details.

## Usage Examples

:point_right: The following examples focus solely on the serialization and deserialization of schema messages, assuming the JSON-RPC message has already been received in the application as a string.

### Detecting a `CallToolRequest` Message on an MCP Server

The following code snippet demonstrates how an MCP message, represented as a JSON string, can be deserialized into a ClientMessage and how to identify it as a CallToolRequest message.

> Note: ClientMessage represents MCP messages sent from an MCP client. The following code demonstrates how an MCP server can deserialize received messages from an MCP client.

```rs

pub fn handle_message(message_payload: &str) -> std::result::Result<(), RpcError> {
    // Deserialize message into ClientMessage.
    let message = ClientMessage::from_str(message_payload)?;

    // Check if the message is a Request
    if let ClientMessage::Request(client_request) = message {
        // Requests delegate to the schema-generated `ClientRequest` enum via `ClientJsonrpcRequest::Known`
        if let ClientJsonrpcRequest::Known(ClientRequest::CallToolRequest(call_tool_request)) = client_request {
            // Process the CallToolRequest (and eventually send a CallToolResult back to the client)
            handle_call_tool_request(call_tool_request);
        }
    }
    Ok(())
}

```

Refer to [examples/mcp_server_handle_message.rs](examples/mcp_server_handle_message.rs) for a complete match implementation that handles all possible `ClientMessage` variants.

### Creating a `CallToolResult` Response on an MCP Server.

In response to a CallToolRequest, the MCP Server is expected to return a CallToolResult message.

This code snippet demonstrates how to create a CallToolResult, serialize it into a string, and send it back to the client via the transport layer.

```rs
    // create a CallToolResult object (the builder sets `resultType: "complete"`)
    let tool_result = CallToolResult::text_content(vec![TextContent::new(
        "Sunny, 22°C in Paris.".to_string(),
        None,
        None,
    )]);

    // wrap it in a JSON-RPC response envelope addressed to the request's `id`
    let message = ServerJsonrpcResponse::new(RequestId::Integer(0), tool_result.into());

    // Serialize the MCP message into a valid JSON string for sending to the client
    let json_payload = serde_json::to_string(&message).unwrap();

    println!("{}", json_payload);
```

output:

```json
{
  "id": 0,
  "jsonrpc": "2.0",
  "result": {
    "content": [{ "type": "text", "text": "Sunny, 22°C in Paris." }],
    "resultType": "complete"
  }
}
```

### Detecting a `CallToolResult` Response Message in an MCP Client:

```rs
fn handle_message(message_payload: &str) -> std::result::Result<(), AppError> {
    // Deserialize message into ServerMessage.
    // ServerMessage represents a message sent by an MCP Server and received by an MCP Client.
    let mcp_message = ServerMessage::from_str(message_payload)?;

    // Check if the message is a Response type of message
    if let ServerMessage::Response(server_response) = mcp_message {
        // Check if it's a CallToolResult response
        if let ServerResult::CallToolResult(call_tool_result) = &server_response.result {
            // Process the CallToolResult
            handle_call_tool_result(call_tool_result);
        }
    }
    Ok(())
}
```

Refer to [mcp_client_handle_message.rs](examples/mcp_client_handle_message.rs) for a complete match implementation that handles all possible `ServerMessage` variants.

## Usage Examples (Without Utilizing `schema_utils`)

If you prefer not to use schema_utils, you can directly work with the generated types in your application or build custom utilities around them.

### Detecting a CallToolRequest Message on an MCP Server (without schema_utils)

The following code example illustrates how to detect a CallToolRequest message on an MCP server:

```rs

fn handle_message(message_payload: &str) -> std::result::Result<(), AppError> {
    // Deserialize the JSON-RPC payload directly into ClientRequest.
    // Its `Deserialize` impl dispatches on the `method` field.
    let client_request: ClientRequest = serde_json::from_str(message_payload).unwrap();

    // Check it's a "tools/call" request
    if let ClientRequest::CallToolRequest(call_tool_request) = client_request {
        // Now that we can handle the message, we simply print out the details.
        println!("CallTool request received!");

        println!("Tool name : {:?} ", call_tool_request.params.name);
        println!("Arguments : {:?} ", call_tool_request.params.arguments);
    }

    Ok(())
}
```

## Contributing

We welcome everyone who wishes to contribute! Please refer to the [contributing guidelines](CONTRIBUTING.md) for more details.

All contributions, including issues and pull requests, must follow
[Rust's Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct).

Unless explicitly stated otherwise, any contribution you submit for inclusion in `rust-mcp-schema` is provided under the terms of the MIT License, without any additional conditions or restrictions.