Sub-question: What are Nomic embeddings (nomic-embed-text-v1.5) and how do they compare to alternatives for a small-scale AI agent knowledge base?

Date: 2026-02-25

JSON Findings¶

{
  "sub_question": "What are Nomic embeddings (nomic-embed-text-v1.5) and how do they compare to alternatives for a small-scale AI agent knowledge base?",
  "confidence": 0.90,
  "satisfactorily_explored": true,
  "findings": [
    {
      "claim": "nomic-embed-text-v1.5 achieves an MTEB average score of 62.28 at 768 dimensions, which is slightly below v1.0 (62.39) but ahead of OpenAI text-embedding-3-small (62.26)",
      "source_url": "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5",
      "source_tier": 1,
      "quote": "MTEB scores: 768d=62.28, 512d=61.96, 256d=61.04, 128d=59.34, 64d=56.10"
    },
    {
      "claim": "nomic-embed-text-v1.5 supports Matryoshka Representation Learning with dimensions from 64 to 768, allowing developers to trade embedding size for negligible performance loss",
      "source_url": "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5",
      "source_tier": 1,
      "quote": "Nomic Embed v1.5 supports any embedding dimension between 64 and 768"
    },
    {
      "claim": "all-MiniLM-L6-v2 has 22.7M parameters, 384 dimensions, 256 max sequence length, and an estimated MTEB average around 56, significantly below nomic-embed-text-v1.5",
      "source_url": "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2",
      "source_tier": 1,
      "quote": "22.7M params, 384 dimensions, max sequence length 256"
    },
    {
      "claim": "nomic-embed-text-v1.5 is licensed under Apache 2.0, with fully open weights, training code, and curated training data released publicly",
      "source_url": "https://www.nomic.ai/blog/posts/nomic-embed-text-v1",
      "source_tier": 1,
      "quote": "Nomic releases the model weights and training code under an Apache-2 license"
    },
    {
      "claim": "GGUF quantized versions of nomic-embed-text-v1.5 are available for llama.cpp, ranging from 48 MiB (Q2_K) to 262 MiB (F16), with Q8_0 at 140 MiB offering near-lossless quality",
      "source_url": "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5-GGUF",
      "source_tier": 1,
      "quote": "Q8_0: 140 MiB, MSE 5.79e-06; F16: 262 MiB, MSE 4.21e-10"
    },
    {
      "claim": "The nomic Python SDK supports three inference modes -- remote, local (via GPT4All), and dynamic (auto-switching) -- from a single API call, using pip install nomic[local] for local inference",
      "source_url": "https://docs.nomic.ai/atlas/capabilities/embeddings",
      "source_tier": 1,
      "quote": "inference_mode: one of remote, local (Embed4All), or dynamic"
    },
    {
      "claim": "Local inference via GPT4All is faster than remote (with 200ms network latency) for inputs up to 1024 tokens on a 2023 MacBook Pro",
      "source_url": "https://www.nomic.ai/blog/posts/local-nomic-embed",
      "source_tier": 1,
      "quote": "local mode is faster than remote inference for up to 1024 token length inputs"
    },
    {
      "claim": "nomic-embed-text-v1.5 has 137M parameters based on a modified BERT architecture (nomic-bert-2048) with 8192 token context length",
      "source_url": "https://ollama.com/library/nomic-embed-text:137m-v1.5-fp16",
      "source_tier": 2,
      "quote": "137M parameters, 8192 context length"
    },
    {
      "claim": "OpenAI text-embedding-3-small costs $0.02/1M tokens, supports 1536 dimensions (shortable), MTEB ~62.3, but is API-only with no local inference option",
      "source_url": "https://platform.openai.com/docs/pricing",
      "source_tier": 1,
      "quote": "$0.02 per 1M tokens, 1536 dimensions"
    },
    {
      "claim": "Nomic Atlas embedding API is priced at approximately $0.10/1M tokens with 1M free tokens included, but full local inference eliminates API costs entirely",
      "source_url": "https://www.nomic.ai/news/nomic-embed-text-v1",
      "source_tier": 2,
      "quote": "1M free tokens included via Nomic Atlas Embedding API"
    },
    {
      "claim": "On a practical retrieval benchmark (BEIR TREC-COVID), nomic-embed-text achieved 86.2% top-5 accuracy vs all-MiniLM-L6-v2 at 78.1%, though with higher latency (41.9ms vs 14.7ms per 1K tokens)",
      "source_url": "https://supermemory.ai/blog/best-open-source-embedding-models-benchmarked-and-ranked/",
      "source_tier": 2,
      "quote": "Nomic Embed v1: 86.2% top-5 accuracy, 41.9 ms/1K tokens; MiniLM: 78.1%, 14.7 ms"
    },
    {
      "claim": "nomic-embed-text requires sentence-transformers, transformers, and torch for HuggingFace-based usage, or just the nomic package (with optional [local] extra for GPT4All) for SDK usage",
      "source_url": "https://huggingface.co/nomic-ai/nomic-embed-text-v1.5",
      "source_tier": 1,
      "quote": "sentence_transformers or nomic SDK with pip install nomic[local]"
    }
  ],
  "gaps": [
    "Exact Nomic Atlas API pricing beyond the free tier was difficult to confirm -- the pricing page uses client-side rendering that could not be scraped. Multiple sources report $0.10/1M tokens but this may have changed with Nomic's 2025 pivot to a seat-based pricing model for their broader platform.",
    "Direct head-to-head MTEB comparison between all-MiniLM-L6-v2 and nomic-embed-text-v1.5 at the same dimension (384 vs 256) was not found in a single authoritative source. The MTEB scores come from different evaluation runs.",
    "Exact disk size of the nomic Python package with [local] extra (including GPT4All dependency) was not precisely quantified. The model download itself is ~274MB via Ollama.",
    "Performance benchmarks specifically for the GGUF quantized version via llama.cpp (as opposed to sentence-transformers or the nomic SDK) on MTEB tasks are not published."
  ]
}

