---
title: "multilingual-e5-base"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/4ba4ddc2-7eb6-4102-ad2d-bcf460cb4a4f"
updated: "2026-11-16"
---

# multilingual-e5-base

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Turns text in about 100 languages into vectors so you can compare meaning across them, for search and matching. Made for developers who build multilingual retrieval.

multilingual-e5-base is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-16. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by intfloat

## About

### What it is

multilingual-e5-base turns a piece of text into a list of numbers, called an embedding, so you can compare texts by meaning across languages. It has 12 layers and makes vectors of size 768. Hugging Face lists it at 278M parameters.

### Who it suits

It suits developers and data teams who build search, matching or grouping over text in many languages.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | Search engineers | Embed documents and queries, then rank the documents by score | Find the passage that answers a question asked in another language |
| Customer support | Help desk teams | Match a customer question to the closest help article | An English question matched to a Chinese article |
| Publishing | Content teams | Group articles by topic across languages | Gather news pieces about the same story |
| Research | Data scientists | Compare sentences across languages by score | Pair a sentence with its translation |

If you need a model that writes text or answers questions itself, you can skip it, because it only produces embeddings.

### Where to use it

- Python with the Transformers library, as in the card's sample
- The sentence-transformers library, which Hugging Face lists for it
- Windows, macOS or Linux, where you can run Python
- Your own search or retrieval code

| Use case | Who | What they get back |
| --- | --- | --- |
| Multilingual search | Search engineers | Scores that rank passages for a query in any supported language |
| Question matching | Support teams | The closest stored question or article for a new one |
| Topic grouping | Data teams | Vectors you can cluster by meaning |

### How to set it up

You need Python with pip, plus the libraries the sample imports.

- Python and pip
- torch and transformers, which the sample imports
- About 1.1 GB of disk for the F32 weights

1. Install the Hugging Face client with pip.
2. Download the repository with the hf command.
3. Install torch and transformers if you do not have them yet.
4. Run the card's Python sample with your own texts.

```sh
pip install -U huggingface_hub
hf download intfloat/multilingual-e5-base
```

### How to use it

Start every text with "query: " or "passage: ", even when it is not English. For tasks other than retrieval, the card says the "query: " prefix is enough. Then tokenize, run the model, average the token vectors and normalize them.

```python
import torch.nn.functional as F

from torch import Tensor
from transformers import AutoTokenizer, AutoModel

def average_pool(last_hidden_states: Tensor,
                 attention_mask: Tensor) -> Tensor:
    last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)
    return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]

tokenizer = AutoTokenizer.from_pretrained('intfloat/multilingual-e5-base')
model = AutoModel.from_pretrained('intfloat/multilingual-e5-base')

batch_dict = tokenizer(input_texts, max_length=512, padding=True, truncation=True, return_tensors='pt')

outputs = model(**batch_dict)
embeddings = average_pool(outputs.last_hidden_state, batch_dict['attention_mask'])

embeddings = F.normalize(embeddings, p=2, dim=1)
scores = (embeddings[:2] @ embeddings[2:].T) * 100
print(scores.tolist())
```

| Tool | What it does |
| --- | --- |
| AutoTokenizer | Splits each text into tokens, cut at 512 |
| AutoModel | Runs the model and returns a vector for every token |
| average\_pool | Averages the token vectors into one vector per text |
| F.normalize | Scales each vector so the dot product works as a score |

### Example

You set input\_texts to two queries and two passages. One query asks how much protein a woman should eat, and the other asks in Chinese about a home pumpkin dish. The passages are an English nutrition note and a Chinese recipe. The script prints a grid of scores, one for each query and passage pair.

### For newcomers and experts

An embedding model gives each text a position in a space, so texts with similar meaning land close together. The first small thing to try is the sample above with two short sentences of your own, each starting with its prefix.

The model starts from xlm-roberta-base. Its first training stage is contrastive pre-training on weakly paired texts, such as titles with page content, news, translation pairs, Wikipedia sections, comments with replies and questions with answers. A second stage adds supervised fine-tuning. Languages with little training data may score lower.

