What is a text embedding and what is it used for?

A text embedding is a list of numbers (a vector) that captures the meaning of a piece of text. Texts with similar meaning sit close together in that number space. Embeddings power semantic search, retrieval-augmented generation (RAG), clustering, deduplication, and recommendation — anywhere you need to compare texts by meaning rather than by exact words.

How do I generate embeddings without an OpenAI API key?

Paste your text and press Generate. This tool uses the open-source all-MiniLM-L6-v2 sentence-transformer instead of a paid API, so you need no OpenAI, Cohere, or Voyage key and pay nothing. The model runs on our server and returns the vector to you — you can copy or download it straight into your own vector database.

What model does this use and how many dimensions is the vector?

It uses sentence-transformers/all-MiniLM-L6-v2 — the same weights as the ONNX build Xenova/all-MiniLM-L6-v2. Every vector has 384 dimensions, is mean-pooled over token embeddings, and is L2-normalised to unit length. The dimensionality badge on each result is read from the vector length, not hard-coded, so what you see is what the model produced.

Can I use these embeddings for semantic search or a RAG pipeline?

Yes. Embed each document once, store the vectors in a vector database (pgvector, Pinecone, Qdrant, Chroma, FAISS), then embed the user query with the same model and retrieve the nearest vectors by cosine similarity. Keep one rule: always embed queries and documents with the same model, or the vectors are not comparable.

Are my texts sent to a server when generating embeddings here?

Your text is sent once to our server, which computes the vector and returns it. It is not stored, logged, or shared, and nothing is sent to any third-party analytics. The comparison-maths demo on the page runs fully in your browser. If you need strict on-device processing, run the model locally with sentence-transformers or Transformers.js.

Why is the vector magnitude always about 1.0?

all-MiniLM-L6-v2 L2-normalises its output, so every vector has unit length (‖v‖ ≈ 1.0). That is deliberate: when both vectors are unit length, cosine similarity equals the plain dot product, which makes nearest-neighbour search faster and simpler. The tool shows the magnitude so you can confirm the output is normalised.

Does the same text always give the same vector?

Yes. The model has fixed weights and does no sampling, so it is deterministic — identical input text produces the identical vector every time. That is why comparing a text with itself returns a cosine similarity of exactly 1.0000.

What happens to very long text?

The model reads at most 256 tokens (roughly 190 English words). Longer text is truncated from the end before encoding, and the tool warns you when your input is likely over the cap. For long documents, split them into paragraphs and embed each chunk separately — that is also better practice for RAG retrieval.

Is all-MiniLM-L6-v2 good for Sinhala or Tamil text?

Not really — this model is English-primary. It will still return a vector for Sinhala or Tamil text, but the similarity scores are unreliable for those languages. A multilingual model such as paraphrase-multilingual-MiniLM would be the right choice, and is on the roadmap for a future version of this tool.

Developer · AI

Text Embedding Generator — free, no API key

Paste any text and get its 384-dimension embedding vector from all-MiniLM-L6-v2 — the numbers behind semantic search and RAG. Copy or download as JSON, CSV, or a Python list, and compare two texts by cosine similarity. No API key, no signup.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 13, 2026

Generate a text embedding

all-MiniLM-L6-v2 · 384-d

Text A21/2,000

≈ 8 tokens

Text B (optional — enables similarity)27/2,000

≈ 8 tokens

Try a sample

Output format

Precision

Paste text and press Generate embedding to turn it into a 384-dimension vector you can copy or download. Add a second text to also get the cosine similarity between the two. The maths panel below runs entirely in your browser and works even before you generate anything.

See the comparison maths (runs in your browser)

Cosine similarity is what turns two embeddings into one comparable number. This worked example uses two toy unit vectors so you can check it by hand:

a = [0.6, 0.8, 0]
‖a‖ = 1.0000

b = [0, 0.8, 0.6]
‖b‖ = 1.0000

a · b = (0.6·0.0) + (0.8·0.8) + (0.0·0.6) = 0.6400
cos(a, b) = (a · b) / (‖a‖ · ‖b‖) = 0.6400

Both formulas agree: 0.64 — the "related" band. Because the vectors are unit length, the full cosine formula and the plain dot product give the same answer.

