Glossary

Vector Database Infrastructure

This pillar covers the specialized storage and retrieval systems designed to index high-dimensional embeddings for rapid semantic search, validating the firm's capability to build scalable memory backends.

Get in touch Learn more

Engineer reviewing vector database search results on laptop, embeddings visualization on screen, home office coding session.

Glossary

Vector Indexing Algorithms

Terms related to the core data structures and algorithms used to organize high-dimensional vectors for efficient similarity search. Target: CTOs, ML Engineers.

HNSW (Hierarchical Navigable Small World)

HNSW (Hierarchical Navigable Small World) is a graph-based approximate nearest neighbor search algorithm that constructs a multi-layered graph to enable fast, logarithmic-time search by navigating through a hierarchy of increasingly dense networks.

IVF (Inverted File Index)

IVF (Inverted File Index) is a vector indexing method that partitions the dataset into Voronoi cells via clustering and uses an inverted index to map centroids to their associated vectors, enabling efficient search by probing only a subset of cells.

IVFPQ (Inverted File with Product Quantization)

IVFPQ (Inverted File with Product Quantization) is a composite vector indexing algorithm that combines an Inverted File (IVF) for coarse partitioning with Product Quantization (PQ) for compressing residual vectors, dramatically reducing memory footprint while maintaining search accuracy.

Product Quantization (PQ)

Product Quantization (PQ) is a lossy compression technique for high-dimensional vectors that splits a vector into subvectors, quantizes each subvector independently using a learned codebook, and represents the original vector by a concatenation of subvector code indices.

Scalar Quantization

Scalar Quantization is a vector compression method that reduces the precision of each vector component (e.g., from 32-bit floats to 8-bit integers) by mapping a continuous range of values to a finite set of discrete levels, thereby decreasing memory usage and accelerating distance calculations.

LSH (Locality-Sensitive Hashing)

LSH (Locality-Sensitive Hashing) is a family of hashing algorithms designed to map similar input vectors into the same hash buckets with high probability, enabling approximate nearest neighbor search by reducing the candidate search space to a small number of buckets.

ANNS (Approximate Nearest Neighbor Search)

ANNS (Approximate Nearest Neighbor Search) refers to a class of algorithms and data structures that trade perfect accuracy for significantly faster search times by finding vectors that are close, but not necessarily the exact closest, to a given query vector in high-dimensional spaces.

FAISS (Facebook AI Similarity Search)

FAISS (Facebook AI Similarity Search) is an open-source library developed by Meta for efficient similarity search and clustering of dense vectors, providing GPU-accelerated implementations of indexing algorithms like IVF, HNSW, and Product Quantization.

SCANN (Scalable Nearest Neighbors)

SCANN (Scalable Nearest Neighbors) is a vector search library from Google Research that uses anisotropic vector quantization and tree-AH indexing to achieve high recall and throughput for maximum inner product search (MIPS) and cosine similarity.

DiskANN

DiskANN is a graph-based approximate nearest neighbor search algorithm optimized for billion-scale datasets that stores the graph index on disk and caches a small working set in memory, enabling high-performance search with a minimal memory footprint.

Voronoi Cells

In vector indexing, Voronoi cells are regions of space containing all points closer to a given centroid than to any other, forming the fundamental partitions used by clustering-based algorithms like IVF to organize the dataset for efficient search.

Graph-Based Index

A Graph-Based Index is a data structure for approximate nearest neighbor search where vectors are represented as nodes in a graph, and edges connect similar nodes, enabling search via greedy traversal or beam search along the graph's connections.

Tree-Based Index

A Tree-Based Index is a hierarchical data structure, such as a KD-Tree or Ball Tree, that recursively partitions the vector space to organize data, enabling efficient nearest neighbor search by pruning branches of the tree that cannot contain closer points.

k-means Clustering

k-means Clustering is an unsupervised learning algorithm that partitions a dataset into k clusters by iteratively assigning vectors to the nearest centroid and updating centroids to the mean of their assigned vectors, commonly used to build coarse quantizers for IVF indexes.

Distance Metric

A Distance Metric is a mathematical function that defines a distance between two points in a vector space, with common metrics for similarity search including Euclidean distance (L2), inner product, and cosine similarity, each influencing index construction and search behavior.

MIPS (Maximum Inner Product Search)

MIPS (Maximum Inner Product Search) is the problem of finding the vectors in a dataset that yield the highest inner product with a given query vector, a critical operation for recommendation systems and retrieval where vector similarity is defined by dot product.

Recall@k

Recall@k is an evaluation metric for approximate nearest neighbor search that measures the proportion of the true k nearest neighbors found in the top k results returned by the search algorithm, quantifying the index's retrieval accuracy.

Quantization Error

Quantization Error is the distortion or loss of information introduced when compressing a continuous-valued vector into a discrete representation, such as during Product or Scalar Quantization, which can impact the accuracy of approximate distance calculations.

Coarse Quantizer

A Coarse Quantizer is the first-stage component in a multi-stage vector index (e.g., IVF) that performs a rough partitioning of the vector space, typically via clustering, to quickly narrow the search scope to a small subset of candidate partitions.

Fine Quantizer

A Fine Quantizer is the second-stage component in a composite index (e.g., IVFPQ) that compresses residual vectors within a coarse partition using a technique like Product Quantization, enabling precise, memory-efficient distance approximations.

Search Beam Width

Search Beam Width is a hyperparameter in graph-based search algorithms that controls the size of the priority queue (or candidate pool) maintained during traversal, balancing search exploration, accuracy, and computational cost.

Asymmetric Distance Computation (ADC)

Asymmetric Distance Computation (ADC) is a method for approximating distances where the query vector is kept in its original full-precision form, while database vectors are quantized, leading to more accurate distance estimates than symmetric computation with two quantized vectors.

Index Build Time

Index Build Time is the computational duration required to construct a searchable data structure from a raw set of vectors, encompassing steps like clustering, graph construction, and quantization, which is a critical operational cost for vector databases.

Index Memory Footprint

Index Memory Footprint refers to the amount of RAM consumed by a vector index's data structures, including graph edges, centroid lists, and quantization codebooks, which is a key constraint for scaling to large datasets.

Dynamic Indexing

Dynamic Indexing refers to the capability of a vector index to support efficient insertion and deletion of vectors after its initial construction, without requiring a full rebuild, which is essential for real-time applications with evolving data.

Multi-Probe Search

Multi-Probe Search is a technique used with inverted file indexes where the search algorithm probes multiple neighboring Voronoi cells beyond the one containing the query's nearest centroid, increasing recall at the cost of higher latency.

Small-World Property

The Small-World Property in graph theory describes networks where most nodes can be reached from every other node by a small number of hops, a characteristic deliberately engineered into graph-based indexes like HNSW to enable fast, logarithmic-time search.

Exact Re-ranking

Exact Re-ranking is a two-stage search strategy where an approximate nearest neighbor search first retrieves a broad candidate set, which is then re-scored using exact, full-precision distance calculations to produce a final, accurate ranking.

Glossary

Approximate Nearest Neighbor Search

Terms related to the trade-offs and techniques for finding similar vectors at scale with sub-linear time complexity. Target: CTOs, Search Engineers.

Approximate Nearest Neighbor Search (ANN)

