Ruvector

Core Vector Database

Advanced Search & Retrieval (new in v2.1.0)

Continuous Training & Optimization (ADR-129)

Distributed Systems

AI & Machine Learning

Graph Transformers (8 verified modules)

Cognitive Containers (RVF format)

PostgreSQL Extension (230+ SQL functions)

Specialized Processing

Genomics & Health (rvDNA)

Platform & Integration

Examples & Applications

Cognitum v0 — The Agentic Appliance: Run tens of thousands of always-on agents at no incremental cost beyond the box. Learns in proximity to any signal — sensors, networks, machines — at near-zero power (~5 uW/inference, <15W total). Sub-millisecond response, 500x cheaper than cloud AI. No cloud bills, no per-agent fees. Like a nervous system, not a brain.

Cognitum v1 — The Agentic Chip: Same architecture on a single 257-core custom chip. Runs on less than 2W — a AA battery. Idle-to-8 GHz burst on demand, 2 TB/s interconnect, built-in encryption per core.

The Problem with Normal Search

Every vector database does the same thing: you give it a query, it finds the closest matches by distance, and returns them. The results never change. Search the same thing a thousand times and you get the same answer a thousand times — even if the first result was wrong and you always clicked the third one instead.

RuVector is different. It watches what happens after the search and uses that to make the next search better.

What the GNN Actually Does

Think of your data as a city map. Each vector is a building, and the HNSW index creates roads between similar buildings. A normal search just walks the shortest road to find nearby buildings.

The GNN is like a local who knows the shortcuts. It looks at the neighborhood around your destination and says: "Yes, that building is close, but this one over here is what you actually want." It learns these shortcuts by watching which results people actually use.

Technically, it works in three steps:

This entire process takes under 1ms thanks to SIMD acceleration (processing 4-8 numbers at once instead of one at a time).

Temporal Learning: Time Matters

Most AI systems treat every input as independent — they don't know or care what happened 5 seconds ago. RuVector tracks the sequence and timing of queries, which reveals patterns that individual queries can't:

Three Types of Learning

RuVector learns at three different speeds simultaneously:

The key innovation is EWC++ (Elastic Weight Consolidation) — it solves the "catastrophic forgetting" problem. Without it, learning new patterns would erase old ones. EWC++ identifies which weights are important for existing knowledge and protects them while still allowing new learning.

Why It's Fast: The HNSW Shortcut

The GNN doesn't run on your entire dataset. It only runs on the small subgraph of HNSW neighbors that are relevant to the current query — typically 10-50 nodes out of millions. This is why it adds under 1ms of latency instead of seconds:

1M vectors in your database
    → HNSW finds ~50 candidate neighbors        (0.3ms)
    → GNN re-ranks those 50 with attention       (0.4ms)
    → Return top K results                       (0.1ms)
    ──────────────────────────────────────────
    Total: <1ms, and results improve over time

What Improves Over Time

Three GNN Architectures (Pick One or Stack Them)

Runs Everywhere

The same GNN code runs natively in Rust, in Node.js via NAPI-RS bindings, and in the browser via WebAssembly. Models trained on the server can be exported and run client-side — a user's browser can do personalized re-ranking without sending queries to a server.

54+ specialized agents working together on complex software engineering tasks:

# Install
npx ruvflo@latest init --wizard

# Spawn a swarm
npx ruvflo@latest swarm init --topology hierarchical --max-agents 8

Key Features:

• SONA Learning: Sub-50ms adaptive routing, learns optimal patterns over time
• Queen-led Swarms: Byzantine fault-tolerant consensus with 5 protocols (Raft, Gossip, CRDT)
• HNSW Memory: 150x-12,500x faster pattern retrieval via RuVector
• 175+ MCP Tools: Native Model Context Protocol integration
• Cost Optimization: 3-tier routing extends Claude Code quota by 2.5x
• Security: AIDefence threat detection (<10ms), prompt injection blocking

66 self-learning agents with Claude Agent SDK, deployable to any cloud:

# Install
npx agentic-flow@latest

# Or with npm
npm install agentic-flow

Key Features:

• SONA Architecture: <1ms adaptive learning, +55% quality improvement
• Flash Attention: 2.49x JS speedup, 7.47x with NAPI bindings
• 213 MCP Tools: Swarm management, memory, GitHub integration
• Agent Booster: 352x faster code editing for simple transforms
• Multi-Provider: Claude, GPT, Gemini, Cohere, local models with failover
• Graph Reasoning: GNN query refinement with +12.4% recall improvement

Using AI to make the world a healthier place. rvDNA puts genomic diagnostics on any device — a phone, a laptop, a browser tab — in 12 milliseconds. No cloud, no GPU, no subscription. Private by default.

cargo add rvdna              # Rust
npm install @ruvector/rvdna  # JavaScript / TypeScript

• Rust crate: crates.io/crates/rvdna
• npm package: @ruvector/rvdna (NAPI-RS native + JS fallback)
• Source: examples/dna

RVF (RuVector Format) is a universal binary substrate that merges database, model, graph engine, kernel, and attestation into a single deployable file. A .rvf file can store vector embeddings, carry LoRA adapter deltas, embed GNN graph state, include a bootable Linux microkernel, run queries in a 5.5 KB WASM runtime, and prove every operation through a cryptographic witness chain — all in one file that runs anywhere from a browser to bare metal.

This is not a database format. It is an executable knowledge unit.

cargo install rvf-cli                          # CLI tool
cargo add rvf-runtime                          # Rust library
npm install @ruvector/rvf                      # TypeScript SDK
npx @ruvector/rvf-mcp-server --transport stdio # MCP server for AI agents

Rust crates (23): rvf-types rvf-wire rvf-manifest rvf-quant rvf-index rvf-crypto rvf-runtime rvf-kernel rvf-ebpf rvf-federation rvf-launch rvf-server rvf-import rvf-cli rvf-wasm rvf-solver-wasm rvf-node + 6 adapters (claude-flow, agentdb, ospipe, agentic-flow, rvlite, sona)

npm packages (6): @ruvector/rvf @ruvector/rvf-node @ruvector/rvf-wasm @ruvector/rvf-mcp-server @ruvector/ruvllm-wasm @ruvector/neural-trader-wasm