Your text is sent once to the server only to compute the vector — it is never stored, logged, or shared. Sources are cited below the tool.

How it works

An embedding maps text to a fixed-length list of numbers so that meaning becomes geometry: two texts that mean similar things land close together, and comparing them is just measuring the angle between their vectors. This tool uses sentence-transformers/all-MiniLM-L6-v2 (UKP Lab · Reimers & Gurevych, 2019), a sentence-transformer that outputs a 384-dimension vector. The model runs on our server through the Hugging Face Inference API — you never download model weights into your browser — and the same weights back the ONNX build Xenova/all-MiniLM-L6-v2 referenced in the model documentation.

The pipeline has four documented stages:

Tokenize.The text is split into subword tokens by the model's WordPiece tokenizer. Sequences over 256 tokens (~190 English words) are truncated; the tool warns you when that is likely.
Encode. The MiniLM encoder produces one embedding per token.
Mean-pool. Token embeddings are averaged using the attention mask so padding is excluded: for token vectors tᵢ and mask mᵢ, the sentence vector is v = (Σ mᵢ·tᵢ) / (Σ mᵢ).
L2-normalise. v ← v / ‖v‖₂, so every vector has unit length. This is why the magnitude shown next to each result is ≈ 1.0000.

To compare two texts the tool computes cosine similarity, cos(a,b) = (a·b) / (‖a‖·‖b‖), clamped to the range [-1, 1] to absorb floating-point drift. Because both vectors are unit length, this reduces to the dot product Σ aᵢbᵢ— the tool computes it both ways and confirms they agree, which is also a live check that the output really is normalised. A score of ≥ 0.85 is labelled "near-duplicate / paraphrase", 0.50–0.85 "related", 0.20–0.50 "loosely related", and below 0.20 "unrelated". The bands are a reading aid; the number is the source of truth.

Worked examples

Cosine on a toy 3-D vector (hand-reconcilable)

a = [0.6, 0.8, 0.0] → ‖a‖ = √(0.36 + 0.64) = 1.0
b = [0.0, 0.8, 0.6] → ‖b‖ = √(0.64 + 0.36) = 1.0
a · b = (0.6·0.0) + (0.8·0.8) + (0.0·0.6) = 0.64
cos(a, b) = 0.64 / (1.0 × 1.0) = 0.6400 → band 'related'

The real model is 384-D and can't be pooled by hand, so this verifies the comparison maths the tool uses. Open the 'See the comparison maths' panel in the tool to watch it run live.

Identity & self-similarity (determinism)

Text A = Text B = 'Sri Lanka income tax calculator'
The model is deterministic, so Vector A == Vector B exactly.
cos(a, a) = Σ aᵢ² = ‖a‖² = 1.0000
The tool displays exactly 1.0000 for identical text.

Load the 'Identical' sample to see this — it is the strongest correctness check the tool can make without hand-pooling.

Paraphrase vs unrelated (directional check)

A = 'A cat sat on the mat.' B = 'A feline rested on the rug.'
Expected: high cosine (~0.6–0.8), band 'related' — a paraphrase.
Now B = 'The quarterly VAT filing deadline is the 20th.'
Expected: cosine < 0.2, band 'unrelated'.

These are model-produced, not hand-computed. The check is directional: the paraphrase must score far higher than the unrelated pair. Load the 'Paraphrase' and 'Unrelated' samples to compare.

Frequently asked questions

Sources & references

Model details and the pooling/normalisation recipe were last cross-checked against these sources on 2026-07-13.

Related tools

LiveAI

AI Alt-Text Generator

Drop an image and get a concise, WCAG-friendly alt-text string plus two longer caption variants. BLIP captioning runs server-side via the Hugging Face Inference API, with a built-in WebAIM linter and W3C role-aware guidance.

Open tool

LiveAI

Text Summarizer

Summarize long articles, papers, or meeting notes into a TL;DR paragraph plus key bullet points. A DistilBART model runs server-side alongside a deterministic TextRank pass. No API key, no signup, sources cited.

Open tool

LiveAI

Paraphrasing Tool

Reword English text in four modes with a seq2seq paraphrase model, plus a deterministic word-overlap and change-metrics cross-check — free, no signup, sources cited.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.