RuVector

A distributed vector database that learns. Store embeddings, query with Cypher, scale horizontally with Raft consensus, and let the index improve itself through Graph Neural Networks.

npx ruvector

All-in-One Package: The core ruvector package includes everything — vector search, graph queries, GNN layers, distributed clustering, AI routing, and WASM support. No additional packages needed.

What Problem Does RuVector Solve?

Traditional vector databases just store and search. When you ask "find similar items," they return results but never get smarter. They don't scale horizontally. They can't route AI requests intelligently.

RuVector is different:

1. Store vectors like any vector DB (embeddings from OpenAI, Cohere, etc.)
2. Query with Cypher like Neo4j (MATCH (a)-[:SIMILAR]->(b) RETURN b)
3. The index learns — GNN layers make search results improve over time
4. Scale horizontally — Raft consensus, multi-master replication, auto-sharding
5. Route AI requests — Semantic routing and FastGRNN neural inference for LLM optimization
6. Compress automatically — 2-32x memory reduction with adaptive tiered compression
7. 39 attention mechanisms — Flash, linear, graph, hyperbolic for custom models
8. Drop into Postgres — pgvector-compatible extension with SIMD acceleration
9. Run anywhere — Node.js, browser (WASM), HTTP server, or native Rust
10. Continuous learning — SONA enables runtime adaptation with LoRA, EWC++, and ReasoningBank

Think of it as: Pinecone + Neo4j + PyTorch + postgres + etcd in one Rust package.

How the GNN Works

Traditional vector search:

Query → HNSW Index → Top K Results

RuVector with GNN:

Query → HNSW Index → GNN Layer → Enhanced Results
                ↑                      │
                └──── learns from ─────┘

The GNN layer:

1. Takes your query and its nearest neighborsa
2. Applies multi-head attention to weigh which neighbors matter
3. Updates representations based on graph structure
4. Returns better-ranked results

Over time, frequently-accessed paths get reinforced, making common queries faster and more accurate.

Quick Start

One-Line Install

Node.js / Browser

# Install
npm install ruvector

# Or try instantly
npx ruvector

Comparison

Feature	RuVector	Pinecone	Qdrant	Milvus	ChromaDB
Latency (p50)	61µs	~2ms	~1ms	~5ms	~50ms
Memory (1M vec)	200MB*	2GB	1.5GB	1GB	3GB
Graph Queries	✅ Cypher	❌	❌	❌	❌
Hyperedges	✅	❌	❌	❌	❌
Self-Learning (GNN)	✅	❌	❌	❌	❌
Runtime Adaptation (SONA)	✅ LoRA+EWC++	❌	❌	❌	❌
AI Agent Routing	✅ Tiny Dancer	❌	❌	❌	❌
Attention Mechanisms	✅ 39 types	❌	❌	❌	❌
Hyperbolic Embeddings	✅ Poincaré	❌	❌	❌	❌
PostgreSQL Extension	✅ pgvector drop-in	❌	❌	❌	❌
SIMD Optimization	✅ AVX-512/NEON	Partial	✅	✅	❌
Metadata Filtering	✅	✅	✅	✅	✅
Sparse Vectors	✅ BM25/TF-IDF	✅	✅	✅	❌
Raft Consensus	✅	❌	✅	❌	❌
Multi-Master Replication	✅	❌	❌	✅	❌
Auto-Sharding	✅	✅	✅	✅	❌
Auto-Compression	✅ 2-32x	❌	❌	✅	❌
Snapshots/Backups	✅	✅	✅	✅	❌
Browser/WASM	✅	❌	❌	❌	❌
Differentiable	✅	❌	❌	❌	❌
Multi-Tenancy	✅ Collections	✅	✅	✅	✅
Open Source	✅ MIT	❌	✅	✅	✅

*With PQ8 compression. Benchmarks on Apple M2 / Intel i7.

Features

Core Capabilities

Feature	What It Does	Why It Matters
Vector Search	HNSW index, <0.5ms latency, SIMD acceleration	Fast enough for real-time apps
Cypher Queries	MATCH, WHERE, CREATE, RETURN	Familiar Neo4j syntax
GNN Layers	Neural network on index topology	Search improves with usage
Hyperedges	Connect 3+ nodes at once	Model complex relationships
Metadata Filtering	Filter vectors by properties	Combine semantic + structured search
Collections	Namespace isolation, multi-tenancy	Organize vectors by project/user

Distributed Systems

