systemprompt-mcp 0.2.0

Core MCP (Model Context Protocol) functionality for systemprompt.io OS
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

use anyhow::Result;
use std::path::{Path, PathBuf};
use systemprompt_loader::ExtensionRegistry;
use systemprompt_models::Config;
use systemprompt_models::mcp::McpServerType;

use crate::services::deployment::DeploymentService;

#[derive(Debug, Clone, Copy)]
pub struct RegistryService;

impl RegistryService {
    pub fn get_enabled_servers_as_config() -> Result<Vec<crate::McpServerConfig>> {
        use systemprompt_loader::ConfigLoader;

        let global_config = Config::get()?;
        let registry = ExtensionRegistry::build(
            Path::new(&global_config.system_path),
            global_config.is_cloud,
            &global_config.bin_path,
        );
        let services_config = ConfigLoader::load()?;
        let mut enabled = Vec::new();

        let mut server_names: Vec<_> = services_config.mcp_servers.keys().collect();
        server_names.sort();

        for server_name in server_names {
            let deployment = &services_config.mcp_servers[server_name];
            if !deployment.enabled {
                continue;
            }
            if deployment.dev_only && global_config.is_cloud {
                continue;
            }

            let crate_path = match deployment.server_type {
                McpServerType::Internal => registry.get_path(&deployment.binary)?,
                McpServerType::External => PathBuf::new(),
            };

            let display_name = deployment
                .package
                .clone()
                .unwrap_or_else(|| deployment.binary.clone());

            let config = crate::McpServerConfig {
                name: server_name.clone(),
                server_type: deployment.server_type,
                binary: deployment.binary.clone(),
                enabled: deployment.enabled,
                display_in_web: deployment.display_in_web,
                port: deployment.port,
                crate_path,
                display_name: display_name.clone(),
                description: format!("{display_name} MCP Server"),
                capabilities: vec![],
                schemas: deployment.schemas.clone(),
                oauth: deployment.oauth.clone(),
                tools: deployment.tools.clone(),
                model_config: deployment.model_config.clone(),
                env_vars: deployment.env_vars.clone(),
                version: env!("CARGO_PKG_VERSION").to_string(),
                host: "0.0.0.0".to_string(),
                module_name: "mcp".to_string(),
                protocol: "mcp".to_string(),
                remote_endpoint: deployment.endpoint.clone(),
            };
            enabled.push(config);
        }

        Ok(enabled)
    }

    pub fn validate_registry() -> Result<()> {
        DeploymentService::validate_config()?;
        Ok(())
    }
}