mcpr 0.1.0

Rust implementation of Anthropic's Model Context Protocol
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

//! Transport layer for MCP communication

use crate::error::MCPError;
use serde::{de::DeserializeOwned, Serialize};
use std::io;

/// Transport trait for MCP communication
pub trait Transport {
    /// Send a message
    fn send<T: Serialize>(&mut self, message: &T) -> Result<(), MCPError>;

    /// Receive a message
    fn receive<T: DeserializeOwned>(&mut self) -> Result<T, MCPError>;
}

/// Async transport trait for MCP communication
#[cfg(feature = "async")]
pub trait AsyncTransport {
    /// Send a message asynchronously
    async fn send<T: Serialize>(&mut self, message: &T) -> Result<(), MCPError>;

    /// Receive a message asynchronously
    async fn receive<T: DeserializeOwned>(&mut self) -> Result<T, MCPError>;
}

/// Standard IO transport
pub mod stdio {
    use super::*;
    use std::io::{BufRead, BufReader, Write};

    /// Standard IO transport
    pub struct StdioTransport {
        reader: BufReader<Box<dyn io::Read>>,
        writer: Box<dyn io::Write>,
    }

    impl Default for StdioTransport {
        fn default() -> Self {
            Self::new()
        }
    }

    impl StdioTransport {
        /// Create a new stdio transport using stdin and stdout
        pub fn new() -> Self {
            Self {
                reader: BufReader::new(Box::new(io::stdin())),
                writer: Box::new(io::stdout()),
            }
        }

        /// Create a new stdio transport with custom reader and writer
        pub fn with_reader_writer(reader: Box<dyn io::Read>, writer: Box<dyn io::Write>) -> Self {
            Self {
                reader: BufReader::new(reader),
                writer,
            }
        }
    }

    impl Transport for StdioTransport {
        fn send<T: Serialize>(&mut self, message: &T) -> Result<(), MCPError> {
            let json = serde_json::to_string(message)?;
            writeln!(self.writer, "{}", json).map_err(|e| MCPError::Transport(e.to_string()))?;
            self.writer
                .flush()
                .map_err(|e| MCPError::Transport(e.to_string()))?;
            Ok(())
        }

        fn receive<T: DeserializeOwned>(&mut self) -> Result<T, MCPError> {
            let mut line = String::new();
            self.reader
                .read_line(&mut line)
                .map_err(|e| MCPError::Transport(e.to_string()))?;
            let message = serde_json::from_str(&line)?;
            Ok(message)
        }
    }
}

/// WebSocket transport
pub mod websocket {
    // To be implemented
}