🛡 Industry First

Per-Tenant Cryptographic Isolation

Every other graph database uses namespace filtering. xrayGraphDB gives each tenant its own cryptographic boundary through a patent-pending isolation architecture. This is cryptographic isolation, not access-control theater.

What This Means in Practice

✓ A database admin with root access to Tenant A cannot decrypt Tenant B's data — even with a disk image
✓ Cloning a volume to another machine yields unreadable ciphertext
✓ Key rotation per tenant without downtime
✓ Meets FIPS 140-2, SOC 2 Type II, and HIPAA encryption requirements

Multi-Layered Defense

Multiple interlocking security layers designed together — integrity verification, per-tenant encryption, cryptographic signatures, anti-cloning protections, and secrets management integration. Not a single layer bolted on after the fact.

Purpose-Built Architecture

Designed from the ground up for multi-tenant, AI-native workloads. The execution engine, planner, storage layer, and wire protocol are all original eMTAi engineering — patent pending.

Built for Speed

✓Patent-pending execution engine — designed for high-throughput analytical workloads
✓xrayProtocol — patent-pending native binary wire format, 24x faster than legacy protocols
✓Patent-pending storage — zero-indirection reads through a proprietary access layer
✓GPU acceleration — optional hardware dispatch for analytics workloads
✓Plan cache — 425x speedup on repeated queries
✓Binary bulk-edge insert — BULK_INSERT_EDGES_KEYED opcode (v5.0.0-alpha) ingests 66K edges/sec, 150× faster than Cypher batches
✓Bundled xgconsole — interactive Cypher shell in the v5 image; docker exec … xgconsole works out of the box
✓Predictable latency — deterministic memory management, no stop-the-world pauses

Measured Results

✓0.1ms warm query latency
✓0.3ms point lookup on 17M+ edges
✓15-hop traversal in <500ms on real ICIJ data — depth where every competitor times out (Neo4j caps at 5, TigerGraph at 10)
✓100K+ nodes/sec bulk ingest via BULK_UPSERT_NODES
✓66K edges/sec bulk ingest via BULK_INSERT_EDGES_KEYED (v5.0.0-alpha, ~150× faster than Cypher MATCH+CREATE batches)
✓5.3M graph elements loaded in ~6 minutes from an empty container — less time than a coffee break
✓1.8B edges on commodity hardware (Friendster benchmark; only system to complete all 8 analytics workloads at this scale with AES-256-GCM encryption on)

See full benchmarks →

Cypher + GFQL + Neo4j Compatibility

Write Cypher as you know it. Use GFQL when dataframe-native syntax fits better. Neo4j-specific queries work automatically with zero changes. Dual-language support is patent pending.

Full Cypher with Neo4j Syntax Rewrites

xrayGraphDB automatically detects and rewrites Neo4j-specific syntax to standard Cypher, so applications migrating from Neo4j work without code changes.

✓ CREATE INDEX — Neo4j's CREATE INDEX FOR syntax auto-detected
✓ SHOW PROCEDURES — returns xrayGraphDB procedures in Neo4j-compatible format
✓ shortestPath() — native traversal implementation
✓ Bolt v5 — full protocol compatibility with Neo4j 5.x drivers

Cypher

// Works identically to Neo4j
CREATE INDEX function_name_idx
FOR (n:Function) ON (n.name);

// Neo4j-compatible procedure listing
SHOW PROCEDURES;

// Native shortest path
MATCH p = shortestPath(
  (a:Function {name: "main"})
  -[:CALLS*..10]->
  (b:Function {name: "render"})
)
RETURN p;

GFQL

// GFQL: Graph Frame Query Language
// Dataframe-native graph queries

SET GFQL_CONTEXT tenant='acme-corp';

FROM nodes(label='Function')
  .filter(complexity > 10)
  .hop(edge_type='CALLS', depth=3)
  .groupby('module')
  .agg(count=count(), avg_cx=avg('complexity'))
  .sort('avg_cx', desc=true)
  .limit(20);

GFQL as a First-Class Citizen

GFQL is a native query language for data scientists who think in dataframes. Multi-hop traversals, aggregation, and filtering in a composable pipeline syntax.

✓ Tenant-scoped sessions — automatic isolation per context
✓ Multi-hop traversals — depth control and edge filtering
✓ Aggregation — groupby, count, avg, min, max on result sets
✓ Composable — chain operations in a single expression

346 Functions · 90+ Native Procedures

The largest native function and procedure library of any graph database — patent pending. 346 built-in functions covering strings, math, temporal, lists, maps, vectors, and graph traversal, plus 90+ native procedures for analytics, code intelligence, and reachability — all running inside the engine, with optional GPU acceleration.

✓Graph ranking & community: pagerank, louvain, kcore, hits, connected_components
✓Centrality & reachability: betweenness_centrality (4 variants), find_path_*, frontier_profile, topk_reachable
✓Code intelligence: dead_code, complexity, security, hotspots, coupling, flow_trace, debt, ownership
✓ML / vectors: embed (native ONNX), node2vec, semantic_search, cosine_similarity

EMBED() for Vector Operations

Native vector embedding support directly in query expressions. Store, index, and query high-dimensional vectors without external plugins or separate systems.

// Store embedding on a node
MATCH (f:Function {name: "parse"})
SET f.embedding = EMBED("function that
  parses input tokens");

// Find semantically similar functions
MATCH (f:Function)
WHERE cosine_similarity(
  f.embedding,
  EMBED("parsing logic")
) > 0.85
RETURN f.name, f.module;

Designed For

xrayGraphDB is purpose-built for workloads where relationships are the signal — not just the schema.

🛡

Relationship Intelligence

Fraud rings, sanctions networks, money laundering chains. Follow relationships through billions of edges in seconds, not hours.

🧠

Graph AI & Memory

AI knowledge graphs, agent memory, RAG with graph context. Native vector embeddings via EMBED() alongside graph traversal.

🌐

Geospatial Intelligence

Infrastructure telemetry, supply chain dependencies, logistics networks. Graph + geo + vector in one query.

🔍

Cyber Threat Detection

Lateral movement tracing, attack path analysis, IOC correlation. Full path context in milliseconds, not alert fragments.

🏥

Healthcare & Life Sciences

Referral networks, drug interaction graphs, patient pathway analysis. HIPAA-ready with per-tenant encryption.

🚀

Operational Graph Analytics

Real-time community detection, influence propagation, centrality monitoring. GPU-accelerated analytics on live data.

Architecture at a Glance

Why xrayGraphDB survives workloads that crash other systems.

Cypher · GFQL · xrayProtocol · Bolt v5

↓

Patent-Pending Execution Engine

↓

GPU Compute
CUDA kernels

CPU Analytics
SIMD-accelerated

Vector / Geo
EMBED(), spatial

↓

Persistent Graph Store · Patent-Pending Storage

↓

🔒 AES-256-GCM Per-Tenant Encryption · Always On

Every layer is original eMTAi engineering. The execution engine, storage layout, wire protocol, and encryption architecture are all patent-pending. GPU acceleration falls back to CPU gracefully when no GPU is available — same API, same results, different speed.