Run Snowflake Arctic Embed Privately | Enterprise RAG Embeddings

Built for Enterprise Retrieval, Not Just Benchmarks

Most embedding models are evaluated on MTEB and trained to maximize scores on its component tasks — a mix of retrieval, classification, clustering, and similarity tasks that approximate real-world needs but don't fully represent the specific challenge of enterprise document retrieval. Snowflake's research team took a different approach with Arctic Embed: they identified asymmetric passage retrieval — the specific task of finding relevant passages in large document collections from short natural language queries — as the primary enterprise use case and optimized directly for it.

The result is an embedding model family that consistently outperforms models of comparable or larger size on real enterprise retrieval tasks, particularly for English-language corporate document corpora including policies, procedures, contracts, technical documentation, and knowledge base articles. Arctic Embed v1 established strong baselines across five size tiers. Arctic Embed 2 (released late 2024) refined the training methodology to push retrieval quality further, particularly at the medium and large size points.

For organizations whose RAG deployment serves primarily English-language enterprise content and where per-query retrieval precision on corporate documents is the defining quality metric, Arctic Embed is a focused, well-engineered option that delivers its performance efficiently across a range of hardware budgets.

Size Variants (XS to Large)

335M

Parameters (Large variant)

512

Max Token Context

Apache 2.0

License — Commercial OK

Arctic Embed Model Family on Ollama

Arctic Embed v1 — Established Baseline

arctic-embed:xs

Ultra-Lightweight

22M parameters, 384 dimensions, 512 token context. Designed for maximum throughput on minimal hardware. Fits alongside a generation model on a 2GB Lightsail instance with room to spare. Quality is adequate for high-volume, lower-precision retrieval workloads.

ollama pull snowflake-arctic-embed:xs RAM: ~88MB · Dims: 384

arctic-embed:s

Lightweight

33M parameters, 384 dimensions, 512 token context. A step up from XS with meaningfully better retrieval quality at modest additional RAM cost. Strong choice for high-throughput embedding pipelines where the XS retrieval quality ceiling is insufficient.

ollama pull snowflake-arctic-embed:s RAM: ~130MB · Dims: 384

arctic-embed:m

Mid-Tier Balance

110M parameters, 768 dimensions, 512 token context. The inflection point in the Arctic Embed family — meaningful quality jump from the small variants without the compute cost of Large. Solid for most enterprise RAG deployments on 4GB+ instances.

ollama pull snowflake-arctic-embed:m RAM: ~440MB · Dims: 768

arctic-embed:m-long

Extended Context

110M parameters, 768 dimensions, extended context support. The medium variant trained for longer document passages. Useful when standard 512-token chunking produces poor retrieval because relevant content spans longer passages.

ollama pull snowflake-arctic-embed:m-long RAM: ~440MB · Extended context

arctic-embed:l

Maximum v1 Quality

335M parameters, 1024 dimensions, 512 token context. The large variant delivers the highest retrieval quality in the v1 family and competes with BERT-large class models. Strong NDCG@10 on enterprise retrieval benchmarks at lower RAM than alternatives.

ollama pull snowflake-arctic-embed:l RAM: ~1.3GB · Dims: 1024

Arctic Embed 2 — Refined Generation

arctic-embed-2:137m

Recommended v2 — Speed

137M parameters, 768 dimensions. The v2 mid-size variant with improved training methodology over v1. Better handling of domain-specific enterprise vocabulary and more consistent retrieval across diverse corporate document types. Best starting point for v2 deployments.

ollama pull snowflake-arctic-embed-2:137m RAM: ~550MB · Dims: 768

arctic-embed-2:568m

Recommended v2 — Quality

568M parameters, 1024 dimensions. The v2 large variant represents Snowflake's current best for enterprise English retrieval. Refined contrastive training with harder negatives produces noticeably better discrimination on semantically similar but distinct passages — a critical quality for enterprise knowledge bases.

ollama pull snowflake-arctic-embed-2:568m RAM: ~2.2GB · Dims: 1024