• Security Hardened RVF (examples/security_hardened.rvf) — 2.1 MB sealed artifact with 22 verified capabilities: TEE attestation (SGX/SEV-SNP/TDX/ARM CCA), AIDefence (injection/jailbreak/PII/exfil), hardened Linux microkernel, eBPF firewall, Ed25519 signing, 6-role RBAC, Coherence Gate, 30-entry witness chain, Paranoid policy, COW branching, audited k-NN. See ADR-042.
• Full documentation: crates/rvf/README.md
• ADR-030: Cognitive Container Architecture
• ADR-031: COW Branching & Real Containers
• ADR-042: Security RVF — AIDefence + TEE
• 56 runnable examples: examples/rvf/examples/

RuVix is a cognition kernel designed for agentic workloads. Where Linux thinks in files, processes, and POSIX syscalls, RuVix thinks in vectors, graphs, proofs, and capabilities. Every mutation is proof-gated — no cryptographic proof, no state change. Every resource access goes through unforgeable capability tokens. The result: a kernel that understands AI workloads natively.

┌─────────────────────────────────────────────────────────────────┐
│                    AGENT CONTROL PLANE                          │
│  Claude Code │ AgentDB │ Custom Agents │ RuVLLM Inference       │
├─────────────────────────────────────────────────────────────────┤
│                    RVF COMPONENT SPACE                          │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐           │
│  │ RuView   │ │ AgentDB  │ │ RuVLLM   │ │ Network  │ ...       │
│  │ Percept. │ │ Intelli. │ │ Infer.   │ │ Stack    │           │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘           │
│       │queue       │queue       │queue       │queue             │
├───────┴────────────┴────────────┴────────────┴──────────────────┤
│                    RUVIX COGNITION KERNEL                       │
│  Capability Manager │ Queue IPC │ Coherence-Aware Scheduler     │
│  Region Memory │ Proof Engine │ Vector/Graph Kernel Objects     │
└─────────────────────────────────────────────────────────────────┘

Phases A-F complete: 20+ crates, 1,200+ tests, 12 syscalls, full deterministic replay.

Developer Tools:

Distributed Testing (QEMU Swarm):

• Full documentation: crates/ruvix/README.md
• ADR-087: RuVix Cognition Kernel Architecture

ruvector-solver solves large math problems (like ranking pages, finding connections in graphs, or computing AI attention) in a fraction of the time traditional solvers need. Where standard approaches slow down dramatically with scale (doubling data = 8x slower), RuVector's 8 specialized algorithms barely notice the increase (doubling data = barely any slower). This is what powers the self-learning engine — fast graph math is what lets search improve in real time instead of waiting minutes to retrain.

cargo add ruvector-solver --features all-algorithms

Key optimizations: AVX2 SIMD SpMV, fused residual kernels, bounds-check elimination, arena allocator

Supporting crates:

• ruvector-attn-mincut — Min-cut gating as alternative to softmax attention

• ruvector-coherence — Coherence measurement for attention comparison

• ruvector-profiler — Memory, power, and latency benchmarking

• 177 tests | 5 Criterion benchmarks | WASM + NAPI bindings

• ADR documentation: docs/research/sublinear-time-solver/

ruvector-sparsifier maintains a compressed "shadow graph" that preserves the structural properties of a much larger graph. Think of it as a lossy summary: instead of storing every connection between millions of nodes, the sparsifier keeps only the most important edges — enough to answer questions about cuts, connectivity, and flow almost as accurately as the full graph, but with far less memory and compute.

It updates incrementally as edges are added or removed, so the compressed version stays current without rebuilding from scratch. A built-in auditor periodically checks that the approximation is still good; if quality drifts, it triggers an automatic rebuild.

cargo add ruvector-sparsifier

• 49 tests | Criterion benchmarks | WASM bindings
• Research: docs/research/spectral-sparsification/

Grouped comparison across 10 categories. RuVector is the only vector database that learns from usage, runs AI locally, and ships as a single self-booting file.

Performance & Storage

Search & Query

Self-Learning & AI — features unique to RuVector

Local AI — no cloud APIs needed

Graph Transformers — verified graph neural network modules

Math & Solvers

Distributed Systems

Cognitive Containers (RVF) — single-file deployment unique to RuVector

Platform & Deployment

Specialized Applications

Licensing & Cost

* Memory with PQ8 compression. Benchmarks on Apple M2 / Intel i7.

Core Capabilities

LLM Runtime

npm install @ruvector/ruvllm        # Node.js
npm install @ruvector/ruvllm-wasm   # Browser (WASM)
cargo add ruvllm                    # Rust

Platform & Edge

cargo install rvf-cli                    # RVF CLI (17 commands)
cargo add rvf-runtime                    # RVF Rust library
npm install @ruvector/rvf                # RVF TypeScript SDK
docker pull ruvnet/ruvector-postgres     # PostgreSQL
npm install rvlite                       # Edge DB
npx ruvector mcp start                   # MCP Server

Distributed Systems

cargo add ruvector-raft ruvector-cluster ruvector-replication

AI & ML

Specialized Processing

Self-Learning & Adaptation

npx @ruvector/cli hooks init      # Install self-learning hooks
npx @ruvector/cli hooks install   # Configure for Claude Code

Attention Mechanisms (@ruvector/attention)

Documentation: Attention Module Docs

Core Attention Mechanisms

Standard attention layers for sequence modeling and transformers.

Graph Attention Mechanisms

Attention layers designed for graph-structured data and GNNs.

Specialized Mechanisms

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

Hyperbolic Math Functions

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

Async & Batch Operations

Utilities for high-throughput inference and training optimization.

# 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]"

Coherence Gate (prime-radiant)

Coherence vs Confidence

Compute Ladder Routing

# Install coherence engine
cargo add prime-radiant

# With GPU acceleration
cargo add prime-radiant --features gpu,simd

Vector Search (HNSW)

15.7x faster than Python — 100% recall at every configuration.

SIMD Distance Calculations (NEON)

SIMD speedup: 2.9x (Euclidean/Dot Product), 5.95x (Cosine).

Quantization

Binary quantization: sub-nanosecond distance calculations.

Insert Throughput

Batch inserts: 30x faster than single inserts.

LLM Inference (ruvllm)

ef_search Tuning

100% recall across all ef_search values — choose speed vs safety margin.

Cloud Scale (Production)

Full results: bench_results/ | docs/benchmarks/ | Run: cargo bench -p ruvector-core

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:

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

AI & LLM Applications

// RAG with local LLM — zero cloud costs, search gets smarter over time
const db = new RuVector({ dimensions: 384 });
const llm = new RuvLLM({ model: 'ruvltra-small-0.5b-q4_k_m.gguf' });

