# Supported Embedding Models in OmniRoute: Complete Provider List (v3.8.51)

> Discover the complete list of supported embedding models in OmniRoute v3.8.51. Explore over 60 models from 20+ providers like OpenAI, Gemini, Voyage AI, and Jina AI.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: api-reference
- Published: 2026-08-29

---

**OmniRoute supports over 60 embedding models across 20+ providers including OpenAI, Gemini, Voyage AI, and Jina AI, all defined centrally in the [`open-sse/config/embeddingRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/embeddingRegistry.ts) configuration.**

OmniRoute treats vector generation as a first-class capability, offering a unified API for cloud and local inference. All **embedding models in OmniRoute** are declared in the **Embedding Registry**, which maps provider IDs to model metadata including vector dimensions and display names. This guide enumerates every supported model as of release v3.8.51.

## How OmniRoute Manages Embedding Models

The architecture relies on a single source of truth. In [`open-sse/config/embeddingRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/embeddingRegistry.ts), the `EMBEDDING_PROVIDERS` constant declares every provider and its associated models. When a request hits the `/v1/embeddings` endpoint, the handler invokes `getEmbeddingProvider()` to resolve the model, or `parseEmbeddingModel()` to split a compound ID such as `"openai/text-embedding-3-small"` into its provider and model components.

The resolution flow follows these steps:

1. The API route [`src/app/api/v1/embeddings/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/embeddings/route.ts) receives the POST request.
2. The payload forwards to the embedding handler.
3. The handler calls `getEmbeddingProvider()` from the registry.
4. If valid, the handler builds an **EmbeddingResolution** ([`src/lib/memory/embedding/types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/memory/embedding/types.ts)) and invokes the concrete implementation.

Because the registry is a simple JavaScript object, adding a model requires only updating this file—the rest of the stack automatically picks up the change.

## Complete List of OmniRoute Embedding Models

The registry ships with 20+ providers. Below is the complete inventory organized by provider, including model IDs and vector dimensions where specified.

### OpenAI and OpenAI-Compatible Providers

- **OpenAI**: `text-embedding-3-small` (**1536** dimensions), `text-embedding-3-large` (**3072** dimensions), `text-embedding-ada-002` (**1536** dimensions)
- **Vercel AI Gateway**: `text-embedding-3-small` (**1536** dimensions), `text-embedding-3-large` (**3072** dimensions)
- **OpenRouter**: `openai/text-embedding-3-small`, `openai/text-embedding-3-large`, plus native OpenRouter prefixes
- **NanoGPT**: `text-embedding-3-small`, `text-embedding-3-large`

### Cohere

- `embed-v4.0`
- `embed-multilingual-v3.0`
- `embed-multilingual-v3.0-images`
- `embed-multilingual-light-v3.0`
- `embed-multilingual-light-v3.0-images`

### Google Gemini

- `gemini-embedding-001` (**768** dimensions)
- `gemini-embedding-2`
- `gemini-embedding-2-preview`

OpenRouter also proxies these Gemini models under the `google/` namespace.

### Voyage AI

Most Voyage models output **1024** dimensions unless noted:

- `voyage-4-large`, `voyage-4`, `voyage-4-lite`
- `voyage-3-large`, `voyage-3.5`, `voyage-3.5-lite` (**512** dimensions)
- `voyage-multilingual-2`
- `voyage-code-3`, `voyage-code-2` (**1536** dimensions)
- `voyage-finance-2`, `voyage-law-2`

### Jina AI

- `jina-embeddings-v5-text-nano` (**768** dimensions)
- `jina-code-embeddings-1.5b` (**1536** dimensions)
- `jina-code-embeddings-0.5b` (**896** dimensions)
- `jina-colbert-v2` (**128** dimensions)
- `jina-embeddings-v5-text-small`, `jina-embeddings-v5-omni-small`, `jina-embeddings-v5-omni-nano`, `jina-embeddings-v4`, `jina-clip-v2`

### DeepInfra and Qwen

DeepInfra hosts multiple Qwen and BGE variants:

- `Qwen/Qwen3-Embedding-8B` (**4096** dimensions)
- `Qwen/Qwen3-Embedding-4B` (**2560** dimensions)
- `Qwen/Qwen3-Embedding-0.6B` (**1024** dimensions)
- `BAAI/bge-large-en-v1.5` (**1024** dimensions)
- `BAAI/bge-base-en-v1.5` (**768** dimensions)
- `BAAI/bge-m3` (**1024** dimensions)
- `intfloat/e5-large-v2` (**1024** dimensions)
- `thenlper/gte-large` (**1024** dimensions)

### Mixbread, Nomic, and Specialized Providers

