jina-code-embeddings is a novel code embedding model suite designed to retrieve code from natural language queries, perform technical question-answering, and identify semantically similar code snippets across programming languages. It makes innovative use of an autoregressive backbone pre-trained on both text and code, generating embeddings via last-token pooling. We outline the training recipe and demonstrate state-of-the-art performance despite the relatively small size of the models, validating this approach to code embedding model construction.

1. Bibliographic Information

• Title: Efficient Code Embeddings from Code Generation Models
• Authors: Daria Kryvosheieva¹,², Saba Sturua², Michael Günther², Scott Martens², Han Xiao²
  • Affiliations: ¹Massachusetts Institute of Technology, ²Jina AI GmbH. The authors are a mix of academic and industry researchers, indicating a focus on practical, high-performance applications grounded in rigorous methodology.
• Journal/Conference: The paper is available on arXiv, a repository for electronic preprints. This means it has not yet undergone formal peer review for publication in a journal or conference. The arXiv identifier 2508.21290 suggests a submission date in August 2025, which is likely a placeholder or a typo in the provided source document.
• Publication Year: The preprint is referenced with a future date (2025), but the content and citations suggest it is contemporary work.
• Abstract: The paper introduces jina-code-embeddings, a new suite of code embedding models. The key innovations include using a pre-trained autoregressive (generative) model as the foundation, generating embeddings via last-token pooling, and using task-specific instructions. The authors claim that despite the models' relatively small size, they achieve state-of-the-art performance on tasks like retrieving code from natural language, technical question-answering, and finding semantically similar code snippets.
• Original Source Link:
  • arXiv Page: https://arxiv.org/abs/2508.21290
  • PDF Link: http://arxiv.org/pdf/2508.21290v1
  • Status: Preprint.

2. Executive Summary

• Background & Motivation (Why):

  • Core Problem: Modern AI-powered software development tools heavily rely on understanding existing codebases. This requires high-quality code embeddings—numerical representations that capture the semantic meaning of code. These embeddings are the backbone of Retrieval-Augmented Generation (RAG) systems, which find relevant code snippets to help a large language model (LLM) generate better code.
  • Existing Gaps: Current code embedding models suffer from a significant data bottleneck. They are often trained on limited, high-quality "aligned" data like code with its corresponding documentation (e.g., docstrings). This data is scarce and often fails to capture the complexity of real-world code. Meanwhile, the vast amount of unaligned code and text used to train powerful code generation LLMs remains an underutilized resource for creating embedding models.
  • Proposed Innovation: This paper flips the conventional approach. Instead of building an embedding model from scratch or using a BERT-like architecture, the authors adapt a pre-trained, compact code generation LLM to function as an embedding model. This leverages the rich, nuanced understanding of code and natural language that the LLM already possesses from its extensive pre-training.

• Main Contributions / Findings (What):

  • Novel Model Suite: The paper introduces two new models, jina-code-embeddings-0.5b (494 million parameters) and jina-code-embeddings-1.5b (1.54 billion parameters).
  • Innovative Architecture: It validates a methodology for creating code embedding models from autoregressive (decoder-only) backbones, using last-token pooling to generate the final embedding vector.
  • Task-Specific Instructions: The models are fine-tuned with specific instruction "prefixes" that prime them for different tasks (e.g., code retrieval vs. technical question answering), improving their specialized performance.
  • State-of-the-Art Performance: The new models are shown to be highly efficient, outperforming or performing competitively with much larger and more complex models on a wide range of code-related benchmarks. This demonstrates that a well-designed, smaller model can be a more practical alternative to giant, general-purpose embedding models.

3. Prerequisite Knowledge & Related Work