Feature	What It Does	Why It Matters
Raft Consensus	Leader election, log replication	Strong consistency for metadata
Auto-Sharding	Consistent hashing, shard migration	Scale to billions of vectors
Multi-Master Replication	Write to any node, conflict resolution	High availability, no SPOF
Snapshots	Point-in-time backups, incremental	Disaster recovery
Cluster Metrics	Prometheus-compatible monitoring	Observability at scale

cargo add ruvector-raft ruvector-cluster ruvector-replication

AI & ML

Feature	What It Does	Why It Matters
Tensor Compression	f32→f16→PQ8→PQ4→Binary	2-32x memory reduction
Differentiable Search	Soft attention k-NN	End-to-end trainable
Semantic Router	Route queries to optimal endpoints	Multi-model AI orchestration
Tiny Dancer	FastGRNN neural inference	Optimize LLM inference costs
Adaptive Routing	Learn optimal routing strategies	Minimize latency, maximize accuracy
SONA	Two-tier LoRA + EWC++ + ReasoningBank	Runtime learning without retraining

Attention Mechanisms (@ruvector/attention)

Feature	What It Does	Why It Matters
39 Mechanisms	Dot-product, multi-head, flash, linear, sparse, cross-attention	Cover all transformer and GNN use cases
Graph Attention	RoPE, edge-featured, local-global, neighborhood	Purpose-built for graph neural networks
Hyperbolic Attention	Poincaré ball operations, curved-space math	Better embeddings for hierarchical data
SIMD Optimized	Native Rust with AVX2/NEON acceleration	2-10x faster than pure JS
Streaming & Caching	Chunk-based processing, KV-cache	Constant memory, 10x faster inference

Documentation: Attention Module Docs

Core Attention Mechanisms

Standard attention layers for sequence modeling and transformers.

Mechanism	Complexity	Memory	Best For
DotProductAttention	O(n²)	O(n²)	Basic attention for small-medium sequences
MultiHeadAttention	O(n²·h)	O(n²·h)	BERT, GPT-style transformers
FlashAttention	O(n²)	O(n)	Long sequences with limited GPU memory
LinearAttention	O(n·d)	O(n·d)	8K+ token sequences, real-time streaming
HyperbolicAttention	O(n²)	O(n²)	Tree-like data: taxonomies, org charts
MoEAttention	O(n·k)	O(n·k)	Large models with sparse expert routing

Graph Attention Mechanisms

Attention layers designed for graph-structured data and GNNs.

Mechanism	Complexity	Best For
GraphRoPeAttention	O(n²)	Position-aware graph transformers
EdgeFeaturedAttention	O(n²·e)	Molecules, knowledge graphs with edge data
DualSpaceAttention	O(n²)	Hybrid flat + hierarchical embeddings
LocalGlobalAttention	O(n·k + n)	100K+ node graphs, scalable GNNs

Specialized Mechanisms

Task-specific attention variants for efficiency and multi-modal learning.

Mechanism	Type	Best For
SparseAttention	Efficiency	Long docs, low-memory inference
CrossAttention	Multi-modal	Image-text, encoder-decoder models
NeighborhoodAttention	Graph	Local message passing in GNNs
HierarchicalAttention	Structure	Multi-level docs (section → paragraph)

Hyperbolic Math Functions

Operations for Poincaré ball embeddings—curved space that naturally represents hierarchies.

Function	Description	Use Case
expMap(v, c)	Map to hyperbolic space	Initialize embeddings
logMap(p, c)	Map to flat space	Compute gradients
mobiusAddition(x, y, c)	Add vectors in curved space	Aggregate features
poincareDistance(x, y, c)	Measure hyperbolic distance	Compute similarity
projectToPoincareBall(p, c)	Ensure valid coordinates	Prevent numerical errors

Async & Batch Operations

Utilities for high-throughput inference and training optimization.

Operation	Description	Performance
asyncBatchCompute()	Process batches in parallel	3-5x faster
streamingAttention()	Process in chunks	Fixed memory usage
HardNegativeMiner	Find hard training examples	Better contrastive learning
AttentionCache	Cache key-value pairs	10x faster inference

# Install attention module
npm install @ruvector/attention

# CLI commands
npx ruvector attention list                    # List all 39 mechanisms
npx ruvector attention info flash              # Details on FlashAttention
npx ruvector attention benchmark               # Performance comparison
npx ruvector attention compute -t dot -d 128   # Run attention computation
npx ruvector attention hyperbolic -a distance -v "[0.1,0.2]" -b "[0.3,0.4]"