const context = await db.search(questionEmbedding, { k: 5 }); // GNN-enhanced
const response = await llm.generate(`Context: ${context}\n\nQ: ${question}`);

Search & Discovery

// Hybrid search: keyword + semantic with filtering
const results = await db.search(query, {
  k: 10,
  filter: { category: 'electronics', price: { $lt: 500 } },
  hybridAlpha: 0.7,  // 70% semantic, 30% keyword
  rerank: true       // GNN-enhanced reranking
});

Recommendations & Knowledge Graphs

-- Neo4j-style graph query — runs inside RuVector, no separate database
MATCH (user:User {id: $userId})-[:VIEWED]->(item:Product)
MATCH (item)-[:SIMILAR_TO]->(rec:Product)
WHERE NOT (user)-[:PURCHASED]->(rec)
RETURN rec ORDER BY rec.gnn_score DESC LIMIT 10

Edge, Browser & IoT

// Full AI in the browser — no server required
import init, { ChatTemplateWasm, ChatMessageWasm, HnswRouterWasm, healthCheck } from '@ruvector/ruvllm-wasm';
await init();
console.log(healthCheck()); // true

// Format prompts for any model
const template = ChatTemplateWasm.detectFromModelId("meta-llama/Llama-3-8B");
const prompt = template.format([
  ChatMessageWasm.system("You are a helpful assistant."),
  ChatMessageWasm.user("Explain quantum computing"),
]);

// Route queries to the best agent in <1ms
const router = new HnswRouterWasm(384, 1000);
router.addPattern(embedding, "quantum-expert", "physics queries");
const result = router.route(queryEmbedding);
console.log(result.name, result.score); // "quantum-expert" 0.95

Self-Learning & Fine-Tuning

AI Safety & Coherence

Neuromorphic & Scientific Computing

Shared Brain at π.ruv.io

Distributed & Enterprise

-- Drop-in PostgreSQL replacement with self-improving search
CREATE EXTENSION ruvector;
CREATE TABLE documents (id SERIAL PRIMARY KEY, content TEXT, embedding VECTOR(384));
CREATE INDEX ON documents USING hnsw_gnn (embedding);

SELECT * FROM documents ORDER BY embedding <-> query_vector LIMIT 10;

Agentic Workflows

Getting Started

Core Components

Bindings & Integration

LLM & AI

Operations

Research

Architecture Decision Records (ADRs)

Core Packages

Graph & GNN

AI Routing & Attention

Learning & Neural

LLM Runtime

Distributed Systems

Edge & Standalone

Genomics & Health

RVF Cognitive Containers

Agentic & Synthetic Data

CLI Tools

WASM Packages

All crates are published to crates.io under the ruvector-* and rvf-* namespaces.

Core Crates

Graph & GNN

Attention Mechanisms

LLM Runtime (ruvllm)

Features: Candle backend, Metal/CUDA acceleration, Apple Neural Engine, GGUF support, SONA learning, BitNet 1.58-bit quantization (TL1 kernels, AVX2/WASM).

cargo add ruvllm --features inference-metal  # Mac with Metal
cargo add ruvllm --features inference-cuda   # NVIDIA GPU

RuvLTRA Models — Pre-trained GGUF models optimized for Claude Code workflows:

# Download and use
wget https://huggingface.co/ruv/ruvltra/resolve/main/ruvltra-small-0.5b-q4_k_m.gguf

Distributed Systems

AI Agent Routing (Tiny Dancer)

Router (Semantic Routing)

Hybrid Routing achieves 90% accuracy for agent routing using keyword-first strategy with embedding fallback. See Issue #122 for benchmarks and the training tutorials for fine-tuning guides.

Neural Trader

Six-layer pipeline treating the limit order book as a dynamic heterogeneous typed graph. See ADR-085 for architecture, ADR-086 for WASM bindings.

Dynamic Min-Cut (December 2025 Breakthrough)

First deterministic exact fully-dynamic min-cut with verified n^0.12 subpolynomial update scaling:

• Brain connectivity — Detect Alzheimer's markers by tracking neural pathway changes in milliseconds
• Network resilience — Predict outages before they happen, route around failures instantly
• AI agent coordination — Find communication bottlenecks in multi-agent systems
• Neural network pruning — Identify which connections can be removed without losing accuracy
• 448+ tests, 256-core parallel optimization, 8KB per core (compile-time verified)

use ruvector_mincut::{DynamicMinCut, Graph};

let mut graph = Graph::new();
graph.add_edge(0, 1, 10.0);
graph.add_edge(1, 2, 5.0);

let mincut = DynamicMinCut::new(&graph);
let (value, cut_edges) = mincut.compute();
// Updates in subpolynomial time as edges change

Quantum Coherence (ruQu)

ruQu Features: Real-time quantum coherence assessment, MWPM decoder integration, mincut-gated attention (50% FLOPs reduction).

use ruqu::{CoherenceGate, SyndromeFilter};

let gate = CoherenceGate::new();
let syndrome = gate.assess_coherence(&quantum_state)?;

Advanced Math & Inference

FPGA & Hardware Acceleration

Neuromorphic & Bio-Inspired Learning

Bio-inspired features:

• Spiking Neural Networks (SNNs) — 10-50x energy efficiency vs traditional ANNs
• BTSP Learning — Behavioral Time-Scale Synaptic Plasticity for rapid adaptation
• MicroLoRA — Sub-microsecond fine-tuning for per-operator learning
• Mamba SSM — State Space Model attention for linear-time sequences

Cognitive Robotics

use ruvector_robotics::planning::{astar, potential_field, PotentialFieldConfig};
use ruvector_robotics::bridge::OccupancyGrid;

let grid = OccupancyGrid::new(100, 100, 0.1);
let path = astar(&grid, (5, 5), (90, 90))?;
let cmd = potential_field(&[0.0, 0.0, 0.0], &[5.0, 3.0, 0.0], &[], &PotentialFieldConfig::default());

Self-Learning (SONA)

SONA Features: Two-tier LoRA adaptation, Elastic Weight Consolidation (EWC++), ReasoningBank for trajectory learning, runtime-adaptive learning for LLM routers.

Genomics & Health (rvDNA)

rvDNA Features: 12 ms full pipeline on 5 real human genes, Bayesian variant calling (155 ns/SNP), Horvath epigenetic clock, CYP2D6 pharmacogenomics, .rvdna binary format with pre-computed AI features, WASM support for browser-based diagnostics. Full README

RVF Cognitive Containers

