Marketplace · Embeddings

snowflake-arctic-embed-l-v2.0-Q4_K_M

Call snowflake-arctic-embed-l-v2.0-Q4_K_M through one OpenAI-compatible API. It's served by 1 host on the Inpherio grid, each at a price it sets — your request goes to the cheapest healthy one, and fails over to the next if it's down.

From
£0.03
per 1M tokens
£1 buys about 33 million tokens (≈ 25 million words)
Hosts
1
Loaded now
0

At a glance.

  • Type: Embeddings
  • Hosts serving it now: 1 (0 with it loaded in memory)
  • Engines: llama_cpp
  • Rentable: a whole host from £0.10 an hour (rentals)
python · openai sdk
from openai import OpenAI
client = OpenAI(base_url="https://inpherio.co.uk/v1",
                api_key=INPHERIO_API_KEY)
vec = client.embeddings.create(
    model="snowflake-arctic-embed-l-v2.0-Q4_K_M",
    input="text to embed",
)

snowflake-arctic-embed-l-v2.0-Q4_K_M in detail.

1. Multilingual without compromise: Excels in English and non-English retrieval, outperforming leading open-source and proprietary models on benchmarks like MTEB Retrieval, CLEF, and MIRACL.

Published by
Snowflake
Parameters
568M
Format
sentence-transformers
Architecture
xlm-roberta
Licence
Apache 2.0
Task
sentence similarity
Library
sentence-transformers
Languages
af, ar, az, be, bg, bn, ca, ceb, cs, cy, da, de
First published
8 Nov 2024
Last updated
28 Jul 2025
Downloads (30 days)
3.3 million on Hugging Face
Likes
268

sentence-transformers onnx xlm-roberta feature-extraction sentence-similarity mteb arctic snowflake-arctic-embed transformers.js af ar az be bg bn ca

The model card

Published by the model's authors on Hugging Face — shown as they wrote it, unedited by Inpherio.

Snowflake's Arctic-embed-l-v2.0

News | Models | Usage | Evaluation | Contact | FAQ License | Acknowledgement

News

Models

Snowflake arctic-embed-l-v2.0 is the newest addition to the suite of embedding models Snowflake has released optimizing for retrieval performance and inference efficiency. Arctic Embed 2.0 introduces a new standard for multilingual embedding models, combining high-quality multilingual text retrieval without sacrificing performance in English. Released under the permissive Apache 2.0 license, Arctic Embed 2.0 is ideal for applications that demand reliable, enterprise-grade multilingual search and retrieval at scale.

Key Features:

  1. Multilingual without compromise: Excels in English and non-English retrieval, outperforming leading open-source and proprietary models on benchmarks like MTEB Retrieval, CLEF, and MIRACL.
  1. Inference efficiency: Its 303m non-embedding parameters inference is fast and efficient for any scale.
  1. Compression-friendly: Achieves high-quality retrieval with embeddings as small as 128 bytes/vector using Matryoshka Representation Learning (MRL) and quantization-aware embedding training. **Please note that like our v1.5 model, the MRL for this model is 256 dimensions, and high-quality 128-byte compression is achieved via 4-bit quantization (e.g. using a pq256x4fs fast-scan FAISS index or using the example code published alongside our 1.5 model).**
  1. Drop-In Replacement: arctic-embed-l-v2.0 builds on BAAI/bge-m3-retromae which allows direct drop-in inference replacement with any form of new libraries, kernels, inference engines etc.
  1. Long Context Support: arctic-embed-l-v2.0 builds on BAAI/bge-m3-retromae which can support a context window of up to 8192 via the use of RoPE.

Quality Benchmarks

Unlike most other open-source models, Arctic-embed-l-v2.0 excels across English (via MTEB Retrieval) and multilingual (via MIRACL and CLEF). You no longer need to support models to empower high-quality English and multilingual retrieval. All numbers mentioned below are the average NDCG@10 across the dataset being discussed.

Model Name# params# non-emb params# dimensionsBEIR (15)MIRACL (4)CLEF (Focused)CLEF (Full)
snowflake-arctic-l-v2.0568M303M102455.655.852.954.3
snowflake-arctic-m109M86M76854.924.934.429.1
snowflake-arctic-l335M303M102456.034.838.233.7
me5 base560M303M102451.454.043.034.6
bge-m3 (BAAI)568M303M102448.856.840.841.3
gte (Alibaba)305M113M76851.152.347.753.1

Aside from high-quality retrieval arctic delivers embeddings that are easily compressible. Leverage vector truncation via MRL to decrease vector size by 4x with less than 3% degredation in quality. Combine MRLed vectors with vector compression (Int4) to power retrieval in 128 bytes per doc.

ModelBEIR (15)Relative PerformanceMIRACL (4)Relative PerformanceCLEF (5)Relative PerformanceCLEF (Full)Relative Performance
snowflake-arctic-l-v2.0102455.6N/A55.8N/A52.9N/A54.3N/A
snowflake-arctic-l-v2.025654.3-0.18%54.3-2.70%51.9-1.81%53.4-1.53%
Read the rest of the model card

Usage

Using Sentence Transformers

from sentence_transformers import SentenceTransformer

### Load the model
model_name = 'Snowflake/snowflake-arctic-embed-l-v2.0'
model = SentenceTransformer(model_name)