Approximate Nearest Neighbor Search (ANN) is a class of algorithms designed to find vectors in a dataset that are most similar to a query vector with high probability, trading off perfect accuracy for significantly faster, sub-linear query times compared to exhaustive search.

Hierarchical Navigable Small World (HNSW)

Hierarchical Navigable Small World (HNSW) is a graph-based approximate nearest neighbor search algorithm that constructs a multi-layered graph where long-range connections in higher layers enable fast, logarithmic-time search, and short-range connections in lower layers provide high accuracy.

Product Quantization (PQ)

Product Quantization (PQ) is a lossy compression technique for high-dimensional vectors that decomposes the vector space into independent subspaces, quantizes each subspace into a small set of centroids, and represents a vector by a short code composed of the indices of its nearest centroids in each subspace.

Locality-Sensitive Hashing (LSH)

Locality-Sensitive Hashing (LSH) is a family of hashing techniques designed to map similar input vectors into the same hash buckets with high probability, enabling approximate nearest neighbor search by only comparing vectors within the same or neighboring buckets.

Inverted File Index (IVF)

An Inverted File Index (IVF) is a two-stage indexing structure for approximate nearest neighbor search that first partitions the dataset into Voronoi cells using a coarse quantizer (like k-means) and then, for a query, searches only within the most promising cell(s) and their neighbors.

Faiss (Facebook AI Similarity Search)

Faiss (Facebook AI Similarity Search) is an open-source library developed by Meta for efficient similarity search and clustering of dense vectors, providing optimized implementations of core ANN algorithms like IVF, Product Quantization, and HNSW for both CPU and GPU.

Maximum Inner Product Search (MIPS)

Maximum Inner Product Search (MIPS) is the problem of finding the vectors in a dataset that yield the highest inner product (dot product) with a given query vector, a common objective in recommendation systems and neural network inference where vectors are not normalized.

k-Nearest Neighbors (k-NN)

k-Nearest Neighbors (k-NN) is a fundamental search problem that involves finding the 'k' vectors in a dataset that are closest to a query vector according to a specified distance metric, such as Euclidean distance or cosine similarity.

Curse of Dimensionality

The curse of dimensionality refers to the phenomenon where the volume of a high-dimensional space grows exponentially, causing data to become sparse and making distance metrics less meaningful, which fundamentally challenges the efficiency and effectiveness of nearest neighbor search.

Cosine Similarity

Cosine similarity is a metric that measures the cosine of the angle between two non-zero vectors in an inner product space, quantifying their orientation similarity irrespective of their magnitude, commonly used for comparing text or image embeddings.

Euclidean Distance

Euclidean distance is the straight-line distance between two points in Euclidean space, calculated as the square root of the sum of squared differences between corresponding vector components, and is the most common metric for L2-normed vector similarity.

Recall@K

Recall@K is an evaluation metric for approximate nearest neighbor search that measures the fraction of the true top-K nearest neighbors (found by an exact search) that are present in the approximate top-K results returned by the system.

IVFADC (Inverted File with Asymmetric Distance Computation)

IVFADC (Inverted File with Asymmetric Distance Computation) is a composite ANN index that combines an Inverted File (IVF) for coarse partitioning with Product Quantization (PQ) for vector compression, using asymmetric distances to compare a raw query vector against compressed database vectors.

Asymmetric Distance Computation (ADC)

Asymmetric Distance Computation (ADC) is a method for estimating the distance between a raw (uncompressed) query vector and a database vector that has been compressed using quantization, typically providing more accurate distance approximations than symmetric computation between two compressed vectors.

Scalable Nearest Neighbors (ScaNN)

Scalable Nearest Neighbors (ScaNN) is a library from Google Research for efficient vector similarity search that uses anisotropic vector quantization techniques to better optimize the index for Maximum Inner Product Search (MIPS) objectives.

ANNOY (Approximate Nearest Neighbors Oh Yeah)

ANNOY (Approximate Nearest Neighbors Oh Yeah) is a C++/Python library for approximate nearest neighbor search based on building a forest of binary trees by recursively splitting the space with random hyperplanes, prioritizing memory efficiency and static indices.

Graph-Based Index

A graph-based index is a data structure for approximate nearest neighbor search where vectors are represented as nodes in a graph, and edges connect neighboring vectors, enabling search via greedy traversal from entry points towards the query's neighborhood.

Navigable Small World (NSW)

Navigable Small World (NSW) is a graph construction principle and the foundational algorithm for HNSW, where a graph is built such that the average number of hops (graph distance) between any two nodes grows logarithmically with the total number of nodes.

Product Quantization Codebooks

Product Quantization codebooks are the sets of centroid vectors learned for each subspace during the training of a Product Quantization (PQ) model, used to map any vector in that subspace to its nearest centroid for compression.

Coarse Quantizer

A coarse quantizer is the first-stage component in a multi-level indexing structure like IVF, typically a k-means model, that partitions the entire vector dataset into a relatively small number of clusters (Voronoi cells) to restrict the search scope.

Beam Search

In the context of graph-based ANN search, beam search is a heuristic search algorithm that explores a graph by maintaining a fixed-size priority queue (the beam) of the most promising candidate nodes to visit next, balancing exploration and efficiency.

Sublinear Time Complexity

Sublinear time complexity describes an algorithm whose runtime grows slower than linearly with the size of the dataset (e.g., O(log N) or O(√N)), which is the primary goal of ANN algorithms to enable fast search in billion-scale vector databases.

Recall-Precision Trade-off

The recall-precision trade-off in ANN search describes the inverse relationship where increasing the search scope or computation (to improve recall) typically comes at the cost of lower query speed (precision in the context of system performance), and vice-versa.

Brute-Force Search

Brute-force search (or exact search) is the method of finding nearest neighbors by computing the distance from a query vector to every single vector in the database, guaranteeing perfect accuracy but requiring linear O(N) time complexity.

Dimensionality Reduction

Dimensionality reduction is the process of reducing the number of random variables (dimensions) under consideration, often via techniques like PCA or random projection, to mitigate the curse of dimensionality before indexing vectors for similarity search.

Random Projection

Random projection is a dimensionality reduction technique that projects high-dimensional data onto a lower-dimensional subspace using a random matrix, approximately preserving pairwise distances between points according to the Johnson-Lindenstrauss lemma.

Search Latency

Search latency is the time delay, typically measured in milliseconds, between issuing a query to an ANN system and receiving the list of approximate nearest neighbor results, a critical performance metric for real-time applications.

Index Build Time

Index build time is the total computational time required to construct an ANN index from a raw dataset of vectors, encompassing steps like clustering for IVF, graph construction for HNSW, or codebook training for Product Quantization.

Index Memory Footprint

Index memory footprint is the amount of RAM required to store an ANN index data structure in memory, a key constraint for large-scale deployments that influences the choice of algorithm (e.g., PQ-based methods are highly memory-efficient).

Streaming ANN

Streaming ANN refers to approximate nearest neighbor search algorithms and systems designed to handle continuously arriving new data vectors, supporting incremental updates to the index without requiring a full rebuild from scratch.

Glossary

Vector Storage and Persistence

Terms related to the physical and logical storage mechanisms for embeddings, from in-memory caches to persistent databases. Target: Infrastructure Engineers, CTOs.