RVF Features: Single-file cognitive containers that boot as Linux microservices, COW branching at cluster granularity, eBPF acceleration, witness chains, post-quantum signatures, federated transfer learning with differential privacy, 28 segment types. Full README

Formal Verification

Verification Features: 82-byte proof attestations, 3-tier gated proof routing (Reflex <10ns / Standard <1us / Deep <100us), FastTermArena with O(1) dedup, batch dimension verification (~11ns/vector), type-safe pipeline composition. Full README

use ruvector_verified::{ProofEnvironment, vector_types, proof_store};

let mut env = ProofEnvironment::new();
let proof = vector_types::prove_dim_eq(&mut env, 384, 384).unwrap();
let att = proof_store::create_attestation(&env, proof);
assert_eq!(att.to_bytes().len(), 82); // 82-byte formal witness

Self-booting example — the claude_code_appliance builds a complete AI dev environment as one file:

cd examples/rvf && cargo run --example claude_code_appliance

Final file: 5.1 MB single .rvf — boots Linux, serves queries, runs Claude Code. One file. Boots on QEMU/Firecracker. Runs SSH. Serves vectors. Installs Claude Code. Proves every step with a cryptographic witness chain.

Graph Transformer

Crates.io

What it does: Every time you modify a graph — adding a node, changing an edge weight, updating a vector — the graph transformer requires a formal proof that the operation is valid before it executes. Think of it like a type system for graph mutations: you can't accidentally corrupt your data because the system mathematically verifies every change.

On top of that proof layer, 8 specialized modules handle different aspects of graph intelligence:

# Rust
cargo add ruvector-graph-transformer --features full

# Node.js
npm install @ruvector/graph-transformer

use ruvector_graph_transformer::sublinear_attention::SublinearGraphAttention;
use ruvector_graph_transformer::config::SublinearConfig;

let attn = SublinearGraphAttention::new(128, SublinearConfig::default());
let outputs = attn.lsh_attention(&features).unwrap(); // O(n log n)

const { GraphTransformer } = require('@ruvector/graph-transformer');
const gt = new GraphTransformer();

// Every operation produces a proof receipt
const proof = gt.proveDimension(128, 128);
const attestation = gt.createAttestation(proof.proof_id); // 82 bytes

Personal AI Memory (OSpipe)

npm npm

npm install @ruvector/ospipe         # TypeScript SDK
npm install @ruvector/ospipe-wasm    # Browser WASM
cargo add ospipe                     # Rust crate

Replaces Screenpipe's SQLite/FTS5 backend with semantic vector search. Ask your computer what you saw, heard, and did -- with semantic understanding.

use ospipe::config::OsPipeConfig;
use ospipe::pipeline::ingestion::IngestionPipeline;
use ospipe::capture::CapturedFrame;

let config = OsPipeConfig::default();
let mut pipeline = IngestionPipeline::new(config)?;

// Ingest a screen capture
let frame = CapturedFrame::new_screen("Firefox", "Meeting Notes", "auth discussion: JWT with refresh tokens", 0);
pipeline.ingest(frame)?;

// Semantic search
let results = pipeline.search("what was the authentication discussion?", 5)?;

See OSpipe README for full documentation, TypeScript/WASM quickstart, and configuration reference.

Standalone Edge Database (rvLite)

rvLite Features: Powered by RuVector WASM, supports SQL/SPARQL/Cypher queries, ideal for IoT, mobile, and embedded systems.

PostgreSQL Extension

PostgreSQL Features: Drop-in pgvector replacement, GNN layers, hybrid search, multi-tenancy, self-healing, self-learning capabilities.

docker pull ruvnet/ruvector-postgres    # Docker image
cargo add ruvector-postgres             # Rust crate

Self-Learning Query DAG (ruvector-dag)

Make your queries faster automatically. RuVector DAG learns from every query execution and continuously optimizes performance—no manual tuning required.

• 7 Attention Mechanisms: Automatically selects the best strategy (Topological, Causal Cone, Critical Path, MinCut Gated, etc.)
• SONA Learning: Self-Optimizing Neural Architecture adapts in <100μs per query
• MinCut Control: Rising "tension" triggers automatic strategy switching and predictive healing
• 50-80% Latency Reduction: Queries improve over time without code changes

use ruvector_dag::{QueryDag, OperatorNode};
use ruvector_dag::attention::{AttentionSelector, SelectionPolicy};

let mut dag = QueryDag::new();
let scan = dag.add_node(OperatorNode::hnsw_scan(0, "vectors_idx", 64));
let filter = dag.add_node(OperatorNode::filter(1, "score > 0.5"));
dag.add_edge(scan, filter).unwrap();

// System learns which attention mechanism works best
let selector = AttentionSelector::new();
let scores = selector.select_and_apply(SelectionPolicy::Adaptive, &dag)?;

See ruvector-dag README for full documentation.

Temporal Tensor Store

High-performance temporal embedding storage optimized for AI agent memory systems:

Performance Targets: >100K writes/sec, <1ms p99 read latency, 4-32x compression (ADR-023)

See Domain-Driven Design for architecture details.

Delta Behavior (Behavioral Change Tracking)

Delta Behavior tracks how vectors change over time — the mathematics of systems that refuse to collapse. Incremental HNSW updates without full rebuilds, CRDT-based distributed consensus, and causal ordering for conflict-free replication.

Profiling & Diagnostics

CRV Signal Line Protocol

Maps CRV stages to ruvector subsystems:

• Stage I (Ideograms) → Poincaré ball hyperbolic embeddings
• Stage II (Sensory) → Multi-head attention vectors
• Stage III (Dimensional) → GNN graph topology
• Stage IV (Emotional) → SNN temporal encoding
• Stage V (Interrogation) → Differentiable search
• Stage VI (3D Model) → MinCut partitioning

Quantum Simulation Engine (ruQu)

npm

npm install @ruvector/ruqu-wasm    # Browser/Node.js
cargo add ruqu-core                # Rust

Pure Rust quantum simulation with 25-qubit WASM support:

use ruqu_core::{QuantumState, Gate, Circuit};

let mut circuit = Circuit::new(3);
circuit.add_gate(Gate::H, 0);           // Hadamard
circuit.add_gate(Gate::CNOT, 0, 1);     // Entangle
circuit.add_gate(Gate::CNOT, 1, 2);     // GHZ state

let state = circuit.execute()?;
let result = state.measure_all();        // Collapse to |000⟩ or |111⟩

See Quantum Engine ADRs for full documentation.

Distributed Systems (Raft & Replication)

