How to Generate Ollama Embeddings: The Right Way in JavaScript

The right way to generate Ollama embeddings depends on whether you are using the REST API directly or the official Ollama JavaScript library (ollama-js). For the REST API, use the endpoint with input as the key for the text. For the JavaScript library, use ollama.embed() with input as the key, not prompt. The ollama.embeddings() method with prompt is a legacy or LangChain-specific pattern and is not the canonical approach in the current ollama-js library. This answer covers both approaches, explains the inconsistency, and provides working code examples.

The Full Answer

Ollama provides two primary ways to generate embeddings: through its REST API and through its official JavaScript library (ollama-js). The confusion arises because older documentation, community examples, and LangChain integrations sometimes use prompt as the input key, while the current REST API and ollama-js use input. This guide resolves that confusion and gives you the correct, working syntax for each method.

Approach 1: Using the Ollama REST API Directly

The Ollama REST API is the foundational interface. According to the Ollama API documentation, the endpoint for generating embeddings is /api/embed. The request body uses input as the key for the text you want to embed. Here is the correct structure:

POST /api/embed
{
  "model": "mxbai-embed-large",
  "input": "Llamas are members of the camelid family"
}

Note that the key is input, not prompt. The response will contain an array of embeddings. For a single input, the response looks like:

{
  "model": "mxbai-embed-large",
  "embeddings": [[0.123, 0.456, ...]]
}

To generate embeddings for multiple inputs, pass an array of strings:

{
  "model": "mxbai-embed-large",
  "input": ["First text", "Second text", "Third text"]
}

The response will contain an array of embeddings, one per input, in the same order.

Approach 2: Using the Ollama JavaScript Library (ollama-js)

The official Ollama JavaScript library, ollama-js, wraps the REST API. Its API is designed to mirror the REST API, so it uses input as the key. The method is ollama.embed(), not ollama.embeddings(). The ollama.embeddings() method with prompt is not documented in the current ollama-js library and appears to be a legacy or LangChain-specific pattern.

Here is the correct way to use ollama-js to generate embeddings, based on the source from M.Ali El-Sayed and the official documentation:

1. Install the library:

npm install ollama --save

2. Import and initialize the client:

import { Ollama } from "ollama";

const ollama = new Ollama({ host: "http://localhost:11434" }); // Replace with your Ollama server URL

3. Create an async function to generate embeddings:

async function textToEmbeddingOllama(text) {
  try {
    const response = await ollama.embed({
      model: "mxbai-embed-large", // Replace with your model name
      input: text,
      truncate: false,
      keep_alive: "1.5h",
      options: {
        embedding: true,
      },
    });
    console.log(response);
    return response.embeddings[0];
  } catch (error) {
    console.error("Error generating embeddings with Ollama:", error);
    throw error;
  }
}

Explanation of parameters:

• model: The name of the embedding model you have pulled (e.g., mxbai-embed-large, nomic-embed-text, all-minilm).
• input: The text string (or array of strings) to embed. This is the correct key, not prompt.
• truncate: A boolean. When set to false, the model will not truncate the input if it exceeds the maximum token length. If you set it to true (or omit it), the input will be truncated. This is useful for long documents.
• keep_alive: A string specifying how long to keep the model loaded in memory after the request. "1.5h" means 1.5 hours. This can speed up subsequent requests.
• options.embedding: A boolean. Setting this to true ensures the model returns embeddings. Some models may require this flag.

The response object has the following structure:

{
  "model": "mxbai-embed-large",
  "embeddings": [[0.123, 0.456, ...]],
  "total_duration": 123456789,
  "load_duration": 123456,
  "prompt_eval_count": 10
}

response.embeddings is an array of arrays. For a single input, it contains one array. For multiple inputs, it contains one array per input. The example above returns response.embeddings[0], which is the embedding vector for the single input.

Why the Confusion? prompt vs input

As noted in the Stack Overflow question, the Ollama embedding models documentation shows this syntax:

ollama.embeddings({
  model: 'mxbai-embed-large',
  prompt: 'Llamas are members of the camelid family',
})

This is not the canonical ollama-js syntax. The official ollama-js documentation states: "The Ollama JavaScript library's API is designed around the Ollama REST API." The REST API uses input, so the library should use input. The prompt key appears in older examples and in LangChain's Ollama integration, which has its own wrapper. If you are using the raw ollama-js library, always use input and the ollama.embed() method.

When to Use Each Approach

• Use the REST API directly if you are not using JavaScript/Node.js, or if you want to make HTTP requests from any language (Python, curl, etc.). It is the most universal.
• Use ollama-js if you are building a Node.js or browser application and want a convenient, promise-based interface. The library handles connection details and provides TypeScript types.
• Avoid ollama.embeddings() with prompt unless you are working with an older codebase or a specific LangChain version that requires it. For new projects, use ollama.embed() with input.