rust-kgdb 0.6.69 → 0.6.70

package/README.md

@@ -8,7 +8,98 @@
 
 ---
 
-## The Problem
+## The Problem With AI Today
+
+Enterprise AI projects keep failing. Not because the technology is bad, but because organizations use it wrong.
+
+A claims investigator asks ChatGPT: *"Has Provider #4521 shown suspicious billing patterns?"*
+
+The AI responds confidently: *"Yes, Provider #4521 has a history of duplicate billing and upcoding."*
+
+The investigator opens a case. Weeks later, legal discovers Provider #4521 has a perfect record. **The AI made it up.** Lawsuit incoming.
+
+This keeps happening:
+
+- A lawyer cites "Smith v. Johnson (2019)" in court. The judge is confused. **That case doesn't exist.**
+- A doctor avoids prescribing "Nexapril" due to cardiac interactions. **Nexapril isn't a real drug.**
+- A fraud analyst flags Account #7842 for money laundering. **It belongs to a children's charity.**
+
+Every time, the same pattern: The AI sounds confident. The AI is wrong. People get hurt.
+
+---
+
+## The Engineering Problem
+
+The root cause is simple: **LLMs are language models, not databases.** They predict plausible text. They don't look up facts.
+
+When you ask "Has Provider #4521 shown suspicious patterns?", the LLM doesn't query your claims database. It generates text that *sounds like* an answer based on patterns from its training data.
+
+The industry's response? Add guardrails. Use RAG. Fine-tune models.
+
+These help, but they're patches:
+- **RAG** retrieves similar documents - similar isn't the same as correct
+- **Fine-tuning** teaches patterns, not facts
+- **Guardrails** catch obvious errors, but "Provider #4521 has billing anomalies" sounds perfectly plausible
+
+A real solution requires a different architecture. One built on solid engineering principles, not hope.
+
+---
+
+## The Solution: Query Generation, Not Answer Generation
+
+What if AI stopped providing answers and started **generating queries**?
+
+Think about it:
+- Your database knows the facts (claims, providers, transactions)
+- AI understands language (can parse "find suspicious patterns")
+- You need both working together
+
+**The AI translates intent into queries. The database finds facts. The AI never makes up data.**
+
+```
+Before (Dangerous):
+  Human: "Is Provider #4521 suspicious?"
+  AI: "Yes, they have billing anomalies"      <-- FABRICATED
+
+After (Safe):
+  Human: "Is Provider #4521 suspicious?"
+  AI: Generates SPARQL query
+  AI: Executes against YOUR database
+  Database: Returns actual facts about Provider #4521
+  Result: Real data with audit trail          <-- VERIFIABLE
+```
+
+rust-kgdb is a knowledge graph database with an AI layer that **cannot hallucinate** because it only returns data from your actual systems.
+
+---
+
+## The Business Value
+
+**For Enterprises:**
+- **Zero hallucinations** - Every answer traces back to your actual data
+- **Full audit trail** - Regulators can verify every AI decision (SOX, GDPR, FDA 21 CFR Part 11)
+- **No infrastructure** - Runs embedded in your app, no servers to manage
+- **Instant deployment** - `npm install` and you're running
+
+**For Engineering Teams:**
+- **449ns lookups** - 35x faster than RDFox, the previous gold standard
+- **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:**
+- **86.4% SPARQL accuracy** - vs 0% with vanilla LLMs on LUBM benchmark
+- **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
+
+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 Technical Problem (SPARQL Generation)
+
+Beyond hallucination, there's a practical issue: **LLMs can't write correct SPARQL.**
 
 We asked GPT-4 to write a simple SPARQL query: *"Find all professors."*
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rust-kgdb",
-  "version": "0.6.69",
+  "version": "0.6.70",
   "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.",
   "main": "index.js",
   "types": "index.d.ts",