Build distributed vector databases with strong consistency guarantees:

• Raft Consensus — Leader election, log replication, automatic failover
• Vector Clocks — Causal ordering for conflict detection
• Conflict Resolution — Last-Write-Wins, custom merge functions, CRDT support
• Change Data Capture — Stream changes to replicas in real-time
• Automatic Failover — Promote replicas on primary failure

import { RaftNode, ReplicaSet, VectorClock } from '@ruvector/raft';
import { ReplicationManager, ConflictStrategy } from '@ruvector/replication';

// Raft consensus cluster
const node = new RaftNode({
  nodeId: 'node-1',
  peers: ['node-2', 'node-3'],
  electionTimeout: [150, 300],
});

await node.start();
const entry = await node.propose({ op: 'insert', vector: embedding });

// Multi-master replication
const replicaSet = new ReplicaSet();
replicaSet.addReplica('primary', 'localhost:5001', 'primary');
replicaSet.addReplica('replica-1', 'localhost:5002', 'replica');

const manager = new ReplicationManager(replicaSet, {
  conflictStrategy: ConflictStrategy.LastWriteWins,
  syncMode: 'async',
});

await manager.write('vectors', { id: 'v1', data: embedding });

See npm/packages/raft/README.md and npm/packages/replication/README.md for full documentation.

Standalone Vector Database (rvLite)

Runs anywhere JavaScript runs — browsers, Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge:

• SQL + SPARQL + Cypher unified query interface
• Zero dependencies — thin orchestration over existing WASM crates
• Self-learning via SONA ReasoningBank integration

import { RvLite } from '@rvlite/wasm';

const db = await RvLite.create();
await db.sql(`CREATE TABLE docs (id SERIAL, embedding VECTOR(384))`);
await db.sparql(`SELECT ?s WHERE { ?s rdf:type ex:Document }`);
await db.cypher(`MATCH (d:Doc)-[:SIMILAR]->(r) RETURN r`);

Self-Optimizing Neural Architecture (SONA)

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);

crates.io npm

Make your queries faster automatically. RuVector DAG learns from every query execution and continuously optimizes performance—no manual tuning required.

What is RuVector DAG?

A self-learning query optimization system—like a "nervous system" for your database queries that:

1. Watches how queries execute and identifies bottlenecks
2. Learns which optimization strategies work best for different query patterns
3. Adapts in real-time, switching strategies when conditions change
4. Heals itself by detecting anomalies and fixing problems before they impact users

Unlike traditional query optimizers that use static rules, RuVector DAG learns from actual execution patterns and gets smarter over time.

Key Benefits

Use Cases

How It Works

Query comes in → DAG analyzes execution plan → Best attention mechanism selected
                                                          ↓
Query executes → Results returned → Learning system records what worked
                                                          ↓
                    Next similar query benefits from learned optimizations

The system maintains a MinCut tension score that acts as a health indicator. When tension rises, the system automatically switches to more aggressive optimization strategies and triggers predictive healing.

7 DAG Attention Mechanisms

Quick Start

Rust:

use ruvector_dag::{QueryDag, OperatorNode, OperatorType};
use ruvector_dag::attention::{TopologicalAttention, DagAttention};

// Build a query DAG
let mut dag = QueryDag::new();
let scan = dag.add_node(OperatorNode::hnsw_scan(0, "vectors_idx", 64));
let filter = dag.add_node(OperatorNode::filter(1, "score > 0.5"));
let result = dag.add_node(OperatorNode::new(2, OperatorType::Result));

dag.add_edge(scan, filter).unwrap();
dag.add_edge(filter, result).unwrap();

// Compute attention scores
let attention = TopologicalAttention::new(Default::default());
let scores = attention.forward(&dag).unwrap();

Node.js:

import { QueryDag, TopologicalAttention } from '@ruvector/rudag';

// Build DAG
const dag = new QueryDag();
const scan = dag.addNode({ type: 'hnsw_scan', table: 'vectors', k: 64 });
const filter = dag.addNode({ type: 'filter', condition: 'score > 0.5' });
dag.addEdge(scan, filter);

// Apply attention
const attention = new TopologicalAttention();
const scores = attention.forward(dag);
console.log('Attention scores:', scores);

Browser (WASM - 58KB):

<script type="module">
import init, { QueryDag, TopologicalAttention } from '@ruvector/rudag-wasm';

await init();
const dag = new QueryDag();
// ... same API as Node.js
</script>

SONA Learning Integration

SONA (Self-Optimizing Neural Architecture) runs post-query in background, never blocking execution:

use ruvector_dag::sona::{DagSonaEngine, SonaConfig};

let config = SonaConfig {
    embedding_dim: 256,
    lora_rank: 2,           // Rank-2 for <100μs updates
    ewc_lambda: 5000.0,     // Catastrophic forgetting prevention
    trajectory_capacity: 10_000,
};
let mut sona = DagSonaEngine::new(config);

// Pre-query: Get enhanced embedding (fast path)
let enhanced = sona.pre_query(&dag);

// Execute query...
let execution_time = execute_query(&dag);

// Post-query: Record trajectory (async, background)
sona.post_query(&dag, execution_time, baseline_time, "topological");

Self-Healing

Reactive (Z-score anomaly detection) + Predictive (rising MinCut tension triggers early intervention):

use ruvector_dag::healing::{HealingOrchestrator, AnomalyConfig, PredictiveConfig};

let mut orchestrator = HealingOrchestrator::new();

// Reactive: Z-score anomaly detection
orchestrator.add_detector("query_latency", AnomalyConfig {
    z_threshold: 3.0,
    window_size: 100,
    min_samples: 10,
});

// Predictive: Rising cut tension triggers early intervention
orchestrator.enable_predictive(PredictiveConfig {
    tension_threshold: 0.6,    // Intervene before 0.7 crisis
    variance_threshold: 1.5,   // Rising variance = trouble coming
    lookahead_window: 50,      // Predict 50 queries ahead
});

Query Convergence Example

A slow query converges over several runs:

[run 1] query: SELECT * FROM vectors WHERE embedding <-> $1 < 0.5
        attention: topological (default)
        mincut_tension: 0.23
        latency: 847ms (improvement: 0.4%)

[run 4] mincut_tension: 0.71 > 0.7 (THRESHOLD)
        --> switching attention: topological -> mincut_gated
        latency: 412ms (improvement: 51.5%)

[run 10] attention: mincut_gated
         mincut_tension: 0.22 (stable)
         latency: 156ms (improvement: 81.6%)

