Mistral: Codestral Embed 2505
Codestral Embed 2505 represents code and natural-language queries as vectors for repository search and coding-assistant retrieval. Its maker documents an 8,192-token context, configurable dimensions up to 3,072 and floating, integer or bit-packed output formats.
About the model
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Codestral Embed 2505 is Mistral AI's embedding model specialized for code retrieval. It receives text containing source code or a natural-language code query and returns numerical vectors. The maker positions it for repository search, context retrieval for coding assistants, similarity and duplicate analysis, and grouping code by its functionality or structure. Its fixed release identifier is codestral-embed-2505.
Input and representation
A code input can be a function, a related source fragment or another meaningful unit of a repository. A natural-language query can describe the behavior to locate rather than naming the exact symbol. The embedding represents that input for comparison; the model does not generate a new implementation or execute the code it receives.
The official release documents a full input context of 8,192 tokens. For retrieval, the maker recommends chunks of about 3,000 characters with 1,000 characters of overlap, noting that larger chunks can hurt retrieval. These are retrieval-preparation recommendations rather than a token limit of 3,000 characters. Keep the file, symbol and source location associated with each prepared item so the application can return the relevant code after search.
Output precision and dimensions
The code-embedding guide documents float, int8, uint8, binary and ubinary output types. Float uses 32-bit single-precision values. Int8 uses signed 8-bit integers from -128 to 127, while uint8 uses unsigned 8-bit values from 0 to 255. Binary and ubinary store quantized single-bit values in packed 8-bit elements, using signed or unsigned containers respectively.
Bit-packed representation changes the returned list length: the guide describes one packed element for every eight logical embedding dimensions. A format-aware comparison is therefore different from treating the packed bytes as ordinary floating coordinates. Preserve the chosen type with the vector and use the same representation for indexed code and its query.
The parameter documentation gives a default dimension of 1,536 and a maximum of 3,072. Dimensions are ordered by relevance, and the maker describes retaining the first chosen number as a way to select representation size. Choose the dimension consistently for the stored collection and new queries. A shorter or quantized representation changes storage and comparison behavior; it does not increase the input context or turn the model into a code generator.
Retrieval-augmented coding
The release's first use case is retrieving context for code completion, editing or explanation. Prepare meaningful code units and retain the repository revision and source identifiers. A question about how a particular error is handled can retrieve related functions, which the application then supplies to a coding model along with the actual change request.
A practical result is a ranked set of source snippets with file paths, symbols and the content needed to understand their behavior. The retrieved snippets can be opened by a developer or passed to an assistant. Codestral Embed performs the representation step; a separate component selects the results and any generation model writes the explanation or proposed code.
Semantic search and similarity
The maker describes searching code with natural-language or code queries. A developer can ask for the implementation of a behavior even when the function name differs from the wording of the request. Include the behavior and conditions that distinguish the intended implementation; a general query about an entire subsystem may retrieve related material without resolving the specific question.
The release also describes finding near-duplicate or functionally similar code despite lexical differences. Such results can help locate a reusable implementation or identify code needing further review. Similarity in embedding space is a signal to inspect the source; it does not establish that two fragments have identical behavior for every input.
Clustering, analytics and comparison
Code embeddings can be used to group code by functionality or structure and inspect the composition of a repository. Keep the original snippets and identifiers available so that a group can be interpreted by a person or a later application step. A cluster is a representation-based grouping, not an automatically verified architecture description.
The maker's floating-vector examples use unit-normalized embeddings, for which cosine similarity, dot product and Euclidean distance give consistent rankings. Quantized and bit-packed output should retain its own format handling rather than inheriting an assumption about raw floating coordinates. The published endpoint also retains input indexes, helping preserve the connection between each vector and its source item.
Edition and practical boundaries
The exact model page lists embedding and batch workflows with an 8k context label, while the release gives the 8,192-token value. Preserve the named 2505 edition, chosen output dimension and type throughout the collection and query workflow. This is code-oriented vector output, distinct from Codestral's text completion and from the fixed-dimensional Mistral Embed text model.
Prepare code units that carry the relevant behavior, keep their source locations and state the question to locate. The useful artifact is a retrievable representation tied to actual code, which supports the next explanation, editing or developer-review step without performing that step itself.
Ailoot Ultra · Embeddings POST /v1/embeddings mistralai/codestral-embed-2505
mistralai/codestral-embed-2505
mistralai/codestral-embed-2505Overview
Codestral Embed 2505 represents code and natural-language queries as vectors for repository search and coding-assistant retrieval. Its maker documents an 8,192-token context, configurable dimensions up to 3,072 and floating, integer or bit-packed output formats.
- 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
- 8,192 tokens
- Output format
- json
| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits mistralai/codestral-embed-2505 | Default— |
Fieldinput | Typestring|string[]|integer[]|integer[][] | RequirementRequired | Values & limits Minimum items: 1 Conditions: Nonempty homogeneous batch. Token IDs are nonnegative integers. Input budget: Maximum: 8,192 · 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 | Contract8192 |
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.0003 / 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": "mistralai/codestral-embed-2505", "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='mistralai/codestral-embed-2505',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 mistralai/codestral-embed-2505
Method path aliases
Use the method paths shown above.
Related caller IDs
FAQ · Mistral: Codestral Embed 2505
- What inputs and results are available?
POST /v1/embeddings·mistralai/codestral-embed-2505:text,token_ids→embedding- Which fields does the request use?
POST /v1/embeddings·mistralai/codestral-embed-2505:model,input,encoding_format,provider- What limits apply?
POST /v1/embeddings·mistralai/codestral-embed-2505:ctx:8192;input.budget.maximum:8192(UTF8 bytes);input.min_items:1