knowledge-graph-memory

Knowledge Graph Memory

Long-term memory system with knowledge graph, concept drift detection, and temporal reasoning.

When to Use

Usage

const { KnowledgeGraph, Memory } = require('./skills/knowledge-graph-memory');
// Create a knowledge graph
const kg = new KnowledgeGraph();
// Add concepts
kg.addConcept('AI', { category: 'technology', importance: 0.9 });
kg.addConcept('Machine Learning', { category: 'technology' });
// Link concepts
kg.link('AI', 'Machine Learning', 'includes');
// Find related concepts
const related = kg.getRelated('AI');
// Detect concept drift
const drift = kg.detectDrift('AI');
// Search concepts
const results = kg.search({ name: 'AI' });

Features

API

KnowledgeGraph

const kg = new KnowledgeGraph({
  maxNodes: 10000,
  consolidationThreshold: 0.1,
  driftDetection: { method: 'statistical', threshold: 2.0 }
});
// Add and get concepts
kg.addConcept(name, properties);
kg.getConcept(idOrName);
// Create relationships
kg.link(sourceId, targetId, edgeType, properties);
// Query
kg.getRelated(conceptId, edgeType);
kg.findPath(startId, endId, maxDepth);
kg.search({ name: 'pattern', type: 'concept' });
// Drift detection
kg.detectDrift(conceptId);
// Memory management
kg.consolidate();
kg.removeConcept(id);
// Serialization
kg.toJSON();
KnowledgeGraph.fromJSON(data);

Concept

const concept = new Concept({
  name: 'AI',
  type: 'concept',
  properties: { category: 'technology' },
  importance: 0.8
});
concept.access();  // Increment access count
concept.update({ newProperty: 'value' });  // Update with history

DriftDetector

const detector = new DriftDetector({
  method: 'statistical',
  windowSize: 100,
  threshold: 2.0
});
const result = detector.addSample(value);
// { drift: boolean, warning: boolean, mean, stdDev }

TemporalReasoner

const reasoner = new TemporalReasoner();
reasoner.addEvent({ type: 'concept_added', conceptId: 'AI' });
reasoner.getEventsInRange(start, end);
reasoner.getEventsBefore(time);
reasoner.getEventsAfter(time);
reasoner.getRecentEvents(10);

Memory

const memory = new Memory({
  shortTermMaxSize: 100,
  consolidationInterval: 3600000
});
memory.remember('key', { data: 'value' }, { importance: 0.8 });
memory.recall('key');
memory.forget('key');
memory.consolidate();

Node Types

Edge Types

Example: Building a Knowledge Base

const { KnowledgeGraph, EdgeType } = require('./skills/knowledge-graph-memory');
const kg = new KnowledgeGraph();
// Build knowledge structure
kg.addConcept('Technology', { category: 'domain' });
kg.addConcept('AI', { category: 'field' });
kg.addConcept('Machine Learning', { category: 'subfield' });
kg.addConcept('Neural Networks', { category: 'technique' });
kg.addConcept('Deep Learning', { category: 'technique' });
// Create relationships
kg.link('AI', 'Technology', EdgeType.IS_A);
kg.link('Machine Learning', 'AI', EdgeType.IS_A);
kg.link('Neural Networks', 'Machine Learning', EdgeType.IS_A);
kg.link('Deep Learning', 'Neural Networks', EdgeType.IS_A);
kg.link('Deep Learning', 'Machine Learning', EdgeType.RELATED_TO);
// Query the graph
const mlRelated = kg.getRelated('Machine Learning');
const path = kg.findPath('Deep Learning', 'Technology');
console.log('ML related concepts:', mlRelated.map(r => r.concept.name));
console.log('Path:', path?.map(c => c.name));

Example: Concept Drift Detection

const { KnowledgeGraph } = require('./skills/knowledge-graph-memory');
const kg = new KnowledgeGraph();
kg.addConcept('User Behavior', { pattern: 'initial' });
// Simulate concept evolution
for (let i = 0; i < 50; i++) {
  const concept = kg.getConcept('User Behavior');
  concept.update({ pattern: evolved_${i} });
  
  const drift = kg.detectDrift('User Behavior');
  if (drift.drift) {
    console.log('Drift detected at iteration', i);
  }
}

Example: Memory Consolidation

const { Memory } = require('./skills/knowledge-graph-memory');
const memory = new Memory();
// Store memories
memory.remember('important_fact', { value: 'critical data' }, { importance: 0.9 });
memory.remember('temporary_note', { value: 'temp data' }, { importance: 0.3 });
// Access important memory multiple times
for (let i = 0; i < 5; i++) {
  memory.recall('important_fact');
}
// Consolidate - promotes frequently accessed to long-term
const result = memory.consolidate();
console.log('Promoted:', result.promoted, 'Removed:', result.removed);

const { KnowledgeGraph, Memory } = require('./skills/knowledge-graph-memory');
// Create a knowledge graph
const kg = new KnowledgeGraph();
// Add concepts
kg.addConcept('AI', { category: 'technology', importance: 0.9 });
kg.addConcept('Machine Learning', { category: 'technology' });
// Link concepts
kg.link('AI', 'Machine Learning', 'includes');
// Find related concepts
const related = kg.getRelated('AI');
// Detect concept drift
const drift = kg.detectDrift('AI');
// Search concepts
const results = kg.search({ name: 'AI' });