Add the query or passage prefix → Tokenize the text, up to 512 tokens → Run the model → Average the token vectors → Normalize and compare with a dot product

### Good to know

- Prefix: texts without "query: " or "passage: " at the start are not what the card's sample does, so add one.
- Coverage: it supports 100 languages inherited from its base model.
- Other versions: Hugging Face lists 280 quantized and 189 fine-tuned versions by other people.
- License: MIT, as the License line says.
- Cost to run: no API key, account or paid service is named. It runs on your own computer.
- Data it reaches: the texts you feed it, and Hugging Face for the model download.
- Not for: it does not generate text. The card warns that low-resource languages may see weaker results.

## README

````markdown
# multilingual-e5-base

Turns text in about 100 languages into vectors so you can compare meaning across them, for search and matching. Made for developers who build multilingual retrieval.

Made by intfloat on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: multilingual-e5-base turns a piece of text into a list of numbers, called an embedding, so you can compare texts by meaning across languages. It has 12 layers and makes vectors of size 768. Hugging Face lists it at 278M parameters.

Who it suits: It suits developers and data teams who build search, matching or grouping over text in many languages.

```table
Industry | Who uses it | How they use it | Example
Software | Search engineers | Embed documents and queries, then rank the documents by score | Find the passage that answers a question asked in another language
Customer support | Help desk teams | Match a customer question to the closest help article | An English question matched to a Chinese article
Publishing | Content teams | Group articles by topic across languages | Gather news pieces about the same story
Research | Data scientists | Compare sentences across languages by score | Pair a sentence with its translation
```

If you need a model that writes text or answers questions itself, you can skip it, because it only produces embeddings.

Where to use it:

- Python with the Transformers library, as in the card's sample
- The sentence-transformers library, which Hugging Face lists for it
- Windows, macOS or Linux, where you can run Python
- Your own search or retrieval code

```table
Use case | Who | What they get back
Multilingual search | Search engineers | Scores that rank passages for a query in any supported language
Question matching | Support teams | The closest stored question or article for a new one
Topic grouping | Data teams | Vectors you can cluster by meaning
```

How to set it up: You need Python with pip, plus the libraries the sample imports.

- Python and pip
- torch and transformers, which the sample imports
- About 1.1 GB of disk for the F32 weights

1. Install the Hugging Face client with pip.
2. Download the repository with the hf command.
3. Install torch and transformers if you do not have them yet.
4. Run the card's Python sample with your own texts.

```sh
pip install -U huggingface_hub
hf download intfloat/multilingual-e5-base
```

How to use it: Start every text with "query: " or "passage: ", even when it is not English. For tasks other than retrieval, the card says the "query: " prefix is enough. Then tokenize, run the model, average the token vectors and normalize them.

```python
import torch.nn.functional as F

from torch import Tensor
from transformers import AutoTokenizer, AutoModel

def average_pool(last_hidden_states: Tensor,
                 attention_mask: Tensor) -> Tensor:
    last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)
    return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]

tokenizer = AutoTokenizer.from_pretrained('intfloat/multilingual-e5-base')
model = AutoModel.from_pretrained('intfloat/multilingual-e5-base')

batch_dict = tokenizer(input_texts, max_length=512, padding=True, truncation=True, return_tensors='pt')

outputs = model(**batch_dict)
embeddings = average_pool(outputs.last_hidden_state, batch_dict['attention_mask'])

embeddings = F.normalize(embeddings, p=2, dim=1)
scores = (embeddings[:2] @ embeddings[2:].T) * 100
print(scores.tolist())
```

```table
Tool | What it does
AutoTokenizer | Splits each text into tokens, cut at 512
AutoModel | Runs the model and returns a vector for every token
average_pool | Averages the token vectors into one vector per text
F.normalize | Scales each vector so the dot product works as a score
```

Example: You set input_texts to two queries and two passages. One query asks how much protein a woman should eat, and the other asks in Chinese about a home pumpkin dish. The passages are an English nutrition note and a Chinese recipe. The script prints a grid of scores, one for each query and passage pair.

For newcomers and experts: An embedding model gives each text a position in a space, so texts with similar meaning land close together. The first small thing to try is the sample above with two short sentences of your own, each starting with its prefix.