Vector Storage Engine

A specialized database engine designed to persistently store, index, and retrieve high-dimensional vector embeddings, often implementing custom data structures like LSM-trees or B-trees optimized for vector operations.

Vector Serialization

The process of converting a vector or embedding data structure into a byte stream or file format suitable for storage, transmission, or persistence.

Vector Compression

The application of data compression techniques to reduce the storage footprint of vector embeddings, often using methods like Product Quantization (PQ) or Scalar Quantization (SQ) which trade minimal precision loss for significant space savings.

Vector Sharding

A horizontal partitioning strategy that distributes vectors across multiple database nodes or disks based on a shard key, enabling scalability and parallel query execution.

Vector Replication

The process of creating and maintaining redundant copies of vector data across different storage nodes or geographical regions to ensure high availability, fault tolerance, and reduced read latency.

Write-Ahead Logging (WAL)

A durability guarantee mechanism where all modifications to vector data are first written to a persistent, append-only log before being applied to the main index, ensuring data integrity in the event of a crash.

LSM-Tree for Vectors

An adaptation of the Log-Structured Merge-Tree (LSM-tree) storage architecture optimized for high-throughput ingestion and management of vector data, typically using memtables and sorted string tables (SSTables) for vector persistence.

Vector Cache

A high-speed data storage layer, typically in-memory (e.g., Redis, Memcached), that stores a subset of frequently accessed vectors or index structures to accelerate read operations and reduce latency.

Vector File Format

A standardized specification for the layout and encoding of vector data on disk, such as NPY/NPZ for NumPy arrays, HDF5, or proprietary formats used by libraries like FAISS and HNSW.

Vector Durability

The property of a vector storage system that guarantees written vector data will survive permanently and not be lost due to system failures, typically achieved through mechanisms like WAL, replication, and synchronous disk writes.

Vector Tombstone

A special marker or record inserted into a vector index or log to indicate that a specific vector has been logically deleted, which is later physically removed during a compaction or garbage collection process.

Time-To-Live (TTL) for Vectors

A data management policy that automatically expires and deletes vectors from storage after a predefined period, useful for managing ephemeral or time-sensitive embedding data.

Vector Columnar Storage

A storage layout where vector data is organized by column (e.g., all values for dimension 1, then dimension 2) rather than by row, improving compression efficiency and scan performance for analytical workloads on embeddings.

Vector Tiered Storage

A storage architecture that automatically moves vector data between different performance and cost tiers (e.g., SSD hot storage, HDD cold storage, archival object storage) based on access patterns and policies.

Vector Storage Metadata

The auxiliary data that describes the structure, schema, location, and properties of stored vectors, such as dimensionality, distance metric, index type, creation time, and data lineage.

Vector Data Locality

The principle of storing vectors that are frequently queried together on the same physical node or disk sector to minimize network latency and I/O overhead during similarity search operations.

Vector Integrity

The assurance that vector data remains unaltered and uncorrupted during storage, transmission, and retrieval, often verified using checksums, cryptographic hashes, or error-correcting codes.

Vector Storage API

The programmatic interface (e.g., REST, gRPC) and set of operations (e.g., PUT, GET, DELETE, SCAN) exposed by a vector database or storage engine for client applications to manage embedding data.

Vector Object Storage

The use of cloud-based object storage services (e.g., Amazon S3, Google Cloud Storage, Azure Blob) as a durable, scalable backend for storing vector index files, snapshots, and archives.

Vector Erasure Coding

A data protection method that breaks vector data into fragments, expands them with redundant parity pieces, and distributes them across multiple storage nodes, providing high durability with lower storage overhead than traditional replication.

Vector Deduplication

A storage optimization technique that identifies and eliminates redundant copies of identical or highly similar vectors, storing only unique instances to conserve capacity.

Vector Storage Consistency Model

The formal guarantee provided by a distributed vector database regarding the visibility and ordering of read and write operations across replicas, such as strong consistency, eventual consistency, or causal consistency.

Vector Storage High Availability

A design characteristic of a vector storage system that minimizes downtime and ensures continuous operation, typically achieved through redundancy, automatic failover, and health monitoring.

Vector Storage SLA

A Service Level Agreement that formally defines the performance, availability, and durability guarantees (e.g., uptime percentage, P99 latency) provided by a vector storage service or vendor.

Vector Storage Health

The operational status of a vector storage system, encompassing metrics like node availability, disk space, I/O latency, error rates, and replication lag, used for monitoring and alerting.

Vector Storage Federation

An architectural pattern that unifies multiple independent vector storage systems or clusters under a single logical namespace or query interface, enabling decentralized data management.

Vector Storage Infrastructure as Code

The practice of managing and provisioning vector storage resources (clusters, networks, policies) using machine-readable definition files and tools like Terraform, Ansible, or Pulumi, rather than manual configuration.

Vector Storage Schema Evolution

The process of managing changes to the structure of stored vector data over time (e.g., adding new metadata fields, changing dimensionality) while maintaining backward and forward compatibility for existing applications.

Vector Data Governance

The overarching framework of policies, standards, and processes that ensure the formal management of vector data assets, including quality, privacy, security, lineage, and compliance throughout their lifecycle.

Glossary

Vector Database Scalability

Terms related to distributing vector workloads across clusters, including sharding, replication, and load balancing. Target: CTOs, DevOps Engineers.

Sharding

Sharding is a database scaling technique that horizontally partitions a dataset across multiple independent servers, called shards, to distribute storage and query load.

Replication

Replication is the process of creating and maintaining multiple copies of data across different nodes in a distributed system to enhance data availability, fault tolerance, and read performance.

Load Balancing

Load balancing is the distribution of network traffic or computational workloads across multiple servers or resources to optimize resource utilization, maximize throughput, minimize latency, and avoid system overload.

Horizontal Scaling

Horizontal scaling, or scaling out, is the strategy of increasing a system's capacity by adding more machines or nodes to a distributed architecture, as opposed to upgrading the hardware of a single machine.

Vertical Scaling

Vertical scaling, or scaling up, is the strategy of increasing a system's capacity by adding more resources, such as CPU, RAM, or storage, to a single existing machine or node.

CAP Theorem

The CAP theorem is a fundamental principle in distributed systems stating that a networked shared-data system can provide at most two out of three guarantees: Consistency, Availability, and Partition tolerance.

Consistency Model

A consistency model defines the contract that specifies how and when a write to a distributed data store becomes visible to subsequent read operations, ranging from strong to eventual consistency.

Eventual Consistency

Eventual consistency is a consistency model where, in the absence of new updates, all replicas in a distributed system will eventually converge to the same state, though reads may temporarily return stale data.

Strong Consistency

Strong consistency is a model where any read operation on a distributed system returns the value from the most recent write operation, guaranteeing that all nodes see the same data at the same time.

Partition Tolerance

Partition tolerance is a system's ability to continue operating despite network partitions, or communication breakdowns, that prevent some nodes from communicating with others in the distributed network.

Replication Factor

The replication factor is a configuration parameter that defines how many copies, or replicas, of each piece of data are maintained across different nodes in a distributed database for redundancy.

Synchronous Replication

