rust-kgdb 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to the rust-kgdb TypeScript SDK will be documented in this file.
 
+## [0.8.2] - 2025-12-21
+
+### Enhanced Introduction
+
+- Updated intro to highlight: totally in-memory KGDB with memory acceleration (449ns lookups)
+- Added multi-way federated joins (KGDB + Snowflake + BigQuery in single SQL)
+- Emphasized W3C DCAT/DPROD data cataloging for self-describing data products
+- Featured ThinkingReasoner with proof-carrying outputs in tagline
+
+---
+
 ## [0.8.1] - 2025-12-21
 
 ### Documentation & README Updates

package/README.md

@@ -67,6 +67,105 @@ Derivation Chain (like Claude's thinking, but verifiable):
 
 *See [ThinkingReasoner: Deductive AI](#thinkingreasoner-deductive-ai) for complete documentation.*
 
+### HyperMind Agent + Deductive Reasoning: The Complete Picture
+
+What happens when you combine natural language understanding with provable deduction?
+
+```javascript
+const {
+  GraphDB,
+  HyperMindAgent,
+  ThinkingReasoner,
+  RpcFederationProxy
+} = require('rust-kgdb')
+
+// 1. Create in-memory KGDB with your domain ontology
+const db = new GraphDB('http://insurance.example.org/')
+db.loadTtl(`
+  @prefix ins: <http://insurance.example.org/> .
+  @prefix owl: <http://www.w3.org/2002/07/owl#> .
+
+  ins:transfers a owl:TransitiveProperty .
+  ins:relatedTo a owl:SymmetricProperty .
+  ins:FraudulentClaim rdfs:subClassOf ins:Claim .
+`)
+
+// 2. Create ThinkingReasoner (auto-generates rules from ontology)
+const reasoner = new ThinkingReasoner()
+reasoner.loadOntology(db.getOntology())
+
+// 3. Create HyperMind Agent with deductive reasoning
+const agent = new HyperMindAgent({
+  kg: db,
+  reasoner: reasoner,                    // Deductive reasoning engine
+  federate: new RpcFederationProxy({     // Cross-database federation
+    endpoint: 'http://localhost:30180'
+  }),
+  thinkingGraph: {
+    enabled: true,                       // Show derivation chain
+    streaming: true                      // Real-time thinking updates
+  }
+})
+
+// 4. Natural language query with federated data + deductive reasoning
+const result = await agent.call(`
+  Find circular payment patterns in claims from the last 30 days.
+  Cross-reference with Snowflake customer data and BigQuery risk scores.
+  Show me the proof chain for any fraud detected.
+`)
+
+// Result includes:
+// - answer: Natural language summary
+// - sparql: Generated SPARQL query
+// - federatedSql: Cross-database SQL
+// - thinkingGraph: Full derivation chain
+// - proofs: Cryptographic witnesses for each conclusion
+
+console.log('Answer:', result.answer)
+console.log('Proofs:', result.proofs.length)
+
+// Display thinking graph (like Claude's thinking, but verifiable)
+for (const step of result.thinkingGraph.derivationChain) {
+  console.log(`[${step.step}] ${step.rule}: ${step.conclusion}`)
+  if (step.proofHash) {
+    console.log(`    Proof: ${step.proofHash}`)
+  }
+}
+```
+
+**Output:**
+```
+Answer: Found 3 circular payment patterns indicating potential fraud.
+        Alice → Bob → Carol → Alice ($28,500 total)
+        Provider #4521 → Clinic #892 → Provider #4521 ($156,000)
+
+Proofs: 6
+
+[1] SPARQL-EXEC: Query customer transfers from KGDB (2.3ms)
+[2] FEDERATION: Join with Snowflake accounts (890ms)
+[3] FEDERATION: Join with BigQuery risk scores (340ms)
+[4] OBSERVATION: Alice transfers $10K to Bob
+[5] OBSERVATION: Bob transfers $9.5K to Carol
+[6] OBSERVATION: Carol transfers $9K to Alice
+[7] DATALOG-INFER: owl:TransitiveProperty → Alice transfers to Carol
+    Premises: [4, 5]
+[8] DATALOG-INFER: circularPayment(Alice, Bob, Carol)
+    Premises: [4, 5, 6]
+    Proof: a3f8c2e7...
+    Confidence: 0.92
+```
+
+**The key difference from other AI frameworks:**
+
+| Aspect | LangChain/LlamaIndex | HyperMind + ThinkingReasoner |
+|--------|---------------------|------------------------------|
+| **Query source** | LLM generates SQL/SPARQL (error-prone) | Schema-aware generation (85.7% accuracy) |
+| **Data access** | Single database | Federated: KGDB + Snowflake + BigQuery |
+| **Reasoning** | None (just retrieval) | Datalog deduction with fixpoint |
+| **Confidence** | LLM-generated (fabricated) | Derived from proof chain |
+| **Audit trail** | None | SHA-256 cryptographic proofs |
+| **Explainability** | "Based on patterns..." | Step-by-step derivation chain |
+
 ---
 
 ## What's New in v0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rust-kgdb",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "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",