Nomic Embed

Generates dense vector embeddings for text using Matryoshka representation learning, which produces nested embeddings at multiple dimensionalities (e.g., 768, 512, 256, 128 dimensions) from a single forward pass. This allows downstream applications to trade off between embedding quality and computational cost by selecting the appropriate dimensionality for their use case, without recomputing embeddings. The architecture uses contrastive learning objectives to ensure that lower-dimensional projections preserve semantic relationships from the full-dimensional space.

Generates aligned embeddings for both text and image inputs in a shared vector space, enabling cross-modal semantic search and similarity matching. The architecture uses a dual-encoder design where separate encoders process text and images, with a contrastive learning objective (e.g., InfoNCE loss) that aligns embeddings so semantically related text-image pairs have high cosine similarity. This allows querying images with text queries and vice versa within a single embedding space.

Enables users to fine-tune pre-trained embedding models on custom datasets using the same training code and hyperparameters published by Nomic. The system provides training scripts that implement contrastive learning objectives (e.g., InfoNCE loss for text, or multimodal alignment for text-image pairs). Users supply their own training data, and the system handles data loading, distributed training across GPUs, and checkpoint management. Fine-tuned models can be exported and used for inference or further fine-tuning.

Provides PyTorch Lightning integration for training embedding models across distributed GPU clusters. The system includes Lightning modules that wrap embedding models and training loops, enabling users to leverage Lightning's distributed training features (DDP, mixed precision, gradient accumulation) without writing custom distributed code. This simplifies scaling training to multiple GPUs or nodes while maintaining reproducibility through Lightning's checkpoint and logging infrastructure.

Integrates with AWS SageMaker for training embedding models on managed infrastructure and deploying trained models as SageMaker endpoints. The system provides SageMaker-compatible training scripts and container definitions, enabling users to launch training jobs through the SageMaker API without managing EC2 instances. Trained models can be deployed as SageMaker endpoints for serverless inference with automatic scaling.

Integrates with GPT4All to enable local embedding inference without requiring API keys or cloud connectivity. The system provides compatibility layers that allow using Nomic embedding models through GPT4All's local inference engine, which runs models on CPU or GPU without external service calls. This enables offline embedding generation and privacy-preserving inference where data never leaves the user's machine.

Publishes complete training datasets, hyperparameters, and training code for all embedding models, enabling users to audit model behavior, understand training data composition, and reproduce results. The architecture includes documented data collection pipelines, preprocessing steps, and training configurations stored in version-controlled repositories. This transparency allows developers to identify potential biases, verify claims about model quality, and fine-tune models on custom datasets using the same methodology.

Provides a Python client library that communicates with the Atlas backend platform to store embeddings in indexed structures (AtlasIndex) and perform efficient vector similarity search. The client accepts pre-computed embeddings or text data, uploads them to Atlas servers, and creates searchable indices that support semantic search queries. The architecture uses a client-server design where the Python client handles data preparation and the Atlas backend manages indexing, storage, and search operations using optimized vector database techniques.

Analyzes indexed embeddings to automatically discover semantic topics and clusters within datasets using unsupervised learning techniques. The system applies clustering algorithms (e.g., HDBSCAN or similar) to embedding space, then generates human-readable topic labels by analyzing the most representative documents in each cluster. This capability runs server-side on the Atlas platform and integrates with the visualization layer to highlight topic regions in 2D maps.

Identifies duplicate or near-duplicate documents within indexed embeddings by analyzing embedding similarity and clustering similar vectors. The system uses embedding-based similarity (e.g., cosine distance thresholds) to find documents that are semantically equivalent or nearly identical, then surfaces these duplicates through the Atlas interface. This enables users to identify and remove redundant content from datasets before training models or performing analysis.

Generates 2D visualizations of high-dimensional embeddings that preserve semantic relationships and enable interactive exploration. The system uses dimensionality reduction techniques (e.g., UMAP, t-SNE variants) to project embeddings into 2D space while maintaining local and global structure, then renders interactive maps in the Atlas web interface. Users can zoom, pan, hover over points to see documents, and filter by topics or tags. The projection is computed server-side and cached for fast loading.

Supports adding new documents and embeddings to existing indexed datasets without recomputing the entire index. The client-server architecture allows appending new data points to an AtlasDataset, which the Atlas backend integrates into existing indices and projections. This enables workflows where datasets grow over time (e.g., continuous data ingestion) without requiring full reindexing. The system updates topic assignments, duplicate detection, and 2D projections incrementally.

Allows users to assign tags and metadata to documents in indexed datasets, then filter and search using these tags. The system stores metadata alongside embeddings and supports filtering search results by tag values. Tags can be assigned manually through the Atlas interface or programmatically through the Python API. Filtering is performed server-side, enabling efficient queries like 'find documents tagged as "important" with high similarity to query embedding'.

Processes large collections of text documents into embeddings efficiently using GPU acceleration and automatic batching. The system handles variable-length inputs, manages GPU memory, and optimizes batch sizes for throughput. The Python API accepts lists of documents and returns embeddings in the same order, with support for streaming results for very large datasets. Internally, the system uses PyTorch with mixed precision (FP16) to reduce memory usage and increase throughput.