Creating Knowledge Graphs with Semantic Memory

import Rekall from '@rekall/agent-sdk';

const rekall = new Rekall({ apiKey: 'rk_your_key' });

// Create a person entity
const adam = await rekall.semantic.createEntity({
  name: 'Adam',
  type: 'person',
  description: 'Lead engineer working on the payments platform',
  properties: {
    role: 'lead-engineer',
    team: 'platform',
    email: 'adam@example.com',
  },
});

// Create a project entity
const paymentsService = await rekall.semantic.createEntity({
  name: 'payments-service',
  type: 'project',
  description: 'Core payment processing microservice handling Stripe integration',
  properties: {
    language: 'typescript',
    framework: 'fastify',
    repo: 'github.com/acme/payments-service',
  },
});

// Create a technology entity
const postgres = await rekall.semantic.createEntity({
  name: 'PostgreSQL',
  type: 'technology',
  description: 'Primary relational database for transactional data',
  properties: {
    version: '16',
    hosting: 'neon',
  },
});

// Adam owns payments-service
await rekall.semantic.createRelationship({
  sourceId: adam.id,
  targetId: paymentsService.id,
  type: 'owns',
  properties: {
    since: '2024-03',
    role: 'tech-lead',
  },
});

// payments-service uses PostgreSQL
await rekall.semantic.createRelationship({
  sourceId: paymentsService.id,
  targetId: postgres.id,
  type: 'uses',
  properties: {
    purpose: 'transaction-storage',
    critical: true,
  },
});

// payments-service depends-on auth-service
const authService = await rekall.semantic.createEntity({
  name: 'auth-service',
  type: 'project',
  description: 'JWT-based authentication and authorization service',
});

await rekall.semantic.createRelationship({
  sourceId: paymentsService.id,
  targetId: authService.id,
  type: 'depends-on',
  properties: {
    interface: 'REST API',
    version: 'v2',
  },
});

// Find entities related to a concept
const results = await rekall.semantic.searchEntities({
  query: 'payment processing infrastructure',
  types: ['project', 'technology'],
  limit: 10,
});

for (const entity of results.entities) {
  console.log(`[${entity.type}] ${entity.name}: ${entity.description}`);
}

// Find all entities of a specific type
const people = await rekall.semantic.searchEntities({
  types: ['person'],
  limit: 50,
});

// Traverse: Adam -> owns -> projects -> uses -> technologies
const techStack = await rekall.semantic.traverse({
  startEntityId: adam.id,
  path: [
    { type: 'owns', direction: 'outgoing' },
    { type: 'uses', direction: 'outgoing' },
  ],
});

console.log('Technologies Adam works with:');
for (const node of techStack.nodes) {
  console.log(`  - ${node.name} (${node.type})`);
}
// - PostgreSQL (technology)
// - Redis (technology)
// - Stripe API (technology)

// Find impact radius: what depends on PostgreSQL?
const impacted = await rekall.semantic.traverse({
  startEntityId: postgres.id,
  path: [
    { type: 'uses', direction: 'incoming' },      // projects that use postgres
    { type: 'owns', direction: 'incoming' },       // people who own those projects
  ],
});

console.log('People affected if PostgreSQL goes down:');
for (const node of impacted.nodes) {
  if (node.type === 'person') {
    console.log(`  - ${node.name}`);
  }
}