Synchronous replication is a method where a write operation is only considered successful after the data has been written to both the primary node and all designated replica nodes, ensuring strong consistency.

Asynchronous Replication

Asynchronous replication is a method where a write operation is acknowledged as successful after being written to the primary node, with replicas updated in the background, favoring lower latency over immediate consistency.

Quorum

A quorum is the minimum number of nodes in a distributed system that must successfully participate in a read or write operation for it to be considered valid, used to enforce consistency in the presence of failures.

Leader Election

Leader election is a process in distributed systems where nodes collectively choose one node to act as the coordinator or primary node responsible for managing writes and maintaining consistency.

Gossip Protocol

A gossip protocol is a peer-to-peer communication mechanism where nodes periodically exchange state information with a few random peers, enabling efficient and robust failure detection and data dissemination in a cluster.

Write-Ahead Log (WAL)

A Write-Ahead Log is a durability mechanism where all modifications to data are first written to a persistent, append-only log file before being applied to the main database structures, ensuring data integrity after a crash.

Data Skew

Data skew is an imbalance in the distribution of data or workload across shards or nodes in a distributed system, where some partitions become overloaded while others are underutilized, degrading performance.

Hot Shard

A hot shard is a specific data partition in a sharded database that receives a disproportionately high volume of read or write traffic compared to other shards, creating a performance bottleneck.

Vector Rebalancing

Vector rebalancing is the process of automatically redistributing vector data and its associated indexes across the nodes or shards of a cluster to maintain workload balance and performance after scaling or data growth.

Multi-Tenancy

Multi-tenancy is an architectural pattern where a single instance of a software application serves multiple distinct customer groups, or tenants, with logical isolation of their data, configuration, and performance.

Service Level Objective (SLO)

A Service Level Objective is a measurable target for the reliability or performance of a service, such as availability or latency, that forms the basis for agreements between service providers and consumers.

High Availability (HA)

High availability is a design characteristic of a system that aims to ensure an agreed level of operational performance, typically uptime, over a prolonged period by minimizing single points of failure and enabling rapid recovery.

Fault Tolerance

Fault tolerance is the property of a system to continue operating correctly, potentially at a reduced level, in the event of the failure of some of its components, without requiring immediate human intervention.

Circuit Breaker

A circuit breaker is a resilience pattern that prevents a network or service from repeatedly attempting an operation that is likely to fail, allowing it to recover by temporarily blocking requests until the downstream service is healthy.

Backpressure

Backpressure is a flow control mechanism in data streaming systems where a fast data producer is signaled to slow down or pause when a slower consumer cannot keep up, preventing system overload and resource exhaustion.

Idempotency

Idempotency is the property of an operation whereby applying it multiple times produces the same result as applying it once, which is critical for ensuring data consistency in distributed systems with retries.

StatefulSet

A StatefulSet is a Kubernetes workload API object used to manage stateful applications, providing stable, unique network identifiers and persistent storage that persists across pod rescheduling.

Service Discovery

Service discovery is the automatic detection of network locations, such as IP addresses and ports, for service instances in a distributed system, allowing clients to dynamically find and communicate with available services.

Chaos Engineering

Chaos engineering is the disciplined practice of proactively injecting failures into a production system to test its resilience, identify weaknesses, and build confidence in its ability to withstand turbulent conditions.

Glossary

Vector Query Optimization

Terms related to improving the speed and accuracy of similarity searches, including latency reduction and recall-precision tuning. Target: ML Engineers, Performance Engineers.

Approximate Nearest Neighbor (ANN) Search

Approximate Nearest Neighbor (ANN) Search is a class of algorithms designed to find vectors in a database that are most similar to a query vector, trading off perfect accuracy for significantly faster query times compared to exhaustive search.

Hierarchical Navigable Small World (HNSW)

Hierarchical Navigable Small World (HNSW) is a graph-based algorithm for approximate nearest neighbor search that constructs a multi-layered graph where long-range connections on higher layers enable fast, logarithmic-time search.

Inverted File Index (IVF)

Inverted File Index (IVF) is a vector indexing method that partitions the dataset into Voronoi cells via clustering and uses an inverted index to map centroids to their member vectors, limiting search to a subset of promising cells.

Product Quantization (PQ)

Product Quantization (PQ) is a lossy compression technique for high-dimensional vectors that splits them into subvectors, quantizes each subspace independently using a learned codebook, and approximates distances via lookup tables.

Locality-Sensitive Hashing (LSH)

Locality-Sensitive Hashing (LSH) is a family of hashing techniques designed to maximize the probability of collision for similar items, enabling efficient approximate nearest neighbor search by hashing vectors into buckets.

Scalar Quantization

Scalar Quantization is a vector compression method that reduces the bit-depth (e.g., from 32-bit floats to 8-bit integers) of each vector component independently, trading precision for reduced memory footprint and faster distance computations.

Distance Metric

A Distance Metric is a mathematical function that defines a notion of distance between two points in a vector space, with common examples for similarity search including Euclidean distance, cosine similarity, and inner product.

Cosine Similarity

Cosine Similarity is a distance metric that measures the cosine of the angle between two non-zero vectors, focusing on their orientation rather than magnitude, making it ideal for comparing text embeddings.

Euclidean Distance (L2)

Euclidean Distance, also known as L2 distance, is a distance metric that calculates the straight-line distance between two points in Euclidean space, representing the magnitude of the difference between two vectors.

Inner Product

Inner Product is a distance metric that calculates the sum of the products of corresponding vector components, often used as a similarity measure for normalized vectors where it correlates with cosine similarity.

Recall

Recall, in the context of vector search, is the fraction of true nearest neighbors (from an exhaustive search) that are successfully retrieved by an approximate search algorithm, measuring its completeness.

Precision

Precision, in the context of vector search, is the fraction of retrieved items that are true nearest neighbors (from an exhaustive search), measuring the accuracy of the approximate search results.

Recall@K

Recall@K is an evaluation metric for search systems that measures the proportion of the true top-K nearest neighbors that are present in the retrieved top-K results from an approximate search.

Query Latency

Query Latency is the time interval between submitting a search query to a vector database and receiving the complete response, a critical performance metric for real-time applications.

P99 Latency

P99 Latency is the 99th percentile of query latency measurements, representing the worst-case latency experienced by all but the slowest 1% of queries, used to define service-level objectives.

Throughput (QPS)

Throughput, often measured in Queries Per Second (QPS), is the maximum number of search queries a vector database system can process per unit time while maintaining acceptable latency.

Search Radius (Epsilon)

Search Radius, often denoted by epsilon (ε), is a parameter in range search queries that defines the maximum distance from the query vector within which all returned vectors must fall.

k-NN Search

k-NN Search, or k-Nearest Neighbors search, is a query that retrieves the 'k' vectors in a database that are most similar to a given query vector according to a specified distance metric.

Range Search

Range Search is a query that retrieves all vectors in a database whose distance from a query vector is less than or equal to a specified radius (epsilon).

Filtered Search

Filtered Search is a hybrid query that combines a vector similarity search with conditional metadata filters (e.g., `user_id = 123`) to retrieve relevant results that also satisfy business logic constraints.

Pre-Filtering

Pre-Filtering is an optimization strategy for filtered search where metadata filters are applied first to produce a candidate set, which is then ranked by vector similarity, potentially missing relevant but filtered-out vectors.

