vespa

Implements approximate nearest neighbor search across distributed clusters using Hierarchical Navigable Small World (HNSW) graph indexing built into the Proton search engine. Vectors are indexed as tensor attributes with configurable distance metrics (L2, angular, hamming) and query-time approximate matching that trades recall for latency. The distributed architecture partitions vector data across content nodes via consistent hashing, with each node maintaining its own HNSW graph and the dispatcher aggregating results from parallel searches.

Defines document structure and indexing behavior through declarative schema files (Vespa Search Definition Language) that specify field types, indexing directives, and ranking features. The schema compiler (in config-model) transforms these declarations into concrete indexing pipelines that automatically handle tokenization, stemming, field weighting, and attribute creation. Document processing chains execute custom Java/C++ processors on inbound documents before indexing, enabling transformations like embedding generation, NLP annotation, or field extraction.

Stores document fields as columnar attributes (dense arrays of values) rather than inverted indexes, enabling fast filtering and sorting without decompressing entire documents. Attributes are loaded into memory and support range queries, equality filters, and sorting operations with O(1) lookup per document. The attribute system supports multiple data types (int, float, string, tensor) and can be imported from other document types via reference fields, enabling efficient joins without denormalization.

Allows defining multiple summary views (document summaries) that specify which fields are returned in search results, with optional field transformations (truncation, highlighting, dynamic snippets). Summaries are defined in schema and can be selected per-query, enabling different result formats for different use cases (mobile vs. desktop, preview vs. full details). The summary framework supports dynamic field computation (e.g., generating snippets from matched text) and field-level access control.

Collects operational metrics from all Vespa components (query latency, indexing throughput, memory usage, cache hit rates) and exposes them via Prometheus-compatible endpoints. The metrics system supports custom metrics defined by application code, enabling tracking of business-specific KPIs (e.g., 'queries with zero results', 'average result rank position'). Metrics are aggregated across the cluster and can be queried via REST API or scraped by monitoring systems.

Provides pluggable embedder components that generate vector embeddings for text fields during indexing or query processing. Built-in embedders support integration with external embedding services (OpenAI, Hugging Face, local models) via HTTP or gRPC. Embeddings are computed once at index time and stored as tensor attributes, or computed at query time for query embeddings. The embedder framework supports batching for efficient inference and caching to avoid redundant computations.

Implements a two-phase ranking architecture where first-phase ranking (BM25, vector similarity, simple expressions) quickly filters candidates, then second-phase ranking applies expensive ML models (ONNX, XGBoost, LightGBM) to re-rank top-K results. Ranking expressions are compiled to efficient C++ code and executed on content nodes. ONNX models are loaded into memory and executed natively without Python/TensorFlow overhead, with support for batched inference across multiple result candidates.

Provides a Document API that accepts document operations (put, update, remove) through HTTP REST endpoints or Java/Python clients, with guaranteed ACID semantics across distributed content nodes. The feed processing pipeline (Document API → MessageBus → Distributor → Persistence Engine) ensures documents are replicated across configured redundancy factor and persisted to disk. Updates are applied as conditional operations with version tracking, and the system provides strong consistency guarantees with configurable durability levels (acknowledged when replicated vs. persisted to disk).

Enables full-text search over documents without building inverted indexes by scanning document storage and applying ranking expressions at query time. The streaming search path uses the Visitor Framework to traverse stored documents, apply query filters, and execute ranking logic on-the-fly. This is useful for small datasets, frequently-changing data, or when index overhead is not justified. Streaming search supports the same ranking expressions and tensor operations as indexed search but with linear scan latency instead of logarithmic index lookup.

Provides a tensor algebra system for computing ML features and ranking scores using multi-dimensional arrays. Tensors are defined in schema with dimensions (e.g., tensor<float>(x[10],y[20])) and can be stored as document attributes, computed from ranking expressions, or passed as query parameters. Ranking expressions support tensor operations (dot products, matrix multiplication, element-wise operations) compiled to optimized C++ code. This enables efficient computation of embedding-based features, neural network layers, and complex feature interactions without external computation.

Monitors resource utilization (CPU, memory, disk) and query latency metrics across content nodes, then automatically adjusts cluster size by provisioning or deprovisioning nodes to maintain target resource levels. The autoscaling system uses the Node Repository to track node state and the Cluster Controller to orchestrate node transitions. Autoscaling policies are defined in deployment.xml with target metrics (e.g., 'keep CPU at 70%'), and the system gradually scales up/down to avoid thrashing while respecting minimum/maximum cluster sizes.

Parses user queries in Vespa Query Language (YQL) — a SQL-like syntax for expressing complex search logic including filters, ranking, grouping, and result pagination. The query parser (in container-search) converts YQL to an internal query tree, which is then executed by the dispatcher that routes sub-queries to content nodes, collects results, and applies second-phase ranking. YQL supports nested queries, aggregations, and tensor operations, enabling complex search workflows without application-level query construction.

Implements a request processing framework (JDisc Container) that routes HTTP requests to pluggable handler components written in Java. Handlers can perform custom logic (authentication, request transformation, result post-processing) and integrate with Vespa's search and document processing pipelines. The container supports dependency injection, component lifecycle management, and chaining of handlers for complex request workflows. This enables building custom APIs and business logic on top of Vespa's core search/feed capabilities.

Supports deploying Vespa clusters across multiple datacenters with automatic document replication and query routing. The deployment model (defined in deployment.xml) specifies which datacenters receive replicas, and the system automatically replicates documents across regions. Query routing can be configured to prefer local datacenters or failover to remote regions on latency/availability issues. The Cluster Controller manages fleet health across datacenters and coordinates node state transitions.