VoyageAI by MongoDB: 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.
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-liteOverview
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 |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits voyageai/voyage-4-lite | Default— |
Fieldinput | Typestring|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— |
Fieldencoding_format | Typestring | RequirementOptional | Values & limits float | Defaultfloat |
Fielddimensions | Typeinteger | RequirementNot supported | Values & limits Minimum: 1 | Default— |
Fielduser | Typejson_value | RequirementOptional | Values & limits Conditions: Source allows this JSON metadata field; exact upstream semantics are model-specific. | Default— |
Fieldsession_id | Typejson_value | RequirementOptional | Values & limits Conditions: Source allows this JSON metadata field; exact upstream semantics are model-specific. | Default— |
Fieldtrace | Typejson_value | RequirementOptional | Values & limits Conditions: Source allows this JSON metadata field; exact upstream semantics are model-specific. | Default— |
Fieldprovider | Typeobject | RequirementOptional | Values & limits Conditions: provider.options rejected | Default— |
Input material combinations
text_to_embedding
Method parameters and lifecycle
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, input |
Parameterinput_shapes | Contractstring, string[], nonnegative_integer_token_array, nonnegative_integer_token_array[] |
Parameterencoding_format | Contractfloat |
Parameterdimensions_override | Contractfalse |
Parametermax_input_budget_units | Contract32000 |
Parametermultimodal_objects | Contractfalse |
Parametermaterial_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 →
Example requests
Ailoot Ultra · Embeddings
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
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 |
|---|---|
Fieldobject | Typestring |
Fieldmodel | Typestring |
Fielddata[].index | Typeinteger |
Fielddata[].embedding | Typefinite float[] |
Fieldusage | 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
Method path aliases
Use the method paths shown above.
Related caller IDs
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