Prose Findings¶

Model Overview and Architecture¶

nomic-embed-text-v1.5 is a 137M-parameter text embedding model built on a modified BERT architecture called nomic-bert-2048, which replaces GeLU with SwiGLU activation, uses rotary positional embeddings (RoPE), and supports Flash Attention (HuggingFace model card). The model natively supports an 8192-token context window -- a significant advantage over all-MiniLM-L6-v2's 256-token limit. Version 1.5 introduced Matryoshka Representation Learning, allowing embeddings to be generated at any dimension from 64 to 768 without retraining. The model is released under the Apache 2.0 license with fully open weights, training code, and curated training data, making it one of the most transparently open embedding models available (Nomic blog). It requires task-type prefixes on input text (search_query:, search_document:, clustering:, classification:) to optimize embeddings for different use cases.

Quality Benchmarks¶

On the MTEB benchmark, nomic-embed-text-v1.5 scores 62.28 at its full 768 dimensions, with graceful degradation at lower dimensions: 61.96 (512d), 61.04 (256d), 59.34 (128d), and 56.10 (64d) (HuggingFace model card). This narrowly exceeds OpenAI text-embedding-3-small (MTEB ~62.3 at 1536d) while substantially outperforming all-MiniLM-L6-v2 (MTEB ~56 at 384d) (Nomic blog, HuggingFace all-MiniLM-L6-v2). On a practical retrieval benchmark (BEIR TREC-COVID), nomic-embed-text-v1 achieved 86.2% top-5 accuracy versus 78.1% for all-MiniLM-L6-v2, though at higher computational cost (41.9ms vs 14.7ms per 1K tokens) (SuperMemory benchmark). Notably, even at 256 dimensions, nomic-embed-text-v1.5 (MTEB 61.04) substantially outperforms all-MiniLM-L6-v2 at 384 dimensions (MTEB ~56), meaning you can use a smaller embedding vector and still get better retrieval quality.

Local Inference Options¶

nomic-embed-text-v1.5 offers multiple paths for local inference. The primary path is the nomic Python SDK with the [local] extra (pip install nomic[local]), which uses GPT4All as the local inference backend. This provides a single-line switch between inference modes: inference_mode='local' for fully offline operation, inference_mode='remote' for the Nomic Atlas API, or inference_mode='dynamic' for automatic routing based on input size (Nomic Atlas docs). Local inference supports Apple Silicon (Metal), NVIDIA GPUs, and AMD GPUs, and is faster than the remote API for inputs under 1024 tokens on a 2023 MacBook Pro. Alternatively, GGUF-quantized versions are available for llama.cpp, ranging from 48 MiB (Q2_K, lossy) to 262 MiB (F16, lossless). The Q8_0 quantization at 140 MiB offers near-lossless quality (MSE 5.79e-06) and is a practical choice for local deployment (HuggingFace GGUF repo). The model is also available via Ollama (ollama pull nomic-embed-text) at 274 MB, providing yet another local inference path.

Dual Local/Remote Architecture¶

The standout feature for picobot's use case is that a single model -- nomic-embed-text-v1.5 -- can transparently serve both local and API modes through the nomic Python SDK. The inference_mode parameter controls routing: 'local' uses GPT4All on the local machine, 'remote' calls the Nomic Atlas API, and 'dynamic' automatically switches based on input characteristics. This means embeddings generated locally and remotely are from the same model and produce compatible vectors, eliminating the vector space mismatch problem that would arise from using different models for offline vs. online modes. For picobot, this means the KB could be indexed locally during offline operation and queries would remain compatible when switching to the API, or vice versa.

