Source: https://ailoot.ai/models/en/voyageai-voyage-4-lite/
Canonical: https://ailoot.ai/models/en/voyageai-voyage-4-lite/
Language: en

# VoyageAI by MongoDB: voyage-4-lite

[Markdown](https://ailoot.ai/models/en/voyageai-voyage-4-lite/index.md) · [JSON](https://ailoot.ai/models/en/voyageai-voyage-4-lite/facts.json)

## [VoyageAI by MongoDB: voyage-4-lite](https://ailoot.ai/models/en/voyageai-voyage-4-lite/)

Voyage AI voyage-4-lite is the latency-oriented text embedding edition in the Voyage 4 family. It supports 32,000-token inputs, four vector dimensions and quantized representations, with a shared embedding space compatible with the other Voyage 4 text models.

- [**Ailoot Ultra · Embeddings** `POST /v1/embeddings` `voyageai/voyage-4-lite`](https://ailoot.ai/models/en/voyageai-voyage-4-lite/#method-0)

About the model

This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.

voyage-4-lite is the latency-oriented text embedding model in Voyage AI’s Voyage 4 family. It represents queries and documents as numerical vectors for general-purpose retrieval. Its distinguishing family feature is a shared embedding space with voyage-4, voyage-4-large and voyage-4-nano, allowing query and document models to be chosen separately.

#### Start with the retrieval roles

Prepare the user’s information need as a query and the searchable material as documents. Voyage recommends the query/document input types for retrieval; its published recipe adds the corresponding retrieval instruction when vectorizing the text.

For an employee handbook collection, a query about carrying unused leave into the next period should be compared with the specific policy sections. Keep the rule, its conditions and any relevant exception in the indexed passage. Retain the original document and section identifier beside the vector so the application can return the actual policy text.

An unspecified input type directly represents the text, while the query/document roles tailor it for retrieval. The maker states that embeddings produced with and without those role settings are compatible, but retaining a consistent preparation policy makes the collection easier to assess.

#### Shared space across the Voyage 4 text family

Voyage explicitly documents an asymmetric retrieval workflow: documents can be encoded with voyage-4-large and searched using query vectors from voyage-4-lite. This is a family-level compatibility statement, rather than a conclusion drawn from two models returning the same vector length.

Keep the selected vector dimension and representation aligned between the collection and query side. The shared space also permits changing the query model within this named Voyage 4 text family without re-vectorizing the existing documents. Assess the resulting ranking with representative questions when choosing the query edition.

The Lite edition’s role is the smaller, latency-focused query and text-embedding option. The maker attributes the mixture-of-experts architecture specifically to voyage-4-large; that architecture is not established for Lite by the family name.

#### Context, dimensions and result format

The published context length is 32,000 tokens per text. The default vector has 1024 dimensions, with 256, 512 and 2048 also available through Matryoshka learning. The maker’s text-embedding flow documents floating-point, signed and unsigned 8-bit integer, and bit-packed binary representations for voyage-4-lite.

For standard floating-point vectors, Voyage’s similarity guidance describes unit-length embeddings, making cosine and dot-product similarity equivalent. Quantized forms need their corresponding representation handling. For example, a bit-packed binary list stores eight embedding bits in each byte; its list length differs from the semantic vector dimension.

In Voyage’s documented batch recipe, a list contains at most 1000 texts and one million total tokens for this exact Lite edition. The default over-length behavior truncates individual text to the context boundary; the alternative setting rejects over-length inputs. These batch and per-text limits are distinct.

#### Prepare and inspect retrieval results

Split long source material into coherent sections that can be returned as evidence. A 32,000-token context permits a long input, but a useful retrieval unit should still lead to the relevant source section. Include the heading or identifying detail needed to interpret a rule.

For RAG, retrieve candidate sections and pass their original text to the answer-writing stage with source associations. The embedding model produces vectors and does not generate a policy answer. Similarity ranks candidates under the chosen model and comparison setup; review the actual passage for the precise condition asked about.

voyage-4-lite’s useful edition-specific combination is a latency-focused text model, flexible representations, a 32,000-token context and documented compatibility within the Voyage 4 text family. Keep those properties with the indexed collection and use source-backed retrieval results to support the surrounding application.

**Ailoot Ultra · Embeddings** `POST /v1/embeddings` `voyageai/voyage-4-lite`

[`voyageai/voyage-4-lite`](https://ailoot.ai/models/en/#m=voyageai%2Fvoyage-4-lite&route=Ultra&caller=voyageai%2Fvoyage-4-lite&fmt=embeddings)

VoyageAI by MongoDB /`voyageai/voyage-4-lite`

### Overview

Voyage AI voyage-4-lite is the latency-oriented text embedding edition in the Voyage 4 family. It supports 32,000-token inputs, four vector dimensions and quantized representations, with a shared embedding space compatible with the other Voyage 4 text models.

Accepted inputs

Text · token\_ids

Results

embedding

### Available in Ailoot · inputs & methods

**Ailoot Ultra · Embeddings** `POST /v1/embeddings`

Input types

`text`, `token_ids`

Output types

`embedding`

Context

32,000 tokens

Output format

json

| Field | Type | Requirement | Values & limits | Default |
| --- | --- | --- | --- | --- |
| Field`model` | Type`string` | RequirementRequired | Values & limits voyageai/voyage-4-lite | Default— |
| Field`input` | Type`string\|string[]\|integer[]\|integer[][]` | RequirementRequired | Values & limits Minimum items: 1 Conditions: Nonempty homogeneous batch. Token IDs are nonnegative integers. Input budget: Maximum: 32,000 · Text unit: UTF8 bytes · Token unit: token-array elements | Default— |
| Field`encoding_format` | Type`string` | RequirementOptional | Values & limits float | Defaultfloat |
| Field`dimensions` | Type`integer` | RequirementNot supported | Values & limits Minimum: 1 | Default— |
| Field`user` | Type`json_value` | RequirementOptional | Values & limits Conditions: Source allows this JSON metadata field; exact upstream semantics are model-specific. | Default— |
| Field`session_id` | Type`json_value` | RequirementOptional | Values & limits Conditions: Source allows this JSON metadata field; exact upstream semantics are model-specific. | Default— |
| Field`trace` | Type`json_value` | RequirementOptional | Values & limits Conditions: Source allows this JSON metadata field; exact upstream semantics are model-specific. | Default— |
| Field`provider` | Type`object` | RequirementOptional | Values & limits Conditions: provider.options rejected | Default— |

Input material combinations

**text\_to\_embedding**

Method parameters and lifecycle

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, input |
| Parameter`input_shapes` | Contractstring, string\[\], nonnegative\_integer\_token\_array, nonnegative\_integer\_token\_array\[\] |
| Parameter`encoding_format` | Contractfloat |
| Parameter`dimensions_override` | Contractfalse |
| Parameter`max_input_budget_units` | Contract32000 |
| Parameter`multimodal_objects` | Contractfalse |
| Parameter`material_types` | Contracttext, token\_ids |

Lifecycle: `synchronous_json`

Keep every vector index and dimension.

Multimodal model name does not admit image objects on this exact path.

### Pricing

Tariff references do not add request options. Supported parameters are listed for the selected method.

Fast mode

Standard rate When fast mode is selected

Flex mode

Standard rate When flex mode is selected

Maximum reasoning effort

Standard rate When maximum reasoning effort uses the default adjustment

#### Ailoot rates

#### Prices by configuration

| Configuration | Rate schedule | Charge |
| --- | --- | --- |
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens **$0.00004** / 1K tokens Output · Output tokens **$0** / 1K tokens Input · Cache read **—** / 1K tokens Input · Cache write **—** / 1K tokens Input · Cache write, 1 hour **—** / 1K tokens |

Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. [How reservation and settlement work →](https://ailoot.ai/docs/en/billing/reserve/)

### Example requests

#### Ailoot Ultra · Embeddings

curlPython SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "voyageai/voyage-4-lite", "input": ["First document", "Second document"]}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/embeddings \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("data",[]): print(json.dumps({"index":x.get("index"),"embedding":x.get("embedding")}))
PY_RESULT
```

```python
from openai import OpenAI
import os

client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.embeddings.create(model='voyageai/voyage-4-lite',input=["First document","Second document"])
print(result)
for item in result.data:print(item.index,item.embedding)
```

### Receive and save results

#### Ailoot Ultra · Embeddings

json

##### Keep all completed results

Keep every complete returned response, file and content part.

Keep every vector with its index. Vector count must equal input count; dimensions must be consistent.

##### If the original response needs checking

No embedding job endpoint is introduced.

Response fields

| Field | Type |
| --- | --- |
| Field`object` | Typestring |
| Field`model` | Typestring |
| Field`data[].index` | Typeinteger |
| Field`data[].embedding` | Typefinite float\[\] |
| Field`usage` | Typeobject |

Errors and next steps

| Response | Condition | Next step |
| --- | --- | --- |
| Response400 · `invalid_request_error` | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |

### Aliases

#### Model aliases

**Ailoot Ultra** [`voyageai/voyage-4-lite`](https://ailoot.ai/models/en/#m=voyageai%2Fvoyage-4-lite&route=Ultra&caller=voyageai%2Fvoyage-4-lite&fmt=embeddings)

#### Method path aliases

Use the method paths shown above.

#### Related caller IDs

[`voyageai/voyage-4-lite`](https://ailoot.ai/models/en/#m=voyageai%2Fvoyage-4-lite&route=Ultra&caller=voyageai%2Fvoyage-4-lite&fmt=embeddings)

FAQ · VoyageAI by MongoDB: voyage-4-lite

What inputs and results are available?

`POST /v1/embeddings` · `voyageai/voyage-4-lite`: `text`, `token_ids` → `embedding`

Which fields does the request use?

`POST /v1/embeddings` · `voyageai/voyage-4-lite`: `model`, `input`, `encoding_format`, `provider`

What limits apply?

`POST /v1/embeddings` · `voyageai/voyage-4-lite`: `ctx`: `32000`; `input.budget.maximum`: `32000` (UTF8 bytes); `input.min_items`: `1`

Connect Ailoot to Claude Code, OpenCode, Hermes or your own app.

## The company and its project portfolio

The company and its project portfolio: millions of customers; monthly sales in the billions.

## Buy tokens at a discount.

Subscription discounts for regular use. Promo codes offer up to 50% off token purchases.

Subscription

Choose a discounted plan for your regular requests.

Promo code: up to 50% off

Enter your code at checkout. The price updates to reflect the current promotion.

Spending in your history

The model, tokens and amount are recorded for each request.

[Choose a subscription](https://ailoot.ai/docs/en/billing/subscriptions/) · [View model prices](https://ailoot.ai/models/en/)

## Connect the API to a product you sell.

Use Ailoot in SaaS, apps and bots under its official service offer and licence agreement. Request a reseller licence for resale.

Commercial application

Add text, image, video and audio generation to paid features in your service.

Reseller licence

Send a description of your project and how you provide access. Request written terms for use and resale.

Documents on the website

The service offer, licence agreement and data processing policy are available before you connect.

[Request a reseller licence](mailto:support@ailoot.ai) · [Service offer and licence agreement](https://ailoot.ai/legal/offer?lang=en)

## Ailoot · The company and its project portfolio





Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control.





The company and its project portfolio: millions of customers; monthly sales in the billions.





Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.