mcp-postgres 1.0.0

High-performance MCP server for PostgreSQL with lock-free connection pool
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

use serde_json::{json, Value};
use tokio_postgres::Client;
use crate::errors::Result as MCPResult;

/// 31. Show all settings
pub async fn show_all_settings(client: &Client, _params: Option<Value>) -> MCPResult<Value> {
    let rows = client
        .query(
            "SELECT name, setting, unit, short_desc, context
             FROM pg_settings
             WHERE context NOT LIKE 'internal%'
             ORDER BY name",
            &[],
        )
        .await?;

    let settings: Vec<Value> = rows
        .iter()
        .map(|row| {
            json!({
                "name": row.get::<_, String>(0),
                "value": row.get::<_, Option<String>>(1),
                "unit": row.get::<_, Option<String>>(2),
                "description": row.get::<_, String>(3),
                "context": row.get::<_, String>(4),
            })
        })
        .collect();

    Ok(json!({ "settings": settings }))
}

/// 32. Get setting
pub async fn get_setting(client: &Client, params: Option<Value>) -> MCPResult<Value> {
    let setting_name = params
        .and_then(|p| p.get("setting").and_then(|v| v.as_str()).map(|s| s.to_string()))
        .ok_or_else(|| crate::errors::MCPError::InvalidParams("Missing 'setting' parameter".into()))?;

    let rows = client
        .query(
            "SELECT name, setting, unit, short_desc, context, vartype, source
             FROM pg_settings
             WHERE name = $1",
            &[&setting_name],
        )
        .await?;

    if rows.is_empty() {
        return Err(crate::errors::MCPError::InvalidParams(format!("Setting not found: {}", setting_name)));
    }

    let row = &rows[0];

    Ok(json!({
        "name": row.get::<_, String>(0),
        "value": row.get::<_, Option<String>>(1),
        "unit": row.get::<_, Option<String>>(2),
        "description": row.get::<_, String>(3),
        "context": row.get::<_, String>(4),
        "type": row.get::<_, String>(5),
        "source": row.get::<_, String>(6),
    }))
}

/// 33. Show memory settings
pub async fn show_memory_settings(client: &Client, _params: Option<Value>) -> MCPResult<Value> {
    let rows = client
        .query(
            "SELECT name, setting, unit
             FROM pg_settings
             WHERE name IN ('shared_buffers', 'effective_cache_size', 'work_mem',
                           'maintenance_work_mem', 'wal_buffers', 'random_page_cost',
                           'effective_io_concurrency')
             ORDER BY name",
            &[],
        )
        .await?;

    let settings: Vec<Value> = rows
        .iter()
        .map(|row| {
            json!({
                "name": row.get::<_, String>(0),
                "value": row.get::<_, Option<String>>(1),
                "unit": row.get::<_, Option<String>>(2),
            })
        })
        .collect();

    Ok(json!({ "memory_settings": settings }))
}

/// 34. Show performance settings
pub async fn show_performance_settings(client: &Client, _params: Option<Value>) -> MCPResult<Value> {
    let rows = client
        .query(
            "SELECT name, setting, unit
             FROM pg_settings
             WHERE name IN ('max_connections', 'checkpoint_timeout', 'checkpoint_completion_target',
                           'wal_level', 'max_wal_senders', 'wal_keep_size', 'synchronous_commit',
                           'constraint_exclusion')
             ORDER BY name",
            &[],
        )
        .await?;

    let settings: Vec<Value> = rows
        .iter()
        .map(|row| {
            json!({
                "name": row.get::<_, String>(0),
                "value": row.get::<_, Option<String>>(1),
                "unit": row.get::<_, Option<String>>(2),
            })
        })
        .collect();

    Ok(json!({ "performance_settings": settings }))
}

/// 35. Show log settings
pub async fn show_log_settings(client: &Client, _params: Option<Value>) -> MCPResult<Value> {
    let rows = client
        .query(
            "SELECT name, setting, unit
             FROM pg_settings
             WHERE name LIKE 'log%'
             ORDER BY name",
            &[],
        )
        .await?;

    let settings: Vec<Value> = rows
        .iter()
        .map(|row| {
            json!({
                "name": row.get::<_, String>(0),
                "value": row.get::<_, Option<String>>(1),
                "unit": row.get::<_, Option<String>>(2),
            })
        })
        .collect();

    Ok(json!({ "log_settings": settings }))
}