Deployment

Feature	What It Does	Why It Matters
HTTP/gRPC Server	REST API, streaming support	Easy integration
WASM/Browser	Full client-side support	Run AI search offline
Node.js Bindings	Native napi-rs bindings	No serialization overhead
FFI Bindings	C-compatible interface	Use from Python, Go, etc.
CLI Tools	Benchmarking, testing, management	DevOps-friendly

Benchmarks

Real benchmark results on standard hardware:

Operation	Dimensions	Time	Throughput
HNSW Search (k=10)	384	61µs	16,400 QPS
HNSW Search (k=100)	384	164µs	6,100 QPS
Cosine Distance	1536	143ns	7M ops/sec
Dot Product	384	33ns	30M ops/sec
Batch Distance (1000)	384	237µs	4.2M/sec

Global Cloud Performance (500M Streams)

Production-validated metrics at hyperscale:

Metric	Value	Details
Concurrent Streams	500M baseline	Burst capacity to 25B (50x)
Global Latency (p50)	<10ms	Multi-region + CDN edge caching
Global Latency (p99)	<50ms	Cross-continental with failover
Availability SLA	99.99%	15 regions, automatic failover
Cost per Stream/Month	$0.0035	60% optimized ($1.74M total at 500M)
Regions	15 global	Americas, EMEA, APAC coverage
Throughput per Region	100K+ QPS	Adaptive batching enabled
Memory Efficiency	2-32x compression	Tiered hot/warm/cold storage
Index Build Time	1M vectors/min	Parallel HNSW construction
Replication Lag	<100ms	Multi-master async replication

Compression Tiers

The architecture adapts to your data. Hot paths get full precision and maximum compute. Cold paths compress automatically and throttle resources. Recent data stays crystal clear; historical data optimizes itself in the background.

Think of it like your computer's memory hierarchy—frequently accessed data lives in fast cache, while older files move to slower, denser storage. RuVector does this automatically for your vectors:

Access Frequency	Format	Compression	What Happens
Hot (>80%)	f32	1x	Full precision, instant retrieval
Warm (40-80%)	f16	2x	Slight compression, imperceptible latency
Cool (10-40%)	PQ8	8x	Smart quantization, ~1ms overhead
Cold (1-10%)	PQ4	16x	Heavy compression, still fast search
Archive (<1%)	Binary	32x	Maximum density, batch retrieval

No configuration needed. RuVector tracks access patterns and automatically promotes/demotes vectors between tiers. Your hot data stays fast; your cold data shrinks.

Use Cases

RAG (Retrieval-Augmented Generation)

const context = ruvector.search(questionEmbedding, 5);
const prompt = `Context: ${context.join('\n')}\n\nQuestion: ${question}`;

Recommendation Systems

MATCH (user:User)-[:VIEWED]->(item:Product)
MATCH (item)-[:SIMILAR_TO]->(rec:Product)
RETURN rec ORDER BY rec.score DESC LIMIT 10

Knowledge Graphs

MATCH (concept:Concept)-[:RELATES_TO*1..3]->(related)
RETURN related

Installation

Platform	Command
npm	npm install ruvector
npm (SONA)	npm install @ruvector/sona
Browser/WASM	npm install ruvector-wasm
Rust	cargo add ruvector-core ruvector-graph ruvector-gnn
Rust (SONA)	cargo add ruvector-sona

Documentation

Topic	Link
Getting Started	docs/guides/GETTING_STARTED.md
Cypher Reference	docs/api/CYPHER_REFERENCE.md
GNN Architecture	docs/gnn/gnn-layer-implementation.md
Node.js API	crates/ruvector-gnn-node/README.md
WASM API	crates/ruvector-gnn-wasm/README.md
Performance Tuning	docs/optimization/PERFORMANCE_TUNING_GUIDE.md
API Reference	docs/api/

Crates

All crates are published to crates.io under the ruvector-* namespace.

Core Crates

Crate	Description	crates.io
ruvector-core	Vector database engine with HNSW indexing
ruvector-collections	Collection and namespace management
ruvector-filter	Vector filtering and metadata queries
ruvector-metrics	Performance metrics and monitoring
ruvector-snapshot	Snapshot and persistence management

Graph & GNN

