Vector Storage Consistency Model

Also known as linearizability, this is the strictest guarantee. It ensures that once a write operation completes, all subsequent read operations (from any node) will return that updated value or a more recent one. This provides a single, up-to-date view of the data, akin to a single-server system.

• Mechanism: Typically implemented using a consensus protocol like Raft or Paxos to synchronize all replicas before acknowledging a write as successful.
• Trade-off: Highest data correctness but introduces higher write latency and reduced availability during network partitions.
• Use Case: Critical for applications where stale data is unacceptable, such as financial ledger updates or real-time inventory management systems using vector similarity for fraud detection.

A weaker guarantee where, in the absence of new writes, all replicas will eventually converge to the same state. Reads may return stale data for a period of time after a write.

• Mechanism: Writes are acknowledged after being applied to a primary node and then asynchronously propagated to replicas. This is often paired with a last-write-wins conflict resolution policy.
• Trade-off: Offers the highest write availability and lowest latency but at the cost of temporary read inconsistency.
• Use Case: Ideal for high-throughput, read-heavy workloads where absolute real-time accuracy is not critical, such as caching user embeddings for non-transactional recommendations.

A middle-ground model that preserves causal relationships between operations. If operation A causally affects operation B (e.g., a user writes a vector, then updates its metadata), then any process that sees B will also see A. Concurrent, unrelated operations may be seen in different orders.

• Mechanism: Tracks dependencies using logical timestamps (e.g., vector clocks) to enforce a partial order of events.
• Trade-off: Stronger than eventual consistency for causally related data, while offering better performance than strong consistency.
• Use Case: Perfect for collaborative or session-based applications, such as maintaining the state of a user's interaction history with an AI agent where steps must be seen in the correct order.

A practical model that guarantees consistency within the context of a single client session. A client will see its own writes immediately and will observe a monotonic read/write order, but different sessions may see state at different points in time.

• Mechanism: The database binds a client to a specific replica (sticky session) or tracks a session-specific version token to ensure read-your-writes and monotonic reads guarantees.
• Trade-off: Provides a intuitive, consistent experience for individual users or services without the global coordination overhead of strong consistency.
• Use Case: The default model for many web and mobile applications interacting with a vector backend, ensuring a user's query always reflects their most recent data insertion.

A specific guarantee that is often a subset of stronger models. It ensures that after a process performs a write, it will always see that write in its subsequent reads, even if other processes see stale data.

• Mechanism: Often implemented by routing a client's reads to the same replica that handled its write or by using client-side version tokens.
• Trade-off: A critical baseline for application usability, providing consistency for the writing client without guaranteeing it for others.
• Use Case: Essential for any interactive system. For example, after a user uploads a document to be embedded, their next semantic search must include that new document's vector.

A flexible approach where the consistency level can be specified per operation (read or write). This allows developers to balance latency and correctness based on the specific needs of each query or update.

• Mechanism: The client API includes parameters (e.g., consistency_level=STRONG or consistency=ONE). The database coordinates the required number of replicas to meet the requested guarantee.
• Trade-off: Provides maximum architectural control, allowing performance optimization for non-critical paths while enforcing strong guarantees where needed.
• Use Case: A vector database powering a hybrid search system might use strong consistency for updating user permissions (a metadata filter) but eventual consistency for the underlying ANN vector search to maximize QPS.