Performance Targets

Installation

# Rust
cargo add ruvector-dag

# Node.js
npm install @ruvector/rudag

# WASM (browser)
npm install @ruvector/rudag-wasm

Full Documentation: ruvector-dag README

crates.io npm downloads

A complete vector database that runs anywhere JavaScript runs — browsers, Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge Functions.

What is rvLite?

rvLite is a lightweight, standalone vector database that runs entirely in WebAssembly. It provides SQL, SPARQL, and Cypher query interfaces, along with graph neural networks and self-learning capabilities—all in under 3MB.

Key Features

Runs Everywhere

Architecture

┌─────────────────────────────────────────┐
│  RvLite (Orchestration)                 │
│  ├─ SQL executor                        │
│  ├─ SPARQL executor                     │
│  ├─ Cypher executor                     │
│  └─ Unified WASM API                    │
└──────────────┬──────────────────────────┘
               │ depends on (100% reuse)
               ▼
┌──────────────────────────────────────────┐
│  Existing WASM Crates                    │
├──────────────────────────────────────────┤
│  • ruvector-core (vectors, SIMD)         │
│  • ruvector-graph-wasm (Cypher)          │
│  • ruvector-gnn-wasm (GNN layers)        │
│  • sona (ReasoningBank learning)         │
│  • micro-hnsw-wasm (ultra-fast HNSW)     │
└──────────────────────────────────────────┘

Quick Start

import { RvLite } from '@ruvector/rvlite';

// Create database
const db = await RvLite.create();

// SQL with vector search
await db.sql(`
  CREATE TABLE docs (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(384)
  )
`);

await db.sql(`
  SELECT id, content, embedding <=> $1 AS distance
  FROM docs
  ORDER BY distance
  LIMIT 10
`, [queryVector]);

// Cypher graph queries
await db.cypher(`
  CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})
`);

// SPARQL RDF queries
await db.sparql(`
  SELECT ?name WHERE {
    ?person foaf:name ?name .
  }
`);

// GNN embeddings
const embeddings = await db.gnn.computeEmbeddings('social_network', [
  db.gnn.createLayer('gcn', { inputDim: 128, outputDim: 64 })
]);

// Self-learning with ReasoningBank
await db.learning.recordTrajectory({ state: [0.1], action: 2, reward: 1.0 });
await db.learning.train({ algorithm: 'q-learning', iterations: 1000 });

Size Budget

Installation

# npm
npm install @ruvector/rvlite

# Rust
cargo add rvlite

# Build WASM
wasm-pack build --target web --release

Full Documentation: rvlite README

npm

Share, Contribute, Compute Together — A distributed computing platform that enables collective resource sharing for AI workloads.

What is Edge-Net?

Edge-Net creates a collective computing network where participants share idle browser resources to power distributed AI workloads:

┌─────────────────────────────────────────────────────────────────────────────┐
│              EDGE-NET: COLLECTIVE AI COMPUTING NETWORK                      │
├─────────────────────────────────────────────────────────────────────────────┤
│   ┌─────────────┐       ┌─────────────┐       ┌─────────────┐              │
│   │  Your       │       │  Collective │       │  AI Tasks   │              │
│   │  Browser    │◄─────►│  Network    │◄─────►│  Completed  │              │
│   │  (Idle CPU) │  P2P  │  (1000s)    │       │  for You    │              │
│   └─────────────┘       └─────────────┘       └─────────────┘              │
│         │                     │                     │                       │
│   Contribute ──────► Earn rUv Units ──────► Use for AI Workloads           │
└─────────────────────────────────────────────────────────────────────────────┘

How It Works

Why Collective AI Computing?

AI Intelligence Stack

┌─────────────────────────────────────────────────────────────────────────────┐
│                        AI INTELLIGENCE STACK                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                    MicroLoRA Adapter Pool (from ruvLLM)              │   │
│  │  • LRU-managed pool (16 slots) • <50µs rank-1 forward               │   │
│  │  • 4-bit/8-bit quantization    • 2,236+ ops/sec                     │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                    SONA - Self-Optimizing Neural Architecture         │   │
│  │  • Instant Loop: Per-request MicroLoRA adaptation                    │   │
│  │  • Background Loop: Hourly K-means consolidation                     │   │
│  │  • Deep Loop: Weekly EWC++ (prevents catastrophic forgetting)        │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│  ┌──────────────────────┐  ┌──────────────────────┐  ┌─────────────────┐  │
│  │   HNSW Vector Index  │  │  Federated Learning  │  │ ReasoningBank   │  │
│  │   • 150x faster      │  │  • Byzantine tolerant│  │ • Pattern learn │  │
│  │   • O(log N) search  │  │  • Diff privacy      │  │ • 87x energy    │  │
│  └──────────────────────┘  └──────────────────────┘  └─────────────────┘  │
└─────────────────────────────────────────────────────────────────────────────┘

Core AI Tasks

Pi-Key Identity System

Ultra-compact cryptographic identity using mathematical constants:

Self-Optimizing Features

Quick Start

Add to Your Website:

<script type="module">
  import init, { EdgeNetNode, EdgeNetConfig } from '@ruvector/edge-net';

  async function joinCollective() {
    await init();

    // Join the collective
    const node = new EdgeNetConfig('my-website')
      .cpuLimit(0.3)          // Contribute 30% CPU when idle
      .memoryLimit(256 * 1024 * 1024)  // 256MB max
      .respectBattery(true)   // Reduce on battery
      .build();

    node.start();

    // Monitor participation
    setInterval(() => {
      console.log(`Contributed: ${node.ruvBalance()} rUv`);
    }, 10000);
  }

  joinCollective();
</script>

Use the Collective's AI Power:

// Submit an AI task to the collective
const result = await node.submitTask('vector_search', {
  query: embeddings,
  k: 10,
  index: 'shared-knowledge-base'
}, 5);  // Spend up to 5 rUv

console.log('Similar items:', result);

Monitor Your Contribution:

const stats = node.getStats();
console.log(`
  rUv Earned: ${stats.ruv_earned}
  rUv Spent: ${stats.ruv_spent}
  Tasks Completed: ${stats.tasks_completed}
  Reputation: ${(stats.reputation * 100).toFixed(1)}%
`);

Key Features

Installation

# npm
npm install @ruvector/edge-net

# Or include directly
<script src="https://unpkg.com/@ruvector/edge-net"></script>

Full Documentation: edge-net README

npm downloads

