F2LLM-v2-1.7B

F2LLM-v2-1.7B is a general-purpose, multilingual embedding model developed by CodeFuse-AI (Ant Group). It’s part of the F2LLM-v2 family, which spans eight sizes from 80M to 14B parameters, all trained on a curated composite of 60 million publicly available high-quality text samples. The 1.7B variant is the sweet spot for practitioners who need strong multilingual retrieval and semantic understanding without the VRAM footprint of larger models.

This is not a chatbot or generative model—it’s a dense encoder optimized for feature extraction and sentence embeddings. Its primary value is producing high-quality vector representations for search, clustering, classification, and retrieval-augmented generation (RAG) pipelines, especially in environments where you cannot offload to cloud APIs. The model supports over 200 languages, with particular attention to mid- and low-resource languages that are often underserved by mainstream embedders.

F2LLM-v2-1.7B competes directly with other small multilingual embedders like multilingual-e5-small and bge-m3 at similar parameter counts. What sets it apart is its open-source transparency: Ant Group released the full training recipe, intermediate checkpoints, and data, making it a reproducible, auditable choice for production systems.

F2LLM-v2-1.7B is a dense transformer encoder with 1.7 billion parameters. It uses a decoder-only backbone (based on Qwen3) but is fine-tuned exclusively for embedding tasks via a two-stage pipeline:

• Stage 1: Contrastive pretraining on the 60M multilingual dataset, learning to align semantically similar texts across languages.
• Stage 2: Instruction tuning with Matryoshka Representation Learning (MRL) and knowledge distillation. MRL lets the model produce variable-dimension embeddings (e.g., 256, 512, 1024) from a single forward pass, giving you control over storage vs. accuracy tradeoffs without retraining.

The model is designed for the transformers library and integrates directly with Sentence Transformers. It uses a standard attention mechanism—no mixture-of-experts (MoE)—so inference is straightforward and predictable in terms of memory and latency.

Context length is not officially specified, but based on the Qwen3 backbone and typical embedding model defaults, you can expect at least 8192 tokens. For most embedding use cases (sentences, paragraphs, documents under 8K tokens), this is sufficient.

F2LLM-v2-1.7B excels at multilingual semantic search and cross-lingual retrieval. It achieves state-of-the-art results on 11 language-specific MTEB leaderboards, including European, Scandinavian, Indic, and East Asian languages. Key strengths:

• Cross-lingual retrieval: Query in English, retrieve relevant documents in Hindi, Vietnamese, or Persian with near-native accuracy.
• Low-resource language support: Covers languages like Swahili, Burmese, Khmer, and Lao that most embedders ignore.
• Matryoshka embeddings: Reduce storage costs by using 256‑dim vectors for approximate search, then re-rank with 1024‑dim for precision—all from the same model.
• RAG pipelines: Use it as the embedding backbone for local RAG systems where the knowledge base spans multiple languages.

Concrete use cases:

• A multilingual FAQ system for a global customer base, where user queries come in Spanish, Arabic, or Thai.
• Document clustering for a research team working with papers in Japanese, German, and Dutch.
• Local-first search over a company’s internal knowledge base in 20+ languages, running on a single consumer GPU.

This model is designed for resource-constrained deployments. Here’s what you need to run it on your own hardware.

• Minimum: Any GPU with 2 GB VRAM (e.g., GTX 1060 6GB, RTX 3050) can run Q4_K_M comfortably.
• Recommended: RTX 3060 12GB or RTX 4060—allows FP16 inference with headroom for batching.
• Apple Silicon: M1/M2/M3/M4 with 8 GB RAM can run Q4_K_M via llama.cpp or MLX. Expect 50–100 tokens/second on an M4 Max.
• CPU-only: Possible with Q4_K_M and 8 GB system RAM, but expect 10–20 tokens/second.

On an RTX 4090 with Q4_K_M, you can process 1000+ tokens/second (batch size 1). For embedding a sentence (~32 tokens), expect <1 ms latency. Throughput scales linearly with batch size up to the GPU’s memory limit.

The fastest way to get started:

1ollama run codefuse-ai/f2llm-v2-1.7b

This pulls the Q4_K_M quantized model and provides a simple API for embedding. For more control, use the transformers library with sentence-transformers:

1from sentence_transformers import SentenceTransformer
2model = SentenceTransformer('codefuse-ai/F2LLM-v2-1.7B')
3embeddings = model.encode(["Your text here"])

Choose F2LLM-v2-1.7B when you need the best accuracy per parameter for multilingual retrieval, especially if your use case includes languages like Hindi, Arabic, or Vietnamese. If you’re strictly English-only or need the smallest possible model, the 0.6B variant of F2LLM-v2 may be a better fit. For pure speed and minimal VRAM, multilingual-e5-small is still a solid option—but you’ll sacrifice accuracy on mid- and low-resource languages.