Refine configuration, and add a default builtin one.

Author: swallez

crates/elastic-mcp/src/bin/start_http.rs

@@ -24,7 +24,7 @@ pub async fn main() -> anyhow::Result<()> {
     println!("Current directory: {:?}", std::env::current_dir()?);
 
     elastic_mcp::run_http(HttpCommand {
-        config: "elastic-mcp.json5".parse()?,
+        config: Some("elastic-mcp.json5".parse()?),
         address: "127.0.0.1:8080".parse()?,
         sse: true,
     })

crates/elastic-mcp/src/cli.rs

@@ -39,8 +39,8 @@ pub enum Command {
 #[derive(Debug, Args)]
 pub struct HttpCommand {
     /// Config file
-    #[clap(short, long, default_value = "elastic-mcp.json5")]
-    pub config: PathBuf,
+    #[clap(short, long)]
+    pub config: Option<PathBuf>,
 
     /// Address to listen to
     #[clap(long, value_name = "IP_ADDRESS:PORT", default_value = "127.0.0.1:8080")]
@@ -55,8 +55,8 @@ pub struct HttpCommand {
 #[derive(Debug, Args)]
 pub struct StdioCommand {
     /// Config file
-    #[clap(short, long, default_value = "elastic-mcp.json5")]
-    pub config: PathBuf,
+    #[clap(short, long)]
+    pub config: Option<PathBuf>,
 }
 
 //---------------------------------------------------------------

crates/elastic-mcp/src/lib.rs

@@ -28,13 +28,13 @@ use rmcp::transport::stdio;
 use rmcp::transport::streamable_http_server::session::never::NeverSessionManager;
 use rmcp::{RoleServer, Service, ServiceExt};
 use std::io::ErrorKind;
-use std::path::Path;
+use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::select;
 use tokio_util::sync::CancellationToken;
 
 pub async fn run_stdio(cmd: StdioCommand) -> anyhow::Result<()> {
-    let (ct, handler) = crate::setup_services(&cmd.config).await?;
+    let (ct, handler) = setup_services(&cmd.config).await?;
     let service = handler.serve(stdio()).await.inspect_err(|e| {
         tracing::error!("serving error: {:?}", e);
     })?;
@@ -69,15 +69,28 @@ pub async fn run_http(cmd: HttpCommand) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn setup_services(config: &Path) -> anyhow::Result<(CancellationToken, impl Service<RoleServer> + Clone)> {
+async fn setup_services(config: &Option<PathBuf>) -> anyhow::Result<(CancellationToken, impl Service<RoleServer> + Clone)> {
     // Read config file and expand variables, also accepting .env files
     match dotenvy::dotenv() {
         Err(dotenvy::Error::Io(io_err)) if io_err.kind() == ErrorKind::NotFound => {}
         Err(err) => return Err(err)?,
         Ok(_) => {}
     }
 
-    let config = std::fs::read_to_string(config)?;
+    let config = if let Some(path) = config {
+        std::fs::read_to_string(path)?
+    } else {
+        // Built-in default configuration, based on env variables.
+        r#"{
+            "elasticsearch": {
+                "url": "${ES_URL}",
+                "api_key": "${ES_API_KEY:}",
+                "username": "${ES_LOGIN:}",
+                "password": "${ES_PASSWORD:}",
+                "ssl_skip_verify": "${ES_SSL_SKIP_VERIFY:false}"
+            }
+        }"#.to_string()
+    };
 
     // Expand environment variables in the config file
     let config = interpolator::interpolate_from_env(config)?;

crates/elastic-mcp/src/servers/elasticsearch/mod.rs

@@ -18,6 +18,7 @@
 mod base_tools;
 mod query_templates;
 
+use crate::utils::none_if_empty_string;
 use crate::servers::IncludeExclude;
 use elasticsearch::Elasticsearch;
 use elasticsearch::auth::Credentials;
@@ -34,21 +35,30 @@ use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::sync::Arc;
+use elasticsearch::cert::CertificateValidation;
+use serde_aux::field_attributes::deserialize_bool_from_anything;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ElasticsearchMcpConfig {
     /// Cluster URL
     pub url: String,
 
     /// API key
+    #[serde(default, deserialize_with = "none_if_empty_string")]
     pub api_key: Option<String>,
 
     /// Login
+    #[serde(default, deserialize_with = "none_if_empty_string")]
     pub login: Option<String>,
 
     /// Password
+    #[serde(default, deserialize_with = "none_if_empty_string")]
     pub password: Option<String>,
 
+    /// Should we skip SSL certificate verification?
+    #[serde(default, deserialize_with = "deserialize_bool_from_anything")]
+    pub ssl_skip_verify: bool,
+
     /// Search templates to expose as tools or resources
     #[serde(default)]
     pub tools: Tools,
@@ -197,6 +207,9 @@ impl ElasticsearchMcp {
         if let Some(creds) = creds {
             transport = transport.auth(creds);
         }
+        if config.ssl_skip_verify {
+            transport = transport.cert_validation(CertificateValidation::None)
+        }
         let transport = transport.build()?;
         let es_client = Elasticsearch::new(transport);
 

crates/elastic-mcp/src/utils/interpolator.rs

@@ -21,7 +21,7 @@ use thiserror::Error;
 #[derive(Error, Debug)]
 #[error("Invalid configuration template: {reason} at {line}:{char}")]
 pub struct InterpolationError {
-    pub reason: &'static str,
+    pub reason: String,
     pub line: usize,
     pub char: usize,
 }
@@ -49,7 +49,7 @@ pub fn interpolate(s: String, lookup: impl Fn(&str) -> Option<String>) -> Result
         }
         let mut char_no = 0;
 
-        let err = |char_no: usize, msg: &'static str| InterpolationError {
+        let err = |char_no: usize, msg: String| InterpolationError {
             reason: msg,
             line: line_no + 1, // editors (and humans) are 1-based
             char: char_no,
@@ -67,14 +67,14 @@ pub fn interpolate(s: String, lookup: impl Fn(&str) -> Option<String>) -> Result
                 let value = if let Some((name, default)) = expr.split_once(':') {
                     lookup(name).unwrap_or(default.to_string())
                 } else {
-                    lookup(expr).ok_or_else(|| err(char_no, "unknown variable"))?
+                    lookup(expr).ok_or_else(|| err(char_no, format!("unknown variable '{expr}'")))?
                 };
                 result.push_str(&value);
 
                 char_no += expr.len() + CLOSE_LEN;
                 line = &line[expr.len() + CLOSE_LEN..];
             } else {
-                return Err(err(char_no, "missing closing braces"));
+                return Err(err(char_no, "missing closing braces".to_string()));
             }
         }
         result.push_str(line);

crates/elastic-mcp/src/utils/mod.rs

@@ -15,5 +15,21 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use serde::{Deserialize, Deserializer};
+
 pub mod interpolator;
 pub mod rmcp_ext;
+
+
+/// Deserialize a string, and return `None` if it's empty. Useful for configuration fields like
+/// `"foo": "${SOME_ENV_VAR:}"` that uses an env var if present without failing if missing.
+pub fn none_if_empty_string<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<Option<String>, D::Error> {
+
+    let s: Option<String> = Deserialize::deserialize(deserializer)?;
+    match s {
+        Some(s) if s.is_empty() => Ok(None),
+        _ => Ok(s)
+    }
+}

elastic-mcp.json5

@@ -2,9 +2,11 @@
 {
     // Configure the target Elasticsearch server
     "elasticsearch": {
-      "type": "elasticsearch",
-      "url": "${ELASTICSEARCH_URL:http://localhost:9200}",
-      "api_key": "${ELASTICSEARCH_API_KEY:}",
+      "url": "${ES_URL}",
+      "api_key": "${ES_API_KEY:}",
+      "username": "${ES_LOGIN:}",
+      "password": "${ES_PASSWORD:}",
+      "ssl_skip_verify": "${ES_SSL_SKIP_VERIFY:false}",
 
       /* WIP
       "tools": {