endee

Implements client-side encryption for vector embeddings before transmission to a remote database, using symmetric encryption (likely AES-256-GCM or similar) with key management handled entirely on the client. Vectors are encrypted at rest and in transit, with decryption occurring only after retrieval on the client side. This architecture ensures the database server never has access to plaintext vectors or their semantic content, enabling privacy-preserving similarity search without trusting the backend infrastructure.

Executes similarity search queries against encrypted vector embeddings using approximate nearest neighbor (ANN) algorithms, likely implementing locality-sensitive hashing (LSH), product quantization, or HNSW-compatible approaches adapted for encrypted data. The client constructs encrypted query vectors and retrieves candidate results from the backend, then decrypts and re-ranks results locally to ensure accuracy despite the encryption layer. This enables semantic search without the server inferring query intent.

Validates vector dimensions against expected embedding model output sizes and checks compatibility between query vectors and stored vectors before operations, preventing dimension mismatches that would cause silent failures or incorrect results. The implementation likely maintains a registry of common embedding models (OpenAI, Anthropic, Sentence Transformers) with their output dimensions, validates vectors at insertion and query time, and provides helpful error messages when mismatches occur.

Deduplicates vector search results based on vector ID or metadata fields, and re-ranks results by relevance score or custom ranking functions after decryption. The implementation likely supports multiple deduplication strategies (exact match, fuzzy match on metadata), custom ranking functions (e.g., boost recent documents), and result normalization (score scaling, percentile ranking). This enables sophisticated result presentation without exposing ranking logic to the server.

Provides a client-side key management abstraction that handles encryption key generation, storage, rotation, and versioning for vector data. The implementation likely supports multiple key derivation strategies (PBKDF2, Argon2, or direct key material) and maintains key version metadata to support rotating keys without re-encrypting all historical vectors. Keys can be sourced from environment variables, key management services (AWS KMS, Azure Key Vault), or derived from user credentials.

Provides a strongly-typed TypeScript API for vector database operations, with full type inference for vector payloads, metadata schemas, and query results. The implementation likely uses generics to allow users to define custom metadata types, with compile-time validation of metadata field access and query filters. This enables IDE autocomplete, compile-time error detection, and self-documenting code for vector operations.

Supports bulk insertion and upsert operations for multiple encrypted vectors in a single API call, with client-side batching and encryption applied to all vectors before transmission. The implementation likely chunks large batches to respect network and memory constraints, applies encryption in parallel using Web Workers or Node.js worker threads, and handles partial failures gracefully with detailed error reporting per vector. This enables efficient bulk loading of vector stores while maintaining end-to-end encryption.

Applies metadata-based filtering to vector search results after decryption on the client side, supporting complex filter expressions (AND, OR, NOT, range queries, string matching) without exposing filter logic to the server. The implementation likely parses filter expressions into an AST, evaluates them against decrypted metadata objects, and returns only results matching all filter criteria. This enables privacy-preserving filtered search where the server cannot infer filtering intent.

Supports deletion of encrypted vectors from the database with optional garbage collection to reclaim storage space, handling the challenge that deleted vectors cannot be verified as deleted without decryption. The implementation likely uses soft deletes (marking vectors as deleted without removing them) or cryptographic deletion proofs, and provides a garbage collection mechanism to physically remove deleted vectors. This maintains data integrity while preserving encryption guarantees.

Supports updating encrypted vectors with new embeddings or metadata, re-encrypting vectors as needed while maintaining version history and backward compatibility. The implementation likely supports partial updates (metadata-only changes without re-encryption) and full updates (new embedding + metadata), with optional version tracking to maintain audit trails. This enables evolving vector data without losing historical information or breaking existing queries.

Manages a pool of connections to the vector database backend with automatic request batching to reduce network round-trips and improve throughput. The implementation likely uses a connection pool with configurable size, batches multiple vector operations (inserts, queries, deletes) into single network requests, and implements backpressure handling to prevent overwhelming the server. This optimizes network utilization and reduces latency for high-throughput workloads.

Caches recently-accessed encrypted vectors in local memory or disk storage with configurable TTL and eviction policies, reducing repeated decryption overhead and network round-trips for frequently-accessed vectors. The implementation likely uses an LRU or LFU cache with optional disk persistence, maintains cache coherency with the remote database, and provides cache statistics for monitoring. This improves performance for read-heavy workloads while maintaining encryption guarantees.