second_brain_core/
embedding.rs1use 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 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}