Find the Right
Vector Database

Rust-based PostgreSQL extension accelerating vector similarity search with diskless HNSW (20x faster than pgvector), DiskANN indexes, and hybrid SQL for ANN on embeddings. Enables FP16/INT8/binary vectors with ACID compliance; perfect for high-throughput RAG in DB, real-time analytics. Superior speed/resource efficiency vs dedicated vector stores like Weaviate, all within Postgres.

Rust crate for quantum circuit simulation and coherence assessment using min-cut gates. Integrates MWPM decoder and post-quantum signatures providing quantum-resistant security for AI safety in quantum-inspired vector computing environments.

Open-source graph-enhanced vector database built in Rust enabling hybrid graph+vector search for KG-RAG applications. Supports graph queries for knowledge graph traversal combined with vector similarity search. Unlike pure vector databases, it natively models relationships for multi-hop reasoning and connected data retrieval.

NucliaDB is a versatile vector database designed for data scientists and machine learning experts working with HuggingFace and other data pipeline platforms. Built on Tantivy in Rust and Python, it efficiently indexes large datasets with multi-tenant support.

Embedded vector + graph + columnar database with HNSW indexing.

Minimal Rust library for fast on-device cosine similarity search with Rayon parallelism and embedded persistence, ideal for low-latency prototyping on edge hardware. Supports quick inserts/queries for real-time AI; lighter than full DBs like Qdrant edge.

Self-optimizing on-device vector database with HNSW, graph RAG, and WASM deployment for low-latency edge AI ops across browsers/IoT/mobile. Supports real-time self-learning retrieval; lighter and offline vs cloud Qdrant.

Rust core for high-performance on-device HNSW vector search with SIMD and compression, achieving low-latency multi-threaded queries for edge AI RAG. Up to 3,597 QPS; optimized for real-time vs cloud alternatives.

QEMU microVM launcher for low-latency RVF cognitive containers in RuVector stack, enabling secure on-device vector processing for edge AI environments.

Pure Rust embedding database as lightweight Axum server for low-latency on-device vector search scaling to 100M+ vectors in memory. High accuracy/speed for edge RAG; simpler than Qdrant edge.

Web-optimized Rust vector DB for low-latency on-device storage/search via WASM, with efficient formats and PCA compression for browsers/edge. Supports JS/Rust APIs; compact vs cloud Qdrant.

Rust-built vector DB with pluggable HNSW/KD-Tree/Flat indexers for low-latency on-device similarity search, HTTP/gRPC/TUI clients, RocksDB persistence. Suited for edge AI; modular vs monolithic Qdrant.

vectordb-from-scratch is a Rust-based learning project implementing a vector database from basics, focusing on HNSW indexing internals and database fundamentals. Demonstrates core concepts like vector storage, ANN search, and persistence. Educational for understanding VDB architecture; not production-ready, contrasts full DBs like Qdrant. Use cases: tutorials, prototyping indexes.

RuVector-enhanced personal AI memory for Screenpipe, replacing SQLite with semantic vector search, knowledge graphs, and attention reranking.

Unified WASM bindings for 18+ attention mechanisms including neural, DAG, and Mamba SSM, optimized for vector search and processing.

Command-line interface for RuVector vector database, supporting initialization, insert, search, and hooks for AI coding assistants.

CRDT-based autonomous credit economy in WASM for decentralized vector resource allocation and AI agent economics.

WASM crate with exotic AI primitives like strange loops and time crystals for advanced vector computations in novel AI architectures.

Rust crate for Graph Neural Network layers and training integrated with vector search. Powers GNN-enhanced HNSW reranking and semantic routing in RuVector. Supports browser and edge deployment via WASM.

Unified graph transformer with proof-gated mutation substrate for verified graph-vector operations, featuring 8 modules and 186 tests.

WASM bindings for browser-side graph transformers with proof verification.

WASM library for MicroLoRA adaptation with sub-100µs latency, enabling fast fine-tuning for vector embeddings and AI models in browser environments.