Crate	Description	crates.io
ruvector-graph	Hypergraph database with Neo4j-style Cypher
ruvector-graph-node	Node.js bindings for graph operations
ruvector-graph-wasm	WASM bindings for browser graph queries
ruvector-gnn	Graph Neural Network layers and training
ruvector-gnn-node	Node.js bindings for GNN inference
ruvector-gnn-wasm	WASM bindings for browser GNN

Attention Mechanisms

Crate	Description	crates.io
ruvector-attention	39 attention mechanisms (Flash, Hyperbolic, MoE, Graph)
ruvector-attention-node	Node.js bindings for attention mechanisms
ruvector-attention-wasm	WASM bindings for browser attention
ruvector-attention-cli	CLI for attention testing and benchmarking

Distributed Systems

Crate	Description	crates.io
ruvector-cluster	Cluster management and coordination
ruvector-raft	Raft consensus implementation
ruvector-replication	Data replication and synchronization

AI Agent Routing (Tiny Dancer)

Crate	Description	crates.io
ruvector-tiny-dancer-core	FastGRNN neural inference for AI routing
ruvector-tiny-dancer-node	Node.js bindings for AI routing
ruvector-tiny-dancer-wasm	WASM bindings for browser AI routing

Router (Semantic Routing)

Crate	Description	crates.io
ruvector-router-core	Core semantic routing engine
ruvector-router-cli	CLI for router testing and benchmarking
ruvector-router-ffi	FFI bindings for other languages
ruvector-router-wasm	WASM bindings for browser routing

Self-Optimizing Neural Architecture (SONA)

Crate	Description	crates.io	npm
ruvector-sona	Runtime-adaptive learning with LoRA, EWC++, and ReasoningBank

SONA enables AI systems to continuously improve from user feedback without expensive retraining:

• Two-tier LoRA: MicroLoRA (rank 1-2) for instant adaptation, BaseLoRA (rank 4-16) for long-term learning
• EWC++: Elastic Weight Consolidation prevents catastrophic forgetting
• ReasoningBank: K-means++ clustering stores and retrieves successful reasoning patterns
• Lock-free Trajectories: ~50ns overhead per step with crossbeam ArrayQueue
• Sub-millisecond Learning: <0.8ms per trajectory processing

# Rust
cargo add ruvector-sona

# Node.js
npm install @ruvector/sona

use ruvector_sona::{SonaEngine, SonaConfig};

let engine = SonaEngine::new(SonaConfig::default());
let traj_id = engine.start_trajectory(query_embedding);
engine.record_step(traj_id, node_id, 0.85, 150);
engine.end_trajectory(traj_id, 0.90);
engine.learn_from_feedback(LearningSignal::positive(50.0, 0.95));

// Node.js
const { SonaEngine } = require('@ruvector/sona');

const engine = new SonaEngine(256); // 256 hidden dimensions
const trajId = engine.beginTrajectory([0.1, 0.2, ...]);
engine.addTrajectoryStep(trajId, activations, attention, 0.9);
engine.endTrajectory(trajId, 0.95);

PostgreSQL Extension

Crate	Description	crates.io	npm
ruvector-postgres	pgvector-compatible PostgreSQL extension with SIMD optimization

v0.2.0 — Drop-in replacement for pgvector with 53+ SQL functions, full AVX-512/AVX2/NEON SIMD acceleration (~2x faster than AVX2), HNSW and IVFFlat indexes, 39 attention mechanisms, GNN layers, hyperbolic embeddings, sparse vectors/BM25, and self-learning capabilities.

# Docker (recommended)
docker run -d -e POSTGRES_PASSWORD=secret -p 5432:5432 ruvector/postgres:latest

# From source
cargo install cargo-pgrx --version "0.12.9" --locked
cargo pgrx install --release

# CLI tool for management
npm install -g @ruvector/postgres-cli
ruvector-pg install
ruvector-pg vector create table --dim 1536 --index hnsw

See ruvector-postgres README for full SQL API reference and advanced features.

Tools & Utilities

Crate	Description	crates.io
ruvector-bench	Benchmarking suite for vector operations
profiling	Performance profiling and analysis tools
micro-hnsw-wasm	Lightweight HNSW implementation for WASM

Scientific OCR (SciPix)

Crate	Description	crates.io
ruvector-scipix	OCR engine for scientific documents, math equations → LaTeX/MathML

SciPix extracts text and mathematical equations from images, converting them to LaTeX, MathML, or plain text. Features GPU-accelerated ONNX inference, SIMD-optimized preprocessing, REST API server, CLI tool, and MCP integration for AI assistants.

# Install
cargo add ruvector-scipix

