@ruvector/edge-full

![WASM]()

The Complete Edge AI Toolkit

Run AI agent swarms, graph databases, neural networks, workflow engines, and ONNX inference - all in the browser, all for free.

@ruvector/edge-full is the batteries-included version of the RuVector edge computing platform. It bundles six powerful WASM modules into a single package, giving you everything you need to build sophisticated distributed AI systems that run entirely on user devices.

$3

| Module | Size | What It Does |
|--------|------|--------------|
| Edge Core | 364KB | Cryptographic identity (Ed25519), AES-256-GCM encryption, HNSW vector search, Raft consensus, spiking neural networks, post-quantum signatures |
| Graph DB | 288KB | Neo4j-style graph database with Cypher query language, relationship modeling, traversal algorithms |
| RVLite | 260KB | Multi-query vector database supporting SQL, SPARQL, and Cypher - semantic search with familiar syntax |
| SONA | 238KB | Self-Optimizing Neural Architecture - LoRA fine-tuning, EWC++, ReasoningBank for adaptive learning |
| DAG | 132KB | Directed acyclic graph engine for workflow orchestration, dependency resolution, topological execution |
| ONNX | 7.1MB | Full ONNX inference engine with 6 pre-trained HuggingFace embedding models, parallel worker support |

Total: 1.28MB core + 7.1MB optional ONNX = 8.4MB complete

$3

- Zero Infrastructure Cost: Everything runs in the browser. No servers, no API keys, no monthly bills.
- Complete Feature Set: Vector search + graph database + neural networks + workflow engine + embeddings. All in one package.
- True P2P: Agents communicate directly via WebRTC, GUN.js, libp2p, or Nostr. No central server required.
- Self-Learning: SONA provides continuous improvement through LoRA fine-tuning and experience replay.
- Production-Ready: Post-quantum cryptography, Byzantine fault tolerance, encrypted communication.

Quick Start

``bash
npm install @ruvector/edge-full
`

$3

`javascript
import { initAll } from '@ruvector/edge-full';

// Initialize all core modules (excludes ONNX for faster startup)
const { edge, graph, rvlite, sona, dag } = await initAll();

// Create agent identity
const identity = new edge.WasmIdentity.generate();
console.log(Agent: ${identity.agent_id()});

// Build a knowledge graph
const graphStore = new graph.WasmGraphStore();
graphStore.run_cypher("CREATE (a:Agent {id: 'agent-1', type: 'researcher'})");

// Vector search with SQL
const db = new rvlite.Database();
db.execute("CREATE TABLE memories (id TEXT, embedding BLOB)");

// Self-learning neural routing
const sonaEngine = new sona.SonaEngine();
sonaEngine.route_request({ task: "analyze code", context: "rust" });

// Workflow orchestration
const workflow = new dag.Dag();
workflow.add_node("fetch");
workflow.add_node("process");
workflow.add_edge("fetch", "process");
`

$3

`javascript
import { initModules } from '@ruvector/edge-full';

// Only load what you need
const { edge, graph } = await initModules(['edge', 'graph']);

// Or import modules directly
import init from '@ruvector/edge-full/edge';
import graphInit, { WasmGraphStore } from '@ruvector/edge-full/graph';

await init();
await graphInit();
`

$3

`javascript
import onnxInit, { WasmEmbedder } from '@ruvector/edge-full/onnx';

await onnxInit();

const embedder = new WasmEmbedder();
await embedder.load_model('all-MiniLM-L6-v2'); // 384-dimensional embeddings

const embedding = await embedder.embed("The quick brown fox");
console.log(Dimensions: ${embedding.length}); // 384
`

Module Deep Dive

$3

`javascript
import init, {
WasmIdentity, // Ed25519 key pairs
WasmCrypto, // AES-256-GCM encryption
WasmHnswIndex, // 150x faster vector search
WasmRaftNode, // Distributed consensus
WasmHybridKeyPair, // Post-quantum signatures
WasmSpikingNetwork // Bio-inspired neural nets
} from '@ruvector/edge-full/edge';

