Skip to main content

second_brain_core/
embedding.rs

1use std::sync::Mutex;
2use std::sync::atomic::{AtomicU64, Ordering};
3use std::time::{SystemTime, UNIX_EPOCH};
4
5use anyhow::{Context, Result};
6use fastembed::{EmbeddingModel, InitOptions, TextEmbedding};
7
8pub struct Embedder {
9    model: Mutex<Option<TextEmbedding>>,
10    last_used_secs: AtomicU64,
11}
12
13pub fn query_prompt(text: &str) -> String {
14    format!("Represent this sentence for searching relevant passages: {text}")
15}
16
17fn now_secs() -> u64 {
18    SystemTime::now()
19        .duration_since(UNIX_EPOCH)
20        .unwrap_or_default()
21        .as_secs()
22}
23
24fn load_model() -> Result<TextEmbedding> {
25    TextEmbedding::try_new(
26        InitOptions::new(EmbeddingModel::BGESmallENV15).with_show_download_progress(false),
27    )
28    .context("loading embedding model")
29}
30
31impl Embedder {
32    pub fn new() -> Result<Self> {
33        let model = TextEmbedding::try_new(
34            InitOptions::new(EmbeddingModel::BGESmallENV15).with_show_download_progress(true),
35        )
36        .context("initializing embedding model")?;
37
38        Ok(Self {
39            model: Mutex::new(Some(model)),
40            last_used_secs: AtomicU64::new(now_secs()),
41        })
42    }
43
44    pub fn embed(&self, text: &str) -> Result<Vec<f32>> {
45        let mut guard = self.model.lock().unwrap();
46        if guard.is_none() {
47            tracing::info!("reloading embedding model after idle drop");
48            *guard = Some(load_model()?);
49        }
50        self.last_used_secs.store(now_secs(), Ordering::Relaxed);
51        let results = guard
52            .as_mut()
53            .unwrap()
54            .embed(vec![text], None)
55            .context("generating embedding")?;
56        results
57            .into_iter()
58            .next()
59            .ok_or_else(|| anyhow::anyhow!("no embedding returned"))
60    }
61
62    // BGE retrieval is asymmetric: the instruction prefix goes on the query only,
63    // documents stay bare, so embed() is left unchanged.
64    pub fn embed_query(&self, text: &str) -> Result<Vec<f32>> {
65        self.embed(&query_prompt(text))
66    }
67
68    pub fn embed_batch(&self, texts: &[&str]) -> Result<Vec<Vec<f32>>> {
69        let mut guard = self.model.lock().unwrap();
70        if guard.is_none() {
71            tracing::info!("reloading embedding model after idle drop");
72            *guard = Some(load_model()?);
73        }
74        self.last_used_secs.store(now_secs(), Ordering::Relaxed);
75        let owned: Vec<String> = texts.iter().map(|t| t.to_string()).collect();
76        let refs: Vec<&str> = owned.iter().map(|s| s.as_str()).collect();
77        guard
78            .as_mut()
79            .unwrap()
80            .embed(refs, None)
81            .context("generating batch embeddings")
82    }
83
84    pub fn drop_if_idle(&self, idle_secs: u64) {
85        let last = self.last_used_secs.load(Ordering::Relaxed);
86        if now_secs().saturating_sub(last) >= idle_secs {
87            let mut guard = self.model.lock().unwrap();
88            if guard.is_some() {
89                *guard = None;
90                tracing::info!("embedding model dropped after {}s idle", idle_secs);
91            }
92        }
93    }
94
95    pub fn dimension(&self) -> usize {
96        384
97    }
98}