v1 vs v2 guidance: If you are starting a new deployment today, begin with Arctic Embed 2. The 137M v2 variant is directly comparable to arctic-embed:m in compute requirements but delivers better retrieval quality on enterprise corpora due to improved training. The 568M v2 variant is the current quality leader in the family. Use v1 variants only if you have an existing deployment with characterized performance or specific size requirements the v2 family does not match precisely.

Who This Model Family is For

👤 Personal use

Snowflake Arctic Embed is useful if you want to build a personal semantic search layer over your own notes, PDFs, bookmarks, or research documents. The smaller variants (XS and S) run comfortably on a laptop and let you find information by meaning rather than exact keywords. Keep in mind these are embedding models — they do not chat or generate answers on their own. You will pair them with a generation model (such as Llama or Qwen) to create a full personal RAG system.

🏢 Business / team use

For internal knowledge bases, support ticket search, policy retrieval, or document search across SharePoint, Confluence, or shared drives, Arctic Embed delivers retrieval quality that competes with much larger commercial embedding APIs. Running it on-premise through NoCloudGPT means sensitive contracts, HR documents, and customer data never leave your infrastructure. The Arctic Embed 2.0 release adds strong multilingual retrieval, which is valuable for teams working with content in German, French, Spanish, Japanese, and other major languages.

⚙️ Developer & technical use

Developers building RAG pipelines will find Arctic Embed a strong default choice. It consistently ranks near the top of the MTEB retrieval leaderboard while remaining small enough to embed millions of chunks efficiently. The model family integrates cleanly with vector databases such as Qdrant, Weaviate, pgvector, and Chroma, and works well with LangChain and LlamaIndex. The 768- and 1024-dimensional outputs are practical sizes that keep vector storage costs manageable.

🔬 Data science & research

Researchers benchmarking retrieval systems will appreciate that Snowflake published detailed training methodology, including their negative mining and curriculum approach, making Arctic Embed a reproducible baseline. The 2.0 release introduced Matryoshka Representation Learning, allowing you to truncate embeddings to smaller dimensions with graceful quality degradation — useful for ablation studies and cost-quality tradeoff analysis. It serves as a credible open alternative to closed embedding APIs when reproducibility matters.

Licensing Information

The Snowflake Arctic Embed models are released under the Apache 2.0 License, which permits commercial use, modification, redistribution, and private deployment without royalty obligations. This makes it one of the most permissively licensed high-quality embedding model families currently available.

You can review the official model cards on Hugging Face:

Snowflake/snowflake-arctic-embed-l
Snowflake/snowflake-arctic-embed-l-v2.0 (multilingual)

Disclaimer: NoCloudGPT provides this licensing summary as a convenience reference only. It does not constitute legal advice. License terms can change. Always review the official model card and consult your legal counsel before deploying any model in a commercial or regulated context.

Available Model Sizes

Model Size	Ollama Tag	Recommended NoCloudGPT Tier	Notes
Arctic Embed XS (22M)	snowflake-arctic-embed:xs	Starter	Tiny footprint. Ideal for edge devices or embedding very large corpora cheaply. Lower retrieval quality than larger variants.	Get quote →
Arctic Embed S (33M)	snowflake-arctic-embed:s	Starter	Good balance for personal projects and small knowledge bases. Fast indexing on CPU.	Get quote →
Arctic Embed M (110M)	snowflake-arctic-embed:m	Starter / Standard	The popular sweet spot. Strong MTEB performance with 768-dim output. Runs well on modest hardware.	Get quote →
Arctic Embed M-Long (137M)	snowflake-arctic-embed:m-long	Standard / Professional	Supports up to 2048-token context. Better for embedding longer document chunks without aggressive splitting.	Get quote →
Arctic Embed L (335M)	snowflake-arctic-embed:l	Professional	Highest quality in the v1 family (1024-dim). Best for production RAG where retrieval precision matters most.	Get quote →
Arctic Embed L v2.0 (568M)	snowflake-arctic-embed2	Professional	Multilingual support across 100+ languages + Matryoshka embeddings (truncatable to 256 dims). Recommended for most new deployments.	Get quote →

What Arctic Embed Does Well

🏢

Enterprise Document Retrieval

Trained with enterprise retrieval as the explicit optimization target, not as a side effect of general benchmark optimization. Corporate policies, procedures, HR documentation, technical manuals, and knowledge base articles are the core design use case.