await init();

// Create cryptographic identity
const identity = WasmIdentity.generate();
const signature = identity.sign(new TextEncoder().encode("hello"));
const verified = identity.verify(new TextEncoder().encode("hello"), signature);

// Encrypted communication
const crypto = new WasmCrypto();
const encrypted = crypto.encrypt(data, key, nonce);

// HNSW vector index (150x faster than brute force)
const index = new WasmHnswIndex(384, 16, 200); // dimensions, M, ef_construction
index.add(0, embedding1);
index.add(1, embedding2);
const neighbors = index.search(queryVector, 10); // top 10 results

// Raft consensus for distributed state
const node = new WasmRaftNode('node-1', ['node-1', 'node-2', 'node-3']);
node.start_election();
`

$3

`javascript
import graphInit, { WasmGraphStore } from '@ruvector/edge-full/graph';

await graphInit();

const store = new WasmGraphStore();

// Create nodes and relationships
store.run_cypher(
CREATE (alice:Person {name: 'Alice', role: 'researcher'})
CREATE (bob:Person {name: 'Bob', role: 'developer'})
CREATE (alice)-[:COLLABORATES_WITH]->(bob)
);

// Query the graph
const results = store.run_cypher(
MATCH (p:Person)-[:COLLABORATES_WITH]->(colleague)
RETURN p.name, colleague.name
);

// Complex traversals
const paths = store.run_cypher(
MATCH path = (start:Person)-[:KNOWS*1..3]->(end:Person)
WHERE start.name = 'Alice'
RETURN path
);
`

$3

`javascript
import rvliteInit, { Database } from '@ruvector/edge-full/rvlite';

await rvliteInit();

const db = new Database();

// SQL for familiar operations
db.execute(
CREATE TABLE documents (
id TEXT PRIMARY KEY,
content TEXT,
embedding BLOB
)
);

db.execute(INSERT INTO documents VALUES (?, ?, ?),
['doc-1', 'Machine learning basics', embedding1]);

// Semantic search
const similar = db.execute(
SELECT * FROM documents
ORDER BY vector_distance(embedding, ?)
LIMIT 5
, [queryEmbedding]);

// SPARQL for knowledge graphs
const sparqlResults = db.sparql(
PREFIX ex:
SELECT ?name ?type
WHERE {
?entity ex:type ?type .
?entity ex:name ?name .
FILTER (?type = "Agent")
}
);
`

$3

`javascript
import sonaInit, { SonaEngine, ReasoningBank } from '@ruvector/edge-full/sona';

await sonaInit();

const engine = new SonaEngine();
const reasoningBank = new ReasoningBank();

// Route tasks to best agent
const decision = await engine.route_request({
task: "review pull request",
context: { language: "rust", complexity: "high" },
available_agents: [
{ id: "agent-1", capabilities: ["rust", "code-review"] },
{ id: "agent-2", capabilities: ["testing", "qa"] }
]
});

console.log(Routed to: ${decision.selected_agent});
console.log(Confidence: ${decision.confidence});

// Learn from outcomes
reasoningBank.record_trajectory({
state: "review pull request",
action: decision.selected_agent,
reward: 0.95, // positive outcome
timestamp: Date.now()
});

// Apply LoRA fine-tuning
await engine.apply_lora_update({
positive_examples: ["rust expert handled rust code well"],
negative_examples: []
});
`

$3

`javascript
import dagInit, { Dag } from '@ruvector/edge-full/dag';

await dagInit();

const workflow = new Dag();

// Define workflow steps
workflow.add_node("fetch_data");
workflow.add_node("validate");
workflow.add_node("transform");
workflow.add_node("store");

// Define dependencies
workflow.add_edge("fetch_data", "validate");
workflow.add_edge("validate", "transform");
workflow.add_edge("transform", "store");

// Get execution order
const order = workflow.topological_sort();
console.log(order); // ["fetch_data", "validate", "transform", "store"]