AI-Powered Synthetic Data Generation at Scale — Generate unlimited, high-quality synthetic data for training AI models, testing systems, and building robust agentic applications.

Why Agentic-Synth?

Key Features

Data Generation Types

Quick Start

# Install
npm install @ruvector/agentic-synth

# Or run instantly with npx
npx @ruvector/agentic-synth generate --count 100

# Interactive mode
npx @ruvector/agentic-synth interactive

Basic Usage

import { AgenticSynth } from '@ruvector/agentic-synth';

// Initialize with your preferred model
const synth = new AgenticSynth({
  model: 'gemini-pro',
  apiKey: process.env.GEMINI_API_KEY
});

// Generate structured data
const users = await synth.generate({
  schema: {
    name: 'string',
    email: 'email',
    age: 'number:18-65',
    role: ['admin', 'user', 'guest']
  },
  count: 1000
});

// Generate time-series data
const stockData = await synth.timeSeries({
  fields: ['open', 'high', 'low', 'close', 'volume'],
  interval: '1h',
  count: 500,
  volatility: 0.02
});

// Stream large datasets
for await (const batch of synth.stream({ count: 100000, batchSize: 1000 })) {
  await processData(batch);
}

Self-Learning with DSPy

import { AgenticSynth, DSPyOptimizer } from '@ruvector/agentic-synth';

// Enable self-learning optimization
const synth = new AgenticSynth({
  model: 'gemini-pro',
  optimizer: new DSPyOptimizer({
    learningRate: 0.1,
    qualityThreshold: 0.85
  })
});

// Quality improves automatically over time
const data = await synth.generate({
  schema: { ... },
  count: 1000,
  optimize: true  // Enable learning
});

console.log(`Quality score: ${data.metrics.quality}`);
// First run: 0.72
// After 100 runs: 0.94 (+25% improvement)

Performance

Ecosystem Integration

Installation

# npm
npm install @ruvector/agentic-synth

# Examples package (50+ production examples)
npm install @ruvector/agentic-synth-examples

Full Documentation: agentic-synth README

npm downloads

Production-ready neural trading system combining state-of-the-art ML for automated trading, sports betting, and portfolio management. Zero external ML dependencies, sub-millisecond latency.

Core AI/ML Engines

Why Neural Trader?

Research-Backed Algorithms

Quick Start

import { KellyCriterion, HybridLSTMTransformer, DRLPortfolioManager } from 'neural-trader';

// Kelly position sizing
const kelly = new KellyCriterion();
const stake = kelly.calculateStake(9000, 0.55, 2.0, 0.2);  // 1/5th Kelly
// → $180 recommended stake (2% of bankroll)

// LSTM-Transformer prediction
const model = new HybridLSTMTransformer({
  lstm: { hiddenSize: 64, layers: 2 },
  transformer: { heads: 4, layers: 2 }
});
const prediction = model.predict(candles);
// → { signal: 'BUY', confidence: 0.73, direction: 'bullish' }

// DRL portfolio allocation
const manager = new DRLPortfolioManager({ numAssets: 10 });
await manager.train(marketData, { episodes: 100 });
const allocation = manager.getAction(currentState);
// → [0.15, 0.12, 0.08, ...] optimal weights

Use Cases

Package Ecosystem (20+)

CLI Interface

# Real-time trading
node cli.js run --strategy=hybrid --symbol=AAPL --capital=100000

# Backtest historical performance
node cli.js backtest --days=252 --capital=50000 --strategy=drl

# Paper trading simulation
node cli.js paper --capital=100000 --strategy=sentiment

# Performance benchmarks
node cli.js benchmark --iterations=100

Exotic Examples

Performance

Installation

# npm
npm install neural-trader

# Full ecosystem
npm install @neural-trader/core @neural-trader/strategies @neural-trader/mcp

Full Documentation: neural-trader README

npm License

What is Agentic-Jujutsu?

Agentic-Jujutsu is a quantum-resistant, self-learning version control system designed for AI agents. It combines lock-free concurrent operations with ReasoningBank trajectory learning for continuous improvement.

Key Features

Quick Start

# Install
npm install agentic-jujutsu

# Basic usage
npx agentic-jujutsu

import { JjWrapper } from 'agentic-jujutsu';

const jj = new JjWrapper();

// Start learning trajectory
jj.startTrajectory('Implement feature X');

// Make changes and commit
await jj.newCommit('Add authentication module');
jj.addToTrajectory();

// Finalize with success score
jj.finalizeTrajectory(0.9, 'Feature implemented successfully');

// Get AI-powered suggestions
const suggestions = await jj.getSuggestions();

Multi-Agent Coordination

// Concurrent commits without locks
const agents = ['agent-1', 'agent-2', 'agent-3'];
await Promise.all(agents.map(agent =>
  jj.newCommit(`Changes from ${agent}`)
));
// All commits succeed - no lock waiting!

Full Documentation: agentic-jujutsu README

crates.io docs.rs License

What is SciPix?

SciPix is a blazing-fast, memory-safe OCR engine written in pure Rust, purpose-built for scientific documents, mathematical equations, and technical diagrams.

*API latency, not processing time

Key Features

Quick Start

# Add to Cargo.toml
cargo add ruvector-scipix

# With features
ruvector-scipix = { version = "0.1.16", features = ["ocr", "math", "optimize"] }

use ruvector_scipix::{SciPixOcr, OcrConfig};

// Initialize OCR engine
let ocr = SciPixOcr::new(OcrConfig::default())?;

// Process scientific image
let result = ocr.process_image("equation.png")?;
println!("LaTeX: {}", result.latex);
println!("Confidence: {:.2}%", result.confidence * 100.0);

Use Cases

• Academic Paper Digitization - Extract text and equations from scanned research papers
• Math Homework Assistance - Convert handwritten equations to LaTeX for AI tutoring
• Technical Documentation - Process engineering diagrams and scientific charts
• AI/LLM Integration - Feed scientific content to language models via MCP

Full Documentation: scipix README

What is Meta-Cognition SNN?

A hybrid AI architecture combining Spiking Neural Networks (SNN), SIMD-optimized vector operations, and 5 attention mechanisms with meta-cognitive self-discovery capabilities.

SIMD Performance

5 Attention Mechanisms

Quick Start

# Install and run demos
cd examples/meta-cognition-spiking-neural-network
npm install
node demos/run-all.js

const { createFeedforwardSNN, rateEncoding } = require('./demos/snn/lib/SpikingNeuralNetwork');

