Enum EmbeddingModel 

#[non_exhaustive]
pub enum EmbeddingModel {
    BgeSmallEnV15,
    BgeBaseEnV15,
    BgeLargeEnV15,
    MultilingualE5Small,
    MultilingualE5Base,
    Qwen3Embedding0_6B,
    Qwen3Embedding4B,
    AllMiniLmL6V2,
    ParaphraseMultilingualMiniLmL12V2,
    TextEmbedding3Small,
}

Stable: external consumers may depend on this; breaking changes require a SemVer bump.

Supported embedding models.

This enum represents the embedding models available for text vectorization. Models are categorized as either local (run on-device via lattice-inference) or remote (require API calls).

Example

use lattice_embed::EmbeddingModel;

let model = EmbeddingModel::default();
assert_eq!(model.dimensions(), 384);
assert!(model.is_local());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

BgeSmallEnV15

BGE small English v1.5 (384 dimensions) - fast and efficient.

BgeBaseEnV15

BGE base English v1.5 (768 dimensions) - balanced quality/speed.

BgeLargeEnV15

BGE large English v1.5 (1024 dimensions) - highest quality local.

MultilingualE5Small

Multilingual E5 small (384 dimensions) - multilingual, same arch as BGE.

MultilingualE5Base

Multilingual E5 base (768 dimensions) - best multilingual quality/speed.

Qwen3Embedding0_6B

Qwen3-Embedding-0.6B (1024 dimensions) - multilingual, decoder-only, GPU-accelerated.

Qwen3Embedding4B

Qwen3-Embedding-4B (2560 dimensions, MRL-capable) - multilingual, decoder-only, GPU-accelerated.

AllMiniLmL6V2

all-MiniLM-L6-v2 (384 dimensions) - BERT-class, WordPiece tokenizer, sentence-transformers.

ParaphraseMultilingualMiniLmL12V2

paraphrase-multilingual-MiniLM-L12-v2 (384 dimensions) - multilingual, XLM-R base, sentence-transformers.

TextEmbedding3Small

OpenAI text-embedding-3-small (1536 dimensions) - remote API.

Implementations

impl EmbeddingModel

pub const fn native_dimensions(&self) -> usize

Stable: get the native (full-resolution) output dimension of this model’s embeddings.

Returns the model’s intrinsic dimension regardless of any MRL truncation. For MRL-capable models with a configured truncation, use ModelConfig::dimensions().

pub const fn dimensions(&self) -> usize

Stable: get the output dimension of this model’s embeddings.

Example

use lattice_embed::EmbeddingModel;

assert_eq!(EmbeddingModel::BgeSmallEnV15.dimensions(), 384);
assert_eq!(EmbeddingModel::BgeBaseEnV15.dimensions(), 768);
assert_eq!(EmbeddingModel::BgeLargeEnV15.dimensions(), 1024);

pub const fn is_local(&self) -> bool

Stable: check if this model can run locally (via lattice-inference).

pub const fn is_remote(&self) -> bool

Stable: check if this model requires a remote API.

pub const fn max_input_tokens(&self) -> usize

Stable: maximum input tokens supported by this model.

Use this for chunking/truncation decisions. Values are conservative to leave room for special tokens.

Reference limits:

• BGE models: 512 tokens
• OpenAI text-embedding-3: 8191 tokens
• Gemini embedding-001: 20000 tokens

pub const fn query_instruction(&self) -> Option<&'static str>

Stable: query instruction prefix for asymmetric retrieval.

Some models require different text for queries vs documents (asymmetric retrieval).

• E5 models (MultilingualE5Small, MultilingualE5Base): trained with “query: “ / “passage: “ asymmetric prefixes. Omitting the prefix degrades retrieval quality significantly — the model expects them during fine-tuning.

• Qwen3-Embedding models: require an instruction prompt to align the decoder embedding space for retrieval tasks.

• BGE / MiniLM models: trained with contrastive objectives on raw text; no prefix needed.

Returns Some(prefix) if the query text should be wrapped as "{prefix}{query}" before embedding. Returns None for models that don’t need instruction prompting.

pub const fn document_instruction(&self) -> Option<&'static str>

Stable: document instruction prefix for asymmetric retrieval.

Some models use different prompts for documents vs queries. Returns Some(prefix) if the document text should be wrapped as "{prefix}{text}" before embedding at storage time.

• E5 models: trained with "passage: " prefix on document/passage inputs. Omitting the prefix on the document side degrades retrieval quality because the model’s embedding space was conditioned on this asymmetry during fine-tuning.
• BGE / MiniLM: no document prefix required (contrastive training on raw text).
• Qwen3-Embedding: raw passage text is used without an instruction prefix; only the query side carries the task instruction.

pub const fn model_id(&self) -> &'static str

Stable: get the model identifier (HuggingFace ID or provider/model).

pub const fn supports_output_dim(&self) -> bool

Stable: whether this model supports configurable output dimensions (MRL/Matryoshka).

pub const fn bert_pooling(&self) -> Option<BertPooling>

Stable: the pooling strategy this model expects from BERT-family inference.

BGE v1.5 models use CLS-token pooling (first token) as documented on their HuggingFace model cards (model_output[0][:, 0]). All other BERT-family models (E5, MiniLM) use masked mean pooling.

Returns None for non-BERT models (Qwen3, OpenAI remote) which have their own pooling paths.

Only available when the native feature is enabled (requires lattice-inference).

pub const fn key_version(&self) -> &'static str

Stable: embedding key revision string for this model family.

Trait Implementations

impl Clone for EmbeddingModel

fn clone(&self) -> EmbeddingModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for EmbeddingModel

impl Debug for EmbeddingModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EmbeddingModel

fn default() -> EmbeddingModel

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EmbeddingModel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for EmbeddingModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for EmbeddingModel

impl FromStr for EmbeddingModel

fn from_str(s: &str) -> Result<Self, Self::Err>

Stable: parse model from string (case-insensitive, flexible matching).

Accepts:

• Display names: “bge-small-en-v1.5”
• Short names: “bge-small”, “small”
• HuggingFace IDs: “BAAI/bge-small-en-v1.5”

type Err = String

The associated error which can be returned from parsing.

impl Hash for EmbeddingModel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EmbeddingModel

fn eq(&self, other: &EmbeddingModel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EmbeddingModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EmbeddingModel