Marketplace · Embeddings

snowflake-arctic-embed:latest

Call snowflake-arctic-embed:latest through one OpenAI-compatible API, served by independent machines at prices their owners set. There's no host for it on the grid at this moment (last live 16 Jul 2026) — so the next machine that loads it serves every request for it.

Hosts now
0
open slot

The grid is one machine short.

If your machine already runs open models, it can most likely serve snowflake-arctic-embed:latest too. 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.

  1. Install the connector. One command on the machine that runs your models. It dials out over an encrypted link — no ports to open. The connector
  2. Load snowflake-arctic-embed:latest. It has run here on ollama; any supported engine works. The platform benchmarks it on your hardware first.
  3. Set your price. Developers see your price beside the speed your machine measures.
  4. Get paid when it's called. Switch it off whenever you like. How hosting works

About snowflake-arctic-embed:latest.

  • Type: Embeddings
  • Runs on: ollama
  • First on the grid: 16 Jul 2026
  • Hosts serving it now: 0
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:latest",
    input="text to embed",
)

snowflake-arctic-embed:latest in detail.

A suite of text embedding models by Snowflake, optimized for performance.

Published by
Snowflake
Parameters
334M
Download size
669 MB (as packaged for Ollama)
Quantisation
F16
Format
gguf
Architecture
bert
Licence
Apache 2.0
Task
sentence similarity
Library
sentence-transformers
First published
12 Apr 2024
Last updated
19 Dec 2024
Downloads (30 days)
536,287 on Hugging Face
Likes
114

sentence-transformers onnx bert feature-extraction sentence-similarity mteb arctic snowflake-arctic-embed transformers.js text-embeddings-inference

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

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

News

12/04/2024: Release of snowflake-arctic-embed-l-v2.0 and snowflake-arctic-embed-m-v2.0 our newest models with multilingual workloads in mind. These models outperform prior versions of Arctic Embed and we suggest these replace prior versions!

07/26/2024: Release preprint [[2407.18887] Embedding And Clustering Your Data Can Improve Contrastive Pretraining](https://arxiv.org/abs/2407.18887) on arXiv.

07/18/2024: Release of snowflake-arctic-embed-m-v1.5, capable of producing highly compressible embedding vectors that preserve quality even when squished as small as 128 bytes per vector. Details about the development of this model are available in the launch post on the Snowflake engineering blog.

05/10/2024: Release the technical report on Arctic Embed

04/16/2024: Release the snowflake-arctic-embed family of text embedding models. The releases are state-of-the-art for Retrieval quality at each of their representative size profiles. [Technical Report]() is coming shortly. For more details, please refer to our Github: Arctic-Text-Embed.

Models

snowflake-arctic-embed is a suite of text embedding models that focuses on creating high-quality retrieval models optimized for performance.

The snowflake-arctic-embedding models achieve state-of-the-art performance on the MTEB/BEIR leaderboard for each of their size variants. Evaluation is performed using these scripts. As shown below, each class of model size achieves SOTA retrieval accuracy compared to other top models.

The models are trained by leveraging existing open-source text representation models, such as bert-base-uncased, and are trained in a multi-stage pipeline to optimize their retrieval performance. First, the models are trained with large batches of query-document pairs where negatives are derived in-batch—pretraining leverages about 400m samples of a mix of public datasets and proprietary web search data. Following pretraining models are further optimized with long training on a smaller dataset (about 1m samples) of triplets of query, positive document, and negative document derived from hard harmful mining. Mining of the negatives and data curation is crucial to retrieval accuracy. A detailed technical report can be found here.

NameMTEB Retrieval Score (NDCG @ 10)Parameters (Millions)Embedding Dimension
snowflake-arctic-embed-xs50.1522384
snowflake-arctic-embed-s51.9833384
snowflake-arctic-embed-m54.90110768
snowflake-arctic-embed-m-long54.83137768
snowflake-arctic-embed-l55.983351024

Aside from being great open-source models, the largest model, snowflake-arctic-embed-l, can serve as a natural replacement for closed-source embedding, as shown below.

Model NameMTEB Retrieval Score (NDCG @ 10)
snowflake-arctic-embed-l55.98
Google-gecko-text-embedding55.7
text-embedding-3-large55.44
Cohere-embed-english-v3.055.00
bge-large-en-v1.554.29
Read the rest of the model card

snowflake-arctic-embed-xs

This tiny model packs quite the punch. Based on the all-MiniLM-L6-v2 model with only 22m parameters and 384 dimensions, this model should meet even the strictest latency/TCO budgets. Despite its size, its retrieval accuracy is closer to that of models with 100m paramers.

Model NameMTEB Retrieval Score (NDCG @ 10)
snowflake-arctic-embed-xs50.15
GIST-all-MiniLM-L6-v245.12
gte-tiny44.92
all-MiniLM-L6-v241.95
bge-micro-v242.56

snowflake-arctic-embed-s

Based on the intfloat/e5-small-unsupervised model, this small model does not trade off retrieval accuracy for its small size. With only 33m parameters and 384 dimensions, this model should easily allow scaling to large datasets.

Model NameMTEB Retrieval Score (NDCG @ 10)
snowflake-arctic-embed-s51.98
bge-small-en-v1.551.68
Cohere-embed-english-light-v3.051.34
text-embedding-3-small51.08
e5-small-v249.04

snowflake-arctic-embed-m

Based on the intfloat/e5-base-unsupervised model, this medium model is the workhorse that provides the best retrieval performance without slowing down inference.

Model NameMTEB Retrieval Score (NDCG @ 10)
snowflake-arctic-embed-m54.90
bge-base-en-v1.553.25
nomic-embed-text-v1.553.25
GIST-Embedding-v052.31
gte-base52.31

snowflake-arctic-embed-m-long

Based on the nomic-ai/nomic-embed-text-v1-unsupervised model, this long-context variant of our medium-sized model is perfect for workloads that can be constrained by the regular 512 token context of our other models. Without the use of RPE, this model supports up to 2048 tokens. With RPE, it can scale to 8192!

Model NameMTEB Retrieval Score (NDCG @ 10)
snowflake-arctic-embed-m-long54.83
nomic-embed-text-v1.553.01
nomic-embed-text-v152.81

snowflake-arctic-embed-l

Based on the intfloat/e5-large-unsupervised model, this large model is a direct drop-in for closed APIs and delivers the most accurate retrieval experience.

Model NameMTEB Retrieval Score (NDCG @ 10)
snowflake-arctic-embed-l55.98
UAE-Large-V154.66
bge-large-en-v1.554.29
mxbai-embed-large-v154.39
e5-Large-v250.56

Usage

Using Sentence Transformers

You can use the sentence-transformers package to use an snowflake-arctic-embed model, as shown below.

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Snowflake/snowflake-arctic-embed-l")

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

query_embeddings = model.encode(queries, prompt_name="query")
document_embeddings = model.encode(documents)

scores = query_embeddings @ document_embeddings.T
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)
Query: what is snowflake?
0.28976774 The Data Cloud!
0.19071159 Mexico City of Course!
Query: Where can I get the best tacos?
0.38650584 Mexico City of Course!
0.25145516 The Data Cloud!

