all-MiniLM-L6-v2

Converts variable-length text inputs into fixed-dimensional dense vector embeddings (384 dimensions) using a distilled BERT architecture optimized for semantic similarity tasks. Implements mean pooling over the final transformer layer outputs to produce normalized embeddings suitable for cosine similarity comparisons. The model uses ONNX quantization to reduce model size from ~90MB to ~22MB while maintaining embedding quality, enabling browser-based and edge deployment via transformers.js.

Performs semantic similarity matching across 50+ languages by leveraging multilingual BERT's shared embedding space, where embeddings from different languages cluster semantically rather than lexically. The model was trained on parallel sentence pairs across multiple languages, enabling zero-shot cross-lingual retrieval — a query in English can find semantically similar documents in Spanish, Mandarin, or Arabic without language-specific fine-tuning. Similarity is computed via cosine distance in the shared 384-dimensional space.

Classifies text by embedding it and computing similarity to class prototypes (embeddings of representative examples or class names). For example, classifying a review as 'positive' or 'negative' by comparing its embedding to embeddings of 'this product is great' and 'this product is terrible'. This zero-shot approach requires no training data — just representative text for each class. Can be extended to multi-class classification by computing similarity to multiple class prototypes and selecting the highest-scoring class.

Executes the entire embedding pipeline (tokenization, transformer inference, pooling) directly in the browser using transformers.js and ONNX Runtime Web, eliminating round-trips to a backend embedding service. The ONNX quantized model (~22MB) is downloaded once and cached in IndexedDB or local storage, then inference runs on the client's CPU/GPU via WebAssembly or WebGL. Latency is typically 50-200ms per embedding on modern hardware, with no network overhead after initial model load.

Computes pairwise cosine similarity between query embeddings and a corpus of document embeddings, returning ranked results sorted by similarity score. The implementation leverages vectorized operations (dot products, L2 normalization) to efficiently compare a single query against thousands of documents in milliseconds. Similarity scores range from -1 to 1 (or 0 to 1 for normalized embeddings), with scores >0.7 typically indicating semantic relevance. Can be implemented in-memory for small corpora or with vector databases (Pinecone, Weaviate) for large-scale retrieval.

Processes multiple text inputs in a single forward pass through the transformer, amortizing tokenization and model loading overhead across the batch. Transformers.js implements dynamic batching where inputs are padded to the longest sequence in the batch, then processed together via ONNX Runtime. Batch sizes of 8-64 are typical; larger batches improve throughput (embeddings/second) but increase latency per batch. Outputs are a 2D array of embeddings (batch_size × 384 dimensions).

Executes transformer inference using 8-bit integer quantization instead of 32-bit floating-point, reducing model size from ~90MB to ~22MB and improving inference speed by 2-4x on CPU-bound hardware. Quantization maps float32 weights to int8 values using learned scale factors, with minimal accuracy loss (<2% on semantic similarity benchmarks). ONNX Runtime automatically handles dequantization during inference, making quantization transparent to the user while providing speed and memory benefits.

Groups semantically similar texts by computing embeddings for all items, then applying clustering algorithms (k-means, hierarchical clustering, DBSCAN) on the 384-dimensional embedding space. Items with embeddings close in vector space are grouped together, enabling deduplication of near-duplicate content and discovery of semantic clusters without manual labeling. Clustering quality depends on the similarity threshold and algorithm choice; typical use cases set thresholds at 0.85-0.95 cosine similarity for deduplication.

Identifies near-duplicate or paraphrased text by comparing embeddings of candidate pairs and flagging those with cosine similarity above a threshold (typically 0.85-0.95). Unlike exact matching or fuzzy string matching, this approach detects semantic duplicates — texts that convey the same meaning despite different wording. Can be implemented as a pairwise comparison (O(n²)) for small corpora or with approximate nearest neighbor (ANN) indexing (Faiss, Annoy) for large-scale detection.

Implements a complete semantic search pipeline: (1) embed user query, (2) retrieve candidate documents from a corpus via similarity search, (3) rank results by cosine similarity score. Unlike keyword search (BM25), this approach matches semantic meaning rather than term overlap, enabling queries like 'how do I fix a broken window' to find results about 'repairing glass panes' without keyword overlap. Can be implemented in-memory for small corpora (<100K docs) or with vector databases (Pinecone, Weaviate, Milvus) for large-scale retrieval.

Compares two or more documents by embedding each and computing pairwise cosine similarity, producing a similarity matrix that quantifies semantic overlap. Useful for finding similar documents in a corpus, measuring document coherence, or detecting plagiarism. Similarity scores range from -1 to 1 (or 0 to 1 for normalized embeddings); scores >0.7 typically indicate substantial semantic overlap. Can be extended to hierarchical comparison (comparing document sections or paragraphs) for fine-grained analysis.