use std::path::PathBuf;
use std::time::Duration;
use clap::{Parser, ValueEnum};
use tracing::info;
use memd::cli::{
run_cli, run_warm_admin, try_run_warm_client, CliCommand, StoreAccess, WarmProcessConfig,
};
use memd::embeddings::{CandleModel, EmbeddingModel};
use memd::store::HybridConfig;
use memd::{
configure_operation_routing, init_logging, load_config, MemoryStore, PersistentStore,
PersistentStoreConfig, RerankerConfig, RerankerMode, TenantManager,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum ModelChoice {
AllMinilm,
Qwen3,
BgeBase,
}
impl From<ModelChoice> for EmbeddingModel {
fn from(choice: ModelChoice) -> Self {
match choice {
ModelChoice::AllMinilm => EmbeddingModel::AllMiniLmL6V2,
ModelChoice::Qwen3 => EmbeddingModel::Qwen3Embedding0_6B,
ModelChoice::BgeBase => EmbeddingModel::AllMiniLmL6V2,
}
}
}
impl From<ModelChoice> for CandleModel {
fn from(choice: ModelChoice) -> Self {
match choice {
ModelChoice::AllMinilm | ModelChoice::Qwen3 => CandleModel::MiniLm,
ModelChoice::BgeBase => CandleModel::BgeBase,
}
}
}
impl ModelChoice {
fn cli_value(self) -> &'static str {
match self {
ModelChoice::AllMinilm => "all-minilm",
ModelChoice::Qwen3 => "qwen3",
ModelChoice::BgeBase => "bge-base",
}
}
}
fn default_search_variant(model: ModelChoice) -> SearchVariant {
match model {
ModelChoice::BgeBase => SearchVariant::DenseOnly,
_ => SearchVariant::HybridFeature,
}
}
fn resolve_search_variant(explicit: Option<SearchVariant>, model: ModelChoice) -> SearchVariant {
explicit.unwrap_or_else(|| default_search_variant(model))
}
#[derive(Debug, Clone, Copy, ValueEnum)]
enum SearchVariant {
HybridFeature,
HybridCrossEncoder,
DenseOnly,
Bm25Only,
}
impl SearchVariant {
fn cli_value(self) -> &'static str {
match self {
SearchVariant::HybridFeature => "hybrid-feature",
SearchVariant::HybridCrossEncoder => "hybrid-cross-encoder",
SearchVariant::DenseOnly => "dense-only",
SearchVariant::Bm25Only => "bm25-only",
}
}
}
#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
#[arg(short, long)]
config: Option<PathBuf>,
#[arg(long)]
data_dir: Option<PathBuf>,
#[arg(long, default_value = "false")]
in_memory: bool,
#[arg(short, long)]
verbose: bool,
#[arg(long, value_enum, default_value = "all-minilm")]
embedding_model: ModelChoice,
#[arg(long, value_enum)]
search_variant: Option<SearchVariant>,
#[command(subcommand)]
command: Option<CliCommand>,
}
#[tokio::main]
async fn main() {
let args = Args::parse();
let config = load_config(args.config.as_deref()).unwrap_or_else(|e| {
eprintln!("error: failed to load configuration: {}", e);
std::process::exit(1);
});
let data_dir = args
.data_dir
.clone()
.or_else(|| config.data_dir_expanded().ok())
.unwrap_or_else(|| PathBuf::from("data"));
let mut config = config;
config.data_dir = data_dir.clone();
if let Err(e) = config.validate() {
eprintln!("error: invalid configuration: {}", e);
std::process::exit(1);
}
configure_operation_routing(
config.server.allow_cross_tenant_project_fallback,
config.server.project_aliases.clone(),
);
let Some(mut cmd) = args.command else {
eprintln!("error: memd requires a CLI subcommand. Use --help for usage.");
std::process::exit(1);
};
cmd.normalize_positional_aliases();
let is_warm_worker = matches!(&cmd, CliCommand::WarmWorker { .. });
let log_level = if args.verbose || is_warm_worker {
"info"
} else {
"warn"
};
init_logging("pretty", log_level);
info!(
version = env!("CARGO_PKG_VERSION"),
config_path = ?args.config,
data_dir = %data_dir.display(),
in_memory = args.in_memory,
"memd CLI starting"
);
match memd::cli::emit_case_if_requested(&cmd) {
Ok(true) => return,
Ok(false) => {}
Err(error) => {
eprintln!("error: {error}");
std::process::exit(1);
}
}
if let Err(e) = memd::cli::resolve_command_scope(&mut cmd) {
eprintln!("error: {}", e);
std::process::exit(1);
}
cmd = match memd::cli::prepare_experience_command(cmd, &data_dir, args.in_memory).await {
Ok(cmd) => cmd,
Err(error) => {
eprintln!("error: {error}");
std::process::exit(1);
}
};
if let Err(error) = memd::cli::prepare_execution_context(&mut cmd) {
eprintln!("error: {error}");
std::process::exit(1);
}
let search_variant = resolve_search_variant(args.search_variant, args.embedding_model);
if let CliCommand::WarmWorker {
embedding_model,
search_variant: worker_variant,
..
} = &mut cmd
{
*embedding_model = Some(args.embedding_model.cli_value().to_string());
*worker_variant = Some(search_variant.cli_value().to_string());
}
let warm_config = WarmProcessConfig {
data_dir: data_dir.clone(),
config_path: args.config.clone(),
embedding_model: args.embedding_model.cli_value().to_string(),
search_variant: search_variant.cli_value().to_string(),
};
if let CliCommand::Warm { command } = &cmd {
if args.in_memory {
eprintln!("error: warm workers require persistent storage");
std::process::exit(1);
}
if let Err(e) = run_warm_admin(&warm_config, command.clone()).await {
eprintln!("error: {}", e);
std::process::exit(1);
}
return;
}
if matches!(&cmd, CliCommand::WarmWorker { .. }) && args.in_memory {
eprintln!("error: warm-worker requires persistent storage");
std::process::exit(1);
}
if let Some(mode) = cmd.warm_mode() {
if args.in_memory {
if mode == memd::cli::WarmMode::Required {
eprintln!("error: --warm required is not supported with --in-memory");
std::process::exit(1);
}
} else if mode != memd::cli::WarmMode::Off {
match try_run_warm_client(&warm_config, &cmd).await {
Ok(true) => return,
Ok(false) => {}
Err(e) => {
eprintln!("error: {}", e);
std::process::exit(1);
}
}
}
}
let tenant_manager = Some(TenantManager::new(data_dir.clone()));
if !cmd.requires_store() {
let store = MemoryStore::new();
if let Err(e) = run_cli(&store, tenant_manager.as_ref(), cmd).await {
eprintln!("error: {}", e);
std::process::exit(1);
}
return;
}
if args.in_memory {
info!("using in-memory store");
let store = MemoryStore::new();
if let Err(e) = run_cli(&store, tenant_manager.as_ref(), cmd).await {
eprintln!("error: {}", e);
std::process::exit(1);
}
} else {
info!(data_dir = %data_dir.display(), embedding_model = ?args.embedding_model, "using persistent store");
let mut store_config = PersistentStoreConfig {
data_dir: data_dir.clone(),
read_only: cmd.store_access() == StoreAccess::ReadOnly,
embedding_model: args.embedding_model.into(),
candle_model: args.embedding_model.into(),
..Default::default()
};
apply_search_variant(search_variant, &mut store_config);
if matches!(&cmd, CliCommand::WarmWorker { .. }) {
store_config.writer_lock_timeout_cap = Some(Duration::from_millis(2_000));
let async_indexing_env = std::env::var("MEMD_ASYNC_INDEXING").ok();
store_config.apply_warm_worker_availability_defaults(async_indexing_env.as_deref());
}
match PersistentStore::open(store_config) {
Ok(store) => {
if let Err(e) = run_cli(&store, tenant_manager.as_ref(), cmd).await {
eprintln!("error: {}", e);
std::process::exit(1);
}
}
Err(e) => {
eprintln!("error: failed to create persistent store: {}", e);
std::process::exit(1);
}
}
}
}
fn apply_search_variant(search_variant: SearchVariant, config: &mut PersistentStoreConfig) {
match search_variant {
SearchVariant::HybridFeature => {
config.enable_dense_search = true;
config.enable_hybrid_search = true;
let hybrid = HybridConfig {
reranker: RerankerConfig {
mode: RerankerMode::Feature,
..RerankerConfig::default()
},
..HybridConfig::default()
};
config.hybrid_config = Some(hybrid);
}
SearchVariant::HybridCrossEncoder => {
config.enable_dense_search = true;
config.enable_hybrid_search = true;
let hybrid = HybridConfig {
reranker: RerankerConfig {
mode: RerankerMode::CrossEncoder,
..RerankerConfig::default()
},
..HybridConfig::default()
};
config.hybrid_config = Some(hybrid);
}
SearchVariant::DenseOnly => {
config.enable_dense_search = true;
config.enable_hybrid_search = false;
config.hybrid_config = None;
}
SearchVariant::Bm25Only => {
config.enable_dense_search = false;
config.enable_hybrid_search = true;
config.enable_tiered_search = false;
let hybrid = HybridConfig {
dense_k: 0,
enable_sparse: true,
enable_rerank: false,
reranker: RerankerConfig {
mode: RerankerMode::Feature,
rrf_weight: 1.0,
recency_weight: 0.0,
project_weight: 0.0,
type_weight: 0.0,
query_text_weight: 0.0,
cross_encoder_weight: 0.0,
..RerankerConfig::default()
},
..HybridConfig::default()
};
config.hybrid_config = Some(hybrid);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn model_choice_maps_to_candle_model() {
assert_eq!(
CandleModel::from(ModelChoice::AllMinilm),
CandleModel::MiniLm
);
assert_eq!(
CandleModel::from(ModelChoice::BgeBase),
CandleModel::BgeBase
);
assert_eq!(CandleModel::from(ModelChoice::Qwen3), CandleModel::MiniLm);
}
#[test]
fn bge_choice_has_cli_value_and_vestigial_onnx_mapping() {
assert_eq!(ModelChoice::BgeBase.cli_value(), "bge-base");
assert_eq!(
EmbeddingModel::from(ModelChoice::BgeBase),
EmbeddingModel::AllMiniLmL6V2
);
}
#[test]
fn default_search_variant_is_dense_only_for_bge_only() {
assert!(matches!(
default_search_variant(ModelChoice::BgeBase),
SearchVariant::DenseOnly
));
assert!(matches!(
default_search_variant(ModelChoice::AllMinilm),
SearchVariant::HybridFeature
));
assert!(matches!(
default_search_variant(ModelChoice::Qwen3),
SearchVariant::HybridFeature
));
}
#[test]
fn explicit_search_variant_overrides_bge_default() {
assert!(matches!(
resolve_search_variant(Some(SearchVariant::HybridFeature), ModelChoice::BgeBase),
SearchVariant::HybridFeature
));
assert!(matches!(
resolve_search_variant(None, ModelChoice::BgeBase),
SearchVariant::DenseOnly
));
assert!(matches!(
resolve_search_variant(None, ModelChoice::AllMinilm),
SearchVariant::HybridFeature
));
}
#[test]
fn bm25_only_disables_non_lexical_ranking_features() {
let mut config = PersistentStoreConfig::default();
apply_search_variant(SearchVariant::Bm25Only, &mut config);
let hybrid = config.hybrid_config.expect("bm25 hybrid configuration");
assert_eq!(hybrid.dense_k, 0);
assert!(hybrid.enable_sparse);
assert!(!hybrid.enable_rerank);
assert!(!config.enable_dense_search);
assert_eq!(hybrid.reranker.rrf_weight, 1.0);
assert_eq!(hybrid.reranker.recency_weight, 0.0);
assert_eq!(hybrid.reranker.project_weight, 0.0);
assert_eq!(hybrid.reranker.type_weight, 0.0);
assert_eq!(hybrid.reranker.query_text_weight, 0.0);
assert_eq!(hybrid.reranker.cross_encoder_weight, 0.0);
}
}