rust-kgdb 0.8.14 → 0.8.16

package/hypermind-agent.js

@@ -4924,6 +4924,7 @@ class HyperMindAgent {
     this.rules = config.rules || new DatalogRuleSet()
     this.sandbox = new WasmSandbox(config.sandbox || {})
     this.name = config.name || 'hypermind-agent'
+    this.answerFormat = config.answerFormat || 'text' // 'text' | 'table' | 'json'
 
     // ThinkingReasoner for deductive reasoning with proof-carrying outputs
     // Enabled by default - every HyperMindAgent has deductive reasoning
@@ -5025,33 +5026,75 @@ class HyperMindAgent {
     }
 
     // 4. Train RDF2Vec embeddings if requested
-    let embeddings = null
+    // Uses native Rust loadTtlWithEmbeddings() - all embedding logic in Rust
+    let embeddingsEnabled = false
     if (options.rdf2vec) {
       try {
-        const { Rdf2VecEngine, EmbeddingService } = loadNativeBindingDirect()
-        const rdf2vec = new Rdf2VecEngine()
-        embeddings = new EmbeddingService()
-
-        // Train RDF2Vec on the graph using native GraphDb
-        rdf2vec.train(db._db, {
-          dimensions: options.rdf2vecDimensions || 128,
-          walkLength: options.rdf2vecWalkLength || 10,
-          walksPerEntity: options.rdf2vecWalksPerEntity || 10,
-          windowSize: options.rdf2vecWindowSize || 5,
-          minCount: 1,
-          epochs: options.rdf2vecEpochs || 5
-        })
+        // Get RDF2Vec config from options (support both boolean and object)
+        const rdf2vecConfig = typeof options.rdf2vec === 'object' ? options.rdf2vec : {}
+        // Use snake_case for NAPI-RS struct field names
+        const config = {
+          vector_size: rdf2vecConfig.dimensions || options.rdf2vecDimensions || 128,
+          window_size: rdf2vecConfig.window || options.rdf2vecWindowSize || 5,
+          walk_length: rdf2vecConfig.walkLength || options.rdf2vecWalkLength || 5,
+          walks_per_node: rdf2vecConfig.walksPerNode || options.rdf2vecWalksPerEntity || 10
+        }
 
-        if (rdf2vec.isTrained()) {
-          console.log(`[HyperMindAgent.create] Trained RDF2Vec embeddings (${rdf2vec.dimensions()} dimensions)`)
-          embeddings._rdf2vec = rdf2vec
+        // Re-load data with embeddings using native Rust (efficient, parallel)
+        const loadResult = JSON.parse(db._db.loadTtlWithEmbeddings(
+          options.data,
+          null,
+          config
+        ))
+
+        if (loadResult.embeddings?.trained) {
+          embeddingsEnabled = true
+          console.log(`[HyperMindAgent.create] Trained RDF2Vec embeddings:`)
+          console.log(`    Entities: ${loadResult.embeddings.entities_embedded}`)
+          console.log(`    Dimensions: ${loadResult.embeddings.dimensions}`)
+          console.log(`    Walks: ${loadResult.embeddings.walks_generated}`)
+          console.log(`    Training time: ${loadResult.embeddings.training_time_secs?.toFixed(2)}s`)
         }
       } catch (e) {
         console.warn(`[HyperMindAgent.create] RDF2Vec training skipped: ${e.message}`)
-        embeddings = null
       }
     }
 
+    // Create wrapper for embedding operations if enabled
+    const embeddings = embeddingsEnabled ? {
+      // Delegate to native GraphDB embedding methods
+      getEmbedding: (entity) => db._db.getEmbedding(entity),
+      findSimilar: (entity, k, threshold) => {
+        try {
+          const results = JSON.parse(db._db.findSimilar(entity, k || 10))
+          if (threshold) {
+            return results.filter(r => r.similarity >= threshold)
+          }
+          return results
+        } catch (e) {
+          return []
+        }
+      },
+      search: (text, k, threshold) => {
+        // For text search, find entities that match and return similar
+        // This uses the embedding similarity from native Rust
+        const entities = db.querySelect(`SELECT ?s WHERE { ?s ?p ?o } LIMIT ${k || 10}`)
+        const results = []
+        for (const e of entities) {
+          const entity = e.bindings?.s || e.s
+          if (entity) {
+            const similar = JSON.parse(db._db.findSimilar(entity, 1))
+            if (similar.length > 0 && (!threshold || similar[0].similarity >= threshold)) {
+              results.push({ entity, similarity: similar[0]?.similarity || 0 })
+            }
+          }
+        }
+        return results.slice(0, k || 10)
+      },
+      hasEmbeddings: () => db._db.hasEmbeddings(),
+      getStats: () => JSON.parse(db._db.getEmbeddingStats())
+    } : null
+
     // 5. Create agent with all components
     const agent = new HyperMindAgent({
       name: options.name,
@@ -5825,36 +5868,120 @@ LIMIT 100`
 
   _formatAnswer(results, inferences, intent, deduction = null) {
     const sparqlResults = results.filter(r => r.tool === 'kg.sparql.query' && r.success)
-    const totalResults = sparqlResults.reduce((sum, r) => sum + (Array.isArray(r.result) ? r.result.length : 0), 0)
+    const allRows = sparqlResults.flatMap(r => Array.isArray(r.result) ? r.result : [])
+    const totalResults = allRows.length
+
+    // Helper to extract readable name from URI
+    const extractName = (uri) => {
+      if (!uri) return null
+      const str = String(uri)
+      const lastSlash = str.lastIndexOf('/')
+      const lastHash = str.lastIndexOf('#')
+      const pos = Math.max(lastSlash, lastHash)
+      const local = pos >= 0 ? str.substring(pos + 1) : str
+      // Convert "lessort__mathias" to "Mathias Lessort"
+      if (local.includes('__')) {
+        const parts = local.split('__')
+        return parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).reverse().join(' ')
+      }
+      return local.charAt(0).toUpperCase() + local.slice(1)
+    }
+
+    // Extract unique entities from results
+    const extractEntities = (rows, maxItems = 10) => {
+      const seen = new Set()
+      const entities = []
+      for (const row of rows) {
+        for (const [key, value] of Object.entries(row)) {
+          const name = extractName(value)
+          if (name && !seen.has(name) && !name.match(/^(none|unknown|integer)$/i)) {
+            seen.add(name)
+            entities.push({ key, name, uri: value })
+            if (entities.length >= maxItems) return entities
+          }
+        }
+      }
+      return entities
+    }
 
-    let answer = `Found ${totalResults} results`
+    // Determine output format
+    const format = this.answerFormat || 'text'
 
-    if (inferences.length > 0) {
-      answer += ` using ${inferences.length} reasoning rules`
+    // JSON format - return structured data
+    if (format === 'json') {
+      return JSON.stringify({
+        count: totalResults,
+        results: allRows.slice(0, 20).map(row => {
+          const formatted = {}
+          for (const [k, v] of Object.entries(row)) {
+            formatted[k] = extractName(v) || v
+          }
+          return formatted
+        }),
+        reasoning: deduction ? {
+          observations: deduction.observations || 0,
+          derivedFacts: (deduction.derivedFacts || []).length,
+          rulesApplied: deduction.rulesFired || 0
+        } : null
+      }, null, 2)
+    }
+
+    // TABLE format - professional tabular output
+    if (format === 'table') {
+      const entities = extractEntities(allRows, 15)
+      if (entities.length === 0) {
+        return `No results found.`
+      }
+
+      // Build table
+      let table = `\n┌${'─'.repeat(40)}┐\n`
+      table += `│ Results (${totalResults} total)${' '.repeat(Math.max(0, 24 - String(totalResults).length))}│\n`
+      table += `├${'─'.repeat(40)}┤\n`
+
+      for (const entity of entities) {
+        const nameStr = entity.name.substring(0, 36).padEnd(36)
+        table += `│  ${nameStr}  │\n`
+      }
+
+      if (totalResults > entities.length) {
+        table += `│  ... and ${totalResults - entities.length} more${' '.repeat(Math.max(0, 23 - String(totalResults - entities.length).length))}│\n`
+      }
+      table += `└${'─'.repeat(40)}┘`
+
+      return table
     }
 
-    // NEW: Deductive reasoning summary (v0.8.6+)
-    if (deduction && deduction.derivedFacts && deduction.derivedFacts.length > 0) {
-      answer += `\n\nDeductive Reasoning: Derived ${deduction.derivedFacts.length} facts `
-      answer += `via ${deduction.rulesFired || 0} rule applications. `
-      answer += `Generated ${(deduction.proofs || []).length} cryptographic proofs.`
-
-      // Top 3 conclusions
-      const topFacts = deduction.derivedFacts.slice(0, 3)
-      if (topFacts.length > 0) {
-        answer += '\n\nKey Conclusions:'
-        for (const fact of topFacts) {
-          const factStr = fact.args
-            ? `${fact.predicate}(${fact.args.join(', ')})`
-            : `${fact.predicate || 'related'}(${fact.subject || 'unknown'}, ${fact.object || 'unknown'})`
-          answer += `\n  - ${factStr}`
-        }
+    // TEXT format (default) - natural language answer
+    const entities = extractEntities(allRows, 10)
+
+    if (totalResults === 0) {
+      return 'No results found.'
+    }
+
+    // Build natural language answer from actual data
+    let answer = ''
+
+    if (entities.length > 0) {
+      const names = entities.map(e => e.name)
+      if (names.length === 1) {
+        answer = names[0]
+      } else if (names.length <= 5) {
+        answer = names.slice(0, -1).join(', ') + ' and ' + names[names.length - 1]
+      } else {
+        answer = names.slice(0, 5).join(', ') + ` and ${totalResults - 5} more`
       }
+    } else {
+      answer = `Found ${totalResults} results`
+    }
+
+    // Add reasoning context if available
+    if (deduction && deduction.derivedFacts && deduction.derivedFacts.length > 0) {
+      answer += `\n\n[Reasoning: ${deduction.observations || 0} observations → ${deduction.derivedFacts.length} derived facts via ${deduction.rulesFired || 0} OWL rules]`
     }
 
+    // Special handling for fraud detection
     if (intent.type === 'detect_fraud' && totalResults > 0) {
-      answer = `Detected ${totalResults} potential fraud cases using ${inferences.length} detection rules` +
-        (answer.indexOf('\n\n') >= 0 ? answer.substring(answer.indexOf('\n\n')) : '')
+      answer = `Detected ${totalResults} potential fraud cases: ${answer}`
     }
 
     return answer

package/package.json

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