• Foundational Concepts:

  • Code Embeddings: A code embedding is a vector of numbers that represents the semantic meaning of a code snippet. If two code snippets perform a similar function, their embedding vectors will be close together in the vector space. This allows for "semantic search," where one can find code based on what it does, not just the keywords it contains.
  • Autoregressive (Decoder-Only) Models: These are language models like GPT that generate text one token (word or sub-word) at a time, where each new token is predicted based on all the tokens that came before it. This contrasts with encoder-based models like BERT, which process the entire input sequence at once to build a contextual understanding. This paper leverages a decoder-only model pre-trained for code generation.
  • Retrieval-Augmented Generation (RAG): A popular technique to make LLMs more accurate and context-aware. When a user asks a question, the RAG system first uses an embedding model to search a database (e.g., a codebase) for relevant information. This retrieved information is then provided to the LLM as extra context along with the original question, helping it generate a better, more grounded response.
  • Pooling Methods: A pooling method is a strategy to convert the multiple token-level outputs from a transformer's last layer into a single, fixed-size vector (the embedding).
    • Last-Token Pooling: Uses the hidden state of the very last token in the input sequence as the final embedding. This is a natural choice for autoregressive models, as the final state is conditioned on the entire preceding sequence to predict the next token.
    • Mean Pooling: Averages the hidden states of all tokens in the sequence.
  • Contrastive Learning: A training method that teaches a model to distinguish between similar and dissimilar things. The model is given a "positive" pair (e.g., a code snippet and its description) and several "negative" pairs (the same code snippet with incorrect descriptions). The training objective, like the InfoNCE loss, pushes the embeddings of positive pairs closer together and pulls the embeddings of negative pairs farther apart.
  • Instruction Tuning: A fine-tuning technique where a model is trained on examples that are prefixed with a natural language instruction (e.g., "Find the most relevant code snippet..."). This helps the model learn to produce outputs tailored to specific tasks.
  • Matryoshka Representation Learning (MRL): A technique to train embeddings so that they can be truncated to shorter lengths without a catastrophic loss in performance. For example, a 1024-dimensional embedding can be shortened to 512 or 256 dimensions. This allows users to trade off accuracy for computational efficiency and storage.

• Previous Works & Differentiation:

  • BERT-based Models: Earlier models like CodeBERT were based on the BERT architecture (encoder-only). While effective, they require specialized pre-training and struggle to find enough high-quality aligned data.
  • General-Purpose Models: Very large models like Gemini Embedding can handle code well, but they are expensive to train and use. This paper aims for efficiency.
  • Adapting General Models: A recent trend is to adapt general-purpose text embedding models for code using techniques like LoRA adapters (jina-embeddings-v3). This paper takes a more direct approach by starting with a model already specialized for code generation.
  • Autoregressive Models for Embeddings: The idea of using decoder-only models for embeddings is recent, seen in models like Qwen3 Embedding. This paper applies and validates this specific approach for the code domain.
  • This Paper's Unique Contribution: The key innovation is the combination of these ideas: starting with a dedicated code generation LLM (Qwen2.5-Coder), applying a systematic task-prefix strategy, and empirically proving that simple last-token pooling is the most effective method for this architecture, resulting in a highly efficient and performant model.

4. Methodology (Core Technology & Implementation)

• Principles: The core idea is to repurpose a model that is already an expert at understanding and generating code. An autoregressive code generation model, by its nature, must develop a deep contextual understanding of a code sequence to predict the next token. The authors hypothesise that the model's internal representations (hidden states) can be effectively transformed into high-quality semantic embeddings.

