rust-kgdb 0.6.84 → 0.7.0

package/README.md

@@ -159,13 +159,13 @@ The AI never touches your data. It translates human language into precise querie
 - **Instant deployment** - `npm install` and you're running
 
 **For Engineering Teams:**
-- **449ns lookups** - 35x faster than RDFox, the previous gold standard
+- **449ns lookups** - 5-11x faster than RDFox (2.5-5µs), measured on commodity hardware
 - **24 bytes per triple** - 25% more memory efficient than competitors
 - **132K writes/sec** - Handle enterprise transaction volumes
 - **94% recall** on memory retrieval - Agent remembers past queries accurately
 
 **For AI/ML Teams:**
-- **91.67% SPARQL accuracy** - vs 0% with vanilla LLMs (Claude Sonnet 4 + HyperMind)
+- **85.7% SPARQL accuracy** - vs 0% with vanilla LLMs (GPT-4o + HyperMind schema injection)
 - **16ms similarity search** - Find related entities across 10K vectors
 - **Recursive reasoning** - Datalog rules cascade automatically (fraud rings, compliance chains)
 - **Schema-aware generation** - AI uses YOUR ontology, not guessed class names
@@ -176,7 +176,7 @@ The AI never touches your data. It translates human language into precise querie
 - **Composite multi-vector** - RRF fusion of RDF2Vec + OpenAI with -2% overhead at scale
 - **Automatic triggers** - Vectors generated on graph upsert, no batch pipelines
 
-The math matters. When your fraud detection runs 35x faster, you catch fraud before payments clear. When your agent remembers with 94% accuracy, analysts don't repeat work. When every decision has a proof hash, you pass audits.
+The math matters. When your fraud detection runs 5-11x faster, you catch fraud before payments clear. When your agent remembers with 94% accuracy, analysts don't repeat work. When every decision has a proof hash, you pass audits.
 
 ---
 
@@ -198,7 +198,7 @@ At no point does the AI "know" anything. It's a translator—from human intent t
 
 | Layer | Component | What It Does |
 |-------|-----------|--------------|
-| **Database** | GraphDB | W3C SPARQL 1.1 compliant RDF store, 449ns lookups, 35x faster than RDFox |
+| **Database** | GraphDB | W3C SPARQL 1.1 compliant RDF store, 449ns lookups, 5-11x faster than RDFox |
 | **Database** | Distributed SPARQL | HDRF partitioning across Kubernetes executors |
 | **Federation** | HyperFederate | Cross-database SQL: KGDB + Snowflake + BigQuery in single query |
 | **Embeddings** | Rdf2VecEngine | Train 384-dim vectors from graph random walks, 68µs lookup |
@@ -292,7 +292,7 @@ At no point does the AI "know" anything. It's a translator—from human intent t
 |   Layer 4: DATABASE (Authoritative)                                       |
 |   +---------------------------------------------------------------------+ |
 |   | rust-kgdb executes query against YOUR actual data                   | |
-|   | - 449ns lookups (35x faster than RDFox)                             | |
+|   | - 449ns lookups (5-11x faster than RDFox)                           | |
 |   | - Returns only facts that exist                                     | |
 |   | - Generates SHA-256 proof hash for audit                            | |
 |   +---------------------------------------------------------------------+ |
@@ -358,7 +358,7 @@ We built rust-kgdb to fix this.
 +------------------------------------v--------------------------------------------+
 |                    RUST CORE ENGINE (Native Performance)                         |
 |  +----------------------------------------------------------------------------+ |
-|  |  GraphDB          | RDF/SPARQL quad store   | 2.78µs lookups, 24 bytes/triple|
+|  |  GraphDB          | RDF/SPARQL quad store   | 449ns lookups, 24 bytes/triple |
 |  |  GraphFrame       | Graph algorithms        | WCOJ optimal joins, PageRank  |
 |  |  EmbeddingService | Vector similarity       | HNSW index, 1-hop ARCADE cache|
 |  |  DatalogProgram   | Rule-based reasoning    | Semi-naive evaluation         |
