Yalda Embedding

Yalda Embedding

Turns Persian text into 1,024-number embeddings for semantic search and retrieval. Built for developers who need to match Persian questions to the right passages.

Made by Yaldat 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: Yalda Embedding turns Persian text into vectors of 1,024 numbers, so a search can match by meaning instead of exact words. It is a tuned copy of Qwen3-Embedding-0.6B, trained on over one million Persian pairs of a query and its matching document. Knowledge distilled from a larger teacher model, F2LLM-v2-8B, shaped the training too.

Who it suits: Developers and search teams who need retrieval over Persian text, and researchers who compare embedding models on Persian tasks.

Industry | Who uses it | How they use it | Example
Software | Backend developers | Add meaning-based search to a Persian document store | A user asks where Iran's capital is and gets the passage about Tehran
Education | Learning platform teams | Match student questions to Persian study passages | A question about autumn leaf colour finds the passage on chlorophyll breaking down
Research | NLP researchers | Use it as a retrieval baseline on Persian tasks | Compare scores on the FaMTEB retrieval tasks the card lists
Knowledge management | Data teams | Embed internal Persian documents once and index them for later queries | Precompute passage vectors and search them in a vector store

You can skip it if your text is not Persian, because the card describes it as built and tested for Persian.

Where to use it: It runs wherever Python and the sentence-transformers library run.

• Python scripts and notebooks that use sentence-transformers
• Windows, macOS or Linux, with Python and pip installed
• A vector search system that stores your precomputed document embeddings

Use case | Who | What they get back
Semantic search | App developers | The passage closest in meaning to each query
Dense retrieval | Search teams | Passages ranked by cosine similarity
Model comparison | Researchers | Retrieval scores on Persian tasks to set beside other models

How to set it up: You need Python with pip and room for the weights, which are about 2.4 GB in F32.

• Python with pip
• About 2.4 GB of disk space for the F32 Safetensors weights
• The sentence-transformers, transformers and torch packages

1. Install the three Python libraries with pip.
2. Optionally download the model files to your computer with the Hugging Face tool.
3. Load the model by its name in Python, as the next section shows.

pip install -U sentence-transformers transformers torch

pip install -U huggingface_hub
hf download Yaldat/Yalda-Embedding

How to use it: Load the model, set left padding and a 512 token limit, then encode queries with the saved query prompt and passages with the document prompt. Normalize both sets, and multiply the two matrices to get similarity scores.

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Yaldat/Yalda-Embedding")
model.tokenizer.padding_side = "left"
model.max_seq_length = 512

queries = [
    "پایتخت ایران کجاست؟",
    "چرا برگ درختان در پاییز تغییر رنگ می‌دهد؟",
]
documents = [
    "تهران پایتخت ایران و یکی از بزرگ‌ترین شهرهای این کشور است.",
    "در پاییز با کاهش نور خورشید، کلروفیل برگ‌ها تجزیه می‌شود و رنگدانه‌های دیگر نمایان می‌شوند.",
    "کتابخانه‌ها فضایی برای مطالعه و دسترسی به منابع علمی فراهم می‌کنند.",
]

query_embeddings = model.encode(
    queries,
    prompt_name="query",
    normalize_embeddings=True,
)
document_embeddings = model.encode(
    documents,
    prompt_name="document",
    normalize_embeddings=True,
)

scores = query_embeddings @ document_embeddings.T
for query, row in zip(queries, scores):
    best_index = int(row.argmax())
    print(f"Query: {query}")
    print(f"Best passage: {documents[best_index]}")
    print(f"Similarity: {row[best_index]:.4f}\n")

Tool | What it does
SentenceTransformer | Loads the model by its name
encode with prompt_name query | Adds the saved search instruction to each query
encode with prompt_name document | Embeds passages with no instruction added
normalize_embeddings=True | Makes the dot product equal the cosine similarity

Example: Take the question "پایتخت ایران کجاست؟", which asks where Iran's capital is, and three Persian passages. The script encodes all four texts, then prints the query, the best passage and its similarity score to four decimals. A passage that talks about Tehran is the natural match.

For newcomers and experts: An embedding is a list of numbers that stands for what a text means. Two texts with similar meaning get lists that point the same way, and the cosine score tells you how close they are. Run the sample under How to use it first, then swap in your own Persian questions and passages.

Under the hood it is a decoder-only Transformer with 28 blocks and grouped-query attention. It reads text left to right and takes the last non-padding token as the vector, which is why the sample sets left padding. Training used relational knowledge distillation from F2LLM-v2-8B. The trade is size against reach: it keeps the 0.6B footprint and scores close to the 4B Qwen model on the card's eight tasks, but only 512 tokens were tested.

Persian text goes in
Add the query or document prompt
Encode with the 28-block transformer
Take the last token as the vector
Normalize it to unit length
Dot product gives the match score

Good to know: The numbers below come from the card's own evaluation, so read them as reported results.

• Input length: Training and tests used 512 tokens, and longer inputs are cut under that setting.
• Prompts: The model has no default prompt, so you pick the query prompt yourself for search queries.
• Reported score: The card gives a mean of 0.5488 on eight Persian FaMTEB retrieval tasks, against 0.5563 for the 4B Qwen model.

Title: Mean retrieval score on eight Persian tasks
Qwen3-Embedding-4B: 0.5563 score
Yalda Embedding: 0.5488 score
F2LLM-v2-0.6B: 0.5063 score
Diba-Embed: 0.4788 score
Qwen3-Embedding-0.6B: 0.4713 score

• License: Apache 2.0.
• Cost to run: none named, the source lists no API key, account or paid service.
• Data it reaches: only the text you pass in, plus the model files it downloads from Hugging Face.
• Not for: text that is not Persian, or inputs past 512 tokens, where the card claims no retrieval quality.

On Hugging Face, 14 November 2026

• Task: sentence similarity
• Library: sentence-transformers
• Parameters: 596M
• Weights: about 2.4 GB in F32; about 298 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 204
• Likes: 5
• License: apache-2.0
• Languages: fa, eng
• Based on: Qwen/Qwen3-Embedding-0.6B
• Tags: sentence-transformers, safetensors, qwen3, text-generation, persian, text-embeddings, dense-retrieval, semantic-search, transformers, knowledge-distillation, feature-extraction, sentence-similarity

Links

• Model: https://huggingface.co/Yaldat/Yalda-Embedding
• Files: https://huggingface.co/Yaldat/Yalda-Embedding/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Yaldat/Yalda-Embedding

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