mistralrs-mcp 0.8.1

MCP (Model Context Protocol) client for mistral.rs
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

use serde::{Deserialize, Serialize};
use std::{collections::HashMap, fmt::Display};

/// OpenAI-compatible tool schema for MCP tools
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolSchema {
    #[serde(rename = "type")]
    pub tool_type: String,
    pub function: McpFunctionSchema,
}

/// Function schema for MCP tools
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpFunctionSchema {
    pub name: String,
    pub description: Option<String>,
    pub parameters: serde_json::Value,
}

/// MCP tool call result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpToolResult {
    pub content: Vec<McpContent>,
    pub is_error: Option<bool>,
}

/// MCP content types
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum McpContent {
    #[serde(rename = "text")]
    Text { text: String },
    #[serde(rename = "image")]
    Image { data: String, mime_type: String },
    #[serde(rename = "resource")]
    Resource { resource: McpResourceReference },
}

/// Reference to an MCP resource
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpResourceReference {
    pub uri: String,
    pub text: Option<String>,
}

/// MCP server capabilities
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpServerCapabilities {
    pub tools: Option<HashMap<String, serde_json::Value>>,
    pub resources: Option<HashMap<String, serde_json::Value>>,
    pub prompts: Option<HashMap<String, serde_json::Value>>,
    pub logging: Option<HashMap<String, serde_json::Value>>,
}

/// MCP initialization result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpInitResult {
    pub protocol_version: String,
    pub capabilities: McpServerCapabilities,
    pub server_info: McpServerInfo,
}

/// MCP server information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpServerInfo {
    pub name: String,
    pub version: String,
}

impl From<crate::McpToolInfo> for McpToolSchema {
    fn from(tool_info: crate::McpToolInfo) -> Self {
        Self {
            tool_type: "function".to_string(),
            function: McpFunctionSchema {
                name: tool_info.name,
                description: tool_info.description,
                parameters: tool_info.input_schema,
            },
        }
    }
}

impl Display for McpToolResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let res = self
            .content
            .iter()
            .map(|content| match content {
                McpContent::Text { text } => text.clone(),
                McpContent::Image { mime_type, .. } => {
                    format!("[Image: {mime_type}]")
                }
                McpContent::Resource { resource } => resource
                    .text
                    .clone()
                    .unwrap_or_else(|| format!("[Resource: {}]", resource.uri)),
            })
            .collect::<Vec<_>>()
            .join("\n");

        write!(f, "{res}")
    }
}