redisctl-mcp 0.8.3

MCP (Model Context Protocol) server for Redis Cloud and Enterprise
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

//! Cluster service management tools for Redis Enterprise

use serde_json::Value;
use tower_mcp::{CallToolResult, ResultExt};

use crate::tools::macros::{enterprise_tool, mcp_module};
use crate::tools::wrap_list;

mcp_module! {
    list_services => "list_enterprise_services",
    get_service => "get_enterprise_service",
    get_service_status => "get_enterprise_service_status",
    update_service => "update_enterprise_service",
    start_service => "start_enterprise_service",
    stop_service => "stop_enterprise_service",
    restart_service => "restart_enterprise_service",
}

enterprise_tool!(read_only, list_services, "list_enterprise_services",
    "List all cluster services.",
    {} => |client, _input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let services = handler
            .list()
            .await
            .tool_context("Failed to list services")?;

        wrap_list("services", &services)
    }
);

enterprise_tool!(read_only, get_service, "get_enterprise_service",
    "Get service details by ID.",
    {
        /// Service ID (e.g., "cm_server", "mdns_server", "stats_archiver")
        pub service_id: String,
    } => |client, input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let service = handler
            .get(&input.service_id)
            .await
            .tool_context("Failed to get service")?;

        CallToolResult::from_serialize(&service)
    }
);

enterprise_tool!(read_only, get_service_status, "get_enterprise_service_status",
    "Get service status including per-node status.",
    {
        /// Service ID
        pub service_id: String,
    } => |client, input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let status = handler
            .status(&input.service_id)
            .await
            .tool_context("Failed to get service status")?;

        CallToolResult::from_serialize(&status)
    }
);

enterprise_tool!(write, update_service, "update_enterprise_service",
    "Update a service's configuration. Pass fields as JSON.",
    {
        /// Service ID to update
        pub service_id: String,
        /// Updated service configuration as JSON (e.g., enabled, config, node_uids)
        pub config: Value,
    } => |client, input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let request = serde_json::from_value(input.config)
            .map_err(|e| tower_mcp::Error::tool(format!("Invalid service config: {}", e)))?;
        let result = handler
            .update(&input.service_id, request)
            .await
            .tool_context("Failed to update service")?;

        CallToolResult::from_serialize(&result)
    }
);

enterprise_tool!(write, start_service, "start_enterprise_service",
    "Start a stopped service.",
    {
        /// Service ID
        pub service_id: String,
    } => |client, input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let result = handler
            .start(&input.service_id)
            .await
            .tool_context("Failed to start service")?;

        CallToolResult::from_serialize(&result)
    }
);

enterprise_tool!(write, stop_service, "stop_enterprise_service",
    "Stop a running service.",
    {
        /// Service ID
        pub service_id: String,
    } => |client, input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let result = handler
            .stop(&input.service_id)
            .await
            .tool_context("Failed to stop service")?;

        CallToolResult::from_serialize(&result)
    }
);

enterprise_tool!(write, restart_service, "restart_enterprise_service",
    "Restart a service (stop then start).",
    {
        /// Service ID
        pub service_id: String,
    } => |client, input| {
        let handler = redis_enterprise::services::ServicesHandler::new(client);
        let result = handler
            .restart(&input.service_id)
            .await
            .tool_context("Failed to restart service")?;

        CallToolResult::from_serialize(&result)
    }
);