Benchmarks

Corpus & Methodology

Mixed real-world corpus across three domains — general knowledge, scientific literature, and long-form prose.

Chunking: 400 words / chunk, 50-word overlap. Embedding: BAAI/bge-m3 (1024-dim) on NVIDIA A40. Recall: 1,000 queries vs exact cosine top-k ground truth.

Retrieval Accuracy

BGE-M3 · 1024-bit binary fingerprints

BGE-base · 768-bit and 256-bit (PCA)

Index Size — 500,000 Chunks

Index only — document text stored separately and equally in all systems.

Download — Verify It Yourself

All files generated from the same 500,000 chunks. Download NodeMind + float32 RAG side by side to verify compression ratios yourself.

Verify compression in Python

# pip install sentence-transformers (only needed for query, not verification)
import pickle

with open("nm_bgem3_index.pkl", "rb") as f: nm  = pickle.load(f)
with open("rag_bgem3_index.pkl","rb") as f: rag = pickle.load(f)

nm_mb  = nm["fps"].nbytes         / 1e6   # → 64
rag_mb = rag["embeddings"].nbytes  / 1e6   # → 2048
ratio  = rag["embeddings"].nbytes // nm["fps"].nbytes   # → 32

print(f"NodeMind : {nm_mb:.0f} MB")
print(f"Float32  : {rag_mb:.0f} MB")
print(f"Ratio    : {ratio}×")

# BGE-base 256-bit (96×)
with open("nm_bgebase256_index.pkl","rb") as f: nm96 = pickle.load(f)
# nm96["fps"] shape: (500000, 32)  →  16 MB
# float32 baseline: 500000 × 768 × 4 = 1,536 MB  →  96×

Run a query

import numpy as np
from sentence_transformers import SentenceTransformer

model  = SentenceTransformer("BAAI/bge-m3")
fps    = nm["fps"]
with open("corpus.pkl","rb") as f: corpus = pickle.load(f)
chunks = corpus["chunks"]

POPCOUNT = np.array([bin(i).count('1') for i in range(256)], dtype=np.int32)

def query_nodemind(text, top_k=5):
    emb  = model.encode([text], normalize_embeddings=True)[0]
    q_fp = _binarise(emb, nm)  # binarisation uses index metadata (patent-protected)
    dists = POPCOUNT[np.bitwise_xor(fps, q_fp[np.newaxis, :])].sum(axis=1)
    top   = np.argsort(dists)[:top_k]
    return [(int(dists[i]), chunks[i][:120]) for i in top]

for dist, text in query_nodemind("What is quantum entanglement?"):
    print(f"  [{dist:4d}] {text}")

The _binarise function uses the metadata stored in the pkl file. The exact method is covered under AU 2026904283 — the index is self-contained without reading the patent.

Corpus & Methodology

Real files across five modalities — text chunks, photographs, environmental audio clips, structured tables, and source code.

RAG baseline: gemini-embedding-2 float32 + HNSW (paid API). NodeMind: bge-visualized-m3 (MIT, self-hosted). Audio routed through Whisper transcription before embedding. Recall measured against 1-to-1 ground truth.

Retrieval Accuracy — All Variants vs Gemini RAG

All 3 NodeMind variants match the float32 baseline exactly across all 50 queries.

Per-Modality Recall@1

Index Size — Production Scale (500,000 chunks)

Same compression math as real-world benchmark — bytes per fingerprint × N chunks. Float32 RAG baseline is identical at production scale regardless of modality.

Download — Verify It Yourself

All artefacts from the 200-item corpus. Includes the indexes, the corpus itself, real images and audio, and a side-by-side query script.

Verify compression in Python

import os

nm_bytes  = os.path.getsize("nodemind_index.pkl")
rag_bytes = os.path.getsize("gemini_rag_index.pkl")

print(f"NodeMind index  : {nm_bytes  / 1e6:.3f} MB")
print(f"Gemini RAG index: {rag_bytes / 1e6:.3f} MB")
print(f"RAG is {rag_bytes // nm_bytes}× larger than NodeMind")

# At production scale — 500,000 chunks:
# NodeMind NM-1024  =   60 MB
# NodeMind NM-512   =   30 MB
# NodeMind NM-256   =   15 MB
# Float32 RAG       = 2,048 MB  →  32× / 68× larger

Run a query

# pip install flagembedding hnswlib numpy
# wget https://huggingface.co/BAAI/BGE-Visualized/resolve/main/Visualized_m3.pth -O bge-visualized-m3.pth

# NodeMind only — no API key needed
python query_demo.py --no-rag --query "dog barking loudly outdoors"

# NodeMind vs Gemini RAG side by side
export GEMINI_API_KEY=your_key_here
python query_demo.py --query "orange tabby cat green eyes"
python query_demo.py --query "crackling fire campfire sound"
python query_demo.py --query "SELECT with JOIN employees departments"

