feat: register mcp server, update proxy cache and change endpoint for list mcps

Author: CeerDecy

.migration/20250825_system_settings.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS tb_system_settings
+(
+    setting_name  TEXT PRIMARY KEY,
+    setting_value TEXT NOT NULL
+);
+
+COMMENT ON TABLE tb_system_settings IS 'MCP-Center system settings';
+
+COMMENT ON COLUMN tb_system_settings.setting_name IS 'MCP-Center system setting name';
+COMMENT ON COLUMN tb_system_settings.setting_value IS 'MCP-Center system setting value';
+
+INSERT INTO tb_system_settings (setting_name, setting_value)
+VALUES ('SELF_ADDRESS', 'http://127.0.0.1');

mc-service/src/db/mcp_handler.rs

@@ -27,8 +27,8 @@ impl McpDBHandler {
             sqlx::query_as::<_, McpServers>(
                 r#"
         INSERT INTO tb_mcp_servers
-            (id,name, tag, endpoint, transport_type, description, extra)
-        VALUES ($1, $2, $3, $4, $5, $6)
+            (id, name, tag, endpoint, transport_type, description, extra)
+        VALUES ($1, $2, $3, $4, $5, $6, $7)
         RETURNING *
         "#,
             )

mc-service/src/db/mod.rs

@@ -1,13 +1,13 @@
 pub mod model;
 mod mcp_handler;
 mod token_handler;
+mod settings_handler;
 
 pub use mcp_handler::*;
-pub use token_handler::*;
+pub use settings_handler::*;
 
 use sqlx::postgres::PgPoolOptions;
 use std::error::Error;
-use std::sync::Arc;
 use sqlx::{Pool, Postgres};
 
 #[derive(Clone)]

mc-service/src/db/model/mcp_servers.rs

@@ -1,8 +1,6 @@
 use serde::{Deserialize, Serialize};
 use sqlx::FromRow;
 use sqlx::types::chrono::NaiveDateTime;
-use std::fmt::Display;
-use std::str::FromStr;
 use uuid::Uuid;
 
 #[derive(Debug, Serialize, Deserialize, FromRow)]

mc-service/src/db/model/mod.rs

@@ -1,3 +1,5 @@
 mod mcp_servers;
+mod system_settings;
 
-pub use mcp_servers::*;
+pub use mcp_servers::*;
+pub use system_settings::*;

mc-service/src/db/model/system_settings.rs

@@ -0,0 +1,21 @@
+use std::fmt::Display;
+use serde::{Deserialize, Serialize};
+use sqlx::FromRow;
+
+#[derive(Debug, Serialize, Deserialize, FromRow)]
+pub struct SystemSettings {
+    pub setting_name: String,
+    pub setting_value: String,
+}
+
+pub enum SettingKey {
+    SelfAddress,
+}
+
+impl Display for SettingKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            SettingKey::SelfAddress => "SELF_ADDRESS".to_string(),
+        })
+    }
+}

mc-service/src/db/settings_handler.rs

@@ -0,0 +1,27 @@
+use crate::db::DBClient;
+use crate::db::model::{SettingKey, SystemSettings};
+use std::sync::Arc;
+
+pub struct SystemSettingsDBHandler {
+    client: Arc<DBClient>,
+}
+
+impl SystemSettingsDBHandler {
+    pub fn new(client: Arc<DBClient>) -> Self {
+        SystemSettingsDBHandler { client }
+    }
+
+    pub async fn get_system_settings(&self, key: SettingKey) -> String {
+        if let Ok(settings) = sqlx::query_as::<_, SystemSettings>(
+            "SELECT * FROM tb_system_settings where setting_name = $1",
+        )
+        .bind(key.to_string())
+        .fetch_one(&self.client.pool)
+        .await
+        {
+            settings.setting_value.trim_end_matches('/').to_string()
+        } else {
+            String::from("http://127.0.0.1")
+        }
+    }
+}

mc-service/src/service/mcp_server.rs