📐

Right-Sized for Every Budget

Five size variants from 22M to 568M parameters cover every deployment scenario from a single 2GB Lightsail instance running alongside a generation model to a dedicated embedding service on modest hardware. No need to overprovision.

🎯

Asymmetric Retrieval Optimization

Specifically optimized for asymmetric passage retrieval — the pattern where short queries retrieve long passages. This is the dominant pattern in enterprise RAG. Models optimized for symmetric similarity or academic QA don't represent this pattern as well.

⚡

Efficient CPU Inference

Even the Large variants are derived from encoder-only architectures (BERT-family) that run efficiently on CPU. No GPU required to achieve strong retrieval quality in the medium and large variants — important for cost-sensitive private deployments.

🔬

Hard Negative Training (v2)

Arctic Embed 2 was trained with carefully mined hard negatives — passages that are topically related but semantically distinct from the correct answer. This produces embeddings that better discriminate between genuinely relevant content and plausible-but-wrong matches.

📋

Well-Characterized Performance

Snowflake published detailed technical reports with retrieval evaluation across multiple enterprise-relevant datasets. Performance behavior is well-documented, making it easier to predict how the model will perform on your specific document type before deployment.

Arctic Embed Deployment Patterns

Basic Ollama Deployment — Arctic Embed 2

# Pull the recommended v2 variant ollama pull snowflake-arctic-embed-2:137m # Embed a document passage curl http://localhost:11434/api/embed \ -d '{ "model": "snowflake-arctic-embed-2:137m", "input": "The termination clause requires 30 days written notice to either party." }' # Embed a user query — same model, asymmetric retrieval curl http://localhost:11434/api/embed \ -d '{ "model": "snowflake-arctic-embed-2:137m", "input": "What notice period is required to end the contract?" }'

LangChain Pipeline with Qdrant

from langchain_community.embeddings import OllamaEmbeddings from langchain_community.vectorstores import Qdrant from langchain_community.llms import Ollama from langchain.chains import RetrievalQA # Arctic Embed 2 for retrieval embeddings = OllamaEmbeddings( model="snowflake-arctic-embed-2:137m" ) # Build vector store from enterprise documents vectorstore = Qdrant.from_documents( documents=enterprise_docs, embedding=embeddings, location="http://localhost:6333", collection_name="corp_knowledge_base", distance_func="Cosine" ) # Generation model — separate from embedding llm = Ollama(model="llama3.1:8b") # Full RAG chain qa_chain = RetrievalQA.from_chain_type( llm=llm, retriever=vectorstore.as_retriever(search_kwargs={"k": 5}), chain_type="stuff" )

Chunking Strategy for Arctic Embed (512-token limit)

from langchain.text_splitter import RecursiveCharacterTextSplitter # Arctic Embed has 512-token max context # Use ~400 tokens per chunk with overlap for safety splitter = RecursiveCharacterTextSplitter( chunk_size=1600, # ~400 tokens at ~4 chars/token chunk_overlap=200, # ~50 token overlap for continuity separators=["\n\n", "\n", ". ", " ", ""] ) chunks = splitter.split_documents(raw_docs) # For m-long variant: can use larger chunks splitter_long = RecursiveCharacterTextSplitter( chunk_size=3200, # ~800 tokens chunk_overlap=400, separators=["\n\n", "\n", ". ", " ", ""] )

Multi-Tenant Corporate KB — Namespace Isolation

from qdrant_client import QdrantClient from qdrant_client.models import Filter, FieldCondition, MatchValue client = QdrantClient("http://localhost:6333") # Each department gets isolated namespace via payload filter # Embeddings from the same Arctic Embed model instance # but queries scoped by department metadata def search_department_kb(query: str, department: str, top_k: int = 5): query_vec = embeddings.embed_query(query) results = client.search( collection_name="corp_knowledge_base", query_vector=query_vec, query_filter=Filter( must=[FieldCondition( key="department", match=MatchValue(value=department) )] ), limit=top_k ) return results # HR team sees only HR docs, Finance sees only Finance docs # Same embedding model, same vector store, isolated retrieval

Hardware Requirements