Rust implementation of subpolynomial fully-dynamic min-cut algorithm for AI coherence checks, network resilience, and agent coordination. Features 256-core parallel optimization and WASM bindings for browser use.

Rust crate implementing spiking neural networks with BTSP learning and EWC plasticity for neuromorphic and bio-inspired vector processing in AI applications. Provides energy-efficient alternatives to traditional ANNs with 10-50x efficiency gains. Designed for integration into vector databases and real-time AI systems.

WASM bindings for ruvector-nervous-system, enabling browser and edge deployment of spiking neural networks with BTSP and EWC for vector similarity tasks. Supports neuromorphic learning in web environments for AI vector applications.

Native Node.js bindings for RuVector via napi-rs, providing high-performance vector database operations in Node.js environments.

Production-ready ONNX embedding generation in pure Rust using ONNX Runtime, no Python required. Supports 8+ pretrained models including all-MiniLM-L6-v2, BGE, E5, GTE with pooling strategies and GPU acceleration (CUDA, TensorRT, CoreML, WebGPU). Enables direct integration with RuVector indices for RAG pipelines and semantic similarity computation.

Rust crate for cognitive robotics platform with perception, A* planning, behavior trees, and swarm coordination using vector search. Supports no_std and cross-domain transfer learning.

Rust OCR engine for scientific documents, extracting text and mathematical equations to LaTeX, MathML, or plain text. Supports batch processing, content detection for equations/tables/diagrams, confidence scoring, and PDF support. Includes TypeScript client (@ruvector/scipix) and CLI (scipix-cli).

HTTP/gRPC server for RuVector vector database, exposing REST API for vector operations.

Rust crate for Self-Optimizing Neural Architecture (SONA) with LoRA adaptation, EWC++ plasticity, and ReasoningBank learning. Enables continuous improvement in LLM routers and agents without forgetting.

Core library for AI agent routing using FastGRNN in the RuVector ecosystem. Enables efficient semantic routing for multi-agent AI systems with low resource footprint, suitable for vector database-integrated workflows.

Rust crate for proof-carrying vector operations using lean-agentic dependent types, providing formal verification with ~500ns proofs for secure vector computations in AI systems.

WASM bindings for ruvector-verified, enabling browser/edge formal verification of vector operations.

RuVix is an operating system kernel designed for AI agents and cognitive workloads, replacing file/process thinking with vectors, graphs, proofs, and capabilities. Features proof-gated mutations, unforgeable capability tokens, io_uring-style IPC, coherence-aware scheduling, and support for bare-metal AArch64, multi-core, Raspberry Pi, networking, and distributed QEMU swarms.

Runtime engine for RVF including store API, copy-on-write, and compaction features. Powers persistent and efficient vector data management in RuVector applications.

Core type definitions for RVF segments, headers, and structures in no_std Rust. Essential foundation for building verified vector data containers in the RuVector project.

Thermodynamic neural motif engine using Ising/soft-spin Hamiltonians, Langevin dynamics, and Landauer dissipation for bio-inspired vector neural networks.

A lightweight, WASM-compatible vector similarity search engine written in Rust, enabling in-browser vector search with support for HNSW index and multiple distance metrics.

Qdrant's custom-built storage engine written in Rust, replacing RocksDB with improved performance and lower latency for payload and sparse vector storage.

A Python ETL framework for stream processing and real-time analytics with built-in real-time vector indexing. Pathway automatically detects document changes and re-indexes in real-time, ensuring AI applications always use the latest information rather than stale data.

Graph-based approximate nearest neighbor search library built on LMDB key-value storage. The successor to Arroy, Hannoy combines graph-based ANN algorithms with production-ready persistent storage for vector databases.

Pure-Rust implementation of HNSW algorithm for approximate nearest neighbor search. Decouples graph from vector storage for flexible deployment. Supports dense floating point and quantized int8 vectors. This is an OSS library.

A Rust implementation of the HNSW (Hierarchical Navigable Small World) approximate nearest neighbor search algorithm, useful for building high-performance, memory-safe vector search components in Rust-based AI and retrieval systems.