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
//! The official Rust SDK for the Model Context Protocol (MCP).
//!
//! The MCP is a protocol that allows AI assistants to communicate with other
//! services. `rmcp` is the official Rust implementation of this protocol.
//!
//! There are two ways in which the library can be used, namely to build a
//! server or to build a client.
//!
//! ## Server
//!
//! A server is a service that exposes capabilities. For example, a common
//! use-case is for the server to make multiple tools available to clients such
//! as Claude Desktop or the Cursor IDE.
//!
//! For example, to implement a server that has a tool that can count, you would
//! make an object for that tool and add an implementation with the `#[tool(tool_box)]` macro:
//!
//! ```rust
//! use std::sync::Arc;
//! use rmcp::{Error as McpError, model::*, tool};
//! use tokio::sync::Mutex;
//!
//! #[derive(Clone)]
//! pub struct Counter {
//! counter: Arc<Mutex<i32>>,
//! }
//!
//! #[tool(tool_box)]
//! impl Counter {
//! fn new() -> Self {
//! Self {
//! counter: Arc::new(Mutex::new(0)),
//! }
//! }
//!
//! #[tool(description = "Increment the counter by 1")]
//! async fn increment(&self) -> Result<CallToolResult, McpError> {
//! let mut counter = self.counter.lock().await;
//! *counter += 1;
//! Ok(CallToolResult::success(vec![Content::text(
//! counter.to_string(),
//! )]))
//! }
//! }
//! ```
//!
//! Next also implement [ServerHandler] for `Counter` and start the server inside
//! `main` by calling `Counter::new().serve(...)`. See the examples directory in the repository for more information.
//!
//! ## Client
//!
//! A client can be used to interact with a server. Clients can be used to get a
//! list of the available tools and to call them. For example, we can `uv` to
//! start a MCP server in Python and then list the tools and call `git status`
//! as follows:
//!
//! ```rust
//! use anyhow::Result;
//! use rmcp::{model::CallToolRequestParam, service::ServiceExt, transport::{TokioChildProcess, ConfigureCommandExt}};
//! use tokio::process::Command;
//!
//! async fn client() -> Result<()> {
//! let service = ().serve(TokioChildProcess::new(Command::new("uvx").configure(|cmd| {
//! cmd.arg("mcp-server-git");
//! }))?).await?;
//!
//! // Initialize
//! let server_info = service.peer_info();
//! println!("Connected to server: {server_info:#?}");
//!
//! // List tools
//! let tools = service.list_tools(Default::default()).await?;
//! println!("Available tools: {tools:#?}");
//!
//! // Call tool 'git_status' with arguments = {"repo_path": "."}
//! let tool_result = service
//! .call_tool(CallToolRequestParam {
//! name: "git_status".into(),
//! arguments: serde_json::json!({ "repo_path": "." }).as_object().cloned(),
//! })
//! .await?;
//! println!("Tool result: {tool_result:#?}");
//!
//! service.cancel().await?;
//! Ok(())
//! }
//! ```
pub use Error;
/// Basic data types in MCP specification
pub use ClientHandler;
pub use ServerHandler;
pub use ;
pub use ;
pub use ;
// re-export
pub use paste;
pub use tool;
pub use schemars;
pub use serde;
pub use serde_json;