Mcp integration

Cargo.toml

@@ -102,6 +102,7 @@ criterion = "0.5"
 crossbeam-channel = "0.5.15"
 crossterm = "0.28.1"
 darling = "0.20.11"
+dashmap = "7.0.0-rc2"
 derive_more = { version = "2.0.1", features = ["display", "into", "from_str"] }
 desert_rust = { version = "0.1.7", features = ["bigdecimal", "uuid", "chrono", "nonempty-collections", "serde-json", "bit-vec", "url", "mac_address"] }
 dir-diff = "0.3.3"
@@ -205,6 +206,7 @@ regex = "1.11.1"
 reqwest = { version = "0.12.13", features = ["gzip", "json", "multipart", "stream", ] }
 ringbuf = "0.4.7"
 rlimit = "0.10.2"
+rmcp = {version = "0.16.0", features = ["server", "transport-streamable-http-server"] }
 rsa = "0.9.7"
 
 rustc-hash = "2.1.1"

cli/golem-cli/src/client.rs

@@ -20,7 +20,7 @@ use golem_client::api::{
     ApiDeploymentClientLive, ApiDomainClientLive, ApiSecurityClientLive, ApplicationClientLive,
     ComponentClientLive, DeploymentClientLive, EnvironmentClientLive, GrantClientLive,
     HealthCheckClientLive, HttpApiDefinitionClientLive, LimitsClientLive, LoginClientLive,
-    PluginClientLive, TokenClientLive, WorkerClientLive,
+    McpDeploymentClientLive, PluginClientLive, TokenClientLive, WorkerClientLive,
 };
 use golem_client::{Context as ClientContext, Security};
 use golem_common::model::account::AccountId;
@@ -47,6 +47,7 @@ pub struct GolemClients {
     pub grant: GrantClientLive,
     pub limits: LimitsClientLive,
     pub login: LoginClientLive,
+    pub mcp_deployment: McpDeploymentClientLive,
     pub plugin: PluginClientLive,
     pub token: TokenClientLive,
     pub worker: WorkerClientLive,
@@ -159,6 +160,9 @@ impl GolemClients {
             login: LoginClientLive {
                 context: login_context(),
             },
+            mcp_deployment: McpDeploymentClientLive {
+                context: registry_context(),
+            },
             plugin: PluginClientLive {
                 context: registry_context(),
             },

cli/golem-cli/src/command.rs

@@ -1573,6 +1573,10 @@ pub mod server {
         #[clap(long)]
         pub custom_request_port: Option<u16>,
 
+        /// Port to serve custom requests on, defaults to 9006
+        #[clap(long)]
+        pub mcp_port: Option<u16>,
+
         /// Directory to store data in. Defaults to $XDG_STATE_HOME/golem
         #[clap(long)]
         pub data_dir: Option<PathBuf>,
@@ -1594,6 +1598,9 @@ pub mod server {
         pub fn custom_request_port(&self) -> u16 {
             self.custom_request_port.unwrap_or(9006)
         }
+        pub fn mcp_port(&self) -> u16 {
+            self.mcp_port.unwrap_or(9007)
+        }
     }
 
     #[derive(Debug, Subcommand)]

cli/golem-cli/src/command_handler/api/deployment.rs

@@ -18,10 +18,10 @@ use crate::context::Context;
 use crate::error::service::{AnyhowMapServiceError, ServiceError};
 use crate::log::{log_action, log_warn_action, LogColorize, LogIndent};
 use crate::model::environment::{EnvironmentResolveMode, ResolvedEnvironmentIdentity};
-use crate::model::http_api::HttpApiDeploymentDeployProperties;
+use crate::model::http_api::{HttpApiDeploymentDeployProperties, McpDeploymentDeployProperties};
 use crate::model::text::http_api_deployment::HttpApiDeploymentGetView;
 use anyhow::{anyhow, bail};
-use golem_client::api::ApiDeploymentClient;
+use golem_client::api::{ApiDeploymentClient, McpDeploymentClient};
 use golem_common::cache::SimpleCache;
 use golem_common::model::deployment::DeploymentPlanHttpApiDeploymentEntry;
 use golem_common::model::diff;
@@ -158,6 +158,34 @@ impl ApiDeploymentCommandHandler {
             .unwrap_or_default())
     }
 
+    pub async fn deployable_manifest_mcp_deployments(
+        &self,
+        environment_name: &EnvironmentName,
+    ) -> anyhow::Result<BTreeMap<Domain, crate::model::http_api::McpDeploymentDeployProperties>>
+    {
+        let app_ctx = self.ctx.app_context_lock().await;
+        let app_ctx = app_ctx.some_or_err()?;
+        Ok(app_ctx
+            .application()
+            .mcp_deployments(environment_name)
+            .map(
+                |deployments: &BTreeMap<
+                    golem_common::model::domain_registration::Domain,
+                    crate::model::app::WithSource<
+                        crate::model::http_api::McpDeploymentDeployProperties,
+                    >,
+                >| {
+                    deployments
+                        .iter()
+                        .map(|(domain, mcp_deployment)| {
+                            (domain.clone(), mcp_deployment.value.clone())
+                        })
+                        .collect::<BTreeMap<_, _>>()
+                },
+            )
+            .unwrap_or_default())
+    }
+
     pub async fn get_http_api_deployment_revision_by_id(
         &self,
         http_api_deployment_id: &HttpApiDeploymentId,
@@ -337,4 +365,152 @@ impl ApiDeploymentCommandHandler {
 
         Ok(())
     }
+
+    pub async fn create_staged_mcp_deployment(
+        &self,
+        environment_id: &ResolvedEnvironmentIdentity,
+        domain: &Domain,
+        deployable_mcp_deployment: &McpDeploymentDeployProperties,
+    ) -> anyhow::Result<()> {
+        let clients = self.ctx.golem_clients().await?;
+
+        log_action(
+            "Creating",
+            format!("MCP deployment {}", domain.0.log_color_highlight()),
+        );
+        let _indent = LogIndent::new();
+
+        let agents = deployable_mcp_deployment
+            .agents
+            .iter()
+            .map(|(k, _v)| {
+                (
+                    k.clone(),
+                    golem_common::model::mcp_deployment::McpDeploymentAgentOptions::default(),
+                )
+            })
+            .collect();
+
+        let mcp_creation = golem_common::model::mcp_deployment::McpDeploymentCreation {
+            domain: domain.clone(),
+            agents,
+        };
+
+        let create = async || {
+            clients
+                .mcp_deployment
+                .create_mcp_deployment(&environment_id.environment_id.0, &mcp_creation)
+                .await
+                .map_err(ServiceError::from)
+        };
+
+        let deployment = match create().await {
+            Ok(result) => Ok(result),
+            Err(err) if err.is_domain_is_not_registered() => {
+                self.ctx
+                    .api_domain_handler()
+                    .register_missing_domain(&environment_id.environment_id, domain)
+                    .await?;
+
+                create().await
+            }
+            Err(err) => Err(err),
+        }?;
+
+        log_action(
+            "Created",
+            format!(
+                "MCP deployment revision: {} {}",
+                deployment.domain.0.log_color_highlight(),
+                deployment.revision.to_string().log_color_highlight()
+            ),
+        );
+
+        Ok(())
+    }
+
+    pub async fn delete_staged_mcp_deployment(
+        &self,
+        mcp_deployment: &golem_common::model::deployment::DeploymentPlanMcpDeploymentEntry,
+    ) -> anyhow::Result<()> {
+        log_warn_action(
+            "Deleting",
+            format!(
+                "MCP deployment {}",
+                mcp_deployment.domain.0.log_color_highlight()
+            ),
+        );
+        let _indent = LogIndent::new();
+
+        self.ctx
+            .golem_clients()
+            .await?
+            .mcp_deployment
+            .delete_mcp_deployment(&mcp_deployment.id.0, mcp_deployment.revision.into())
+            .await
+            .map_service_error()?;
+
+        log_action(
+            "Deleted",
+            format!(
+                "MCP deployment revision: {} {}",
+                mcp_deployment.domain.0.log_color_highlight(),
+                mcp_deployment.revision.to_string().log_color_highlight()
+            ),
+        );
+
+        Ok(())
+    }
+
+    pub async fn update_staged_mcp_deployment(
+        &self,
+        mcp_deployment: &golem_common::model::deployment::DeploymentPlanMcpDeploymentEntry,
+        update: &golem_common::model::mcp_deployment::McpDeploymentUpdate,
+        diff: &diff::DiffForHashOf<diff::McpDeployment>,
+    ) -> anyhow::Result<()> {
+        log_action(
+            "Updating",
+            format!(
+                "MCP deployment {}",
+                mcp_deployment.domain.0.log_color_highlight()
+            ),
+        );
+        let _indent = LogIndent::new();
+
+        let agents_changed = match diff {
+            diff::DiffForHashOf::HashDiff { .. } => true,
+            diff::DiffForHashOf::ValueDiff { diff } => !diff.agents_changes.is_empty(),
+        };
+
+        let deployment = self
+            .ctx
+            .golem_clients()
+            .await?
+            .mcp_deployment
+            .update_mcp_deployment(
+                &mcp_deployment.id.0,
+                &golem_common::model::mcp_deployment::McpDeploymentUpdate {
+                    current_revision: update.current_revision,
+                    domain: update.domain.clone(),
+                    agents: if agents_changed {
+                        update.agents.clone()
+                    } else {
+                        None
+                    },
+                },
+            )
+            .await
+            .map_service_error()?;
+
+        log_action(
+            "Updated",
+            format!(
+                "MCP deployment revision: {} {}",
+                deployment.domain.0.log_color_highlight(),
+                deployment.revision.to_string().log_color_highlight()
+            ),
+        );
+
+        Ok(())
+    }
 }

cli/golem-cli/src/command_handler/app/deploy_diff.rs

@@ -14,7 +14,7 @@
 
 use crate::model::component::{show_exported_agents, ComponentDeployProperties};
 use crate::model::environment::ResolvedEnvironmentIdentity;
-use crate::model::http_api::HttpApiDeploymentDeployProperties;
+use crate::model::http_api::{HttpApiDeploymentDeployProperties, McpDeploymentDeployProperties};
 use crate::model::text::component::is_sensitive_env_var_name;
 use anyhow::bail;
 use golem_client::model::{DeploymentPlan, DeploymentSummary};
@@ -38,6 +38,8 @@ pub struct DeployQuickDiff {
     pub deployable_manifest_components: BTreeMap<ComponentName, ComponentDeployProperties>,
     pub deployable_manifest_http_api_deployments:
         BTreeMap<Domain, HttpApiDeploymentDeployProperties>,
+    #[allow(dead_code)]
+    pub deployable_manifest_mcp_deployments: BTreeMap<Domain, McpDeploymentDeployProperties>,
     pub diffable_local_deployment: diff::Deployment,
     pub local_deployment_hash: diff::Hash,
 }
@@ -75,6 +77,8 @@ pub struct DeployDiff {
     pub environment: ResolvedEnvironmentIdentity,
     pub deployable_components: BTreeMap<ComponentName, ComponentDeployProperties>,
     pub deployable_http_api_deployments: BTreeMap<Domain, HttpApiDeploymentDeployProperties>,
+    #[allow(dead_code)]
+    pub deployable_mcp_deployments: BTreeMap<Domain, McpDeploymentDeployProperties>,
     pub diffable_local_deployment: diff::Deployment,
     pub local_deployment_hash: diff::Hash,
     #[allow(unused)] // NOTE: for debug logs
@@ -226,6 +230,21 @@ impl DeployDiff {
             })
     }
 
+    #[allow(dead_code)]
+    pub fn deployable_manifest_mcp_deployment(
+        &self,
+        domain: &Domain,
+    ) -> &McpDeploymentDeployProperties {
+        self.deployable_mcp_deployments
+            .get(domain)
+            .unwrap_or_else(|| {
+                panic!(
+                    "Expected MCP deployment {} not found in deployable manifest",
+                    domain
+                )
+            })
+    }
+
     pub fn staged_component_identity(
         &self,
         component_name: &ComponentName,
@@ -258,6 +277,22 @@ impl DeployDiff {
             })
     }
 
+    pub fn staged_mcp_deployment_identity(
+        &self,
+        domain: &Domain,
+    ) -> &golem_common::model::deployment::DeploymentPlanMcpDeploymentEntry {
+        self.staged_deployment
+            .mcp_deployments
+            .iter()
+            .find(|dep| &dep.domain == domain)
+            .unwrap_or_else(|| {
+                panic!(
+                    "Expected MCP deployment {} not found in staged deployment",
+                    domain
+                )
+            })
+    }
+
     pub fn current_component_identity(
         &self,
         component_name: &ComponentName,
@@ -757,6 +792,14 @@ fn normalized_diff_deployment(
             })
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect(),
+        mcp_deployments: deployment
+            .mcp_deployments
+            .iter()
+            .filter(|(domain, _)| {
+                diff.is_some_and(|diff| diff.mcp_deployments.contains_key(*domain))
+            })
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect(),
     }
 }