Post-Filtering

Post-Filtering is an optimization strategy for filtered search where an approximate nearest neighbor search is performed first, and the resulting candidates are then filtered by metadata, which can reduce recall if filters are highly selective.

EF Search (HNSW)

EF Search is a hyperparameter in the HNSW algorithm that controls the size of the dynamic candidate list during graph traversal, directly trading off between higher search accuracy (recall) and increased query latency.

M Parameter (HNSW)

The M Parameter is a hyperparameter in the HNSW algorithm that controls the maximum number of bi-directional connections (edges) each node can have in the graph, influencing index construction time, memory usage, and search performance.

Asymmetric Distance Computation (ADC)

Asymmetric Distance Computation (ADC) is a technique used with Product Quantization where distances are calculated between an uncompressed query vector and compressed database vectors, providing more accurate approximations than symmetric computation.

IVFADC (Faiss)

IVFADC is a composite index structure in the Faiss library that combines an Inverted File (IVF) for coarse quantization with Asymmetric Distance Computation (ADC) using Product Quantization for fine quantization, balancing speed and accuracy.

Beam Search

Beam Search is a heuristic search algorithm used in graph-based ANN methods like HNSW that explores a graph by maintaining a fixed-width 'beam' of the most promising candidate nodes at each step to balance exploration and efficiency.

Query Planning

Query Planning is the process by which a vector database's query optimizer analyzes an incoming search request (including filters and parameters) and selects the most efficient execution strategy and index access paths.

Dynamic Pruning

Dynamic Pruning is a query optimization technique that terminates the exploration of search paths (e.g., in a graph or tree index) early when it can be determined that they cannot improve the current top-K results, reducing latency.

Candidate Generation

Candidate Generation is the first stage in a multi-stage retrieval pipeline where a fast, approximate search algorithm (e.g., using an IVF index) produces a broad set of potentially relevant vectors for subsequent, more precise scoring or re-ranking.

Glossary

Hybrid and Filtered Search

Terms related to combining vector similarity with metadata filters and keyword matching for precise retrieval. Target: Search Architects, CTOs.

Hybrid Search

Hybrid search is a retrieval technique that combines the results from multiple search methods, typically semantic (vector) and keyword-based (lexical) searches, to improve overall recall and precision.

Filtered Search

Filtered search is a retrieval process where metadata-based constraints, such as date ranges or categorical tags, are applied to narrow down the candidate set before or during a similarity or keyword search.

Faceted Search

Faceted search is an interactive information retrieval technique that allows users to refine search results by applying multiple filters (facets) across various metadata dimensions, such as category, price, or date.

Boolean Filter

A Boolean filter is a logical expression, typically using AND, OR, and NOT operators, applied to metadata fields to include or exclude documents from a search result set based on precise criteria.

Pre-Filtering

Pre-filtering is a search optimization strategy where metadata filters are applied first to create a reduced candidate set, upon which a more expensive vector similarity search is performed.

Post-Filtering

Post-filtering is a search strategy where a broad similarity or keyword search is executed first, and the resulting candidates are subsequently filtered based on metadata constraints.

Reranking

Reranking is the process of applying a more sophisticated, often computationally expensive, scoring model to a smaller set of candidate documents retrieved by a fast first-stage search to improve final result ordering.

Multi-Stage Retrieval

Multi-stage retrieval is a search architecture that uses a sequence of increasingly accurate but slower models to progressively refine a large candidate set into a small, high-quality final result list.

Reciprocal Rank Fusion (RRF)

Reciprocal Rank Fusion (RRF) is a score fusion method for hybrid search that combines ranked lists from different retrieval systems by summing the reciprocal of each document's rank across lists, promoting documents that rank well consistently.

Score Fusion

Score fusion is the technique of combining normalized relevance scores from multiple, disparate retrieval systems (e.g., vector and keyword) into a single unified score for final result ranking.

Filter Pushdown

Filter pushdown is a database query optimization technique where filtering predicates are evaluated as early as possible in the query execution plan, often within the storage layer, to minimize data movement and processing overhead.

Bitmap Index

A bitmap index is a specialized database index structure that uses a series of bit arrays (bitmaps) to represent the membership of records for specific attribute values, enabling extremely fast set operations for filtering.

ANN with Filters

ANN with filters refers to approximate nearest neighbor search algorithms that have been modified or extended to efficiently respect hard metadata constraints during the vector similarity search process.

HNSW with Filters

HNSW with filters is a modification of the Hierarchical Navigable Small World graph index that incorporates metadata filtering logic during graph traversal to perform efficient filtered vector similarity search.

Query Planning

Query planning is the process by which a database system's optimizer analyzes a search query and metadata filters to generate an efficient sequence of operations, or execution plan, for retrieving results.

Conjunctive Query

A conjunctive query is a database query that uses the logical AND operator to combine multiple filter conditions, requiring all specified predicates to be true for a record to be included in the result set.

Disjunctive Query

A disjunctive query is a database query that uses the logical OR operator to combine filter conditions, requiring at least one of the specified predicates to be true for a record to be included.

BM25

BM25 (Best Matching 25) is a probabilistic ranking function used in information retrieval to estimate the relevance of documents to a given search query, serving as a state-of-the-art algorithm for keyword search.

Semantic Search

Semantic search is an information retrieval technique that uses the meaning and contextual relationships of words, typically via vector embeddings, to find relevant content rather than relying solely on literal keyword matching.

Lexical Search

Lexical search is an information retrieval technique that finds documents based on the exact occurrence of query terms or their morphological variants, using algorithms like BM25 or TF-IDF.

Dense Retrieval

Dense retrieval is a search paradigm where queries and documents are encoded into dense vector embeddings, and relevance is determined by calculating the similarity (e.g., cosine) between these embeddings.

Sparse Retrieval

Sparse retrieval is a search paradigm where queries and documents are represented as high-dimensional, sparse vectors (e.g., bag-of-words with TF-IDF weights), and relevance is calculated using lexical matching metrics.

Cross-Encoder

A cross-encoder is a neural ranking model that takes a query and a document as a single input pair, allowing deep, attention-based interaction between all tokens to produce a highly accurate relevance score, typically used for reranking.

Bi-Encoder

A bi-encoder is a neural retrieval model that encodes queries and documents independently into dense vector embeddings, enabling efficient approximate nearest neighbor search for first-stage retrieval.

Cosine Similarity

Cosine similarity is a metric that measures the cosine of the angle between two non-zero vectors in an inner product space, commonly used to gauge the semantic similarity between dense vector embeddings in high-dimensional spaces.

Maximum Inner Product Search (MIPS)

Maximum Inner Product Search (MIPS) is the problem of finding the vectors in a database that have the highest inner product (dot product) with a given query vector, a common objective for recommendation systems using certain embedding models.

Filter Selectivity

Filter selectivity is a measure, expressed as a fraction or percentage, that estimates the proportion of records in a dataset that will satisfy a given filter predicate, used by query optimizers to choose efficient execution plans.

Bloom Filter

A Bloom filter is a probabilistic, memory-efficient data structure used to test whether an element is a member of a set, allowing for fast pre-filtering checks with a configurable false positive rate.