@@ -371,7 +371,7 @@ We built rust-kgdb to fix this.
 +----------------------------------------------------------------------------------+
 ```
 
-**Key Insight**: The Rust core provides raw performance (2.78µs lookups). The HyperMind framework adds mathematical guarantees (type safety, composition laws, proof generation) without sacrificing speed.
+**Key Insight**: The Rust core provides raw performance (449ns lookups). The HyperMind framework adds mathematical guarantees (type safety, composition laws, proof generation) without sacrificing speed.
 
 ### What's Rust Core vs SDK Layer?
 
@@ -379,7 +379,7 @@ All major capabilities are implemented in **Rust** via the HyperMind SDK crates
 
 | Component | Implementation | Performance | Notes |
 |-----------|---------------|-------------|-------|
-| **GraphDB** | Rust via NAPI-RS | 2.78µs lookups | Zero-copy RDF quad store |
+| **GraphDB** | Rust via NAPI-RS | 449ns lookups | Zero-copy RDF quad store |
 | **GraphFrame** | Rust via NAPI-RS | WCOJ optimal | PageRank, triangles, components |
 | **EmbeddingService** | Rust via NAPI-RS | Sub-ms search | HNSW index + 1-hop cache |
 | **DatalogProgram** | Rust via NAPI-RS | Semi-naive eval | Rule-based reasoning |
@@ -739,17 +739,17 @@ We don't make claims we can't prove. All measurements use **publicly available,
 
 | Metric | Value | Why It Matters | Source |
 |--------|-------|----------------|--------|
-| **Lookup Latency** | 2.78 µs | 35x faster than RDFox | [Our benchmark](./HYPERMIND_BENCHMARK_REPORT.md) vs [RDFox specs](https://docs.oxfordsemantic.tech/stable/performance.html) |
+| **Lookup Latency** | 449 ns | 5-11x faster than RDFox (2.5-5µs) | [Criterion.rs benchmark](./CONCURRENT_BENCHMARK_RESULTS.md) |
 | **Memory per Triple** | 24 bytes | 25% more efficient than RDFox | Measured via Criterion.rs |
-| **Bulk Insert** | 146K triples/sec | Production-ready throughput | LUBM(10) dataset |
-| **SPARQL Accuracy** | 86.4% | vs 0% vanilla LLM (LUBM benchmark) | [HyperMind benchmark](./vanilla-vs-hypermind-benchmark.js) |
+| **Bulk Insert** | 156K quads/sec | Production-ready throughput | Concurrent benchmark |
+| **SPARQL Accuracy** | 85.7% | vs 0% vanilla LLM (LUBM benchmark) | [HyperMind benchmark](./HYPERMIND_BENCHMARK_REPORT.md) |
 | **W3C Compliance** | 100% | Full SPARQL 1.1 + RDF 1.2 | [W3C test suite](https://www.w3.org/2009/sparql/docs/tests/) |
 
 ### Honest Feature Comparison
 
 | Feature | rust-kgdb | RDFox | Tentris | AllegroGraph | Jena |
 |---------|-----------|-------|---------|--------------|------|
-| **Lookup Latency** | 2.78 µs | ~100 µs | ~10 µs | ~50 µs | ~200 µs |
+| **Lookup Latency** | 449 ns | 2.5-5 µs | ~10 µs | ~50 µs | ~200 µs |
 | **Memory/Triple** | 24 bytes | 32 bytes | 40 bytes | 64 bytes | 50-60 bytes |
 | **SPARQL 1.1** | 100% | 100% | ~95% | 100% | 100% |
 | **OWL Reasoning** | OWL 2 RL | OWL 2 RL/EL | No | RDFS++ | OWL 2 |
@@ -769,7 +769,7 @@ We don't make claims we can't prove. All measurements use **publicly available,
 - **Jena**: Largest ecosystem, most tutorials, best community support
 
 **Where rust-kgdb Wins:**
-- **Raw Speed**: 35x faster lookups than RDFox due to zero-copy Rust architecture
+- **Raw Speed**: 5-11x faster lookups than RDFox due to zero-copy Rust architecture
 - **Mobile**: Only RDF database with native iOS/Android FFI bindings
 - **AI Integration**: HyperMind is the only type-safe agent framework with schema-aware SPARQL generation
 - **Embeddings**: Native HNSW vector search integrated with symbolic reasoning
@@ -780,12 +780,13 @@ We don't make claims we can't prove. All measurements use **publicly available,
 - **Dataset**: [LUBM benchmark](http://swat.cse.lehigh.edu/projects/lubm/) (industry standard since 2005)
   - LUBM(1): 3,272 triples, 30 classes, 23 properties
   - LUBM(10): ~32K triples for bulk insert testing
-- **Hardware**: Apple Silicon M2 MacBook Pro
+- **Hardware**: MacBook Pro 16,1 (2019) - Intel Core i9-9980HK @ 2.40GHz, 8 cores/16 threads, 64GB DDR4
+  - *Note: This is commodity developer hardware. Production servers will see improved numbers.*
 - **Methodology**: 10,000+ iterations, cold-start, statistical analysis via [Criterion.rs](https://github.com/bheisler/criterion.rs)
 - **Comparison**: [Apache Jena 4.x](https://jena.apache.org/), [RDFox 7.x](https://www.oxfordsemantic.tech/) under identical conditions
 
 **Baseline Sources:**
-- **RDFox**: [Oxford Semantic Technologies documentation](https://docs.oxfordsemantic.tech/stable/performance.html) - ~100µs lookups, 32 bytes/triple
+- **RDFox**: [Oxford Semantic Technologies documentation](https://docs.oxfordsemantic.tech/stable/performance.html) - 2.5-5µs lookups, 32 bytes/triple
 - **Tentris**: [ISWC 2020 paper](https://papers.dice-research.org/2020/ISWC_Tentris/tentris_public.pdf) - Tensor-based execution
 - **AllegroGraph**: [Franz Inc benchmarks](https://allegrograph.com/benchmark/) - Enterprise scale focus
 - **Apache Jena**: [TDB2 documentation](https://jena.apache.org/documentation/tdb2/) - Industry-standard baseline
@@ -1275,12 +1276,13 @@ const similar = rdf2vec.findSimilar('http://person/1', candidates, 5)
 
 ### Agentic Framework Accuracy (LLM WITH vs WITHOUT HyperMind)
 
-| Model | Without HyperMind | With HyperMind | Improvement |
-|-------|-------------------|----------------|-------------|
-| **Claude Sonnet 4** | 0.0% | **91.67%** | **+91.67 pp** |
-| **GPT-4o** | 0.0%* | **66.67%** | **+66.67 pp** |
+| Model | Without Schema | With Schema | With HyperMind |
+|-------|----------------|-------------|----------------|
+| **Vanilla OpenAI (GPT-4o)** | 0.0% | 71.4% | **85.7%** |
+| **LangChain** | 0.0% | 71.4% | **85.7%** |
+| **DSPy** | 14.3% | 71.4% | **85.7%** |
 
-*0% because raw LLM outputs markdown-wrapped SPARQL that fails parsing.
+*7 LUBM queries, real API calls. 0% without schema because raw LLM outputs markdown-wrapped SPARQL that fails parsing. See [HYPERMIND_BENCHMARK_REPORT.md](./HYPERMIND_BENCHMARK_REPORT.md).*
 
 **Key finding**: Same LLM, same questions - HyperMind's type contracts and schema injection transform unreliable LLM outputs into production-ready queries.
 
@@ -1747,6 +1749,46 @@ The TypeScript SDK is intentionally thin. A thin RPC proxy. All the hard work ha
 | **Data Catalog** | ✅ DCAT DPROD ontology | ❌ Proprietary |
 | **Proof/Lineage** | ✅ Full provenance (W3C PROV) | ❌ None |
 
+### HyperFederate SQL Benchmarks
+
+Performance measured on MacBook Pro 16,1 (2019) - Intel Core i9-9980HK @ 2.40GHz, 64GB DDR4.
+*Commodity developer hardware. Production servers will see improved numbers.*
+
+| Query Type | Sources | Latency | Notes |
+|------------|---------|---------|-------|
+| **KGDB graph_search** | KGDB only | 12-25 ms | SPARQL → SQL bridge |
+| **KGDB + Snowflake** | 2 sources | 234-456 ms | TPC-H customer join |
+| **Snowflake + BigQuery** | 2 sources | 450-680 ms | Cross-cloud join |
+| **Three-Way (KG+SF+BQ)** | 3 sources | **890 ms** | Full federated pipeline |
+| **graph_search + vector_search** | KGDB | 45-80 ms | Hybrid semantic/graph |
+| **pagerank() + Snowflake** | 2 sources | 320-550 ms | Graph analytics + SQL |
+
+**Semantic UDFs (7 functions):**
+
+| UDF | Description | Latency |
+|-----|-------------|---------|
+| `similar_to(entity, threshold)` | RDF2Vec similarity | 68 µs |
+| `text_search(query, limit)` | Semantic text search | 12-25 ms |
+| `neighbors(entity, hops)` | N-hop graph traversal | 5-15 ms |
+| `graph_pattern(s, p, o)` | Triple pattern matching | 2-8 ms |
+| `sparql_query(sparql)` | Inline SPARQL execution | 10-30 ms |
+| `entity_type(entity)` | Get RDF types | <1 ms |
+| `entity_properties(entity)` | Get all properties | 1-5 ms |
+
+**Table Functions (9 analytics):**
+
+| Function | Description | Latency (1K nodes) |
+|----------|-------------|-------------------|
+| `graph_search(sparql)` | SPARQL → SQL bridge | 12-25 ms |
+| `vector_search(text, k, threshold)` | Semantic similarity | 16-44 ms |
+| `pagerank(sparql, damping, iterations)` | PageRank centrality | 45-120 ms |
+| `connected_components(sparql)` | Community detection | 30-80 ms |
+| `shortest_paths(src, dst, max_hops)` | Path finding | 15-50 ms |
+| `triangle_count(sparql)` | Graph density | 25-60 ms |
+| `label_propagation(sparql, iterations)` | Community detection | 40-100 ms |
+| `datalog_reason(rules)` | Datalog inference | 20-80 ms |
+| `motif_search(pattern)` | Pattern matching | 35-90 ms |
+
 ### Using RpcFederationProxy
 
 ```javascript