# CLI usage
scipix-cli ocr --input equation.png --format latex
scipix-cli serve --port 3000

# MCP server for Claude/AI assistants
scipix-cli mcp
claude mcp add scipix -- scipix-cli mcp

ONNX Embeddings

Example	Description	Path
ruvector-onnx-embeddings	Production-ready ONNX embedding generation in pure Rust	examples/onnx-embeddings

ONNX Embeddings provides native embedding generation using ONNX Runtime — no Python required. Supports 8+ pretrained models (all-MiniLM, BGE, E5, GTE), multiple pooling strategies, GPU acceleration (CUDA, TensorRT, CoreML, WebGPU), and direct RuVector index integration for RAG pipelines.

use ruvector_onnx_embeddings::{Embedder, PretrainedModel};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create embedder with default model (all-MiniLM-L6-v2)
    let mut embedder = Embedder::default_model().await?;

    // Generate embedding (384 dimensions)
    let embedding = embedder.embed_one("Hello, world!")?;

    // Compute semantic similarity
    let sim = embedder.similarity(
        "I love programming in Rust",
        "Rust is my favorite language"
    )?;
    println!("Similarity: {:.4}", sim); // ~0.85

    Ok(())
}

Supported Models:

Model	Dimension	Speed	Best For
AllMiniLmL6V2	384	Fast	General purpose (default)
BgeSmallEnV15	384	Fast	Search & retrieval
AllMpnetBaseV2	768	Accurate	Production RAG

Bindings & Tools

Crate	Description	crates.io
ruvector-node	Main Node.js bindings (napi-rs)
ruvector-wasm	Main WASM bindings for browsers
ruvector-cli	Command-line interface
ruvector-server	HTTP/gRPC server

Examples

Production-ready examples demonstrating RuVector integration patterns, from cognitive AI substrates to WASM browser deployments.

Example	Description	Type
exo-ai-2025	Cognitive substrate with 9 neural-symbolic crates for AI reasoning	Rust
google-cloud	GCP deployment templates for Cloud Run, GKE, and Vertex AI	Rust
meta-cognition-spiking-neural-network	Spiking neural network with meta-cognitive learning	npm
onnx-embeddings	Production ONNX embedding generation without Python	Rust
refrag-pipeline	RAG pipeline with vector search and document processing	Rust
scipix	Scientific OCR: equations → LaTeX/MathML with ONNX inference	Rust
spiking-network	Biologically-inspired spiking neural networks	Rust
wasm-react	React integration with WASM vector operations	WASM
wasm-vanilla	Vanilla JS WASM example for browser vector search	WASM
agentic-jujutsu	Quantum-resistant version control for AI agents	Rust
graph	Graph database examples with Cypher queries	Rust
nodejs	Node.js integration examples	Node.js
rust	Core Rust usage examples	Rust

npm Packages

✅ Published

Package	Description	npm
ruvector	All-in-one CLI & package (vectors, graphs, GNN)
@ruvector/core	Core vector database with native Rust bindings
@ruvector/gnn	Graph Neural Network layers & tensor compression
@ruvector/graph-node	Hypergraph database with Cypher queries
@ruvector/tiny-dancer	FastGRNN neural inference for AI agent routing
@ruvector/router	Semantic router with HNSW vector search
@ruvector/agentic-synth	Synthetic data generator for AI/ML
@ruvector/attention	39 attention mechanisms for transformers & GNNs
@ruvector/postgres-cli	CLI for ruvector-postgres extension management
@ruvector/wasm	WASM fallback for core vector DB
@ruvector/gnn-wasm	WASM fallback for GNN layers
@ruvector/graph-wasm	WASM fallback for graph DB
@ruvector/attention-wasm	WASM fallback for attention mechanisms
@ruvector/tiny-dancer-wasm	WASM fallback for AI routing
@ruvector/router-wasm	WASM fallback for semantic router
@ruvector/sona	Self-Optimizing Neural Architecture (SONA)
@ruvector/cluster	Distributed clustering & sharding
@ruvector/server	HTTP/gRPC server mode

Platform-specific native bindings (auto-detected):