// Check for cycles
if (workflow.has_cycle()) {
console.error("Invalid workflow!");
}

// Get dependencies for a node
const deps = workflow.get_dependencies("transform");
console.log(deps); // ["validate"]
`

$3

`javascript
import onnxInit, { WasmEmbedder } from '@ruvector/edge-full/onnx';

await onnxInit();

const embedder = new WasmEmbedder();

// Available models:
// - all-MiniLM-L6-v2 (384D, fastest)
// - all-MiniLM-L12-v2 (384D, better quality)
// - bge-small-en-v1.5 (384D, SOTA)
// - bge-base-en-v1.5 (768D, highest quality)
// - e5-small-v2 (384D, search/retrieval)
// - gte-small (384D, multilingual)

await embedder.load_model('bge-small-en-v1.5');

// Single embedding
const embedding = await embedder.embed("What is machine learning?");

// Batch processing (3.8x faster with parallel workers)
const embeddings = await embedder.embed_batch([
"First document about AI",
"Second document about ML",
"Third document about neural networks"
]);

// Compute similarity
function cosineSimilarity(a, b) {
let dot = 0, normA = 0, normB = 0;
for (let i = 0; i < a.length; i++) {
dot += a[i] * b[i];
normA += a[i] * a[i];
normB += b[i] * b[i];
}
return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

const similarity = cosineSimilarity(embeddings[0], embeddings[1]);
`

Interactive Generator

The package includes an interactive HTML generator that creates ready-to-use code for any combination of:

- 6 Network Topologies: Mesh, Star, Hierarchical, Ring, Gossip, Sharded
- 4 P2P Transports: GUN.js, WebRTC, libp2p, Nostr
- 6 Use Cases: AI Assistants, Data Pipeline, Gaming, IoT, Marketplace, Research
- 6 WASM Modules: Edge, Graph, RVLite, SONA, DAG, ONNX
- 8 Core Features: Identity, Encryption, HNSW, Semantic Match, Raft, Post-Quantum, Spiking NN, Compression
- 7 Exotic Patterns: MCP Tools, Byzantine Fault, Quantum Resistant, Neural Consensus, Swarm Intelligence, Self-Healing, Emergent Behavior

Open generator.html in your browser to start generating code.

Bundle Size Comparison

| Configuration | Size | Use Case |
|--------------|------|----------|
| Edge only | 364KB | Minimal crypto + vectors |
| Edge + Graph | 652KB | Agent relationships |
| Edge + RVLite | 624KB | SQL-style queries |
| Edge + SONA | 602KB | Self-learning routing |
| All Core | 1.28MB | Full capabilities |
| With ONNX | 8.4MB | ML embeddings |

Free Infrastructure

All components use free public infrastructure:

| Service | Free Providers |
|---------|----------------|
| P2P Relay | GUN.js (gun-manhattan, gun-us-west) |
| STUN | Google, Twilio, Cloudflare |
| Signaling | PeerJS Cloud (free tier) |
| Nostr Relays | nostr.wine, relay.damus.io, nos.lol |

Performance

| Module | Operation | Performance |
|--------|-----------|-------------|
| Edge | Ed25519 sign/verify | 50,000 ops/sec |
| Edge | AES-256-GCM | 1 GB/sec |
| Edge | HNSW search | 150x faster than brute force |
| Graph | Cypher query | <1ms for simple queries |
| RVLite | Vector search | Sub-millisecond |
| SONA | Route decision | <5ms |
| ONNX | Single embed | ~20ms (MiniLM-L6) |
| ONNX | Batch embed | 3.8x speedup with workers |

Examples

See the /examples` directory for:

- Multi-agent chat with shared memory
- Distributed RAG pipeline
- Real-time multiplayer coordination
- IoT sensor swarm
- Knowledge graph construction
- Workflow automation

License

MIT License - Use freely for any purpose.

Links

- npm
- GitHub
- @ruvector/edge (lightweight version)