• Steps & Procedures:

  1. Backbone Selection: The authors chose pre-trained, compact code generation LLMs as their foundation: Qwen2.5-Coder-0.5B and Qwen2.5-Coder-1.5B. These models have an autoregressive decoder architecture.

  2. Instruction Prefixes: For any given input (a natural language query or a code snippet), a task-specific prefix is added to the beginning. The paper identifies five core task categories and defines distinct prefixes for the "query" and the "document" to be embedded.

     Table 1 Transcription: Task categories and their corresponding instruction prefixes.

     Task type	Query prefix	Document prefix
     NL2Code	"Find the most relevant code snippet given the following query:\n"	"Candidate code snippet:\n"
     TechQA	"Find the most relevant answer given the following question:\n"	"Candidate answer:\n"
     Code2Code	"Find an equivalent code snippet given the following code snippet:\n"	"Candidate code snippet:\n"
     Code2NL	"Find the most relevant comment given the following code snippet:\n"	"Candidate comment:\n"
     Code2Completion	"Find the most relevant completion given the following start of code snippet:\n"	"Candidate completion:\n"

     Note: This table is a transcription of the original data from Table 1.

  3. Embedding Generation: The prefixed text is fed into the model. The embedding is then generated by taking the hidden state vector of the last token from the final layer of the transformer. This is known as last-token pooling.

  4. Training: The models are further trained using a contrastive objective.

     • Data: Training data consists of pairs of related texts, such as a programming problem and its code solution, or a question from a forum and its accepted answer. The data is sourced from existing benchmarks, adapted public datasets, and synthetically generated using GPT-4o.
     • Loss Function: The training uses the InfoNCE loss function. In each training batch, a given query q_i is paired with its correct document d_i (the "positive" sample). All other documents d_j in the same batch are treated as "negative" samples. The loss function encourages the model to produce a high similarity score for the (q_i, d_i) pair and low similarity scores for all (q_i, d_j) pairs where i ≠ j.

• Mathematical Formulas & Key Details: The InfoNCE loss function is defined as: $$\mathcal{L}_{\mathrm{NCE}}(S(B), \tau) := - \sum_{i, j = 0}^{n} \ln \sigma(S(B), \tau, i, j) \quad \mathrm{where} \quad \sigma(S, \tau, i, j) := \frac{e^{S_{i, j} / \tau}}{\sum_{k=0}^{n} e^{S_{i, k} / \tau}}$$

  • $B$: A batch of $n$ query-document pairs.
  • S(B): A similarity matrix where $S_{i,j}$ is the cosine similarity between the embedding for the $i$-th query and the embedding for the $j$-th document.
  • $n$: The batch size. A larger batch size provides more negative examples for contrastive learning.
  • $\tau$: The temperature, a hyperparameter that controls the sharpness of the distribution. A small value like the $\tau = 0.05$ used here makes the model more sensitive to differences in similarity scores, pushing it to better distinguish between positive and negative samples.
  • $\sigma(\cdot)$: The softmax function applied over the similarity scores for a given query against all documents in the batch, scaled by the temperature. The overall loss aims to maximize the probability assigned to the correct (positive) document.

5. Experimental Setup

• Datasets:

  • Training: A diverse mix of datasets was used for training, detailed in Appendix A. This includes training splits from MTEB code tasks, CoSQA+, adapted datasets from sources like GitHub and StackExchange, and synthetic data generated by GPT-4o for tasks where data is scarce (e.g., cross-framework code translation). Table 3 Transcription: Datasets used to train jina-code-embeddings

    Dataset	Type	Source
    AppsRetrieval CodeFeedbackMT CodeFeedbackST CodeTransOceanContest CodeTransOceanDL CodeSearchNetCCRetrieval COIR-CodeSearchNet CoSQA StackOverflowQA SyntheticText2SQL	MTEB Code	https://huggingface.co/datasets/CoIR-Retrieval/...
    CodeForcesP2S CodeForcesS2S CodeSearchNet CommitPackFT CoSQA+ DataScience Doc2Code GlaiveCodeAssistantV2 HackerEarth LeetCodeP2S LeetCodeXLang MBPP MLQuestions Spider StackExchangeBody StackExchangePost StackExchangeTitle SWE-Bench WikiSQL	Adapted	(various GitHub and Hugging Face links)
    CodeChefP2S CodeChefS2S CodeChefXLang SyntheticDLTrans	Synthetic	(Generated by authors)

    Note: This table is a transcription of the original data from Table 3.

  • Evaluation: The models were evaluated on the MTEB-CoIR benchmark, a comprehensive suite of 10 code information retrieval tasks, along with several other established code-related benchmarks like CodeSearchNetRetrieval, HumanEval, MBPP, DS-1000, and CoSQA+. This ensures a thorough assessment across different tasks like text-to-code, code-to-code, and technical QA.