### Define the queries and documents
queries = ['what is snowflake?', 'Where can I get the best tacos?']
documents = ['The Data Cloud!', 'Mexico City of Course!']

### Compute embeddings: use `prompt_name="query"` to encode queries!
query_embeddings = model.encode(queries, prompt_name="query") 
document_embeddings = model.encode(documents)

### Compute cosine similarity scores
scores = model.similarity(query_embeddings, document_embeddings)

### Output the results
for query, query_scores in zip(queries, scores):
    doc_score_pairs = list(zip(documents, query_scores))
    doc_score_pairs = sorted(doc_score_pairs, key=lambda x: x[1], reverse=True)
    print("Query:", query)
    for document, score in doc_score_pairs:
        print(score, document)

Using Huggingface Transformers

You can use the transformers package to use Snowflake's arctic-embed model, as shown below. For optimal retrieval quality, use the CLS token to embed each text portion and use the query prefix below (just on the query).

import torch
from transformers import AutoModel, AutoTokenizer

model_name = 'Snowflake/snowflake-arctic-embed-l-v2.0'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name, add_pooling_layer=False)
model.eval()

query_prefix = 'query: '
queries  = ['what is snowflake?', 'Where can I get the best tacos?']
queries_with_prefix = ["{}{}".format(query_prefix, i) for i in queries]
query_tokens = tokenizer(queries_with_prefix, padding=True, truncation=True, return_tensors='pt', max_length=8192)

documents = ['The Data Cloud!', 'Mexico City of Course!']
document_tokens =  tokenizer(documents, padding=True, truncation=True, return_tensors='pt', max_length=8192)

### Compute token embeddings
with torch.no_grad():
    query_embeddings = model(**query_tokens)[0][:, 0]
    document_embeddings = model(**document_tokens)[0][:, 0]

### normalize embeddings
query_embeddings = torch.nn.functional.normalize(query_embeddings, p=2, dim=1)
document_embeddings = torch.nn.functional.normalize(document_embeddings, p=2, dim=1)

scores = torch.mm(query_embeddings, document_embeddings.transpose(0, 1))
for query, query_scores in zip(queries, scores):
    doc_score_pairs = list(zip(documents, query_scores))
    doc_score_pairs = sorted(doc_score_pairs, key=lambda x: x[1], reverse=True)
    #Output passages & scores
    print("Query:", query)
    for document, score in doc_score_pairs:
        print(score, document)

This should produce the following scores

Query: what is snowflake?
tensor(0.2715) The Data Cloud!
tensor(0.0661) Mexico City of Course!
Query: Where can I get the best tacos?
tensor(0.2797) Mexico City of Course!
tensor(0.1250) The Data Cloud!

Using Huggingface Transformers.js

If you haven't already, you can install the Transformers.js JavaScript library from NPM using:

npm i @huggingface/transformers

You can then use the model for retrieval, as follows:

import { pipeline, dot } from '@huggingface/transformers';

// Create feature extraction pipeline
const extractor = await pipeline('feature-extraction', 'Snowflake/snowflake-arctic-embed-m-v2.0', {
    dtype: 'q8',
});

// Generate sentence embeddings
const sentences = [
    'query: what is snowflake?',
    'The Data Cloud!',
    'Mexico City of Course!',
]
const output = await extractor(sentences, { normalize: true, pooling: 'cls' });

// Compute similarity scores
const [source_embeddings, ...document_embeddings ] = output.tolist();
const similarities = document_embeddings.map(x => dot(source_embeddings, x));
console.log(similarities); // [0.24783534471401417, 0.05313122704326892]

Contact

Feel free to open an issue or pull request if you have any questions or suggestions about this project. You also can email Daniel Campos([email protected]).

License

Arctic is licensed under the Apache-2. The released models can be used for commercial purposes free of charge.

Sources: Snowflake/snowflake-arctic-embed-l-v2.0 on Hugging Face. Collected from public sources on 8 Nov 2026; the host serving it may run a different build or quantisation — the marketplace shows each host's own measurements.

Who's serving it.

Every host benchmarked this model on its own hardware before serving it. Prices are set by each host; health is scored by the platform from what it observes.

Hosts serving snowflake-arctic-embed-l-v2.0-Q4_K_M right now
HostTierPriceMeasured speedHealthStateRent
iPhone 14 Pro Max · on-deviceL1£0.0377 ms79loads on request£0.10/h

Live data, refreshed on every visit. How billing works.

Room on the grid for your machine.

Right now one machine serves snowflake-arctic-embed-l-v2.0-Q4_K_M. If it drops, so does every request for it — a second host is what turns it into failover, and the grid needs that more than another copy. The router weighs price, measured speed, health and whether the model is already loaded — so a host with a sharper price or quicker hardware wins the next call.

Hosts now
1
0 loaded in memory
Price to beat
£0.03
per 1M tokens
Fastest measured
77 ms

Set your own price — you keep 85% of what it earns, and new hosts start with 12 months fee-free (up to £250 of earnings). A payout fee of £2 + 1% per payout to a UK bank account, £2 + 2% to any other country applies when you're paid. Install the connector, load snowflake-arctic-embed-l-v2.0-Q4_K_M, and the platform benchmarks it on your hardware before your first request.