Matryoshka Dimensionality¶

The Matryoshka dimension support is particularly relevant for a small-scale KB (100-1000 files). At 256 dimensions, the MTEB score is 61.04 -- still well above all-MiniLM-L6-v2's 56 at 384 dimensions. This means picobot could use 256-dimensional embeddings, reducing storage by 67% versus the full 768d, while maintaining strong retrieval quality (Nomic Matryoshka blog). For a KB of 1000 documents, this means embedding storage of roughly 1 MB (1000 x 256 x 4 bytes) at 256d versus 3 MB at 768d -- both negligible, but the flexibility to tune this dimension is valuable for experimentation and for scaling to larger KBs in the future.

Dependencies and Package Weight¶

The dependency footprint depends on the inference path chosen. The nomic SDK with [local] brings in GPT4All as a dependency, which includes its own native inference engine. This avoids the heavier PyTorch + sentence-transformers stack (which can be 2+ GB installed). Alternatively, using the GGUF model via llama-cpp-python or Ollama avoids the nomic SDK entirely. For the HuggingFace path, the full dependency chain includes transformers, sentence-transformers, and torch, which is substantially heavier. For picobot's use case, the nomic SDK path with [local] is likely the best balance: it provides the unified local/remote API while avoiding the full PyTorch dependency. The model download itself is approximately 274 MB.

Pricing and Cost¶

OpenAI text-embedding-3-small costs $0.02/1M tokens with no free tier for embeddings specifically (OpenAI pricing). The Nomic Atlas API has been reported at $0.10/1M tokens with 1M free tokens included, though Nomic's 2025 pricing page now shows a seat-based model ($40/user/month with $20 AI usage included) suggesting their pricing structure has evolved. However, since Nomic's model is fully open-source, the local inference path eliminates API costs entirely -- a significant advantage for a project like picobot where offline operation is a requirement. For a 1000-document KB, the entire corpus can be embedded locally with zero API cost.

Recommendation for Picobot¶

nomic-embed-text-v1.5 is a strong upgrade over all-MiniLM-L6-v2 for picobot's KB embedding needs. It offers better retrieval quality (MTEB 62.28 vs ~56), longer context (8192 vs 256 tokens), flexible dimensions via Matryoshka learning, and -- critically -- a unified local/remote inference path through the nomic SDK. The Apache 2.0 license is permissive and compatible with picobot's open-source nature. The main trade-off is a larger model (137M vs 22.7M parameters, ~274 MB vs ~90 MB download) and slower inference, but for a 100-1000 document KB, inference latency is not a concern. The recommended configuration would be: nomic-embed-text-v1.5 at 256 dimensions via the nomic SDK with inference_mode='local' as default, falling back to inference_mode='remote' when an API key is configured and network is available.

Comparison Table¶

Sources¶

All Accessed Sources¶

Cited Sources¶

Evaluation¶

Confidence Assessment: 0.90 (High)¶

The core claims about nomic-embed-text-v1.5 are well-supported by Tier 1 sources (HuggingFace model cards, official Nomic documentation, the arxiv technical report). MTEB benchmark numbers are sourced directly from the model card. The local/remote dual inference capability is confirmed by multiple sources including official docs and framework integrations (LangChain, LlamaIndex).

Areas of Lower Confidence¶

• Nomic API pricing (0.65): The $0.10/1M tokens figure appears in multiple secondary sources but Nomic's current pricing page shows a seat-based model, suggesting pricing has evolved. For picobot this is largely moot since local inference eliminates API costs.
• all-MiniLM-L6-v2 MTEB score (0.75): The ~56 MTEB average is approximate. The HuggingFace model card does not list an explicit MTEB score; this number comes from secondary benchmarking sources. However, even with some variance, the gap to nomic's 62.28 is substantial.
• Dependency weight (0.70): Exact installed sizes for nomic[local] including GPT4All were not precisely measured. The model download (~274 MB) is confirmed.

Key Finding¶

nomic-embed-text-v1.5 is the strongest candidate for picobot's KB embeddings. It is the only model in the comparison that offers a single unified SDK for both local and remote inference with compatible embedding vectors. The quality improvement over all-MiniLM-L6-v2 is significant (+6 MTEB points), the context length is 32x longer (8192 vs 256 tokens), the Matryoshka dimensionality gives tuning flexibility, and the Apache 2.0 license is fully permissive. The main trade-off -- larger model size and slower inference -- is irrelevant at picobot's scale of 100-1000 documents.