• Evaluation Metrics: The paper reports performance as percentages. For retrieval tasks, this is typically a metric like Normalized Discounted Cumulative Gain (nDCG), which is standard for the MTEB benchmark.

  1. Conceptual Definition: nDCG measures the quality of a ranked list of search results. It evaluates two things: Are relevant documents being returned (gain)? And are the most relevant documents ranked higher up the list (discounted)? The score is "normalized" by dividing by the score of a perfect ranking, so the final value is between 0 and 1 (or 0% and 100%). A higher nDCG score means better retrieval performance. The MTEB leaderboard typically uses nDCG@10, focusing on the top 10 results.
  2. Mathematical Formula: $\mathrm{DCG@k} = \sum_{i=1}^{k} \frac{rel_i}{\log_2(i+1)}$ $\mathrm{nDCG@k} = \frac{\mathrm{DCG@k}}{\mathrm{IDCG@k}}$
  3. Symbol Explanation:
     • $k$: The number of top results to consider (e.g., 10 for nDCG@10).
     • $rel_i$: The relevance score of the document at rank $i$.
     • $\mathrm{IDCG@k}$: The "Ideal" DCG, which is the DCG score of a perfect ranking where all relevant documents are ranked at the top.

• Baselines: The proposed models (JCE-0.5B, JCE-1.5B) were compared against a strong set of existing models:

  • jina-embeddings-v4 (JV4): A larger, general-purpose multilingual embedding model.
  • Qwen3-Embedding-0.6B (Qw3-0.6B): A general-purpose embedding model of a similar size, also based on an autoregressive architecture. This is a key comparison to show the benefit of specialization.
  • voyage-code-3 (VC3): A powerful, proprietary, state-of-the-art code embedding model.
  • gemini-embedding-001 (GE-001): A very large, general-purpose embedding model from Google.

6. Results & Analysis

• Core Results: The main results are presented in Table 2, which compares the performance of the jina-code-embeddings (JCE) models against the baselines across numerous benchmarks.

  Table 2 Transcription: Evaluation Results on Code Retrieval Tasks

  Benchmark	JCE-0.5B	JCE-1.5B	JV4	Qw3-0.6B	VC3	GE-001
  CoSQA+	15.42%	16.38%	13.29%	15.63%	13.57%	16.44%
  CoSQA*	39.25%	35.10%	29.99%	37.75%	34.11%	51.94%
  MBPP	89.01%	90.13%	89.93%	88.29%	94.68%	93.46%
  COIR-CSN*	85.73%	86.45%	84.03%	84.78%	89.35%	81.06%
  CSN*	90.68%	91.38%	84.84%	90.77%	93.92%	91.38%
  Doc2Code	95.98%	96.34%	91.46%	94.77%	97.18%	96.54%
  SWE-Bench	83.00%	86.33%	81.00%	76.12%	87.02%	87.40%
  CES*	83.25%	84.43%	72.75%	64.21%	80.30%	81.69%
  CP-FT	63.00%	65.06%	45.93%	38.50%	59.24%	61.18%
  AppsR*	84.17%	86.63%	78.32%	75.22%	93.77%	95.70%
  LeetCode	57.86%	59.075%	59.11%	58.23%	58.89%	58.40%
  CodeChef	94.03%	96.89%	87.98%	84.29%	99.18%	99.55%
  SynText2SQL*	72.80%	73.91%	76.98%	66.91%	63.39%	59.24%
  Spider	81.65%	82.18%	81.18%	81.45%	81.99%	81.15%
  WikiSQL	98.31%	98.02%	96.06%	96.04%	95.71%	90.94%
  CF-MT*	89.56%	89.91%	70.07%	90.79%	93.47%	64.95%
  CF-ST*	85.73%	86.18%	85.47%	86.43%	90.56%	85.70%
  StackOQA*	91.04%	92.37%	93.80%	89.96%	96.90%	96.02%
  DS-1000	59.77%	62.88%	64.11%	61.19%	69.49%	70.10%
  MLQuestions	81.05%	77.46%	54.71%	60.52%	66.87%	62.95%
  CTOC*	90.37%	92.54%	92.23%	86.28%	93.49%	92.59%
  CTODL*	41.69%	37.319%	46.29%	31.78%	38.72%	32.84%
  CodeChefXLang	99.70%	99.44%	92.82%	90.94%	99.13%	99.79%
  CSN-CC*	90.41%	91.12%	83.69%	91.41%	90.09%	84.69%
  HumanEval	96.77%	98.41%	96.74%	94.84%	99.77%	98.90%
  Overall AVG	78.41%	79.04%	74.11%	73.49%	79.23%	77.38%
  MTEB Code AVG	78.72%	78.94%	74.87%	74.69%	79.84%	76.48%

  Note: This table is a transcription of the original data from Table 2.

  • Key Findings:
    • High Efficiency: Both JCE-0.5B and JCE-1.5B significantly outperform the similarly-sized generalist Qw3-0.6B and the larger generalist jina-embeddings-v4 on average. This validates the benefit of using a specialized code backbone and training recipe.
    • Competitive with Giants: The JCE models achieve an overall average score competitive with the much larger and proprietary voyage-code-3 and outperform gemini-embedding-001. This is a remarkable result, demonstrating SOTA performance for their size class.
    • Strengths: The JCE models show particular strength on tasks like WikiSQL, MLQuestions, and cross-language retrieval (CodeChefXLang), highlighting their versatility.

