rust-kgdb 0.8.10 → 0.8.12

package/README.md

@@ -91,38 +91,33 @@ const agent = new HyperMindAgent({
   federate: federation
 })
 
-// 4. Record observations (ground truth from SPARQL/SQL results)
-agent.reasoner.observe("Alice transfers $10K to Bob", { subject: "alice", predicate: "transfers", object: "bob" })
-agent.reasoner.observe("Bob transfers $9.5K to Carol", { subject: "bob", predicate: "transfers", object: "carol" })
-agent.reasoner.observe("Carol transfers $9K to Alice", { subject: "carol", predicate: "transfers", object: "alice" })
-
-// 5. Deduce → Get derivation chain
-const deduction = agent.reasoner.deduce()
-const graph = agent.reasoner.getThinkingGraph()
-console.log('Events:', agent.reasoner.getStats().events)    // 3 observations
-console.log('Facts:', agent.reasoner.getStats().facts)      // 3 facts recorded
-
-// 6. Natural language query with federated data
+// 4. Natural language query - ThinkingReasoner AUTOMATICALLY:
+//    • Records observations from SPARQL/SQL results
+//    • Runs deductive reasoning with OWL rules
+//    • Generates cryptographic proofs
 const result = await agent.call('Find circular payments and cross-ref with Snowflake TPCH')
-console.log(result.answer)
+
+// 5. Access reasoning results (all automatic)
+console.log(result.answer)                                   // Natural language answer
+console.log(result.thinkingGraph)                            // Derivation chain
+console.log(result.proofs)                                   // Cryptographic proofs
+console.log(result.reasoningStats)                           // { events, facts, rules, proofs }
 ```
 
 **Output (verified):**
 ```
-Events: 3
-Facts: 3
+Answer: Found 3 circular payment patterns
 
-Derivation Chain:
+Thinking Graph (Derivation Chain):
   Step 1: [OBSERVATION] alice transfers bob
   Step 2: [OBSERVATION] bob transfers carol
   Step 3: [OBSERVATION] carol transfers alice
+  Step 4: [owl:TransitiveProperty] alice transfers carol
 
-Stats: { events: 3, facts: 3, rules: 0, proofs: 0, contexts: 1, actors: 1 }
+Reasoning Stats: { events: 3, facts: 6, rules: 4, proofs: 3 }
 ```
 
-**Note**: Observations are recorded as ground truth. OWL rule application and proof generation happen when custom rules are added via `agent.reasoner.addRule()`. The ThinkingReasoner provides the infrastructure for deductive reasoning with cryptographic proofs.
-
-**The key insight**: The LLM proposes hypotheses. The ThinkingReasoner validates them against your ontology. Only facts with valid proofs become assertions. No hallucinations—every conclusion traces back to ground truth observations.
+**The key insight**: `call()` automatically records observations and runs deduction. No manual `observe()` calls needed—every SPARQL/SQL result becomes ground truth for reasoning.
 
 *See [ThinkingReasoner: Deductive AI](#thinkingreasoner-deductive-ai) for complete documentation.*
 

package/hypermind-agent.js

@@ -5119,9 +5119,9 @@ class HyperMindAgent {
    * @private
    */
   _recordObservations(results, trace) {
-    const observationIds = []
+    let observationCount = 0
 
-    if (!Array.isArray(results)) return observationIds
+    if (!Array.isArray(results)) return observationCount
 
     for (const result of results) {
       if (!result.success) continue
@@ -5134,17 +5134,20 @@ class HyperMindAgent {
 
           if (keys.length >= 2) {
             try {
-              const obsId = this.reasoner.observe(
-                `SPARQL result: ${JSON.stringify(bindings)}`,
-                {
-                  subject: String(bindings[keys[0]] || 'unknown'),
-                  predicate: keys.length >= 2 ? String(keys[1]) : 'related',
-                  object: String(bindings[keys[keys.length > 2 ? 2 : 1]] || 'value')
-                }
+              // Use appendEvent for observations (NAPI-RS API)
+              this.reasoner.appendEvent(
+                'Observation',
+                `SPARQL: ${JSON.stringify(bindings)}`,
+                this.name || 'agent',
+                trace.sessionId || 'session'
               )
-              if (obsId && obsId.id) {
-                observationIds.push(obsId.id)
-              }
+              observationCount++
+
+              // Also record as hypothesis for deduction
+              const subject = String(bindings[keys[0]] || 'unknown')
+              const predicate = keys.length >= 2 ? String(keys[1]) : 'related'
+              const object = String(bindings[keys[keys.length > 2 ? 2 : 1]] || 'value')
+              this.reasoner.hypothesize(subject, predicate, object, 0.9, [])
             } catch (e) {
               // Continue on observation errors
             }
@@ -5155,28 +5158,38 @@ class HyperMindAgent {
       // Handle triple-format results
       if (result.result?.subject && result.result?.predicate && result.result?.object) {
         try {
-          const obsId = this.reasoner.observe(
-            `Triple: ${result.result.subject} ${result.result.predicate} ${result.result.object}`,
-            result.result
+          const { subject, predicate, object } = result.result
+          // Use appendEvent for observations (NAPI-RS API)
+          this.reasoner.appendEvent(
+            'Observation',
+            `Triple: ${subject} ${predicate} ${object}`,
+            this.name || 'agent',
+            trace.sessionId || 'session'
+          )
+          observationCount++
+
+          // Also record as hypothesis for deduction
+          this.reasoner.hypothesize(
+            String(subject),
+            String(predicate),
+            String(object),
+            0.9,
+            []
           )
-          if (obsId && obsId.id) {
-            observationIds.push(obsId.id)
-          }
         } catch (e) {
           // Continue on observation errors
         }
       }
     }
 
-    if (observationIds.length > 0) {
+    if (observationCount > 0) {
       trace.addStep({
         type: 'observations_recorded',
-        count: observationIds.length,
-        ids: observationIds.slice(0, 5)
+        count: observationCount
       })
     }
 
-    return observationIds
+    return observationCount
   }
 
   /**

package/package.json

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