Query DSL (Domain-Specific Language)

A Query Domain-Specific Language (DSL) is a specialized computer language tailored for expressing search queries, often combining vector similarity, keyword matching, and complex Boolean filtering in a declarative syntax.

Metadata Filtering

Metadata filtering is the application of constraints based on structured attributes (e.g., author, timestamp, category) associated with documents to restrict the scope of a search query.

Glossary

Vector Data Management

Terms related to the lifecycle of embeddings, including versioning, ingestion pipelines, and index updates. Target: Data Engineers, ML Platform Engineers.

Embedding Versioning

Embedding versioning is the systematic tracking and management of different generations of vector embeddings generated by evolving machine learning models to ensure data lineage and reproducibility in semantic search systems.

Vector Ingestion Pipeline

A vector ingestion pipeline is a data processing workflow that transforms raw data into vector embeddings and loads them into a vector database, typically involving stages for extraction, chunking, embedding, and indexing.

Upsert Operation

An upsert operation in a vector database is a combined update-or-insert action that either updates an existing vector and its metadata if a matching identifier is found, or inserts it as a new record if not.

Idempotent Ingestion

Idempotent ingestion is a property of a data pipeline where processing the same input data multiple times results in the same final state in the vector store, preventing duplicate entries from retries or reprocessing.

Data Version Control (DVC)

Data Version Control (DVC) is a system and methodology for tracking changes to datasets, machine learning models, and their associated embeddings, enabling reproducible machine learning pipelines and experiment tracking.

Schema Evolution

Schema evolution is the process of managing changes to the structure of metadata associated with vector embeddings over time, such as adding, removing, or modifying fields, while maintaining backward and forward compatibility.

Vector Normalization

Vector normalization is the process of scaling a vector to a unit length (magnitude of 1), which is a critical preprocessing step for similarity searches that rely on cosine similarity, as it makes the dot product equivalent to the cosine of the angle between vectors.

Payload Management

Payload management refers to the storage, indexing, and retrieval of structured metadata (the payload) associated with vector embeddings, enabling hybrid search queries that combine semantic similarity with filtering on attributes.

Write-Ahead Log (WAL)

A Write-Ahead Log (WAL) is a durability mechanism in vector databases where all data modification operations are first recorded to a persistent log before being applied to the main index, ensuring data integrity and enabling crash recovery.

Snapshot Isolation

Snapshot isolation is a transaction isolation level that provides a consistent, read-only view of a vector database's state at a specific point in time, allowing queries to execute without being blocked by concurrent write operations.

Vector Tombstoning

Vector tombstoning is a deletion strategy where a deleted vector is marked as invalid (tombstoned) in the index rather than being physically removed immediately, allowing for efficient garbage collection and consistency in distributed systems.

Consistency Level

Consistency level defines the guarantee a distributed vector database provides about the visibility and ordering of read and write operations across its replicas, ranging from strong consistency to eventual consistency.

Change Data Capture (CDC)

Change Data Capture (CDC) is a design pattern that identifies and captures incremental changes made to a source database, streaming them to a vector database's ingestion pipeline to keep the vector index synchronized in near real-time.

Backfill Process

A backfill process is a batch operation that re-processes historical data through an embedding pipeline to populate or update a vector index, often triggered by a model change, schema evolution, or the initial population of a new system.

Cold Start Problem

The cold start problem in vector databases refers to the initial period where the system has an empty or sparse index, resulting in poor recall for similarity searches until sufficient data has been ingested and indexed.

A/B Indexing

A/B indexing is a deployment strategy where two different vector indexes (e.g., built with different algorithms or parameters) are maintained in parallel, allowing for performance and quality comparisons via canary routing of live traffic.

Index State

Index state refers to the current operational condition and data consistency of a vector index, encompassing whether it is ready for queries, undergoing a rebuild, or is in a corrupted or degraded state.

Vector Drift

Vector drift is the phenomenon where the statistical distribution of newly generated embeddings shifts over time relative to the existing corpus in the index, degrading search relevance and necessitating model retraining or index updates.

Data Freshness

Data freshness is a metric that quantifies how up-to-date the information in a vector index is relative to the source data, directly impacting the relevance of search results in dynamic applications.

Time-To-Live (TTL)

Time-To-Live (TTL) is a data management policy that automatically expires and deletes vector records after a predefined duration, used to manage storage costs and ensure search results are based on recent data.

Exactly-Once Semantics

Exactly-once semantics is a guarantee in a vector ingestion pipeline that each unique piece of source data is processed and inserted into the vector index precisely one time, despite potential failures or retries.

Dead Letter Queue (DLQ)

A Dead Letter Queue (DLQ) is a secondary storage queue in a vector ingestion pipeline where messages that cannot be processed successfully after multiple retries (e.g., due to malformed data) are moved for manual inspection and remediation.

Backpressure Mechanism

A backpressure mechanism is a flow control strategy in a streaming vector ingestion pipeline that signals upstream data sources to slow down or pause when the system is unable to keep up with the incoming data rate, preventing resource exhaustion.

Vector Quantization

Vector quantization is a lossy compression technique that reduces the memory footprint of high-dimensional vectors by mapping them to a finite set of representative codes from a pre-trained codebook, trading off some precision for efficiency.

Re-embedding Pipeline

A re-embedding pipeline is an automated workflow that regenerates vector embeddings for an existing dataset, typically triggered by an upgrade to a new embedding model, to maintain search quality and consistency across the index.

Incremental Indexing

Incremental indexing is a strategy where a vector index is updated with new or modified embeddings without requiring a full rebuild of the entire index, enabling low-latency updates and continuous data freshness.

Optimistic Concurrency Control (OCC)

Optimistic Concurrency Control (OCC) is a transaction management method where vector database clients proceed with modifications without locking, checking for conflicts with other transactions only at commit time, improving throughput in low-conflict scenarios.

Vector Provenance

Vector provenance is the recorded lineage of a vector embedding, detailing its source data, the model and parameters used to generate it, the ingestion timestamp, and any subsequent transformations, crucial for auditability and debugging.

Lineage Tracking

Lineage tracking is the comprehensive recording of data flow and transformations across a vector data management pipeline, from source systems through embedding generation to final storage in the vector index.

Glossary

Vector Database Operations

Terms related to the monitoring, health checks, backup, and recovery of production vector database systems. Target: DevOps, SREs, CTOs.

Health Check Endpoint

A dedicated API endpoint on a vector database service that returns the operational status of the system, used by orchestration platforms like Kubernetes for liveness and readiness probes.

Liveness Probe

A Kubernetes mechanism that periodically checks if a containerized application, such as a vector database pod, is running and responsive, restarting it if the probe fails.

Readiness Probe

A Kubernetes mechanism that determines if a containerized application, such as a vector database pod, is ready to accept traffic, preventing requests from being sent before it is fully initialized.

Recovery Point Objective (RPO)

The maximum acceptable amount of data loss measured in time, defining how far back in time a vector database must be able to recover after a failure or disaster.

Recovery Time Objective (RTO)

The maximum acceptable duration of downtime for a vector database system, defining the target time within which operations must be restored after a failure or disaster.

Failover

The automatic process of switching operations from a failed primary node in a vector database cluster to a healthy standby replica to maintain service availability.