• Ablations / Parameter Sensitivity: The authors conducted an ablation study (Appendix B) to justify their choice of pooling method. They trained three identical versions of the 0.5B model, changing only the pooling strategy.

  Table 5 Transcription: Results of the pooling ablation experiments.

  Benchmark	Last-token	Mean	Latent attention
  ... (individual benchmarks) ...	...	...	...
  Overall AVG	78.41%	77.20%	78.27%
  MTEB Code AVG	78.72%	77.18%	78.41%

  Note: This table is a transcription summary of the original data from Table 5.

  • Analysis: The results show that last-token pooling consistently provides the best average performance, although the margins are sometimes small. This empirically validates their design choice and suggests that for autoregressive models, the final hidden state is a rich source of semantic information for the entire sequence.

7. Conclusion & Reflections

• Conclusion Summary: The paper successfully introduces jina-code-embeddings, a new family of highly efficient and powerful code embedding models. By pioneering a method that adapts pre-trained autoregressive code generation models using task-specific prefixes and last-token pooling, the authors demonstrate that it is possible to achieve state-of-the-art performance without resorting to massive, general-purpose models. The results validate their unique construction methodology as an effective path toward building specialized embedding models.

• Limitations & Future Work (Author-Stated and Inferred):

  • English-Centric Instructions: The instruction prefixes are in English. This could limit the models' effectiveness for queries in other natural languages, even if the code itself is language-agnostic.
  • Backbone Dependency: The performance is inherently tied to the quality of the underlying Qwen2.5-Coder backbone. A different or better backbone might yield different results.
  • Synthetic Data Validation: While the authors used synthetic data to fill gaps, its validation was limited to "manual inspection of samples." This may not be sufficient to eliminate all potential biases or artifacts from the generation model (GPT-4o).
  • Preprint Status: As a non-peer-reviewed preprint, the results and claims are preliminary until they have been vetted by the wider research community.

• Personal Insights & Critique:

  • This work is an excellent example of model recycling and specialization. Instead of training a massive model from scratch, it cleverly repurposes an existing, highly capable asset (a code LLM) for a related but distinct task (embedding). This is a sustainable and practical direction for AI research.
  • The systematic approach to task definition and instruction tuning is a key strength. It shows a deep understanding of the downstream applications of code embeddings and provides a clear recipe for others to follow.
  • The paper's clear and concise presentation, backed by thorough experimentation and ablation studies, makes a strong case for its claims.
  • An interesting question for future work is why last-token pooling excels. A common intuition is that the final hidden state in an autoregressive model is optimized to contain all the necessary context to predict the next token, effectively serving as a summary of the sequence. A deeper theoretical or empirical analysis of this phenomenon would be a valuable contribution.
  • The success of this approach opens the door for creating specialized, efficient embedding models for other domains (e.g., legal text, medical records) by starting with domain-specific generative LLMs.