Using Huggingface transformers

You can use the transformers package to use an snowflake-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

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

query_prefix = 'Represent this sentence for searching relevant passages: '
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=512)

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

### 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)

Using Transformers.js

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

npm i @xenova/transformers

You can then use the model to compute embeddings as follows:

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

// Create feature extraction pipeline
const extractor = await pipeline('feature-extraction', 'Snowflake/snowflake-arctic-embed-l', {
    quantized: false, // Comment out this line to use the quantized version
});

// Generate sentence embeddings
const sentences = [
    'Represent this sentence for searching relevant passages: Where can I get the best tacos?',
    '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.25145517380846977, 0.3865060421197194]

Using Infinity

OpenAI compatible API deployment with Infinity and Docker.

docker run --gpus all -v $PWD/data:/app/.cache -p "7997":"7997" \
michaelf34/infinity:0.0.70 \
v2 --model-id Snowflake/snowflake-arctic-embed-l --dtype float16 --batch-size 32 --engine torch --port 7997

FAQ

TBD

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.

Acknowledgement

We want to thank the open-source community, which has provided the great building blocks upon which we could make our models. We thank our modeling engineers, Danmei Xu, Luke Merrick, Gaurav Nuti, and Daniel Campos, for making these great models possible. We thank our leadership, Himabindu Pucha, Kelvin So, Vivek Raghunathan, and Sridhar Ramaswamy, for supporting this work. We also thank the open-source community for producing the great models we could build on top of and making these releases possible. Finally, we thank the researchers who created BEIR and MTEB benchmarks. It is largely thanks to their tireless work to define what better looks like that we could improve model performance.

Sources: Snowflake/snowflake-arctic-embed-l on Hugging Face · snowflake-arctic-embed:latest on Ollama. 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.

Live now instead.

Similar embeddings models with hosts serving them right now.

Every live model →

Questions about snowflake-arctic-embed:latest.

Can I use snowflake-arctic-embed:latest through an API?

Yes. Inpherio serves snowflake-arctic-embed:latest through one OpenAI-compatible API whenever a host on the grid is running it — the code on this page works unchanged. With no host right now, a call returns a "not available on any node" error and is never charged, and similar models are live on the marketplace.

How do I host snowflake-arctic-embed:latest and get paid?

Install the Inpherio connector on the machine that runs your models, load snowflake-arctic-embed:latest in a supported engine, and set a price. The platform benchmarks it on your hardware, then requests for it reach your machine. 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.

Why is snowflake-arctic-embed:latest not being served right now?

Hosts on Inpherio are independent machines that come and go. It was last live on 16 Jul 2026. When a host loads it again, this page shows live prices and measured speeds.