Variant	Parameters	Min RAM	Recommended Instance	Throughput (CPU)
arctic-embed:xs	22M	512 MB	Lightsail 2GB	400–800 docs/s
arctic-embed:s	33M	512 MB	Lightsail 2GB	300–600 docs/s
arctic-embed:m / arctic-embed-2:137m	110–137M	1 GB	Lightsail 2–4GB	100–200 docs/s
arctic-embed:l	335M	2 GB	Lightsail 4GB	40–80 docs/s
arctic-embed-2:568m	568M	4 GB	Lightsail 4–8GB	20–40 docs/s
arctic-embed-2:568m + LLM	568M + 8B	16 GB	GPU instance / on-premise	Varies by LLM

Separate Embedding and Generation Services

For production deployments using arctic-embed-2:568m or arctic-embed:l alongside an 8B+ generation model, running separate Lightsail instances for embedding and generation is the recommended architecture. The embedding service can be a 4GB instance handling batch ingestion and real-time query embedding. The generation service runs on a separate 8GB instance. Internal Lightsail networking connects them at no bandwidth cost. NoCloudGPT configures this two-instance architecture as a standard production pattern.

Use Cases Where Arctic Embed Excels

HR and people operations knowledge bases: Employee handbooks, benefits documentation, policy manuals, onboarding materials. Arctic Embed's enterprise retrieval optimization handles the formal, procedural language of HR documentation particularly well.
IT service management and technical documentation: IT knowledge bases, runbooks, troubleshooting guides, and system documentation. The asymmetric retrieval training means a casual user question reliably finds the relevant formal documentation passage.
Legal and compliance document retrieval: Contract clauses, regulatory requirements, compliance policies, and legal precedents. Hard negative training in v2 helps discriminate between similar-but-distinct compliance requirements — a critical quality for legal retrieval.
Financial services internal knowledge: Investment policies, risk management frameworks, trading procedures, and regulatory filings. For English-language financial document retrieval where multilingual capability is not required, Arctic Embed delivers strong precision.
Manufacturing and operations documentation: Standard operating procedures, quality control documentation, equipment manuals, and safety guidelines. High-volume embedding of dense technical content benefits from the XS and S variants' throughput efficiency.
Customer-facing support knowledge bases: Product documentation, FAQ databases, and troubleshooting guides. The M variant running on a 4GB instance can handle real-time retrieval for customer-facing RAG applications at the query volumes typical of mid-sized support operations.
Research and intelligence platforms: Internal research reports, market intelligence briefs, and analyst notes where users need to query large archives of formal English business writing. Arctic Embed's training on enterprise-style content produces better results than models trained primarily on web text.

Arctic Embed vs. Comparable Embedding Options

Model	Max Tokens	Dims	Languages	Enterprise Focus	RAM (Medium)
Arctic Embed 2 (137M)	512	768	English primary	Explicit design goal	~550MB
Arctic Embed 2 (568M)	512	1,024	English primary	Explicit design goal	~2.2GB
Mxbai-Embed-Large	512	1,024	English primary	Good	~1.3GB
BGE-Large	512	1,024	English + Chinese	Good	~1.3GB
BGE-M3	8,192	1,024	100+	Good	~1.1GB
Qwen3-Embedding-4B	32,768	2,048	100+	Excellent	~8GB
Nomic Embed v1.5	8,192	768	English primary	Good	~540MB

Arctic Embed's honest positioning: For English-language enterprise retrieval with the 512-token context window constraint, Arctic Embed 2 is among the best options available at its size tier. Its limitation relative to BGE-M3, Nomic Embed, and Qwen 3 Embedding is the 512-token context ceiling — if your documents require longer passages, you will need to chunk aggressively or choose a model with longer context. For organizations where documents chunk naturally into paragraph-length passages and multilingual retrieval is not needed, Arctic Embed delivers focused, efficient enterprise retrieval that justifies its place in the deployment decision.