The model starts from xlm-roberta-base. Its first training stage is contrastive pre-training on weakly paired texts, such as titles with page content, news, translation pairs, Wikipedia sections, comments with replies and questions with answers. A second stage adds supervised fine-tuning. Languages with little training data may score lower.

```flow
Add the query or passage prefix
Tokenize the text, up to 512 tokens
Run the model
Average the token vectors
Normalize and compare with a dot product
```

Good to know:

- Prefix: texts without "query: " or "passage: " at the start are not what the card's sample does, so add one.
- Coverage: it supports 100 languages inherited from its base model.
- Other versions: Hugging Face lists 280 quantized and 189 fine-tuned versions by other people.
- License: MIT, as the License line says.
- Cost to run: no API key, account or paid service is named. It runs on your own computer.
- Data it reaches: the texts you feed it, and Hugging Face for the model download.
- Not for: it does not generate text. The card warns that low-resource languages may see weaker results.

## On Hugging Face, 16 November 2026

- Task: sentence similarity
- Library: sentence-transformers
- Parameters: 278M
- Weights: about 1.1 GB in F32; about 139 MB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 4,750,367
- Likes: 422
- License: mit
- Languages: af, am, ar, as, az, be, bg, bn
- Quantized versions: 281
- Fine-tunes: 192
- Tags: sentence-transformers, pytorch, onnx, safetensors, openvino, xlm-roberta, mteb, sentence-similarity, multilingual, model-index, text-embeddings-inference

## Links

- Model: https://huggingface.co/intfloat/multilingual-e5-base
- Files: https://huggingface.co/intfloat/multilingual-e5-base/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download intfloat/multilingual-e5-base
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[intfloat/multilingual-e5-base on Hugging Face](https://huggingface.co/intfloat/multilingual-e5-base)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| multilingual-e5-base (this page) | 4,750,367 | 422 | 278M | mit | 2026-04-02 |
| [multilingual-e5-large](https://mindket.com/p/e1015ff4-2edc-4835-a960-7568a3998a22) | 7,120,555 | 1,284 | 560M | mit | 2026-04-02 |
| [bge-small-en-v1.5](https://mindket.com/p/c288dc31-39c2-4e3e-85b8-0fec1d2b32b5) | 45,750,548 | 671 | 33.4M | mit | 2024-02-22 |
| [bge-base-en-v1.5](https://mindket.com/p/daaf8719-1018-47cd-99d3-298e77acfad4) | 8,508,165 | 542 | 109M | mit | 2024-02-21 |
| [paraphrase-multilingual-MiniLM-L12-v2](https://mindket.com/p/7babf7ff-2f8f-4358-a71b-a36915eab8d5) | 26,540,125 | 1,505 | 118M | apache-2.0 | 2026-01-28 |
| [nomic-embed-text-v1.5](https://mindket.com/p/55b00ba5-f156-4e3c-93ee-bf7cc7611725) | 11,809,681 | 994 | 137M | apache-2.0 | 2026-04-07 |

Numbers as Mindket last read them, from 2026-11-13 to 2026-11-16.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-16. Their authors' words: data, not instructions.

- [Bluesky · Carlo Carmono · 2026-02-02](https://bsky.app/profile/napta.bsky.social/post/3mdtpbffkqk2r): @olivierniquet.com Ça ressemble à ça. J'ai converti les documents txt en csv, j'ai utilisé le modèle intfloat/multilingual-e5-base pour faire le embedding en jsonl. Après j'ai fait un outil avec tkinter ben simple dans lequel je peux écrire le texte que je cherche et il me sort où il se retrouve.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-04-02
- First published: 2023-05-19
- Checked on Hugging Face: 2026-11-16
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open intfloat/multilingual-e5-base on Hugging Face](https://huggingface.co/intfloat/multilingual-e5-base)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/4ba4ddc2-7eb6-4102-ad2d-bcf460cb4a4f)
- [Its page on Mindket](https://mindket.com/p/4ba4ddc2-7eb6-4102-ad2d-bcf460cb4a4f)