The NodeMind binarisation method is patent-protected (AU 2026904283). The .pkl indexes are self-contained — work without reading the patent.

Why this benchmark

Standard RAG (Pinecone, Weaviate, FAISS-flat) has to keep 308 MB of float32 vectors in RAM forever to answer a query against this 75K corpus. NodeMind doesn't — once the index is built, you can delete the float32 vectors entirely. All you keep is the 9.6 MB binary fingerprint index (or 2.4 MB at 96×).

For non-technical readers: if your AI assistant today needs 300 MB of "memory" per book, NodeMind needs 10 MB for the same book — same query, same answers. At a million documents that's "fits on a laptop" vs "$5,000/mo Pinecone bill".

Corpus & Methodology

Embedded with BGE-M3 (1024-dim) and BGE-base-en-v1.5 (768-dim). Hardware: NVIDIA A40. Recall formula: hits / |relevant_set|.

Retrieval Accuracy — Cell 32× / 48× (BGE-M3, 1024-bit)

NodeMind B beats FAISS Fixed Binary at the same index size; loses ~3 pp R@10 vs HNSW float32 at 48× less storage.

Retrieval Accuracy — Cell 96× (BGE-base, 256-bit)

At 96× compression NodeMind A beats FAISS Fixed Binary by +27% relative R@10 at the same index size.

Index Size — 75,128 Chunks

Download — Verify It Yourself

All five methods ran on the same 75,128 chunks. Float32 baselines are transparent — anyone can run cosine on them to verify our recall numbers without trusting our code.

Verify compression in Python

import os

f32_m3   = os.path.getsize("float32_rag_bgem3.pkl")
nm_32x   = os.path.getsize("nodemind_index_32x.pkl")
f32_base = os.path.getsize("float32_rag_bgebase.pkl")
nm_96x   = os.path.getsize("nodemind_index_96x.pkl")

print(f"Float32 RAG (BGE-M3)    : {f32_m3   / 1e6:7.1f} MB")
print(f"NodeMind 32x            : {nm_32x   / 1e6:7.1f} MB   →  {f32_m3   / nm_32x:5.1f}× smaller")
print(f"Float32 RAG (BGE-base)  : {f32_base / 1e6:7.1f} MB")
print(f"NodeMind 96x            : {nm_96x   / 1e6:7.1f} MB   →  {f32_base / nm_96x:5.1f}× smaller")

# Expected:
# Float32 RAG (BGE-M3)    :  307.7 MB
# NodeMind 32x            :    9.6 MB   →   32.0× smaller
# Float32 RAG (BGE-base)  :  230.8 MB
# NodeMind 96x            :    2.4 MB   →   96.0× smaller

Run a query against the float32 baseline

import pickle, numpy as np
from sentence_transformers import SentenceTransformer

with open("float32_rag_bgem3.pkl", "rb") as f:
    rag = pickle.load(f)
embs = rag["embeddings"]                          # (75128, 1024) float32

enc = SentenceTransformer("BAAI/bge-m3")
q   = enc.encode(["your query here"], normalize_embeddings=True)[0]
top = np.argsort(-(embs @ q))[:5]
print(top)

The float32 RAG .pkl files are transparent — verify our recall numbers without trusting our code. NodeMind .pkl files use opaque pickle keys; the codec is patent-protected (AU 2026904283).

How It Works

Honest Caveats

• Self-retrieval protocols (real-world + multimodal). Queries derived from corpus items (perturbed real-world chunks; ground-truth-mapped multimodal queries). Optimistic for binary methods. End-to-end QA against official BEIR qrels is published as the third benchmark above (BEIR-Combined, 75K chunks, 2,677 queries, no perturbation).
• Float32 cosine wins on raw recall (BEIR-Combined). Exact float32 cosine still gives the best retrieval if your dataset fits in RAM. NodeMind's value proposition is storage / RAM at scale, not "we beat exact search" — at 32× / 96× less storage we lose ~3 pp R@10 on the 32× cell and more at 96×. NodeMind beats FAISS Fixed Binary at every same-size comparison.
• HNSW comparison is size-only. Real FAISS HNSW with tuned graph degree achieves recall@10 ≈ 0.95–0.99. We compare compression against HNSW (incl. ~50% graph overhead) and recall against exact float32 cosine — not against tuned HNSW recall.
• 96× / 128× require a lighter encoder or shorter fingerprint. BGE-base + PCA-256 gives 96×. NM-256 multimodal gives 128×. BGE-M3 1024-bit (stronger, cross-lingual) gives 32× / 48×.
• Multimodal corpus is small (200 items). Perfect-recall is partly because every query has exactly one correct corpus item. Larger neutral test sets are pending.
• 2 GB download for the real-world float32 baseline. Budget the bandwidth if you want to verify those baseline sizes yourself.

Patents

AU 2026904283 — NodeMind Codec & Index: patent-pending binarisation method + portable single-file binary fingerprint index format.

Filed at IP Australia. Built in Coleambally, NSW, Australia.