use crate::rank::fusion::QueryIntent;
use crate::types::BackendId;
use dashmap::DashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct AbsConfig {
pub min_backends: usize,
pub max_backends: usize,
pub exploration_factor: f64,
pub always_include_reliable: bool,
}
impl Default for AbsConfig {
fn default() -> Self {
Self {
min_backends: 3,
max_backends: 8,
exploration_factor: 1.41, always_include_reliable: true,
}
}
}
#[derive(Debug)]
struct BackendStats {
selections: AtomicU64,
successes: AtomicU64,
total_reward: AtomicU64, }
impl BackendStats {
fn new() -> Self {
Self {
selections: AtomicU64::new(0),
successes: AtomicU64::new(0),
total_reward: AtomicU64::new(0),
}
}
fn success_rate(&self) -> f64 {
let sel = self.selections.load(Ordering::Relaxed);
if sel == 0 {
return 0.5; }
self.successes.load(Ordering::Relaxed) as f64 / sel as f64
}
fn avg_reward(&self) -> f64 {
let sel = self.selections.load(Ordering::Relaxed);
if sel == 0 {
return 0.5; }
(self.total_reward.load(Ordering::Relaxed) as f64 / 1000.0) / sel as f64
}
}
fn intent_affinity(intent: &QueryIntent, backend: &BackendId) -> f64 {
if *backend == BackendId::Searxng {
return 0.85; }
match backend {
BackendId::Tavily | BackendId::Serper | BackendId::Exa | BackendId::Firecrawl => {
return 0.80; }
_ => {}
}
match intent {
QueryIntent::Academic | QueryIntent::Data => match backend {
BackendId::Arxiv => 0.95,
BackendId::GoogleScholar => 0.90,
BackendId::Wikipedia => 0.70,
BackendId::StackOverflow => 0.60,
BackendId::Github => 0.50,
_ => 0.30,
},
QueryIntent::Code => match backend {
BackendId::Github => 0.95,
BackendId::StackOverflow => 0.90,
BackendId::HackerNews => 0.50,
BackendId::Reddit => 0.40,
_ => 0.30,
},
QueryIntent::HowTo => match backend {
BackendId::StackOverflow => 0.95,
BackendId::Github => 0.80,
BackendId::DuckDuckGo => 0.80,
BackendId::Google => 0.75,
BackendId::Brave => 0.70,
BackendId::Bing => 0.65,
BackendId::Wikipedia => 0.15,
BackendId::Arxiv => 0.10,
BackendId::Reddit => 0.35,
_ => 0.40,
},
QueryIntent::CurrentEvents => match backend {
BackendId::HackerNews => 0.90,
BackendId::Reddit => 0.85,
BackendId::Google => 0.75,
BackendId::Bing => 0.65,
BackendId::DuckDuckGo => 0.60,
BackendId::Brave => 0.55,
BackendId::StackOverflow => 0.30,
BackendId::Github => 0.15,
BackendId::Wikipedia => 0.10, BackendId::Arxiv => 0.10, _ => 0.30,
},
QueryIntent::Comparison => match backend {
BackendId::DuckDuckGo => 0.85,
BackendId::Google => 0.80,
BackendId::Brave => 0.75,
BackendId::Bing => 0.70,
BackendId::StackOverflow => 0.68,
BackendId::Wikipedia => 0.60,
BackendId::Reddit => 0.20,
BackendId::HackerNews => 0.20,
BackendId::Arxiv => 0.05,
_ => 0.40,
},
QueryIntent::Factual => match backend {
BackendId::Wikipedia => 0.95,
BackendId::DuckDuckGo => 0.70,
BackendId::Google => 0.65,
BackendId::Brave => 0.60,
BackendId::Github => 0.20,
_ => 0.40,
},
QueryIntent::Informational => match backend {
BackendId::Wikipedia => 0.95,
BackendId::DuckDuckGo => 0.80,
BackendId::Google => 0.75,
BackendId::Brave => 0.70,
BackendId::Bing => 0.65,
BackendId::StackOverflow => 0.55,
BackendId::Reddit => 0.45,
BackendId::HackerNews => 0.40,
BackendId::Arxiv => 0.35,
BackendId::Github => 0.10,
_ => 0.40,
},
QueryIntent::Verification => match backend {
BackendId::Wikipedia => 0.90,
BackendId::Arxiv => 0.85,
BackendId::GoogleScholar => 0.80,
BackendId::DuckDuckGo => 0.60,
_ => 0.35,
},
QueryIntent::Opinion => match backend {
BackendId::Reddit => 0.90,
BackendId::HackerNews => 0.85,
BackendId::StackOverflow => 0.80,
BackendId::DuckDuckGo => 0.70,
BackendId::Google => 0.65,
BackendId::Brave => 0.60,
BackendId::Wikipedia => 0.40,
BackendId::Arxiv => 0.15,
_ => 0.50,
},
QueryIntent::Casual => match backend {
BackendId::DuckDuckGo => 0.85,
BackendId::Google => 0.85,
BackendId::Brave => 0.80,
BackendId::Bing => 0.75,
BackendId::Reddit => 0.70,
BackendId::Wikipedia => 0.30,
BackendId::HackerNews => 0.20,
BackendId::StackOverflow => 0.10,
BackendId::Github => 0.05,
BackendId::Arxiv => 0.05,
BackendId::GoogleScholar => 0.05,
_ => 0.40,
},
_ => match backend {
BackendId::DuckDuckGo => 0.70,
BackendId::Google => 0.70,
BackendId::StackOverflow => 0.65,
BackendId::Bing => 0.60,
BackendId::Brave => 0.60,
BackendId::Wikipedia => 0.55,
_ => 0.50,
},
}
}
fn intent_backend_allowed(intent: &QueryIntent, backend: &BackendId) -> bool {
match intent {
QueryIntent::CurrentEvents => !matches!(
backend,
BackendId::StackOverflow | BackendId::Github | BackendId::Arxiv
),
QueryIntent::Factual | QueryIntent::Informational => {
!matches!(
backend,
BackendId::StackOverflow | BackendId::Github | BackendId::Arxiv
)
}
QueryIntent::Verification => {
!matches!(backend, BackendId::StackOverflow | BackendId::Github)
}
QueryIntent::HowTo => !matches!(backend, BackendId::Arxiv | BackendId::GoogleScholar),
QueryIntent::Comparison => !matches!(
backend,
BackendId::Arxiv | BackendId::GoogleScholar | BackendId::Reddit | BackendId::HackerNews
),
QueryIntent::Academic | QueryIntent::Data => !matches!(backend, BackendId::Reddit),
QueryIntent::Opinion => !matches!(backend, BackendId::Arxiv),
QueryIntent::Casual => {
!matches!(
backend,
BackendId::StackOverflow
| BackendId::Github
| BackendId::Arxiv
| BackendId::GoogleScholar
)
}
_ => true,
}
}
#[derive(Clone)]
pub struct AdaptiveBackendSelector {
stats: Arc<DashMap<String, BackendStats>>,
total_rounds: Arc<AtomicU64>,
config: AbsConfig,
}
#[derive(Debug, Clone)]
pub struct BackendSelection {
pub backends: Vec<BackendId>,
pub scores: Vec<f64>,
}
impl AdaptiveBackendSelector {
pub fn new(config: AbsConfig) -> Self {
Self {
stats: Arc::new(DashMap::new()),
total_rounds: Arc::new(AtomicU64::new(0)),
config,
}
}
pub fn select(
&self,
intent: &QueryIntent,
available_backends: &[BackendId],
unhealthy_backends: &[BackendId],
) -> BackendSelection {
let total = self.total_rounds.fetch_add(1, Ordering::Relaxed) + 1;
let healthy: Vec<&BackendId> = available_backends
.iter()
.filter(|b| !unhealthy_backends.contains(b))
.filter(|b| intent_backend_allowed(intent, b))
.collect();
if healthy.is_empty() {
return BackendSelection {
backends: vec![],
scores: vec![],
};
}
let mut scored: Vec<(BackendId, f64)> = healthy
.iter()
.map(|&backend| {
let key = backend.to_string();
let ucb1 = self.ucb1_score(&key, total);
let affinity = intent_affinity(intent, backend);
let combined = ucb1 * 0.4 + affinity * 0.6; (backend.clone(), combined)
})
.collect();
scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
let n = scored
.len()
.min(self.config.max_backends)
.max(self.config.min_backends.min(scored.len()));
let mut backends: Vec<BackendId> = scored[..n].iter().map(|(b, _)| b.clone()).collect();
let mut scores: Vec<f64> = scored[..n].iter().map(|(_, s)| *s).collect();
if self.config.always_include_reliable {
let reliable: &[BackendId] = match intent {
QueryIntent::CurrentEvents => &[BackendId::DuckDuckGo, BackendId::HackerNews],
QueryIntent::Code => &[BackendId::StackOverflow, BackendId::DuckDuckGo],
QueryIntent::HowTo => &[BackendId::StackOverflow, BackendId::DuckDuckGo],
QueryIntent::Academic | QueryIntent::Data => {
&[BackendId::Arxiv, BackendId::Wikipedia]
}
_ => &[BackendId::Wikipedia, BackendId::DuckDuckGo],
};
let has_reliable = backends.iter().any(|b| reliable.contains(b));
if !has_reliable {
if let Some(reliable_b) = reliable
.iter()
.find(|b| healthy.contains(b) && !backends.contains(b))
{
if backends.len() >= self.config.max_backends {
backends.pop();
scores.pop();
}
backends.push(reliable_b.clone());
scores.push(0.5);
}
}
}
BackendSelection { backends, scores }
}
pub fn report_outcome(&self, backend: &BackendId, result_count: usize, quality: f64) {
let key = backend.to_string();
let entry = self.stats.entry(key).or_insert_with(BackendStats::new);
entry.selections.fetch_add(1, Ordering::Relaxed);
if result_count > 0 {
entry.successes.fetch_add(1, Ordering::Relaxed);
}
let reward_int = (quality.clamp(0.0, 1.0) * 1000.0) as u64;
entry.total_reward.fetch_add(reward_int, Ordering::Relaxed);
}
pub fn summary(&self) -> Vec<(String, f64, u64)> {
self.stats
.iter()
.map(|entry| {
let key = entry.key().clone();
let rate = entry.value().success_rate();
let count = entry.value().selections.load(Ordering::Relaxed);
(key, rate, count)
})
.collect()
}
fn ucb1_score(&self, key: &str, total_rounds: u64) -> f64 {
match self.stats.get(key) {
Some(stats) => {
let selections = stats.selections.load(Ordering::Relaxed);
if selections == 0 {
return 1.0; }
let avg = stats.avg_reward();
let exploration = self.config.exploration_factor
* ((total_rounds as f64).ln() / selections as f64).sqrt();
(avg + exploration).min(1.0)
}
None => 1.0, }
}
}
impl Default for AdaptiveBackendSelector {
fn default() -> Self {
Self::new(AbsConfig::default())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn all_backends() -> Vec<BackendId> {
vec![
BackendId::DuckDuckGo,
BackendId::Google,
BackendId::Bing,
BackendId::Wikipedia,
BackendId::HackerNews,
BackendId::Arxiv,
BackendId::Github,
BackendId::Reddit,
BackendId::StackOverflow,
BackendId::Brave,
]
}
#[test]
fn academic_query_prefers_arxiv() {
let abs = AdaptiveBackendSelector::default();
let selection = abs.select(&QueryIntent::Academic, &all_backends(), &[]);
let top3: Vec<_> = selection.backends.iter().take(3).collect();
assert!(
top3.contains(&&BackendId::Arxiv),
"Academic query should include arXiv in top 3, got: {:?}",
top3
);
}
#[test]
fn code_query_prefers_github() {
let abs = AdaptiveBackendSelector::default();
let selection = abs.select(&QueryIntent::Code, &all_backends(), &[]);
let top3: Vec<_> = selection.backends.iter().take(3).collect();
assert!(
top3.contains(&&BackendId::Github),
"Code query should include GitHub in top 3, got: {:?}",
top3
);
}
#[test]
fn unhealthy_backends_excluded() {
let abs = AdaptiveBackendSelector::default();
let unhealthy = vec![BackendId::Google, BackendId::Bing];
let selection = abs.select(&QueryIntent::Factual, &all_backends(), &unhealthy);
assert!(!selection.backends.contains(&BackendId::Google));
assert!(!selection.backends.contains(&BackendId::Bing));
}
#[test]
fn respects_max_backends() {
let config = AbsConfig {
max_backends: 3,
min_backends: 1,
..AbsConfig::default()
};
let abs = AdaptiveBackendSelector::new(config);
let selection = abs.select(&QueryIntent::Factual, &all_backends(), &[]);
assert!(selection.backends.len() <= 3);
}
#[test]
fn learning_improves_selection() {
let abs = AdaptiveBackendSelector::default();
for _ in 0..20 {
abs.report_outcome(&BackendId::Wikipedia, 10, 0.95);
}
for _ in 0..20 {
abs.report_outcome(&BackendId::Bing, 0, 0.0);
}
let selection = abs.select(&QueryIntent::Factual, &all_backends(), &[]);
let wiki_pos = selection
.backends
.iter()
.position(|b| *b == BackendId::Wikipedia);
let bing_pos = selection
.backends
.iter()
.position(|b| *b == BackendId::Bing);
match (wiki_pos, bing_pos) {
(Some(w), Some(b)) => assert!(w < b, "Wikipedia should rank above Bing after learning"),
(Some(_), None) => {} _ => panic!("Wikipedia should be selected"),
}
}
#[test]
fn reliable_backend_always_included() {
let config = AbsConfig {
always_include_reliable: true,
max_backends: 3,
min_backends: 1,
..AbsConfig::default()
};
let abs = AdaptiveBackendSelector::new(config);
let backends = vec![
BackendId::Arxiv,
BackendId::Github,
BackendId::HackerNews,
BackendId::Wikipedia, ];
let selection = abs.select(&QueryIntent::Factual, &backends, &[]);
assert!(
selection.backends.contains(&BackendId::Wikipedia)
|| selection.backends.contains(&BackendId::DuckDuckGo),
"Should include at least one reliable backend for Factual"
);
let code_backends = vec![
BackendId::Arxiv,
BackendId::Github,
BackendId::HackerNews,
BackendId::StackOverflow, ];
let selection = abs.select(&QueryIntent::Code, &code_backends, &[]);
assert!(
selection.backends.contains(&BackendId::StackOverflow)
|| selection.backends.contains(&BackendId::DuckDuckGo),
"Should include at least one reliable backend for Code"
);
}
#[test]
fn empty_available_returns_empty() {
let abs = AdaptiveBackendSelector::default();
let selection = abs.select(&QueryIntent::Factual, &[], &[]);
assert!(selection.backends.is_empty());
}
#[test]
fn factual_excludes_code_backends() {
let abs = AdaptiveBackendSelector::default();
let backends = vec![
BackendId::StackOverflow,
BackendId::Github,
BackendId::Wikipedia,
BackendId::DuckDuckGo,
BackendId::Searxng,
];
let selection = abs.select(&QueryIntent::Factual, &backends, &[]);
assert!(!selection.backends.contains(&BackendId::StackOverflow));
assert!(!selection.backends.contains(&BackendId::Github));
}
#[test]
fn current_events_excludes_static_dev_sources() {
let abs = AdaptiveBackendSelector::default();
let backends = vec![
BackendId::StackOverflow,
BackendId::Github,
BackendId::Arxiv,
BackendId::HackerNews,
BackendId::Searxng,
BackendId::DuckDuckGo,
];
let selection = abs.select(&QueryIntent::CurrentEvents, &backends, &[]);
assert!(!selection.backends.contains(&BackendId::StackOverflow));
assert!(!selection.backends.contains(&BackendId::Github));
assert!(!selection.backends.contains(&BackendId::Arxiv));
}
}