rust-kgdb 0.6.4 → 0.6.6

package/examples/fraud-detection-agent.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+ no#!/usr/bin/env node
 /**
  * ═══════════════════════════════════════════════════════════════════════════════
  * FRAUD DETECTION AGENT - Professional HyperMind Framework Implementation
@@ -331,19 +331,22 @@ async function main() {
   // ───────────────────────────────────────────────────────────────────────────
 
   console.log('┌─ PHASE 2: Agent Initialization ─────────────────────────────────────────┐')
-  console.log('│  HyperMindAgent.spawn(AgentSpec)                                        │')
+  console.log('│  new HyperMindAgent({ kg, memory, embeddings, ... })                    │')
   console.log('└─────────────────────────────────────────────────────────────────────────┘')
 
-  const agent = await HyperMindAgent.spawn({
+  // Initialize embedding service
+  const embeddingService = new EmbeddingService()
+
+  // Create agent with knowledge graph and embeddings
+  const agent = new HyperMindAgent({
+    kg: db,
+    embeddings: embeddingService,
     name: CONFIG.agent.name,
-    model: CONFIG.llm.model,
-    tools: CONFIG.agent.tools,
-    endpoint: 'http://localhost:30080',
-    tracing: CONFIG.agent.tracingEnabled
+    apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || null
   })
 
-  console.log(`  ✓ Agent spawned: "${agent.getName()}"`)
-  console.log(`  ✓ Model: ${agent.getModel()}`)
+  console.log(`  ✓ Agent created: "${agent.name}"`)
+  console.log(`  ✓ Model: ${CONFIG.llm.model}`)
   console.log(`  ✓ Tools: ${CONFIG.agent.tools.join(', ')}`)
   console.log()
 
@@ -352,24 +355,12 @@ async function main() {
   // ───────────────────────────────────────────────────────────────────────────
 
   console.log('┌─ PHASE 2.5: Memory Layer Initialization ─────────────────────────────────┐')
-  console.log('│  AgentRuntime + MemoryManager + GovernanceEngine + AgentScope            │')
+  console.log('│  MemoryManager + GovernancePolicy + AgentScope                            │')
   console.log('└─────────────────────────────────────────────────────────────────────────┘')
 
-  // Create agent runtime with identity
-  const runtime = new AgentRuntime({
-    name: CONFIG.agent.name,
-    model: CONFIG.llm.model,
-    tools: CONFIG.agent.tools,
-    memoryCapacity: 100,
-    episodeLimit: 1000
-  })
-
-  // Initialize memory manager with GraphDB
-  const memoryManager = new MemoryManager(runtime, db, {
-    recencyWeight: 0.3,
-    relevanceWeight: 0.5,
-    importanceWeight: 0.2
-  })
+  // Memory is automatically initialized via agent.memory
+  // Access it directly from the agent
+  const memoryManager = agent.memory
 
   // Create governance policy for fraud detection
   const policy = new GovernancePolicy({
@@ -390,24 +381,20 @@ async function main() {
     maxToolCalls: 50
   })
 
-  // Transition to READY state
+  // Create agent runtime for execution tracking
+  const runtime = new AgentRuntime({
+    name: CONFIG.agent.name,
+    model: CONFIG.llm.model,
+    tools: CONFIG.agent.tools
+  })
   runtime.transitionTo(AgentState.READY)
 
-  console.log(`  ✓ Runtime ID: ${runtime.id}`)
-  console.log(`  ✓ State: ${runtime.state}`)
   console.log(`  ✓ Memory Manager: recency=${memoryManager.weights.recency}, relevance=${memoryManager.weights.relevance}, importance=${memoryManager.weights.importance}`)
   console.log(`  ✓ Governance: ${policy.capabilities.size} capabilities, ${policy.limits.maxToolCalls} max tool calls`)
   console.log(`  ✓ Scope: ${scope.name} (graphs: ${scope.namespace.allowedGraphs.length})`)
+  console.log(`  ✓ Runtime: ${runtime.name} (state: ${runtime.state})`)
   console.log()
 
-  // Store initial context in working memory
-  memoryManager.addToWorking({
-    type: 'session_start',
-    task: 'fraud_detection',
-    target_graph: CONFIG.kg.graphUri,
-    triple_count: tripleCount
-  })
-
   // ───────────────────────────────────────────────────────────────────────────
   // PHASE 3: Tool Execution Pipeline
   // ───────────────────────────────────────────────────────────────────────────

package/examples/hypermind-fraud-underwriter.ts

@@ -48,13 +48,14 @@
 // Import HyperMind SDK (exposed via NAPI-RS FFI)
 import {
   GraphDB,
-  // HyperMind Agent Framework primitives
-  spawn,
-  AgentSpec,
-  Model,
+  // HyperMind Agent Framework
+  HyperMindAgent,
+  HyperMindAgentSpec,
+  HyperMindModel,
+  HyperMindTool,
+  TraceEntry,
   // Type system
   TypeId,
-  ExecutionWitness,
   // Graph algorithms
   GraphFrame,
   // Embeddings
@@ -160,47 +161,44 @@ class FraudDetectionAgent {
    * Create a fraud detection agent
    *
    * Uses HyperMind primitives:
-   * - spawn() - Create agent with typed tools
-   * - AgentSpec - Configure model, tools, limits
-   * - Model - LLM provider abstraction
+   * - HyperMindAgent.spawn() - Create agent with typed tools
+   * - HyperMindAgentSpec - Configure model, tools, limits
+   * - HyperMindModel - LLM model type ('claude-sonnet-4', 'gpt-4o', etc.)
    */
   static async create(config: KGDBConfig): Promise<FraudDetectionAgent> {
-    // Initialize database based on deployment mode
-    let db: any;
-    if (config.mode === 'in-memory') {
-      db = new GraphDB(config.namespace || 'http://hypermind.ai/fraud/');
-      console.log('📦 Using in-memory GraphDB');
-    } else {
-      db = await GraphDB.connect(config.endpoint!);
-      console.log(`🌐 Connected to K8s cluster at ${config.endpoint}`);
+    // Initialize database (always in-memory for SDK)
+    const db = new GraphDB(config.namespace || 'http://hypermind.ai/fraud/');
+    console.log('📦 Using in-memory GraphDB');
+    if (config.mode === 'k8s-cluster') {
+      console.log(`🌐 Agent will target K8s cluster at ${config.endpoint}`);
     }
 
-    // Create agent using HyperMind spawn() primitive
-    const agent = await spawn({
+    // Create agent using HyperMindAgent.spawn()
+    // Tools are typed morphisms (A -> B) with category theory composition
+    const agent = await HyperMindAgent.spawn({
       name: 'fraud-detection-agent',
-      description: 'Detects fraud patterns using knowledge graph analysis with WASM sandbox',
 
-      // LLM Model (supports Claude, GPT-4, Ollama, etc.)
-      model: Model.Claude('claude-3-opus'),
+      // LLM Model: 'claude-sonnet-4' | 'claude-opus-4' | 'gpt-4o' | 'gpt-4' | 'mock'
+      model: 'claude-sonnet-4' as HyperMindModel,
 
-      // Tools are typed morphisms (A -> B) with category theory composition
+      // Available tools:
+      // 'kg.sparql.query' | 'kg.sparql.update' | 'kg.motif.find' |
+      // 'kg.datalog.apply' | 'kg.semantic.search' | 'kg.traversal.oneHop' | 'kg.traversal.paths'
       tools: [
-        'kg.sparql.query',           // Query -> BindingSet
-        'kg.motif.find',             // Graph -> PatternSet
-        'kg.datalog.apply',          // Rules -> InferredFacts
-        'kg.embeddings.search',      // Entity -> SimilarEntities
-        'kg.graphframes.pagerank',   // Graph -> Rankings
-        'kg.graphframes.connected_components', // Graph -> Components
+        'kg.sparql.query' as HyperMindTool,    // Query -> BindingSet
+        'kg.motif.find' as HyperMindTool,      // Graph -> PatternSet
+        'kg.datalog.apply' as HyperMindTool,   // Rules -> InferredFacts
+        'kg.semantic.search' as HyperMindTool, // Entity -> SimilarEntities
       ],
 
-      // Execution limits
-      maxIterations: 10,
+      // K8s cluster endpoint (optional for in-memory mode)
+      endpoint: config.endpoint,
 
-      // Enable full provenance tracking (Curry-Howard witnesses)
-      tracingEnabled: true,
+      // Execution timeout (optional)
+      timeout: 30000,
 
-      // Execute tools in WASM sandbox (wasmtime)
-      wasmSandbox: true,
+      // Enable full provenance tracking
+      tracing: true,
     });
 
     return new FraudDetectionAgent(agent, db, config);
@@ -412,26 +410,31 @@ class UnderwritingAgent {
    * Create an underwriting agent
    */
   static async create(config: KGDBConfig): Promise<UnderwritingAgent> {
-    let db: any;
-    if (config.mode === 'in-memory') {
-      db = new GraphDB(config.namespace || 'http://hypermind.ai/underwriting/');
-    } else {
-      db = await GraphDB.connect(config.endpoint!);
-    }
+    // Initialize database (in-memory)
+    const db = new GraphDB(config.namespace || 'http://hypermind.ai/underwriting/');
 
-    const agent = await spawn({
+    // Create agent using HyperMindAgent.spawn()
+    const agent = await HyperMindAgent.spawn({
       name: 'underwriting-agent',
-      description: 'Insurance underwriting with risk assessment using knowledge graph',
-      model: Model.Claude('claude-3-opus'),
+
+      // LLM Model
+      model: 'claude-sonnet-4' as HyperMindModel,
+
+      // Available tools for underwriting
       tools: [
-        'kg.sparql.query',
-        'kg.datalog.apply',
-        'kg.embeddings.search',
-        'kg.graphframes.pagerank',
+        'kg.sparql.query' as HyperMindTool,
+        'kg.datalog.apply' as HyperMindTool,
+        'kg.semantic.search' as HyperMindTool,
       ],
-      maxIterations: 8,
-      tracingEnabled: true,
-      wasmSandbox: true,
+
+      // K8s cluster endpoint
+      endpoint: config.endpoint,
+
+      // Execution timeout
+      timeout: 30000,
+
+      // Enable tracing for audit
+      tracing: true,
     });
 
     return new UnderwritingAgent(agent, db);
@@ -504,7 +507,7 @@ interface FraudAnalysisReport {
   patterns: DetectedPattern[];
   suspiciousEntities: SuspiciousEntity[];
   recommendedActions: string[];
-  executionWitness: ExecutionWitness;
+  trace: TraceEntry[];  // Execution trace for audit
 }
 
 interface DetectedPattern {

package/examples/underwriting-agent.js

@@ -275,24 +275,26 @@ async function main() {
   // PHASE 2: Spawn HyperMind Agent
   // ─────────────────────────────────────────────────────────────────────────
 
-  console.log('┌─ AGENT: HyperMindAgent.spawn() ──────────────────────────────────────┐')
-  console.log('│  AgentSpec: {                                                        │')
+  console.log('┌─ AGENT: new HyperMindAgent() ──────────────────────────────────────────┐')
+  console.log('│  Config: {                                                           │')
   console.log('│    name: "underwriter",                                              │')
   console.log(`│    model: "${MODEL}",                                       │`)
   console.log('│    tools: [kg.sparql.query, kg.datalog.apply, kg.embeddings.search],│')
-  console.log('│    tracing: true                                                     │')
   console.log('│  }                                                                   │')
   console.log('└─────────────────────────────────────────────────────────────────────┘')
 
-  const agent = await HyperMindAgent.spawn({
+  // Initialize embedding service
+  const embeddingService = new EmbeddingService()
+
+  // Create agent with knowledge graph and embeddings
+  const agent = new HyperMindAgent({
+    kg: db,
+    embeddings: embeddingService,
     name: 'underwriter',
-    model: MODEL,
-    tools: ['kg.sparql.query', 'kg.datalog.apply', 'kg.embeddings.search'],
-    endpoint: 'http://localhost:30080',
-    tracing: true
+    apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || null
   })
 
-  console.log(`  Agent "${agent.getName()}" spawned with model: ${agent.getModel()}`)
+  console.log(`  Agent "${agent.getName()}" created with model: ${agent.getModel()}`)
   console.log()
 
   // ─────────────────────────────────────────────────────────────────────────
@@ -311,13 +313,10 @@ async function main() {
     memoryCapacity: 100,
     episodeLimit: 1000
   })
+  runtime.transitionTo(AgentState.READY)
 
-  // Initialize memory manager with GraphDB
-  const memoryManager = new MemoryManager(runtime, db, {
-    recencyWeight: 0.3,
-    relevanceWeight: 0.5,
-    importanceWeight: 0.2
-  })
+  // Memory is automatically initialized via agent.memory
+  const memoryManager = agent.memory
 
   // Create governance policy for underwriting
   const policy = new GovernancePolicy({
@@ -350,10 +349,7 @@ async function main() {
     triple_count: tripleCount
   })
 
-  // Transition to READY state first
-  runtime.transitionTo(AgentState.READY)
-
-  // Start execution for episodic tracking
+  // Start execution for episodic tracking (runtime is already in READY state)
   const executionId = runtime.startExecution('Commercial underwriting risk analysis')
 
   // ─────────────────────────────────────────────────────────────────────────
@@ -646,7 +642,7 @@ async function main() {
       referToUW: referToUW.map(d => d.args[0])
     },
     premiums: premiums.map(p => ({ id: p.id, premium: p.premium, decision: p.decision })),
-    trace: agent.getTrace(),
+    trace: agent.getAuditLog(),
     // Memory Layer (v0.5.13+)
     memory: {
       runtimeId: runtime.id,