Failback

The process of returning operations to the original primary node in a vector database cluster after it has been repaired following a failover event.

Consistency Level

A configurable setting in a distributed vector database that determines how many replicas must acknowledge a read or write operation before it is considered successful, balancing between data accuracy and latency.

Write-Ahead Log (WAL)

A persistent append-only log in a vector database where all data modifications are recorded before being applied to the main index, ensuring durability and enabling crash recovery.

Point-in-Time Recovery (PITR)

A backup and restore capability that allows a vector database to be recovered to any specific moment in the past, using a combination of full backups and write-ahead logs.

Vector Snapshot

A complete, read-only copy of a vector index and its associated metadata at a specific point in time, used for consistent backups or creating clones of the data.

Vector Corruption

A state where the binary data representing a vector embedding or its associated index structure becomes damaged, leading to incorrect search results or system crashes.

CRC Check

A cyclic redundancy check, a data verification technique used in vector databases to detect accidental corruption of stored vectors or index files during storage or transmission.

Vector Garbage Collection

: The process of reclaiming storage space occupied by deleted or obsolete vectors and their associated index entries in a vector database.

Rolling Restart

A deployment strategy for vector database clusters where nodes are restarted one at a time in a controlled sequence, allowing the service to remain available with minimal disruption.

Blue-Green Deployment

A release management strategy for vector databases where two identical production environments (blue and green) exist, and traffic is switched from the old version (blue) to the new version (green) instantaneously.

Canary Release

A deployment technique for vector databases where a new software version is gradually rolled out to a small subset of users or traffic before a full release, allowing for performance and stability monitoring.

Load Shedding

A defensive mechanism in a vector database where the system intentionally rejects or delays incoming queries when it is under excessive load to prevent a total failure and protect core functionality.

Circuit Breaker

A stability pattern in distributed vector database systems that temporarily stops calling a failing service (e.g., an embedding model endpoint) after a threshold of failures is reached, allowing it time to recover.

Vector Cache Hit Ratio

A key performance metric for a vector database that measures the percentage of similarity search requests served directly from an in-memory cache versus requiring a disk read, indicating cache effectiveness.

Cold Start Latency

The increased query response time experienced when a vector database or a specific index segment is first loaded into memory from disk, before its working set is cached.

Vector Telemetry

The automated collection, transmission, and measurement of operational data from a vector database system, including metrics, logs, and traces, for monitoring and observability.

Slow Query Log

A diagnostic log file in a vector database that records details of queries whose execution time exceeds a predefined threshold, used for performance troubleshooting and optimization.

Service Level Objective (SLO) for Recall

A target level of reliability for the accuracy of a vector database's similarity search, formally defined as the proportion of true nearest neighbors successfully returned over a measurement period.

Error Budget

The calculated amount of acceptable unreliability for a vector database service, derived from its Service Level Objectives (SLOs), which dictates how often reliability-targeting changes can be made.

Maintenance Window

A scheduled period of time during which planned, disruptive operations like software upgrades, index rebuilds, or hardware maintenance are performed on a vector database system.

Zero-Downtime Migration

The process of moving a vector database's data, schema, or underlying infrastructure to a new environment without causing any service interruption for client applications.

Configuration Drift

The unintended divergence of a vector database system's actual runtime configuration from its defined, desired state, which can lead to inconsistent behavior and operational issues.

Vector Tombstone

A marker or record inserted into a vector database to logically indicate that a vector has been deleted, which is later physically removed during a compaction or garbage collection process.

Idempotent Ingestion

A property of a vector database's data ingestion pipeline where inserting the same vector data multiple times results in the same final state as inserting it once, preventing duplicates from retries.

Glossary

Vector Database Security

Terms related to access control, encryption, and multi-tenant isolation for vector data. Target: Security Engineers, CTOs.

Access Control List (ACL)

An Access Control List (ACL) is a security mechanism that specifies which users or system processes are granted access to specific objects, such as vector database collections or indexes, and what operations are allowed on those objects.

API Key Authentication

API Key Authentication is a method of verifying the identity of a client application or user by requiring a unique cryptographic key to be included in the header of each request to a vector database's API.

Audit Logging

Audit Logging is the process of recording a chronological sequence of security-relevant events, such as data access, queries, and administrative changes, within a vector database to support forensic analysis and compliance.

Authentication

Authentication is the security process of verifying the identity of a user, service, or application before granting access to a vector database system.

Authorization

Authorization is the security process of determining what permissions and access rights an authenticated entity has within a vector database, such as the ability to read, write, or query specific data.

Bring Your Own Key (BYOK)

Bring Your Own Key (BYOK) is a cloud security model where a customer generates and manages their own encryption keys, which are then provided to a cloud service provider, such as a vector database vendor, to encrypt the customer's data.

Client-Side Encryption

Client-Side Encryption is a security practice where data is encrypted on the client's machine before it is transmitted and stored in a vector database, ensuring the service provider never handles plaintext data.

Data At Rest Encryption

Data At Rest Encryption is the cryptographic protection of vector data and indexes while they are stored on persistent media, such as SSDs or hard drives, to prevent unauthorized access from physical theft or disk-level attacks.

Data In Transit Encryption

Data In Transit Encryption is the cryptographic protection of vector data and queries as they travel over a network between a client and a database server, typically using protocols like TLS/SSL.

Data Poisoning Defense

Data Poisoning Defense refers to security measures designed to detect and mitigate adversarial attempts to corrupt the training data or embedding generation process, which could degrade the performance or reliability of a vector search system.

Denial-of-Service (DoS) Protection

Denial-of-Service (DoS) Protection encompasses the security controls, such as API rate limiting and traffic filtering, implemented by a vector database to prevent malicious or accidental overload that would deny service to legitimate users.

Encrypted Search

Encrypted Search is a set of cryptographic techniques, such as searchable symmetric encryption, that allow a vector database to perform similarity searches over encrypted data without needing to decrypt it first.

Encryption Key Management

Encryption Key Management is the comprehensive administration of cryptographic keys throughout their lifecycle, including generation, storage, distribution, rotation, and deletion, within a vector database's security infrastructure.

Fine-Grained Access Control

Fine-Grained Access Control is a security model that allows administrators to define precise permissions at the level of individual database objects, such as specific collections, vectors, or metadata fields, based on user attributes or roles.

Hardware Security Module (HSM)

A Hardware Security Module (HSM) is a physical computing device that safeguards and manages digital keys for strong authentication and provides cryptoprocessing, often used to protect the root or master encryption keys for a vector database.

Identity and Access Management (IAM)

Identity and Access Management (IAM) is a framework of policies and technologies for ensuring that the right individuals and services have the appropriate access to vector database resources, encompassing authentication, authorization, and user lifecycle management.

Key Management Service (KMS)

A Key Management Service (KMS) is a cloud-based service that provides secure creation, storage, and control of cryptographic keys used for encrypting data within a vector database and other cloud services.

Least Privilege Access

Least Privilege Access is a core security principle mandating that users, accounts, and processes should have only the minimum levels of access—or permissions—necessary to perform their legitimate functions within a vector database.

Multi-Factor Authentication (MFA)