• @ruvector/node-linux-x64-gnu, @ruvector/node-linux-arm64-gnu, @ruvector/node-darwin-x64, @ruvector/node-darwin-arm64, @ruvector/node-win32-x64-msvc
• @ruvector/gnn-linux-x64-gnu, @ruvector/gnn-linux-arm64-gnu, @ruvector/gnn-darwin-x64, @ruvector/gnn-darwin-arm64, @ruvector/gnn-win32-x64-msvc
• @ruvector/tiny-dancer-linux-x64-gnu, @ruvector/tiny-dancer-linux-arm64-gnu, @ruvector/tiny-dancer-darwin-x64, @ruvector/tiny-dancer-darwin-arm64, @ruvector/tiny-dancer-win32-x64-msvc
• @ruvector/router-linux-x64-gnu, @ruvector/router-linux-arm64-gnu, @ruvector/router-darwin-x64, @ruvector/router-darwin-arm64, @ruvector/router-win32-x64-msvc
• @ruvector/attention-linux-x64-gnu, @ruvector/attention-linux-arm64-gnu, @ruvector/attention-darwin-x64, @ruvector/attention-darwin-arm64, @ruvector/attention-win32-x64-msvc

🚧 Planned

Package	Description	Status
@ruvector/raft	Raft consensus for distributed ops	Crate ready
@ruvector/replication	Multi-master replication	Crate ready
@ruvector/scipix	Scientific OCR (LaTeX/MathML)	Crate ready

See GitHub Issue #20 for multi-platform npm package roadmap.

# Install all-in-one package
npm install ruvector

# Or install individual packages
npm install @ruvector/core @ruvector/gnn @ruvector/graph-node

# List all available packages
npx ruvector install

const ruvector = require('ruvector');

// Vector search
const db = new ruvector.VectorDB(128);
db.insert('doc1', embedding1);
const results = db.search(queryEmbedding, 10);

// Graph queries (Cypher)
db.execute("CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})");
db.execute("MATCH (p:Person)-[:KNOWS]->(friend) RETURN friend.name");

// GNN-enhanced search
const layer = new ruvector.GNNLayer(128, 256, 4);
const enhanced = layer.forward(query, neighbors, weights);

// Compression (2-32x memory savings)
const compressed = ruvector.compress(embedding, 0.3);

// Tiny Dancer: AI agent routing
const router = new ruvector.Router();
const decision = router.route(candidates, { optimize: 'cost' });

Rust

cargo add ruvector-graph ruvector-gnn

use ruvector_graph::{GraphDB, NodeBuilder};
use ruvector_gnn::{RuvectorLayer, differentiable_search};

let db = GraphDB::new();

let doc = NodeBuilder::new("doc1")
    .label("Document")
    .property("embedding", vec![0.1, 0.2, 0.3])
    .build();
db.create_node(doc)?;

// GNN layer
let layer = RuvectorLayer::new(128, 256, 4, 0.1);
let enhanced = layer.forward(&query, &neighbors, &weights);

use ruvector_raft::{RaftNode, RaftNodeConfig};
use ruvector_cluster::{ClusterManager, ConsistentHashRing};
use ruvector_replication::{SyncManager, SyncMode};

// Configure a 5-node Raft cluster
let config = RaftNodeConfig {
    node_id: "node-1".into(),
    cluster_members: vec!["node-1", "node-2", "node-3", "node-4", "node-5"]
        .into_iter().map(Into::into).collect(),
    election_timeout_min: 150,  // ms
    election_timeout_max: 300,  // ms
    heartbeat_interval: 50,     // ms
};
let raft = RaftNode::new(config);

// Auto-sharding with consistent hashing (150 virtual nodes per real node)
let ring = ConsistentHashRing::new(64, 3); // 64 shards, replication factor 3
let shard = ring.get_shard("my-vector-key");

// Multi-master replication with conflict resolution
let sync = SyncManager::new(SyncMode::SemiSync { min_replicas: 2 });

Project Structure

crates/
├── ruvector-core/           # Vector DB engine (HNSW, storage)
├── ruvector-graph/          # Graph DB + Cypher parser + Hyperedges
├── ruvector-gnn/            # GNN layers, compression, training
├── ruvector-tiny-dancer-core/  # AI agent routing (FastGRNN)
├── ruvector-*-wasm/         # WebAssembly bindings
└── ruvector-*-node/         # Node.js bindings (napi-rs)

Contributing

We welcome contributions! See CONTRIBUTING.md.

# Run tests
cargo test --workspace

# Run benchmarks
cargo bench --workspace

# Build WASM
cargo build -p ruvector-gnn-wasm --target wasm32-unknown-unknown

License

MIT License — free for commercial and personal use.

---

Built by rUv • GitHub • npm • Docs

Vector search that gets smarter over time.