- **Mixedbread**: `mixedbread-ai/mxbai-embed-large-v1`, `mixedbread-ai/mxbai-embed-2d-large-v1`
- **Nomic**: `nomic-embed-text` (also available via Fireworks as `nomic-ai/nomic-embed-text-v1.5` with **768** dimensions)
- **NVIDIA**: `nvidia/nv-embedqa-e5-v5`
- **Upstage**: `embedding-query`, `embedding-passage` (both **4096** dimensions)
- **Mistral**: `mistral-embed` (**1024** dimensions)
- **Together AI**: `BAAI/bge-large-en-v1.5` (**1024** dimensions), `togethercomputer/m2-bert-80M-8k-retrieval` (**768** dimensions)
- **Nebius**: `Qwen/Qwen3-Embedding-8B` (**4096** dimensions)
- **EmbeddingGemma**: `embeddinggemma`
- **BGE-M3**: `bge-m3` (available via multiple providers)

### Local Model Placeholders

- **LMStudio**: Configurable for local models (no defaults listed)
- **Ollama Local**: Configurable for local Ollama deployments (no defaults listed)

## How to Call OmniRoute Embedding Models

Use the generic endpoint for automatic provider resolution, or target a specific provider route.

### Generic Endpoint

```typescript
import fetch from "node-fetch";

const response = await fetch("http://localhost:20128/v1/embeddings", {
  method: "POST",
  headers: { 
    "Content-Type": "application/json", 
    "Authorization": "Bearer <API-KEY>" 
  },
  body: JSON.stringify({
    model: "text-embedding-3-small",
    input: ["Hello world!", "OmniRoute is awesome"]
  })
});

const data = await response.json();
console.log(data);

```

### Provider-Specific Route

```typescript
await fetch("http://localhost:20128/v1/providers/openai/embeddings", {
  method: "POST",
  headers: { "Authorization": "Bearer <API-KEY>" },
  body: JSON.stringify({
    model: "openai/text-embedding-3-large",
    input: "Embedding a single string"
  })
});

```

### Programmatic Resolution

```typescript
import { parseEmbeddingModel } from "@omniroute/open-sse/config/embeddingRegistry";

const { provider, model } = parseEmbeddingModel("openai/text-embedding-3-small");
console.log(provider); // "openai"
console.log(model);    // "text-embedding-3-small"

```

## Key Implementation Files

Understanding these files helps customize the embedding layer:

- **[`open-sse/config/embeddingRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/embeddingRegistry.ts)**: Defines `EMBEDDING_PROVIDERS` and exports `parseEmbeddingModel()` and `getEmbeddingProvider()`.
- **[`src/app/api/v1/embeddings/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/embeddings/route.ts)**: Handles POST requests to `/v1/embeddings`.
- **`src/app/api/v1/providers/[provider]/embeddings/route.ts`**: Handles provider-scoped routes such as `/v1/providers/openai/embeddings`.
- **[`src/lib/memory/embedding/types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/memory/embedding/types.ts)**: Exports TypeScript interfaces including `EmbeddingResolution` and `EmbeddingResult`.
- **[`src/shared/validation/schemas/apiV1.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/shared/validation/schemas/apiV1.ts)**: Contains Zod schemas validating the embedding request payload.

## Summary

- OmniRoute defines all **embedding models** in a central registry at [`open-sse/config/embeddingRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/embeddingRegistry.ts).
- The platform supports 60+ models across 20+ providers including OpenAI, Cohere, Voyage AI, Gemini, and Jina AI.
- Vector dimensions range from 128 (Jina ColBERT v2) to 4096 (Qwen3 8B and Upstage).
- Local deployment placeholders exist for LMStudio and Ollama.
- Resolution occurs via `parseEmbeddingModel()` and validation uses Zod schemas in [`apiV1.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/apiV1.ts).

## Frequently Asked Questions

### How do I add a custom embedding model to OmniRoute?

Edit [`open-sse/config/embeddingRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/embeddingRegistry.ts) and append a new entry to the `models` array within the appropriate provider object. Specify the `id`, `name`, and `dimensions` (if known). The API layer automatically recognizes the change without modifying route handlers or validation logic, as the registry serves as the single source of truth.

### What are the vector dimensions for OmniRoute embedding models?

Dimensions vary by model architecture. Common sizes include **1536** (OpenAI small/Ada), **3072** (OpenAI large), **4096** (Qwen3 8B, Upstage), **1024** (Mistral, Voyage AI, BGE large), **768** (Gemini 001, BGE base, Nomic 1.5), and **128** (Jina ColBERT v2). The registry stores the dimension value in the `dimensions` field of each model descriptor.

### Does OmniRoute support local embedding models via Ollama or LMStudio?

Yes. The registry includes placeholder providers for **LMStudio** and **Ollama Local**. While no default models are pre-configured, you can define local model IDs in [`embeddingRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/embeddingRegistry.ts) or configure the handlers to route requests to your local inference server endpoints.

### How does OmniRoute validate embedding model requests?

Requests validate against a Zod schema defined in [`src/shared/validation/schemas/apiV1.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/shared/validation/schemas/apiV1.ts). The handler first calls `parseEmbeddingModel()` to ensure the model string maps to a known provider in `EMBEDDING_PROVIDERS`. If the provider or model is missing, the API returns a validation error before attempting resolution.