Struct StaticEncoder 

pub struct StaticEncoder { /* private fields */ }

CPU-only static encoder.

Owns a loaded StaticEmbedModel plus identity metadata. The embedder is constructed by main.rs::load_pipeline via StaticEncoder::from_pretrained, passing either a local path containing the Model2Vec files or (planned) an HF repo ID.

Implementations

impl StaticEncoder

pub fn encode_query(&self, query: &str) -> Vec<f32>

Encode a query string into a single embedding row.

Used by RipvecIndex::search for hybrid/semantic dispatch.

pub fn from_pretrained(model_repo: &str) -> Result<Self>

Load a model by HuggingFace repo ID or local path.

Two acceptance shapes:

1. Local path — if model_repo names an existing directory, load directly from it. Used by the parity test fixture path (/tmp/potion-base-32M) and any user pre-staging files.
2. HuggingFace repo ID — otherwise treat as org/repo, download config.json / tokenizer.json / model.safetensors via hf-hub into ~/.cache/huggingface/hub/, and load from there. Matches load_classic_cpu / load_modernbert_cpu’s behaviour so the user-facing API is consistent: bare --model ripvec with no --model-repo flag works.

Errors

Propagates the underlying I/O, download, or parse error if the files cannot be obtained or the safetensors layout is unrecognized.

Trait Implementations

impl VectorEncoder for StaticEncoder

fn embed_root( &self, root: &Path, cfg: &SearchConfig, profiler: &Profiler, ) -> Result<(Vec<CodeChunk>, Vec<Vec<f32>>)>

Three-stage bounded-queue pipeline:

1. Chunk producer — rayon par_iter over the file list. Each file is read, parsed by tree-sitter (or line-merged on fallback), and emitted as (CodeChunk, String) pairs into a bounded channel of capacity PIPELINE_BATCH_SIZE * 8.
2. Batch accumulator — a single scoped thread drains the chunk channel, packs PIPELINE_BATCH_SIZE pairs per batch, and forwards into a bounded channel of capacity PIPELINE_RING_SIZE.
3. Encode worker — a single scoped thread receives batches and calls StaticEmbedModel::encode_batch, whose internal par_iter lights up rayon for the pool_ids kernel.

Why this shape:

• The previous “chunk all, then embed all” implementation held the entire Vec<String> of chunk contents in memory between phases. On the linux corpus that was ~400 MB peak. The bounded queues cap in-flight memory at PIPELINE_BATCH_SIZE * 8 + PIPELINE_RING_SIZE * PIPELINE_BATCH_SIZE chunks regardless of corpus size — under 15 MB.
• The chunk phase (13s on linux) is hidden inside the embed phase (70s) instead of serializing before it. Pre-pipeline profile showed user-time at 394s on 82s wall = 4.8x parallelism on 12 cores; pipeline lets idle cores chew on chunking while embed runs.
• Mirrors embed::embed_all_streaming’s shape so the two pipelines (BERT + semble) share architectural conventions.

fn hidden_dim(&self) -> usize

Hidden dimension of the emitted embeddings.

fn identity(&self) -> &str

Stable identifier used as the cache-manifest key.