rvlite

Executes semantic similarity search over embedded vectors using SQL SELECT queries with WHERE clauses that filter by vector distance metrics (cosine, euclidean, dot product). The system converts SQL predicates into vector space operations, enabling developers to combine semantic search with traditional relational filtering (e.g., 'SELECT * FROM documents WHERE embedding MATCH query_vector AND created_date > 2024'). This bridges SQL familiarity with vector database operations without requiring separate query languages.

Executes SPARQL queries against vector-embedded RDF triples, enabling semantic graph traversal where nodes are matched by vector similarity rather than exact URI matching. The system converts SPARQL triple patterns into vector distance queries, allowing queries like 'MATCH ?doc WHERE ?doc rdf:type Document AND ?doc hasEmbedding SIMILAR_TO query_vector'. This enables knowledge graph navigation with semantic flexibility for fuzzy entity matching and similarity-based relationship discovery.

Supports bulk insert and delete operations on vectors and documents, optimizing throughput for loading large datasets or removing multiple records in single operations. The system batches index updates and applies them atomically, reducing overhead compared to individual insert/delete calls. Developers can insert thousands of embeddings with metadata in one call, improving performance for initial data loading and bulk updates.

Serializes the entire vector database (indices, embeddings, metadata) to a compact format that can be saved to disk, IndexedDB, or other storage backends, and restored to recreate the exact database state. The system supports both full snapshots and incremental updates, enabling point-in-time recovery and database migration across runtimes. Developers can checkpoint databases before risky operations, backup to external storage, or distribute pre-indexed databases as part of application bundles.

Supports multiple vector distance metrics (cosine similarity, euclidean distance, dot product) with configurable selection per query or database-wide, enabling developers to choose the metric best suited for their embedding model and use case. The system implements efficient calculations for each metric and allows switching between metrics without reindexing. Different embedding models (e.g., OpenAI vs. Hugging Face) may perform better with different metrics, and rvlite enables experimentation without database restructuring.

Executes Cypher queries (Neo4j-style graph query language) over property graphs where node and relationship matching can be based on vector embeddings. The system translates Cypher patterns like 'MATCH (a:Document)-[:RELATED_TO]->(b:Document) WHERE a.embedding SIMILAR_TO query_vector' into vector distance operations combined with graph traversal. This enables property graph navigation with semantic node matching, allowing developers to find similar entities and their relationships in a single query.

Builds and maintains approximate nearest neighbor (ANN) indices over vector embeddings using in-memory data structures (likely LSH, HNSW, or similar algorithms based on lightweight vector DB patterns). The system automatically indexes vectors as they are inserted, enabling fast similarity search without explicit index creation. Indices are stored in memory and can be serialized to disk/browser storage for persistence, supporting both exact and approximate search modes with configurable recall/speed tradeoffs.

Provides unified vector database API that works identically across Node.js, browser, and edge runtime environments (Cloudflare Workers, Vercel Edge, etc.) by abstracting storage and compute layers. The system uses WebAssembly for core vector operations and adapts I/O to each runtime (filesystem in Node.js, IndexedDB in browsers, KV storage in edge). Developers write once and deploy the same code to multiple runtimes without runtime-specific branching or configuration.

Operates as a fully self-contained vector database with no external service dependencies — all vector operations, indexing, and query execution happen within the rvlite process/runtime. The system bundles vector algorithms, query parsers, and storage logic as a single npm package, eliminating network calls or external service requirements. Developers instantiate the database in-process and interact via JavaScript API, making it suitable for offline-first and privacy-sensitive applications.

Provides unified query interface supporting three distinct query languages (SQL, SPARQL, Cypher) over the same underlying vector dataset, with automatic translation between query languages and vector operations. The system includes separate query parsers for each language that compile to a common intermediate representation (likely an AST or query plan), enabling developers to choose the most natural language for their use case. A single database instance can handle mixed queries in different languages without data duplication or separate indices.

Enables vector search directly in web browsers using IndexedDB for persistent storage of embeddings and indices, eliminating server-side vector database requirements for client-side RAG and semantic search. The system serializes vector indices to IndexedDB, loads them on page initialization, and executes queries entirely in the browser process using WASM-accelerated vector operations. Developers can build offline-capable search features that sync with servers only when needed, reducing latency and bandwidth for vector operations.

Accepts vector embeddings from any source (OpenAI, Hugging Face, local models, etc.) without requiring specific embedding model integration or format conversion. The system stores embeddings as raw float arrays and executes distance calculations (cosine, euclidean, dot product) on any embedding regardless of dimensionality or source. Developers can mix embeddings from different models in the same database and query across them, enabling flexible multi-model RAG pipelines and embedding experimentation.

Ranks query results by vector similarity distance and returns explicit similarity scores for each match, enabling developers to filter results by confidence threshold or present relevance scores to users. The system calculates distances using configurable metrics (cosine, euclidean, dot product) and sorts results by distance, optionally normalizing scores to 0-1 range. Scores are returned alongside results, allowing applications to implement confidence-based filtering, result reranking, or relevance visualization.