Struct Embedder 

pub struct Embedder { /* private fields */ }

Implementations

impl Embedder

pub fn load(config: EmbedderConfig) -> Result<Self, EmbedError>

pub fn model_id(&self) -> &str

pub fn native_dim(&self) -> usize

pub fn dimension(&self) -> usize

pub fn provider_used(&self) -> &str

Provider serving inference: "cpu", "directml" or "coreml".

pub fn fallback_reason(&self) -> Option<&str>

Why an accelerator was replaced by CPU, when it was. A vector parity failure reads like directml -> cpu: vector parity failed: cosine 0.579 at ~20 tokens, floor 0.995.

pub fn accelerator_parity(&self) -> Option<AcceleratorParity>

The load-time vector parity result of the accelerator in use: lowest cosine to the CPU provider’s vectors, the prompt length it occurred at and the pairs compared. None when the provider is CPU (no parity work is done) and when an accelerator was replaced by CPU (the failure is in Self::fallback_reason). Always at least ACCELERATOR_PARITY_MIN_COSINE when Some.

pub fn load_timings(&self) -> Option<&LoadTimings>

Where Embedder::load spent its time, for an E40 bundle (including one that fell back to the E40 graphs on CPU): tokenizer load, token-table read, probe, every graph build and the parity check (or its cached verdict). For a Core ML bundle (macOS) it holds the tokenizer load, probe, parity check, pre-warm (total and per length) and the total; the phases it has no figure for stay zero or None. None for every other bundle and for a Q4 embedder served from fallback_model_dir.

pub fn coreml_units(&self) -> Option<&CoreMlUnits>

The Core ML compute units in use per length: Some for a Core ML bundle (macOS) that was not replaced by a Q4 fallback, None for every other embedder. An embedder that fell back to the package on CPU reports cpu_only everywhere.

pub fn pipeline_id(&self) -> String

Stable fingerprint of everything that changes the produced vectors, so callers can detect when stored vectors need re-embedding. Fed by:

• the pipeline schema version of this crate’s embedding math;
• model id and native dimension;
• SHA-256 of model_q4.onnx, model_q4.onnx_data, tokenizer.json and config.json (absent file recorded as absent);
• the document and query prompt templates;
• pooling and normalization descriptions;
• Matryoshka truncate dimension and max token length;
• whether Gemma 2 modality sentinels are scrubbed.

Not fed by provider, thread count or batch size: those change only floating-point noise (see max_batch tolerance in the README), not the pipeline. The accelerator parity check is not an input either: it only decides which provider serves the same math, and an admitted accelerator reproduces the CPU vectors to the parity floor. Computed once on first call (hashes the model files) and cached; format rkpipe1-<32 hex>.

pub fn embed(&self, text: &str) -> Result<Vec<f32>, EmbedError>

pub fn embed_query(&self, text: &str) -> Result<Vec<f32>, EmbedError>

pub fn embed_batch<'a, I>(&self, texts: I) -> Result<Vec<Vec<f32>>, EmbedError>

where I: IntoIterator<Item = &'a str>,

Embeds documents in input order. Texts are tokenized together, ordered by length so chunks pad little, run max_batch rows per ONNX call with the attention mask honoured, then returned in input order.

pub fn embed_query_batch<'a, I>( &self, texts: I, ) -> Result<Vec<Vec<f32>>, EmbedError>

where I: IntoIterator<Item = &'a str>,

Query-prompt counterpart of Self::embed_batch.