use serde::{Deserialize, Serialize};
use std::fmt;
use std::str::FromStr;
pub(crate) const DEFAULT_MAX_FILE_SIZE_BYTES: u64 = 1_000_000;
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct VeraConfig {
pub indexing: IndexingConfig,
pub retrieval: RetrievalConfig,
pub embedding: EmbeddingConfig,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexingConfig {
pub max_chunk_lines: u32,
pub default_excludes: Vec<String>,
pub max_file_size_bytes: u64,
#[serde(default)]
pub extra_excludes: Vec<String>,
#[serde(default)]
pub no_ignore: bool,
#[serde(default)]
pub no_default_excludes: bool,
#[serde(default = "default_max_chunk_bytes")]
pub max_chunk_bytes: usize,
}
fn env_usize(key: &str, default: usize) -> usize {
match std::env::var(key) {
Ok(value) => match value.parse() {
Ok(parsed) => parsed,
Err(error) => {
tracing::warn!(
key,
value = %value,
default,
error = %error,
"invalid numeric environment override; using default"
);
default
}
},
Err(std::env::VarError::NotPresent) => default,
Err(error) => {
tracing::warn!(
key,
default,
error = %error,
"could not read numeric environment override; using default"
);
default
}
}
}
fn default_max_chunk_bytes() -> usize {
env_usize("VERA_MAX_CHUNK_BYTES", 24_576)
}
impl Default for IndexingConfig {
fn default() -> Self {
Self {
max_chunk_lines: 200,
default_excludes: vec![
".git".to_string(),
".vera".to_string(),
"node_modules".to_string(),
"target".to_string(),
"build".to_string(),
"dist".to_string(),
"__pycache__".to_string(),
".venv".to_string(),
],
max_file_size_bytes: DEFAULT_MAX_FILE_SIZE_BYTES, extra_excludes: Vec::new(),
no_ignore: false,
no_default_excludes: false,
max_chunk_bytes: default_max_chunk_bytes(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetrievalConfig {
pub default_limit: usize,
pub rrf_k: f64,
pub rerank_candidates: usize,
pub reranking_enabled: bool,
#[serde(default = "default_max_rerank_batch")]
pub max_rerank_batch: usize,
#[serde(default = "default_max_output_chars")]
pub max_output_chars: usize,
}
fn default_max_output_chars() -> usize {
12_000
}
fn default_max_rerank_batch() -> usize {
env_usize("VERA_MAX_RERANK_BATCH", 20)
}
impl Default for RetrievalConfig {
fn default() -> Self {
Self {
default_limit: 5,
rrf_k: 60.0,
rerank_candidates: 50,
reranking_enabled: false,
max_rerank_batch: default_max_rerank_batch(),
max_output_chars: 12_000,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingConfig {
pub batch_size: usize,
pub max_concurrent_requests: usize,
#[serde(default = "default_max_in_flight_inputs")]
pub max_in_flight_inputs: usize,
pub timeout_secs: u64,
pub max_retries: u32,
pub max_stored_dim: usize,
#[serde(default)]
pub gpu_mem_limit_mb: u64,
#[serde(default)]
pub low_vram: bool,
#[serde(default)]
pub query_prefix: Option<String>,
#[serde(default)]
pub document_prefix: Option<String>,
#[serde(default)]
pub model_aliases: Vec<Vec<String>>,
}
impl Default for EmbeddingConfig {
fn default() -> Self {
let is_local = is_local_mode();
Self {
batch_size: if is_local { 4 } else { 128 },
max_concurrent_requests: if is_local { 1 } else { 8 },
max_in_flight_inputs: default_max_in_flight_inputs(),
timeout_secs: 60,
max_retries: 3,
max_stored_dim: 1024,
gpu_mem_limit_mb: 0,
low_vram: false,
query_prefix: None,
document_prefix: None,
model_aliases: Vec::new(),
}
}
}
fn default_max_in_flight_inputs() -> usize {
env_usize("VERA_MAX_IN_FLIGHT_INPUTS", 16).max(1)
}
impl EmbeddingConfig {
pub fn bounded_parallelism(&self) -> (usize, usize) {
let max_in_flight = self.max_in_flight_inputs.max(1);
let batch_size = self.batch_size.max(1).min(max_in_flight);
let max_concurrent_requests = self
.max_concurrent_requests
.max(1)
.min((max_in_flight / batch_size).max(1));
(batch_size, max_concurrent_requests)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum OnnxExecutionProvider {
Cpu,
Cuda,
Rocm,
DirectMl,
CoreMl,
OpenVino,
}
impl fmt::Display for OnnxExecutionProvider {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Cpu => write!(f, "cpu"),
Self::Cuda => write!(f, "cuda"),
Self::Rocm => write!(f, "rocm"),
Self::DirectMl => write!(f, "directml"),
Self::CoreMl => write!(f, "coreml"),
Self::OpenVino => write!(f, "openvino"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum InferenceBackend {
Api,
OnnxJina(OnnxExecutionProvider),
PotionCode,
}
impl InferenceBackend {
pub fn is_local(self) -> bool {
matches!(self, Self::OnnxJina(_) | Self::PotionCode)
}
pub fn is_onnx(self) -> bool {
matches!(self, Self::OnnxJina(_))
}
pub fn execution_provider(self) -> Option<OnnxExecutionProvider> {
match self {
Self::OnnxJina(ep) => Some(ep),
Self::Api | Self::PotionCode => None,
}
}
}
impl fmt::Display for InferenceBackend {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Api => write!(f, "api"),
Self::OnnxJina(ep) => write!(f, "onnx-jina-{ep}"),
Self::PotionCode => write!(f, "potion-code-cpu"),
}
}
}
impl FromStr for InferenceBackend {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"api" => Ok(Self::Api),
"onnx-jina-cpu" => Ok(Self::OnnxJina(OnnxExecutionProvider::Cpu)),
"onnx-jina-cuda" => Ok(Self::OnnxJina(OnnxExecutionProvider::Cuda)),
"onnx-jina-rocm" => Ok(Self::OnnxJina(OnnxExecutionProvider::Rocm)),
"onnx-jina-directml" => Ok(Self::OnnxJina(OnnxExecutionProvider::DirectMl)),
"onnx-jina-coreml" => Ok(Self::OnnxJina(OnnxExecutionProvider::CoreMl)),
"onnx-jina-openvino" => Ok(Self::OnnxJina(OnnxExecutionProvider::OpenVino)),
"potion-code-cpu" | "potion-code" | "potion-cpu" => Ok(Self::PotionCode),
other => Err(format!("unknown backend: {other}")),
}
}
}
pub fn is_local_mode() -> bool {
std::env::var("VERA_LOCAL")
.map(|v| v == "1" || v == "true")
.unwrap_or(false)
}
pub fn graph_augmentation_enabled() -> bool {
std::env::var("VERA_GRAPH_AUGMENT")
.map(|value| {
value.eq_ignore_ascii_case("1")
|| value.eq_ignore_ascii_case("true")
|| value.eq_ignore_ascii_case("yes")
})
.unwrap_or(false)
}
fn backend_from_env() -> Option<InferenceBackend> {
std::env::var("VERA_BACKEND")
.ok()
.and_then(|value| InferenceBackend::from_str(&value).ok())
}
impl VeraConfig {
pub fn adjust_for_backend(&mut self, backend: InferenceBackend) {
match backend {
InferenceBackend::PotionCode => {
self.embedding.batch_size = 1024;
self.embedding.max_concurrent_requests = 1;
self.embedding.max_stored_dim = self.embedding.max_stored_dim.min(256);
}
InferenceBackend::OnnxJina(OnnxExecutionProvider::Cpu) => {
self.embedding.batch_size = 4;
self.embedding.max_concurrent_requests = 1;
}
InferenceBackend::OnnxJina(ep) => {
self.embedding.max_concurrent_requests = 1;
if self.embedding.low_vram {
self.embedding.batch_size = 1;
if self.embedding.gpu_mem_limit_mb == 0 {
self.embedding.gpu_mem_limit_mb = 1024;
}
tracing::info!(
"low-vram mode: batch_size=1, gpu_mem_limit={}MB",
self.embedding.gpu_mem_limit_mb
);
return;
}
let gpu_info = detect_gpu_info(ep);
if let Some(vram) = gpu_info.vram_free_mb {
tracing::info!("detected GPU VRAM: {vram}MB");
let auto_batch = if vram < 512 {
1
} else if vram < 3072 {
4
} else if vram < 5120 {
16
} else if vram < 8192 {
32
} else if vram < 12288 {
64
} else {
128
};
if ep == OnnxExecutionProvider::CoreMl {
self.embedding.batch_size = auto_batch.min(64);
} else {
self.embedding.batch_size = auto_batch;
}
if self.embedding.gpu_mem_limit_mb == 0 && vram < 8192 {
self.embedding.gpu_mem_limit_mb = ((vram as f64 * 0.8) as u64).max(128);
tracing::info!(
"auto-set gpu_mem_limit={}MB (80% of {vram}MB)",
self.embedding.gpu_mem_limit_mb
);
}
} else {
self.embedding.batch_size = 16;
}
}
InferenceBackend::Api => {}
}
}
}
#[derive(Debug, Clone)]
pub struct GpuInfo {
pub vram_free_mb: Option<u64>,
pub fingerprint: String,
}
pub fn detect_gpu_info(ep: OnnxExecutionProvider) -> GpuInfo {
match ep {
OnnxExecutionProvider::Cuda => detect_nvidia_gpu_info(),
OnnxExecutionProvider::Rocm => detect_rocm_gpu_info(),
OnnxExecutionProvider::CoreMl => detect_apple_silicon_mem_info(),
_ => GpuInfo {
vram_free_mb: None,
fingerprint: host_fingerprint(ep),
},
}
}
fn detect_apple_silicon_mem_info() -> GpuInfo {
let output = std::process::Command::new("sysctl")
.args(["-n", "hw.memsize"])
.output()
.ok();
let total_mb = output
.filter(|o| o.status.success())
.and_then(|o| {
String::from_utf8_lossy(&o.stdout)
.trim()
.parse::<u64>()
.ok()
})
.map(|bytes| bytes / (1024 * 1024));
let vram_free_mb = total_mb.map(|mb| mb / 2);
let brand = std::process::Command::new("sysctl")
.args(["-n", "machdep.cpu.brand_string"])
.output()
.ok()
.filter(|o| o.status.success())
.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
.filter(|s| !s.is_empty());
let fingerprint = match (brand, total_mb) {
(Some(brand), Some(mb)) => format!("{brand}|{mb}MB-unified"),
_ => host_fingerprint(OnnxExecutionProvider::CoreMl),
};
GpuInfo {
vram_free_mb,
fingerprint,
}
}
fn detect_nvidia_gpu_info() -> GpuInfo {
let output = std::process::Command::new("nvidia-smi")
.args([
"--query-gpu=memory.free,name,memory.total,driver_version",
"--format=csv,noheader,nounits",
])
.output()
.ok();
let Some(output) = output.filter(|o| o.status.success()) else {
return GpuInfo {
vram_free_mb: None,
fingerprint: host_fingerprint(OnnxExecutionProvider::Cuda),
};
};
let stdout = String::from_utf8_lossy(&output.stdout);
let first_line = stdout.lines().find_map(|line| {
let trimmed = line.trim();
(!trimmed.is_empty()).then(|| trimmed.to_string())
});
let Some(line) = first_line else {
return GpuInfo {
vram_free_mb: None,
fingerprint: host_fingerprint(OnnxExecutionProvider::Cuda),
};
};
let parts: Vec<&str> = line.split(',').map(str::trim).collect();
let vram_free_mb = parts.first().and_then(|s| s.parse::<u64>().ok());
let fingerprint = if parts.len() >= 4 {
format!("{}|{}|{}", parts[1], parts[2], parts[3])
} else {
line.replace(", ", "|").replace(',', "|")
};
GpuInfo {
vram_free_mb,
fingerprint,
}
}
fn detect_rocm_gpu_info() -> GpuInfo {
let output = std::process::Command::new("rocm-smi")
.args(["--showproductname", "--showmeminfo", "vram", "--csv"])
.output()
.ok();
let Some(output) = output.filter(|o| o.status.success()) else {
return GpuInfo {
vram_free_mb: None,
fingerprint: host_fingerprint(OnnxExecutionProvider::Rocm),
};
};
let stdout = String::from_utf8_lossy(&output.stdout);
parse_rocm_gpu_csv(&stdout)
}
fn parse_rocm_gpu_csv(stdout: &str) -> GpuInfo {
let mut vram_free_mb = None;
let mut fingerprint_fields: Vec<&str> = Vec::new();
let mut free_column = None;
let mut total_column = None;
let mut used_column = None;
for line in stdout.lines() {
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let parts: Vec<&str> = trimmed.split(',').map(str::trim).collect();
let is_data_row = parts.first().is_some_and(|first| {
let first = first.to_ascii_lowercase();
first.starts_with("gpu[") || first.starts_with("card")
});
if !is_data_row {
for (index, part) in parts.iter().enumerate() {
let label = part.to_ascii_lowercase();
if label.contains("free memory") {
free_column.get_or_insert(index);
} else if label.contains("used memory") {
used_column.get_or_insert(index);
} else if label.contains("total memory") {
total_column.get_or_insert(index);
}
}
continue;
}
if vram_free_mb.is_none() {
vram_free_mb = rocm_free_memory_mb(&parts, free_column, total_column, used_column);
}
if fingerprint_fields.is_empty() {
fingerprint_fields = parts
.iter()
.copied()
.filter(|part| is_stable_fingerprint_field(part))
.collect();
}
}
GpuInfo {
vram_free_mb,
fingerprint: if fingerprint_fields.is_empty() {
host_fingerprint(OnnxExecutionProvider::Rocm)
} else {
fingerprint_fields.join("|")
},
}
}
fn is_stable_fingerprint_field(part: &str) -> bool {
let lower = part.to_ascii_lowercase();
!part.is_empty()
&& part.parse::<u64>().is_err()
&& !lower.contains("memory")
&& !lower.contains("vram")
}
fn rocm_free_memory_mb(
parts: &[&str],
free_column: Option<usize>,
total_column: Option<usize>,
used_column: Option<usize>,
) -> Option<u64> {
let row_label_value = |needle: &str| {
parts
.iter()
.position(|part| part.to_ascii_lowercase().contains(needle))
.and_then(|label_index| parts.get(label_index + 1))
.and_then(|value| value.parse::<u64>().ok())
};
let column_value = |column: Option<usize>| {
column
.and_then(|index| parts.get(index))
.and_then(|value| value.parse::<u64>().ok())
};
let free_bytes = row_label_value("free memory")
.or_else(|| column_value(free_column))
.or_else(|| {
let total = row_label_value("total memory").or_else(|| column_value(total_column))?;
let used = row_label_value("used memory").or_else(|| column_value(used_column))?;
Some(total.saturating_sub(used))
})?;
Some(free_bytes / (1024 * 1024))
}
fn host_fingerprint(ep: OnnxExecutionProvider) -> String {
let host = std::env::var("HOSTNAME")
.ok()
.filter(|value| !value.trim().is_empty())
.or_else(|| {
std::process::Command::new("hostname")
.output()
.ok()
.filter(|o| o.status.success())
.and_then(|o| {
let s = String::from_utf8_lossy(&o.stdout).trim().to_string();
(!s.is_empty()).then_some(s)
})
})
.unwrap_or_else(|| "unknown-host".to_string());
format!(
"{host}|os={}|arch={}|backend={ep}",
std::env::consts::OS,
std::env::consts::ARCH
)
}
pub fn resolve_backend(backend: Option<InferenceBackend>) -> InferenceBackend {
if let Some(b) = backend {
return b;
}
if let Some(b) = backend_from_env() {
return b;
}
if is_local_mode() {
return InferenceBackend::OnnxJina(OnnxExecutionProvider::Cpu);
}
InferenceBackend::Api
}
pub fn model_names_match_with_aliases(a: &str, b: &str, aliases: &[Vec<String>]) -> bool {
let a = normalize_model_name(a);
let b = normalize_model_name(b);
a == b || aliases_match(&a, &b, aliases) || aliases_match_env(&a, &b)
}
fn normalize_model_name(s: &str) -> String {
s.rsplit('/')
.next()
.unwrap_or(s)
.trim()
.to_ascii_lowercase()
}
fn aliases_match(a: &str, b: &str, aliases: &[Vec<String>]) -> bool {
aliases.iter().any(|group| {
let mut has_a = false;
let mut has_b = false;
for alias in group {
let normalized = normalize_model_name(alias);
has_a |= normalized == a;
has_b |= normalized == b;
}
has_a && has_b
})
}
fn aliases_match_env(a: &str, b: &str) -> bool {
std::env::var("VERA_EMBEDDING_MODEL_ALIASES")
.ok()
.map(|value| aliases_match(a, b, &parse_model_alias_groups(&value)))
.unwrap_or(false)
}
fn parse_model_alias_groups(value: &str) -> Vec<Vec<String>> {
value
.split(';')
.filter_map(|group| {
let aliases = group
.split(',')
.map(str::trim)
.filter(|alias| !alias.is_empty())
.map(ToOwned::to_owned)
.collect::<Vec<_>>();
(aliases.len() >= 2).then_some(aliases)
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_env::run_env_test;
#[test]
fn default_config_is_valid() {
let config = VeraConfig::default();
assert!(config.indexing.max_chunk_lines > 0);
assert!(config.retrieval.default_limit > 0);
assert!(config.retrieval.rrf_k > 0.0);
assert!(config.embedding.batch_size > 0);
assert!(config.embedding.max_in_flight_inputs > 0);
let (batch_size, concurrency) = config.embedding.bounded_parallelism();
assert!(
batch_size * concurrency <= config.embedding.max_in_flight_inputs,
"default embedding parallelism must respect its in-flight bound"
);
}
#[test]
fn graph_augmentation_env_accepts_only_truthy_values() {
for value in ["1", "true", "TRUE", "yes", "YeS"] {
run_env_test(
"config::tests::graph_augmentation_truthy_probe",
&[("VERA_GRAPH_AUGMENT", Some(value))],
);
}
for value in ["0", "false", "no", "", "on"] {
run_env_test(
"config::tests::graph_augmentation_falsey_probe",
&[("VERA_GRAPH_AUGMENT", Some(value))],
);
}
}
#[test]
#[ignore = "driven by graph_augmentation_env_accepts_only_truthy_values"]
fn graph_augmentation_truthy_probe() {
let value = std::env::var("VERA_GRAPH_AUGMENT").unwrap();
assert!(
graph_augmentation_enabled(),
"{value} should enable the flag"
);
}
#[test]
#[ignore = "driven by graph_augmentation_env_accepts_only_truthy_values"]
fn graph_augmentation_falsey_probe() {
let value = std::env::var("VERA_GRAPH_AUGMENT").unwrap();
assert!(
!graph_augmentation_enabled(),
"{value} should disable the flag"
);
}
#[test]
fn embedding_parallelism_clamps_batch_and_concurrency() {
let config = EmbeddingConfig {
batch_size: 128,
max_concurrent_requests: 8,
max_in_flight_inputs: 16,
..EmbeddingConfig::default()
};
assert_eq!(config.bounded_parallelism(), (16, 1));
}
#[test]
fn embedding_parallelism_normalizes_zero_values_to_one() {
let config = EmbeddingConfig {
batch_size: 0,
max_concurrent_requests: 0,
max_in_flight_inputs: 0,
..EmbeddingConfig::default()
};
assert_eq!(config.bounded_parallelism(), (1, 1));
}
#[test]
fn max_in_flight_environment_value_normalizes_zero_to_one() {
run_env_test(
"config::tests::max_in_flight_environment_value_normalizes_zero_to_one_probe",
&[("VERA_MAX_IN_FLIGHT_INPUTS", Some("0"))],
);
}
#[test]
#[ignore = "driven by max_in_flight_environment_value_normalizes_zero_to_one"]
fn max_in_flight_environment_value_normalizes_zero_to_one_probe() {
assert_eq!(default_max_in_flight_inputs(), 1);
}
#[test]
fn invalid_numeric_environment_value_falls_back_to_default() {
run_env_test(
"config::tests::invalid_numeric_environment_value_falls_back_to_default_probe",
&[("VERA_MAX_CHUNK_BYTES", Some("24_576"))],
);
}
#[test]
#[ignore = "driven by invalid_numeric_environment_value_falls_back_to_default"]
fn invalid_numeric_environment_value_falls_back_to_default_probe() {
assert_eq!(default_max_chunk_bytes(), 24_576);
}
#[test]
fn rocm_csv_parses_gpu_rows_and_free_memory_column() {
let csv = "GPU, vram total used memory (bytes), vram total free memory (bytes)\n\
GPU[0], vram total used memory (bytes), 4294967296, vram total free memory (bytes), 12884901888\n\
GPU[1], vram total used memory (bytes), 1073741824, vram total free memory (bytes), 3221225472\n";
let info = parse_rocm_gpu_csv(csv);
assert_eq!(info.vram_free_mb, Some(12_288));
assert!(info.fingerprint.contains("GPU[0]"));
}
#[test]
fn rocm_csv_uses_free_memory_header_for_numeric_rows() {
let csv = "GPU, vram total used memory (bytes), vram total free memory (bytes)\n\
GPU[0], 4294967296, 12884901888\n\
GPU[1], 1073741824, 3221225472\n";
let info = parse_rocm_gpu_csv(csv);
assert_eq!(info.vram_free_mb, Some(12_288));
assert!(info.fingerprint.contains("GPU[0]"));
}
#[test]
fn rocm_csv_derives_free_from_total_minus_used_for_card_rows() {
let csv = "device, VRAM Total Memory (B), VRAM Total Used Memory (B), Card series\n\
card0, 17179869184, 4294967296, AMD Radeon RX 7900 XTX\n";
let info = parse_rocm_gpu_csv(csv);
assert_eq!(info.vram_free_mb, Some(12_288));
assert!(info.fingerprint.contains("card0"));
assert!(info.fingerprint.contains("AMD Radeon RX 7900 XTX"));
}
#[test]
fn rocm_fingerprint_ignores_live_memory_values() {
let header = "device, VRAM Total Memory (B), VRAM Total Used Memory (B), Card series\n";
let idle = format!("{header}card0, 17179869184, 1073741824, AMD Radeon\n");
let busy = format!("{header}card0, 17179869184, 16106127360, AMD Radeon\n");
assert_eq!(
parse_rocm_gpu_csv(&idle).fingerprint,
parse_rocm_gpu_csv(&busy).fingerprint,
"live VRAM usage must not leak into the device fingerprint"
);
assert_eq!(parse_rocm_gpu_csv(&idle).vram_free_mb, Some(15_360));
assert_eq!(parse_rocm_gpu_csv(&busy).vram_free_mb, Some(1_024));
}
#[test]
fn rocm_csv_saturates_when_used_exceeds_total() {
let csv = "device, VRAM Total Memory (B), VRAM Total Used Memory (B)\n\
card0, 1073741824, 4294967296\n";
assert_eq!(parse_rocm_gpu_csv(csv).vram_free_mb, Some(0));
}
#[test]
fn rocm_csv_without_memory_data_reports_no_vram() {
let csv = "device, Card series\ncard0, AMD Radeon\n";
assert_eq!(parse_rocm_gpu_csv(csv).vram_free_mb, None);
}
#[test]
fn config_serialization_round_trip() {
let config = VeraConfig::default();
let json = serde_json::to_string(&config).unwrap();
let deserialized: VeraConfig = serde_json::from_str(&json).unwrap();
assert_eq!(
deserialized.indexing.max_chunk_lines,
config.indexing.max_chunk_lines
);
assert_eq!(
deserialized.retrieval.default_limit,
config.retrieval.default_limit
);
}
#[test]
fn openvino_backend_round_trip() {
let backend = InferenceBackend::from_str("onnx-jina-openvino").unwrap();
assert_eq!(
backend,
InferenceBackend::OnnxJina(OnnxExecutionProvider::OpenVino)
);
assert_eq!(backend.to_string(), "onnx-jina-openvino");
assert!(backend.is_local());
}
#[test]
fn potion_code_backend_round_trip() {
let backend = InferenceBackend::from_str("potion-code-cpu").unwrap();
assert_eq!(backend, InferenceBackend::PotionCode);
assert_eq!(backend.to_string(), "potion-code-cpu");
assert!(backend.is_local());
assert!(!backend.is_onnx());
assert_eq!(backend.execution_provider(), None);
}
#[test]
fn default_excludes_contains_common_dirs() {
let config = IndexingConfig::default();
assert!(config.default_excludes.contains(&".git".to_string()));
assert!(
config
.default_excludes
.contains(&"node_modules".to_string())
);
assert!(config.default_excludes.contains(&"target".to_string()));
}
#[test]
fn resolve_backend_prefers_saved_backend_env() {
run_env_test(
"config::tests::resolve_backend_prefers_saved_backend_env_probe",
&[
("VERA_BACKEND", Some("onnx-jina-cuda")),
("VERA_LOCAL", Some("1")),
],
);
}
#[test]
#[ignore = "driven by resolve_backend_prefers_saved_backend_env"]
fn resolve_backend_prefers_saved_backend_env_probe() {
assert_eq!(
resolve_backend(None),
InferenceBackend::OnnxJina(OnnxExecutionProvider::Cuda)
);
}
#[test]
fn resolve_backend_falls_back_to_legacy_local_env() {
run_env_test(
"config::tests::resolve_backend_falls_back_to_legacy_local_env_probe",
&[("VERA_BACKEND", None), ("VERA_LOCAL", Some("1"))],
);
}
#[test]
#[ignore = "driven by resolve_backend_falls_back_to_legacy_local_env"]
fn resolve_backend_falls_back_to_legacy_local_env_probe() {
assert_eq!(
resolve_backend(None),
InferenceBackend::OnnxJina(OnnxExecutionProvider::Cpu)
);
}
fn model_names_match(a: &str, b: &str) -> bool {
model_names_match_with_aliases(a, b, &[])
}
#[test]
fn model_names_match_exact() {
assert!(model_names_match(
"jina-embeddings-v5",
"jina-embeddings-v5"
));
}
#[test]
fn model_names_match_with_org_prefix() {
assert!(model_names_match(
"jinaai/jina-embeddings-v5-text-nano-retrieval",
"jina-embeddings-v5-text-nano-retrieval"
));
}
#[test]
fn model_names_match_case_insensitive() {
assert!(model_names_match(
"Jina-Embeddings-V5",
"jina-embeddings-v5"
));
}
#[test]
fn model_names_match_different_models() {
assert!(!model_names_match("jina-embeddings-v5", "jina-reranker-v2"));
}
#[test]
fn model_names_match_configured_alias_group() {
let aliases = vec![vec![
"text-embedding-3-large".to_string(),
"text-embedding-3-large-2".to_string(),
]];
assert!(model_names_match_with_aliases(
"text-embedding-3-large",
"text-embedding-3-large-2",
&aliases
));
assert!(!model_names_match_with_aliases(
"text-embedding-3-large",
"text-embedding-3-small",
&aliases
));
}
#[test]
fn model_names_match_env_alias_group() {
run_env_test(
"config::tests::model_names_match_env_alias_group_probe",
&[(
"VERA_EMBEDDING_MODEL_ALIASES",
Some("text-embedding-3-large,text-embedding-3-large-2;other,other-prod"),
)],
);
}
#[test]
#[ignore = "driven by model_names_match_env_alias_group"]
fn model_names_match_env_alias_group_probe() {
assert!(model_names_match(
"text-embedding-3-large",
"text-embedding-3-large-2"
));
assert!(model_names_match("other", "other-prod"));
assert!(!model_names_match(
"text-embedding-3-large",
"text-embedding-3-small"
));
}
#[test]
fn model_alias_groups_ignore_single_entry_groups() {
assert!(parse_model_alias_groups("solo;").is_empty());
assert_eq!(
parse_model_alias_groups("a,b; c , d").len(),
2,
"whitespace-tolerant groups parse"
);
}
}