// Create SNN with SIMD optimization
const snn = createFeedforwardSNN([100, 50, 10], {
  dt: 1.0,
  tau: 20.0,
  a_plus: 0.005,
  lateral_inhibition: true
});

// Train with STDP
const input = rateEncoding(pattern, snn.dt, 100);
snn.step(input);

6 Emergent Discoveries

1. Multi-Scale Attention Hierarchy (Novelty: 5/5)
2. Spike Synchronization Patterns
3. Attention-Gated Spike Propagation
4. Temporal Coherence Emergence
5. Emergent Sparsity (80% fewer active neurons)
6. Meta-Plasticity (faster learning on later tasks)

Full Documentation: meta-cognition-snn README

Rust License HuggingFace

What is RuvLLM?

RuvLLM is a self-learning language model orchestration system that combines frozen foundation models with adaptive memory and intelligent routing. Unlike traditional LLMs that rely solely on static parameters, RuvLLM continuously improves from every interaction.

"The intelligence is not in one model anymore. It is in the loop."

SONA: 3-Tier Temporal Learning

Core Components

Performance (CPU-Only)

Quick Start

use ruvllm::{RuvLLMOrchestrator, OrchestratorConfig};

// Initialize orchestrator
let config = OrchestratorConfig::default();
let orchestrator = RuvLLMOrchestrator::new(config)?;

// Query with automatic learning
let response = orchestrator.query("Explain quantum entanglement").await?;
println!("{}", response.text);

// Response improves over time as SONA learns patterns

Federated Learning

use rvf_federation::{ExportBuilder, DiffPrivacyEngine, FederationPolicy};

// Build a privacy-preserving federated export
let mut dp = DiffPrivacyEngine::gaussian(1.0, 1e-5, 1.0, 10.0)?;
let export = ExportBuilder::new("contributor_pseudo".into(), "code_review".into())
    .add_priors(local_engine.extract_priors())
    .add_weights(sona_weights)
    .with_policy(FederationPolicy::default())  // quality gate + min observations
    .build(&mut dp)?;                          // PII strip → DP noise → manifest

// Import and merge federated learning from another contributor
let merger = ImportMerger::new();
merger.validate(&remote_export)?;              // signature + witness chain check
merger.merge_priors(&mut local, &remote_export.priors, 1);  // version-aware merge

See rvf-federation for FedAvg/FedProx aggregation, Byzantine tolerance, RDP privacy accounting, and PII stripping pipeline.

Dynamic Embedding Fine-Tuning

RuvLLM's adaptive learning system enables real-time model improvement without retraining.

// Contrastive fine-tuning for agent routing
import { ContrastiveTrainer } from '@ruvector/ruvllm';

const trainer = new ContrastiveTrainer({
  margin: 0.5,
  hardNegativeRatio: 0.7
});

// Learn: task → correct agent, not wrong agent
trainer.addTriplet(taskEmb, correctAgentEmb, wrongAgentEmb, true);
const model = trainer.train();

// Task-specific adapter hot-swapping
use ruvllm::lora::RuvLtraAdapters;

let adapters = RuvLtraAdapters::new();
let coder = adapters.create_lora("coder", 768)?;      // Rank 16, code patterns
let security = adapters.create_lora("security", 768)?; // Rank 16, vulnerability detection

// Hot-swap at runtime without model reload
orchestrator.set_adapter(coder);
let code_response = orchestrator.query("Implement binary search").await?;

orchestrator.set_adapter(security);
let audit_response = orchestrator.query("Audit this code for vulnerabilities").await?;

Advanced Features

• SIMD Inference: AVX2/AVX512/SSE4.1 optimization
• Q4 Quantization: 4-bit weights for memory efficiency
• HuggingFace Export: Export LoRA weights and preference pairs
• Multi-Model Routing: SmolLM, Qwen2, TinyLlama selection
• WASM Support: Run SONA in browsers and edge devices
• Browser Fine-Tuning: MicroLoRA WASM with localStorage persistence

Full Documentation: ruvLLM README | Fine-Tuning Guide | Task Adapters

What is REFRAG?

REFRAG implements the Compress-Sense-Expand architecture from arXiv:2509.01092, achieving ~30x RAG latency reduction by storing pre-computed representation tensors instead of raw text.

Architecture

┌────────────────┐    ┌────────────────┐    ┌────────────────┐
│   COMPRESS     │───▶│     SENSE      │───▶│    EXPAND      │
│    Layer       │    │     Layer      │    │    Layer       │
└────────────────┘    └────────────────┘    └────────────────┘

Binary tensor         Policy network        Dimension projection
storage with          decides COMPRESS      (768 → 4096 dims)
zero-copy access      vs EXPAND

Compression Strategies

Policy Networks

Quick Start

# Run demo
cargo run --bin refrag-demo

# Run benchmarks
cargo run --bin refrag-benchmark --release

use refrag_pipeline_example::{RefragStore, RefragEntry};

// Create REFRAG-enabled store
let store = RefragStore::new(384, 768)?;

// Insert with representation tensor
let entry = RefragEntry::new("doc_1", search_vector, "The quick brown fox...")
    .with_tensor(tensor_bytes, "llama3-8b");
store.insert(entry)?;

// Hybrid search (policy-based COMPRESS/EXPAND)
let results = store.search_hybrid(&query, 10, Some(0.85))?;

for result in results {
    match result.response_type {
        RefragResponseType::Compress => {
            // Tensor directly injectable into LLM context
            println!("Tensor: {} dims", result.tensor_dims.unwrap());
        }
        RefragResponseType::Expand => {
            // Original text when full context needed
            println!("Text: {}", result.content.unwrap());
        }
    }
}

Target LLM Dimensions

Full Documentation: refrag-pipeline README

Rust Tests Coverage

What is 7sense?

7sense transforms bird calls into navigable geometric space using cutting-edge AI and vector search. It converts audio recordings of bird songs into rich, searchable embeddings using Perch 2.0 neural networks and ultra-fast HNSW indexing.

Performance Targets

9 Rust Crates

Quick Start

# Build and run
cd examples/vibecast-7sense
cargo build --release
cargo run -p sevensense-api --release

use sevensense_audio::AudioProcessor;
use sevensense_embedding::EmbeddingPipeline;
use sevensense_vector::HnswIndex;

// Load and process audio
let processor = AudioProcessor::new(Default::default());
let segments = processor.process_file("recording.wav").await?;

// Generate Perch 2.0 embeddings
let pipeline = EmbeddingPipeline::new(Default::default()).await?;
let emb