Deployment with Ollama — Complete Setup

        # ── Step 1: Install Ollama ──────────────────────────────────

        curl -fsSL https://ollama.com/install.sh | sh

        # ── Step 2: Pull Arctic Embed variants ─────────────────────

        ollama pull snowflake-arctic-embed:xs        # 22M — ultralight

        ollama pull snowflake-arctic-embed:s         # 33M — light

        ollama pull snowflake-arctic-embed:m         # 110M — mid

        ollama pull snowflake-arctic-embed:m-long    # 110M — extended context

        ollama pull snowflake-arctic-embed:l         # 335M — v1 large

        ollama pull snowflake-arctic-embed-2:137m    # v2 mid — recommended

        ollama pull snowflake-arctic-embed-2:568m    # v2 large — max quality

        # ── Step 3: Start Ollama as background service ──────────────

        ollama serve &

        # ── Step 4: Verify embedding endpoint ──────────────────────

        curl http://localhost:11434/api/embed \

          -H "Content-Type: application/json" \

          -d '{

            "model": "snowflake-arctic-embed-2:137m",

            "input": "What is the company vacation policy?"

          }'

        # ── Step 5: Install Qdrant for vector storage ───────────────

        docker run -d --name qdrant \

          -p 6333:6333 \

          -v $(pwd)/qdrant_storage:/qdrant/storage \

          qdrant/qdrant

        # ── Step 6: Create collection with correct dimensions ───────

        curl -X PUT http://localhost:6333/collections/enterprise_kb \

          -H 'Content-Type: application/json' \

          -d '{

            "vectors": {

              "size": 768,

              "distance": "Cosine"

            }

          }'

        # Note: use size 1024 for arctic-embed:l and arctic-embed-2:568m

90-Day Lightsail Pilot — Arctic Embed Edition

NoCloudGPT's standard 90-day pilot program adapted for Arctic Embed deployments covers the following milestones:

Days 1–14: Infrastructure Setup

Foundation

AWS Lightsail instance provisioning, Ollama installation and service configuration, Arctic Embed variant selection and pull, Qdrant deployment and collection initialization with correct dimensions for chosen variant. SSL termination and access controls configured.

Days 15–30: Document Ingestion Pipeline

Data Layer

Chunking strategy configured for 512-token constraint (m-long if extended context needed), document parsing for your specific file types (PDF, DOCX, HTML, plain text), metadata schema design for filtering, batch ingestion pipeline with progress monitoring.

Days 31–60: RAG Chain Integration

Application Layer

Generation model deployment (Llama 3.1 8B or Mistral 7B standard), LangChain or LlamaIndex retrieval chain configuration, OpenWebUI interface deployment, retrieval quality evaluation on a held-out test set of representative queries and documents.

Days 61–90: Tuning and Handoff

Optimization

Retrieval quality refinement based on evaluation results, chunking parameter adjustment, reranker integration if retrieval precision requires it, documentation, runbook, and team training. Monitoring dashboards and backup schedule configured.

Deployment Service Tiers

Lightweight Arctic Embed Stack

Budget-conscious deployments

Arctic Embed XS or S on a 2GB Lightsail instance, configured as an embedding microservice for an existing RAG pipeline. Suitable for organizations with an existing generation model deployment that needs a private embedding layer added.

Full Enterprise RAG — Arctic Embed 2 Most Common

Standard production engagement

Arctic Embed 2 (137M or 568M) as dedicated embedding service on a 4GB Lightsail instance, plus Llama 3.1 8B or Mistral 7B for generation on a separate 4–8GB instance, Qdrant vector store, document ingestion pipeline, and OpenWebUI interface. Full 90-day pilot included.

On-Premise Arctic Embed Deployment

Air-gap and compliance deployments

Arctic Embed 2 (568M) deployed on your own hardware for organizations that cannot use any cloud infrastructure. Includes network isolation configuration, on-premise Qdrant deployment, integration with existing enterprise document management systems, and staff training.

Request Deployment Quote

Related Embedding Models

Need multilingual retrieval beyond English? BGE-M3 adds 100-language support and 8K context at comparable compute cost to Arctic Embed Large. Need maximum quality regardless of compute? Qwen 3 Embedding leads the MTEB multilingual leaderboard with 32K context. Need the lightest possible English embedding option? All-MiniLM runs in under 100MB of RAM. Need long-context English retrieval with Matryoshka dimensions? Nomic Embed v1.5 offers 8K context at the M-size compute tier.