contextvm-sdk 0.1.1

Rust SDK for the ContextVM protocol — MCP over Nostr
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

//! Example: Expose an echo MCP tool via Nostr gateway.
//!
//! This demonstrates how to create a ContextVM gateway that receives
//! MCP requests over Nostr and responds to them.
//!
//! Usage: cargo run --example gateway

use contextvm_sdk::core::types::*;
use contextvm_sdk::gateway::{GatewayConfig, NostrMCPGateway};
use contextvm_sdk::signer;
use contextvm_sdk::transport::server::NostrServerTransportConfig;

#[tokio::main]
async fn main() -> contextvm_sdk::Result<()> {
    tracing_subscriber::fmt::init();

    // Generate ephemeral keys for this session
    let keys = signer::generate();
    println!("Server pubkey: {}", keys.public_key().to_hex());

    // Configure the gateway
    let nostr_config = NostrServerTransportConfig::default()
        .with_server_info(
            ServerInfo::default()
                .with_name("Echo Server")
                .with_about("A simple echo tool exposed via ContextVM"),
        )
        .with_announced_server(true);
    let config = GatewayConfig::new(nostr_config);

    let mut gateway = NostrMCPGateway::new(keys, config).await?;
    let mut rx = gateway.start().await?;

    // Publish server announcement
    let announcement_id = gateway.announce().await?;
    println!("Published announcement: {announcement_id}");

    println!("Gateway running. Waiting for requests...");

    // Process incoming requests
    while let Some(req) = rx.recv().await {
        println!(
            "Request from {}: {:?}",
            &req.client_pubkey[..8],
            req.message.method()
        );

        let response = match &req.message {
            JsonRpcMessage::Request(r) => match r.method.as_str() {
                "initialize" => JsonRpcMessage::Response(JsonRpcResponse {
                    jsonrpc: "2.0".to_string(),
                    id: r.id.clone(),
                    result: serde_json::json!({
                        "protocolVersion": "2024-11-05",
                        "capabilities": { "tools": {} },
                        "serverInfo": { "name": "Echo Server", "version": "0.1.0" }
                    }),
                }),
                "tools/list" => JsonRpcMessage::Response(JsonRpcResponse {
                    jsonrpc: "2.0".to_string(),
                    id: r.id.clone(),
                    result: serde_json::json!({
                        "tools": [{
                            "name": "echo",
                            "description": "Echoes back the input message",
                            "inputSchema": {
                                "type": "object",
                                "properties": {
                                    "message": { "type": "string", "description": "Message to echo" }
                                },
                                "required": ["message"]
                            }
                        }]
                    }),
                }),
                "tools/call" => {
                    let message = r
                        .params
                        .as_ref()
                        .and_then(|p| p.get("arguments"))
                        .and_then(|a| a.get("message"))
                        .and_then(|m| m.as_str())
                        .unwrap_or("(no message)");

                    JsonRpcMessage::Response(JsonRpcResponse {
                        jsonrpc: "2.0".to_string(),
                        id: r.id.clone(),
                        result: serde_json::json!({
                            "content": [{ "type": "text", "text": format!("Echo: {message}") }]
                        }),
                    })
                }
                _ => JsonRpcMessage::ErrorResponse(JsonRpcErrorResponse {
                    jsonrpc: "2.0".to_string(),
                    id: r.id.clone(),
                    error: JsonRpcError {
                        code: -32601,
                        message: "Method not found".to_string(),
                        data: None,
                    },
                }),
            },
            // Ignore notifications
            _ => continue,
        };

        gateway.send_response(&req.event_id, response).await?;
    }

    Ok(())
}