Multi-Factor Authentication (MFA) is an authentication method that requires a user to provide two or more verification factors (e.g., a password and a time-based code from an app) to gain access to a vector database management interface or API.

Network Segmentation

Network Segmentation is a security architecture that divides a network into smaller, isolated segments or subnetworks to control traffic flow and limit the potential impact of a security breach, often applied to isolate vector database clusters from other systems.

Private Endpoint

A Private Endpoint is a network interface that connects a client's virtual network directly and privately to a cloud service, such as a vector database, using a private IP address, ensuring traffic never traverses the public internet.

Role-Based Access Control (RBAC)

Role-Based Access Control (RBAC) is a security model where access permissions to vector database resources are assigned to roles, and users are granted access by being assigned to one or more of these roles.

Row-Level Security (RLS)

Row-Level Security (RLS) is a database security feature that uses policies to control access to individual rows in a table based on the characteristics of the user executing a query, applicable to metadata tables in a vector database.

Secure Socket Layer (SSL) / Transport Layer Security (TLS)

Transport Layer Security (TLS) and its predecessor, Secure Sockets Layer (SSL), are cryptographic protocols designed to provide communications security, including encryption and authentication, for data in transit between a client and a vector database.

Single Sign-On (SSO)

Single Sign-On (SSO) is an authentication scheme that allows a user to log in with a single set of credentials to gain access to multiple independent software systems, such as a vector database console and related management tools.

Tenant Data Isolation

Tenant Data Isolation is the architectural and security practice of ensuring that the data of one customer (tenant) in a multi-tenant vector database is logically or physically separated and inaccessible to any other tenant.

Token-Based Authentication

Token-Based Authentication is a security protocol where a client application exchanges valid credentials for a signed token (like a JWT), which is then presented with each request to a vector database API to prove authentication and authorization.

Trusted Execution Environment (TEE)

A Trusted Execution Environment (TEE) is a secure area of a main processor that guarantees code and data loaded inside are protected with respect to confidentiality and integrity, potentially used for secure query processing on encrypted vector data.

Virtual Private Cloud (VPC)

A Virtual Private Cloud (VPC) is an isolated virtual network within a public cloud environment, providing logical network isolation where a vector database can be deployed, allowing control over IP addressing, subnets, routing, and security groups.

Zero Trust Architecture

Zero Trust Architecture is a security framework that assumes no implicit trust is granted to assets or user accounts based solely on their physical or network location, requiring strict identity verification for every person and device trying to access resources, such as a vector database.

Glossary

Vector Database APIs and SDKs

Terms related to the programmatic interfaces, protocols, and client libraries for interacting with vector databases. Target: Developers, Software Engineers.

REST API

A REST API is a programmatic interface for a vector database that uses HTTP methods and standard resource-oriented URLs to perform operations like inserting, querying, and managing vector data.

gRPC API

A gRPC API is a high-performance, schema-driven interface for a vector database that uses the HTTP/2 protocol and Protocol Buffers for efficient, low-latency communication, often preferred for internal service-to-service calls.

Client SDK

A Client SDK is a software development kit that provides a language-specific library, abstracting the underlying API calls to simplify interactions with a vector database for developers.

Embedding API

An Embedding API is a service endpoint provided by a vector database or external service that converts raw data (like text or images) into numerical vector representations (embeddings).

Query API

A Query API is the primary interface for executing similarity searches, such as nearest neighbor queries, against the indexed vectors in a database, often supporting filters and distance metrics.

Index API

An Index API provides endpoints for creating, configuring, and managing the underlying vector index data structures that enable efficient similarity search.

Collection API

A Collection API manages logical groupings of vectors and their associated metadata within a vector database, analogous to a table in a relational database.

Batch API

A Batch API allows for the submission of multiple operations (like inserts or deletes) in a single request to improve throughput and reduce network overhead when interacting with a vector database.

Async API

An Async API provides non-blocking endpoints that return an immediate acknowledgment, allowing clients to poll for results later or receive callbacks, ideal for long-running vector operations.

Pagination

Pagination is a technique used by vector database APIs to split large result sets from a query into manageable chunks or pages, controlled via limit/offset or cursor-based tokens.

Rate Limiting

Rate limiting is a control mechanism enforced by a vector database API to restrict the number of requests a client can make within a specific time period to ensure fair usage and system stability.

API Key

An API Key is a unique alphanumeric token used to authenticate and authorize a client application's requests to a vector database's API.

OAuth 2.0

OAuth 2.0 is an authorization framework used by vector database APIs to grant limited access to resources on behalf of a user without sharing their credentials, often for third-party integrations.

API Endpoint

An API Endpoint is a specific URL (Uniform Resource Locator) where a client can send requests to interact with a particular function or resource of a vector database, such as `/v1/collections`.

Request Payload

A Request Payload is the data sent by a client in the body of an API request to a vector database, such as the vectors and metadata for an insert operation.

Idempotency

Idempotency is a property of certain API operations (like PUT or idempotent POST) where making the same request multiple times has the same effect as making it once, crucial for reliable retries in vector data management.

API Versioning

API Versioning is the practice of managing changes to a vector database's public interface by assigning version identifiers (e.g., `v1`, `v2`) to prevent breaking existing client applications.

OpenAPI Specification

The OpenAPI Specification is a standard, language-agnostic format for describing RESTful APIs, used to generate documentation, code, and test clients for vector database interfaces.

Connection Pooling

Connection pooling is a performance optimization technique used by SDKs to maintain a cache of reusable database connections, reducing the overhead of establishing new connections for each API call.

Retry Logic

Retry logic is an error-handling strategy implemented in SDKs where failed API requests to a vector database are automatically reattempted, often with exponential backoff, to handle transient failures.

Circuit Breaker

A circuit breaker is a resilience pattern in an SDK that temporarily stops sending requests to a failing vector database API to prevent cascading failures and allow the downstream service to recover.

Vector Upsert

Vector upsert is an API operation that inserts a new vector into a database or updates an existing vector if one with the same unique identifier already exists.

Nearest Neighbor Query

A nearest neighbor query is a search operation, executed via a Query API, that finds the most similar vectors in a database to a given query vector based on a specified distance metric.

Distance Metric

A distance metric is a mathematical function (e.g., cosine similarity, Euclidean distance) used by a vector database's Query API to measure the similarity or dissimilarity between two vectors.

Filter Expression

A filter expression is a conditional statement applied to metadata during a vector search to narrow results, enabling hybrid search by combining semantic similarity with structured filtering.

Webhook

A webhook is a user-defined HTTP callback triggered by a vector database to notify an external system of an event, such as the completion of an asynchronous index build.

API Gateway

An API gateway is an intermediary service that sits in front of a vector database's API, handling request routing, composition, rate limiting, and authentication for a unified entry point.

mTLS (Mutual TLS)

Mutual TLS is a security protocol where both the client and the vector database server authenticate each other using X.509 certificates, providing strong authentication for API connections.

API Deprecation

API deprecation is the process of marking a version or feature of a vector database's interface as obsolete and scheduled for future removal, following a communicated sunset policy.

SLA (Service Level Agreement)

An SLA is a formal commitment from a vector database provider that defines measurable performance and availability targets for its API, such as uptime percentage and latency percentiles.

How We Work

Custom AI workflows for your Business

One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.

Talk to Us