@@ -2101,7 +2143,7 @@ node examples/hypermind-agent-architecture.js
 |  +------------------------------------------------------------------------+   |
 |  |                    rust-kgdb KNOWLEDGE GRAPH                            |   |
 |  |  RDF Triples | SPARQL 1.1 | GraphFrames | Embeddings | Datalog         |   |
-|  |  2.78µs lookups | 24 bytes/triple | 35x faster than RDFox              |   |
+|  |  449ns lookups | 24 bytes/triple | 5-11x faster than RDFox             |   |
 |  +------------------------------------------------------------------------+   |
 +================================================================================+
 ```
@@ -3738,7 +3780,7 @@ Here's the semantic hash: `semhash:collusion-p001-p002-prov001` - same query int
 +-------------------------------------------------------------------------------+
 |                                                                               |
 |   KNOWLEDGE GRAPH DATABASE (this is what powers it)                           |
-|   +-- 2.78 µs lookups (35x faster than RDFox)                                |
+|   +-- 449 ns lookups (5-11x faster than RDFox)                               |
 |   +-- 24 bytes/triple (25% more efficient)                                   |
 |   +-- W3C SPARQL 1.1 + RDF 1.2 (100% compliance)                             |
 |   +-- RDFS + OWL 2 RL reasoners (ontology inference)                         |
@@ -3770,7 +3812,7 @@ Here's the semantic hash: `semhash:collusion-p001-p002-prov001` - same query int
 |  Amazon Neptune: Managed, but cloud-only vendor lock-in         |
 |  LangChain:      Vibe coding, fails compliance audits           |
 |                                                                 |
-|  rust-kgdb:      2.78 µs lookups, mobile-native, open standards |
+|  rust-kgdb:      449 ns lookups, mobile-native, open standards  |
 |                  Standalone -> Clustered on same codebase        |
 |                  Mathematical foundations, audit-ready           |
 |                                                                 |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rust-kgdb",
-  "version": "0.6.84",
-  "description": "High-performance RDF/SPARQL database with AI agent framework. GraphDB (449ns lookups, 35x faster than RDFox), GraphFrames analytics (PageRank, motifs), Datalog reasoning, HNSW vector embeddings. HyperMindAgent for schema-aware query generation with audit trails. W3C SPARQL 1.1 compliant. Native performance via Rust + NAPI-RS.",
+  "version": "0.7.0",
+  "description": "High-performance RDF/SPARQL database with AI agent framework and cross-database federation. GraphDB (449ns lookups, 5-11x faster than RDFox), HyperFederate (KGDB + Snowflake + BigQuery), GraphFrames analytics, Datalog reasoning, HNSW vector embeddings. HyperMindAgent for schema-aware query generation with audit trails. W3C SPARQL 1.1 compliant. Native performance via Rust + NAPI-RS.",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {