Liquid AI's LFM2.5 Beats Larger Rivals at Multilingual Search in 11 Languages
Liquid AI releases two 350M retrieval models with sub-2ms GPU latency and best-in-class multilingual search across 11 languages

- Liquid AI releases LFM2.5-Embedding-350M and LFM2.5-ColBERT-350M, two 350M multilingual retrieval models covering 11 languages.
- Sub-2ms query latency on H100 GPU; under 10ms on MacBook M4 Max via llama.cpp GGUF.
- Both are the first bidirectional encoders in the LFM family, built by patching the causal LFM2.5-350M-Base backbone.
- LFM2.5-ColBERT-350M scores 0.605 avg NDCG@10 on NanoBEIR multilingual, beating GTE-ModernColBERT-v1 (0.489) and LightOn LateOn (0.484).
- Three-stage training: English contrastive pretraining, multilingual distillation from a teacher model, then hard-negative fine-tuning.
- Available now on Hugging Face; plug into
sentence-transformers(Embedding) orpylate(ColBERT) with drop-in RAG compatibility.
Retrieval is one of those problems where you're always trading something. Speed costs accuracy. Accuracy costs index size. Multilingual coverage costs both. Liquid AI just released two models that try to sidestep that tradeoff: LFM2.5-Embedding-350M and LFM2.5-ColBERT-350M, a pair of 350M-parameter multilingual retrieval models that cover 11 languages and hit sub-2ms query latency on GPU.
Two models, one decision
Both models are 350M parameters and the first bidirectional members of the LFM family, built on LFM2.5-350M-Base. They are designed for fast and reliable multilingual and cross-lingual search across 11 languages, with a footprint small enough to run almost anywhere.
The two models represent different points on the speed-vs-accuracy curve:
- LFM2.5-Embedding-350M: turns each document into a single vector. Pick it when you want the fastest search and the smallest, cheapest index.
- LFM2.5-ColBERT-350M: converts each token into a vector rather than a single vector per document. This lets it match queries word-by-word for higher accuracy and better generalization, at the cost of a larger index. Pick it when accuracy matters more than storage.
The ColBERT approach (late interaction) is worth understanding. Queries and documents are encoded separately at the token level. The system compares token vectors at query time using MaxSim (maximum similarity). This preserves fine-grained token interactions without the full cost of joint cross-attention, and allows pre-computation for documents. In practice, you get something closer to a reranker's precision at a bi-encoder's speed.
The architecture trick that makes it work
Both models are built from LFM2.5-350M-Base, a mid-trained general-purpose checkpoint. Liquid AI applies a small set of bidirectional patches to the LFM2 architecture, adapting it from a causal decoder to a bidirectional encoder.
This is the key architectural move. Standard LFMs are causal: each token only sees what came before it, which is great for text generation but suboptimal for retrieval. The team replaces the causal attention mask with a bidirectional one, so every token can attend to both left and right context. They also make the LFM2 short convolutions non-causal, so they mix local information symmetrically around each token rather than only from the past.
From this shared bidirectional encoder, the two models differ only in how they represent text. LFM2.5-Embedding-350M uses CLS-style pooling to produce a single dense embedding, while LFM2.5-ColBERT-350M keeps compact per-token embeddings for MaxSim late interaction.
How they were trained
Both models follow the same three-stage training recipe: large-scale contrastive pretraining in English, multilingual and cross-lingual distillation from a strong teacher across all 11 supported languages, and final fine-tuning on hard-mined negatives. Hard-mined negatives means the training data includes documents that are close but wrong, forcing the model to learn fine-grained distinctions rather than just separating obviously unrelated content.
The training data combines curated internal data with open-source English retrieval datasets. Liquid AI leverages LLM-based translation of queries and documents to expand multilingual and cross-lingual pairs used during the second and third training phases.
The numbers
Evaluation focuses on two capabilities: multilingual retrieval with NanoBEIR, and cross-lingual open-domain QA with MKQA-11. Together, they test whether the models can retrieve relevant documents within a language and across language boundaries.
On NanoBEIR Multilingual Extended (NDCG@10), both models lead their respective categories across almost every language:
| Model | Type | AVG | ar | ja | ko | en |
|---|---|---|---|---|---|---|
| LFM2.5-ColBERT-350M | Late interaction | 0.605 | 0.551 | 0.614 | 0.590 | 0.687 |
| LFM2.5-Embedding-350M | Dense bi-encoder | 0.577 | 0.529 | 0.575 | 0.563 | 0.644 |
| Qwen3-Embedding-0.6B | Dense bi-encoder | 0.556 | 0.514 | 0.551 | 0.530 | 0.649 |
| GTE-ModernColBERT-v1 | Late interaction | 0.489 | 0.309 | 0.459 | 0.368 | 0.680 |
The gap is especially pronounced in non-European languages. GTE-ModernColBERT-v1 scores 0.309 on Arabic and 0.368 on Korean; LFM2.5-ColBERT-350M scores 0.551 and 0.590 respectively. The Embedding model similarly outperforms Qwen3-Embedding-0.6B despite being smaller (350M vs 600M parameters).
One caveat: both models show best-in-class multilingual and cross-lingual performance, but their results remain consistently competitive across all 11 supported languages rather than dominating English specifically. On English-only NanoBEIR, LateOn from LightOn actually edges out LFM2.5-ColBERT (0.690 vs 0.687). These models are optimized for multilingual breadth, not English-only depth.
Latency that actually matters
Benchmark scores are one thing. Latency in production is another. Liquid AI measured end-to-end query embedding latency across two deployment targets:
- MacBook M4 Max via llama.cpp (FP16): query embedding runs at 7.3ms p50 for the Embedding model and 8.1ms p50 for ColBERT. With MaxSim included, ColBERT stays at 8.2ms p50 when documents are cached.
- H100 GPU with Liquid's internal stack: query embedding hits 1.5ms p50 for the Embedding model and 1.3ms p50 for ColBERT. Full ColBERT with MaxSim runs at 2.5ms p50.
For portable deployment, Liquid AI releases GGUF versions of both models for llama.cpp, so the models can run on CPUs, laptops, and edge devices at near-zero cost.
Getting started
Both models plug directly into standard tooling. The Embedding model uses sentence-transformers; the ColBERT model uses pylate. Here's the minimal setup for each:
# Dense bi-encoder (sentence-transformers)
from sentence_transformers import SentenceTransformer
model = SentenceTransformer(
"LiquidAI/LFM2.5-Embedding-350M",
trust_remote_code=True,
)
q_emb = model.encode(["What is the capital of France?"], prompt_name="query", normalize_embeddings=True)
d_emb = model.encode(["Paris is the capital of France."], prompt_name="document", normalize_embeddings=True)
scores = q_emb @ d_emb.T# Late interaction ColBERT (pylate)
from pylate import models, indexes, retrieve
model = models.ColBERT(
model_name_or_path="LiquidAI/LFM2.5-ColBERT-350M",
trust_remote_code=True,
)
# Encode documents once, cache the index
docs_emb = model.encode(["document text"], is_query=False)
# Encode query at search time
query_emb = model.encode(["search query"], is_query=True)Both models can be used as a drop-in replacement for your current RAG pipeline and target fast, cheap, and reliable multilingual and cross-lingual search across 11 languages. The official blog post also recommends fine-tuning the Embedding model on domain-specific data using standard sentence-transformers training for best results on specialized corpora.
Where it fits
The models are especially well-suited for short-context search: product catalogs, FAQ knowledge bases, support docs, and other collections that need to be searched quickly, cost-effectively, and reliably across languages. Specifically:
- E-commerce: semantic product search where descriptions are in one language but users query in another
- FAQ and support: retrieve the right answer reliably across customer-facing surfaces
- On-device search: search files, emails, and notes locally on consumer hardware via GGUF
- Enterprise knowledge assistants: retrieve internal legal, financial, and technical documents across languages
Both LFM2.5-Embedding-350M and LFM2.5-ColBERT-350M are available now on Hugging Face under the LFM Open License v1.0. Enterprise deployment is available through Liquid AI's LEAP platform.