@@ -1,26 +1,46 @@
-use crate::db::McpDBHandler;
-use crate::db::model::McpServers;
+use crate::db::model::{McpServers, SettingKey, SystemSettings};
+use crate::db::{McpDBHandler, SystemSettingsDBHandler};
+use crate::event::Event;
 use crate::service::{AppState, Response};
 use axum::Json;
-use axum::extract::State;
-use chrono::NaiveDateTime;
+use axum::extract::{Query, State};
 use http::StatusCode;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
+#[derive(Deserialize, Debug)]
+pub struct ListAllRequest {
+    use_raw_endpoint: Option<bool>,
+}
+
 pub async fn list_all(
     State(state): State<AppState>,
+    Query(params): Query<ListAllRequest>,
 ) -> Result<Json<Response>, (StatusCode, String)> {
-    let db_client = state.db.clone();
-    let handler = McpDBHandler::new(db_client);
-    let servers = handler.list_all().await.map_err(|e| {
+    let mcp_handler = McpDBHandler::new(state.db.clone());
+    let settings_handler = SystemSettingsDBHandler::new(state.db.clone());
+
+    let self_address = settings_handler
+        .get_system_settings(SettingKey::SelfAddress)
+        .await;
+
+    let mut servers = mcp_handler.list_all().await.map_err(|e| {
         tracing::error!("Failed to list mcp servers {}", e);
         (
             StatusCode::INTERNAL_SERVER_ERROR,
             "Failed to list mcp servers".to_string(),
         )
     })?;
 
+    if params.use_raw_endpoint.is_none() || !params.use_raw_endpoint.unwrap() {
+        servers.iter_mut().for_each(|server| {
+            server.endpoint = format!(
+                "{self_address}/proxy/connect/{}/{}",
+                server.name, server.tag
+            );
+        })
+    }
+
     let data = serde_json::to_value(servers).map_err(|e| {
         tracing::error!("Failed to parse mcp servers {}", e);
         (
@@ -32,7 +52,7 @@ pub async fn list_all(
     Ok(Json(Response::new(Some(data))))
 }
 
-#[derive(Deserialize,Serialize,Clone)]
+#[derive(Deserialize, Serialize, Clone)]
 pub struct McpRegisterRequest {
     pub name: String,
     pub tag: String,
@@ -47,24 +67,38 @@ pub async fn register_mcp_server(
     Json(server): Json<McpRegisterRequest>,
 ) -> Result<Json<Response>, (StatusCode, String)> {
     let db_client = state.db.clone();
-    let res = McpDBHandler::new(db_client).create_or_update(&McpServers{
-        id: Uuid::new_v4(),
-        name: server.name.clone(),
-        tag: server.tag.clone(),
-        endpoint: server.endpoint.clone(),
-        transport_type: server.transport_type.clone(),
-        description: server.description.clone(),
-        extra: server.extra.clone(),
-        created_at: Default::default(),
-        updated_at: Default::default(),
-        deleted_at: None,
-    }).await.map_err(|e| {
-        tracing::error!("Failed to create mcp server {}", e);
-        (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Failed to create mcp server".to_string(),
-        )
-    })?;
+    let res = McpDBHandler::new(db_client)
+        .create_or_update(&McpServers {
+            id: Uuid::new_v4(),
+            name: server.name.clone(),
+            tag: server.tag.clone(),
+            endpoint: server.endpoint.clone(),
+            transport_type: server.transport_type.clone(),
+            description: server.description.clone(),
+            extra: server.extra.clone(),
+            created_at: Default::default(),
+            updated_at: Default::default(),
+            deleted_at: None,
+        })
+        .await
+        .map_err(|e| {
+            tracing::error!("Failed to create mcp server {}", e);
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Failed to create mcp server".to_string(),
+            )
+        })?;
+
+    tokio::task::spawn(async move {
+        if let Err(err) = state.event_sender.send(Event::CreateOrUpdate {
+            mcp_name: server.name.clone(),
+            tag: server.tag.clone(),
+            endpoint: server.endpoint.clone(),
+        }) {
+            tracing::error!("Failed to send event {}", err);
+        }
+        tracing::info!("MCP server {} registered", server.name);
+    });
 
     let data = serde_json::to_value(res).map_err(|e| {
         tracing::error!("Failed to parse mcp servers {}", e);