Model reference · open weights
nomic-embed-code is an open-weight embedding model from nomic-ai. nomic-embed-code (FP32) weighs 14.1 GB; the smallest configuration that runs it is RTX 4060 Ti 16 GB.
Summary of the nomic-ai/nomic-embed-code model card, 2026-10-01
What it is
| Released by | nomic-ai |
|---|---|
| Released | 2025-03-24 |
| Parameters | 7.1B |
| VRAM | 14.1 GB for the weights |
What it runs on
| Card | Runs | Memory |
|---|---|---|
| RTX 3060 12 GB | does not fit | 11.6 GB |
| RTX 4060 Ti 16 GB | tight | 15.4 GB |
| RTX 3090 24 GB | fits | 23.4 GB |
| RTX 4090 24 GB | fits | 23.4 GB |
| RTX 5090 32 GB | fits | 31.0 GB |
| L40S 48 GB | fits | 44.0 GB |
| A100 80 GB | fits | 78.2 GB |
| H100 80 GB | fits | 78.1 GB |
| RTX PRO 6000 Blackwell 96 GB | fits | 93.8 GB |
| DGX Spark (GB10) 128 GB unified | fits | 107 GB |
| H200 141 GB | fits | 138 GB |
| B200 180 GB | fits | 176 GB |
Builds
| Build | Params | Precision | Weights | Smallest setup |
|---|---|---|---|---|
| nomic-embed-code (above) ↗ | 7.1B | FP32 | 14.1 GB | RTX 4060 Ti 16 GB |
| nomic-embed-code-GGUF ↗ 15 builds: Q2_K 2.8 GB … F32 28.3 GB |
— | GGUF | 4.4 GB | RTX 3060 12 GB |
From the model card
Blog | Technical Report | AWS SageMaker | Atlas Embedding and Unstructured Data Analytics Platform
nomic-embed-code is a state-of-the-art code embedding model that excels at code retrieval tasks:
| Model | Python | Java | Ruby | PHP | JavaScript | Go |
|---|---|---|---|---|---|---|
| Nomic Embed Code | 81.7 | 80.5 | 81.8 | 72.3 | 77.1 | 93.8 |
| Voyage Code 3 | 80.8 | 80.5 | 84.6 | 71.7 | 79.2 | 93.2 |
| OpenAI Embed 3 Large | 70.8 | 72.9 | 75.3 | 59.6 | 68.1 | 87.6 |
| Nomic CodeRankEmbed-137M | 78.4 | 76.9 | 79.3 | 68.8 | 71.4 | 92.7 |
| CodeSage Large v2 (1B) | 74.2 | 72.3 | 76.7 | 65.2 | 72.5 | 84.6 |
| CodeSage Large (1B) | 70.8 | 70.2 | 71.9 | 61.3 | 69.5 | 83.7 |
| Qodo Embed 1 7B | 59.9 | 61.6 | 68.4 | 48.5 | 57.0 | 81.4 |
You can install the necessary dependencies with:
pip install transformers sentence-transformers torch
import torch
import torch.nn.functional as F
from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("nomic-ai/nomic-embed-code")
model = AutoModel.from_pretrained("nomic-ai/nomic-embed-code")
def last_token_pooling(hidden_states, attention_mask):
sequence_lengths = attention_mask.sum(-1) - 1
return hidden_states[torch.arange(hidden_states.shape[0]), sequence_lengths]
queries = ['Represent this query for searching relevant code: Calculate the n-th factorial']
codes = ['def fact(n):\n if n < 0:\n raise ValueError\n return 1 if n == 0 else n * fact(n - 1)']
code_snippets = queries + codes
encoded_input = tokenizer(code_snippets, padding=True, truncation=True, return_tensors='pt')
model.eval()
with torch.no_grad():
model_output = model(**encoded_input)[0]
embeddings = last_token_pooling(model_output, encoded_input['attention_mask'])
embeddings = F.normalize(embeddings, p=2, dim=1)
print(embeddings.shape)
similarity = F.cosine_similarity(embeddings[0], embeddings[1], dim=0)
print(similarity)
from sentence_transformers import SentenceTransformer
queries = ['Calculate the n-th factorial']
code_snippets = ['def fact(n):\n if n < 0:\n raise ValueError\n return 1 if n == 0 else n * fact(n - 1)']
model = SentenceTransformer("nomic-ai/nomic-embed-code")
query_emb = model.encode(queries, prompt_name="query")
code_emb = model.encode(code_snippets)
similarity = model.similarity(query_emb[0], code_emb[0])
print(similarity)
Starting with the deduplicated Stackv2, we create text-code pairs from function docstrings and respective code. We filtered out low-quality pairs where the docstring wasn't English, too short, or that contained URLs, HTML tags, or invalid characters. We additionally kept docstrings with text lengths of 256 tokens or longer to help the model learn long-range dependencies.
After the initial filtering, we used dual-consistency filtering to remove potentially noisy examples. We embed each docstring and code pair and compute the similarity between each docstring and every code example. We remove pairs from the dataset if the corresponding code example is not found in the top-2 most similar examples for a given docstring.
During training, we employ a novel curriculum-based hard negative mining strategy to ensure the model learns from challenging examples. We use a softmax-based sampling strategy to progressively sample hard negatives with increasing difficulty over time.
If you find the model, dataset, or training code useful, please cite our work:
@misc{suresh2025cornstackhighqualitycontrastivedata,
title={CoRNStack: High-Quality Contrastive Data for Better Code Retrieval and Reranking},
author={Tarun Suresh and Revanth Gangi Reddy and Yifei Xu and Zach Nussbaum and Andriy Mulyar and Brandon Duderstadt and Heng Ji},
year={2025},
eprint={2412.01007},
archivePrefix={arXiv},
primaryClass={cs.CL},
url={https://arxiv.org/abs/2412.01007},
}
Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.