recallnest 1.4.1

package/src/multi-vector.ts

@@ -0,0 +1,234 @@
+/**
+ * Multi-Vector L0/L1/L2 Embedding Support
+ *
+ * Borrowed from UltraMemory's multi-vector approach:
+ * - L0 (abstract): 1-sentence concept-level summary → good for broad topic match
+ * - L1 (overview): bullet-point structure → good for structural match
+ * - L2 (detail): full content → default vector (already exists)
+ *
+ * RecallNest already stores L0/L1/L2 text in metadata. This module:
+ * 1. Extracts L0/L1 text from metadata
+ * 2. Generates additional vector embeddings for them
+ * 3. Provides a blending function for retrieval scoring
+ *
+ * Opt-in via RECALLNEST_MULTI_VECTOR=true environment variable.
+ * When disabled, all functions are no-ops that return empty results.
+ */
+
+import type { Embedder } from "./embedder.js";
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+export function isMultiVectorEnabled(): boolean {
+  return process.env.RECALLNEST_MULTI_VECTOR === "true";
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface MultiVectorEmbeddings {
+  /** L0 abstract vector (concept-level). Null if no L0 text available. */
+  vector_l0: number[] | null;
+  /** L1 overview vector (structure-level). Null if no L1 text available. */
+  vector_l1: number[] | null;
+}
+
+export interface MultiVectorBlendConfig {
+  /** Weight for main vector channel (default: 0.65) */
+  vectorWeight: number;
+  /** Weight for L0 abstract channel (default: 0.20) */
+  l0Weight: number;
+  /** Weight for L1 overview channel (default: 0.15) */
+  l1Weight: number;
+}
+
+export const DEFAULT_BLEND_CONFIG: MultiVectorBlendConfig = {
+  vectorWeight: 0.65,
+  l0Weight: 0.20,
+  l1Weight: 0.15,
+};
+
+// ---------------------------------------------------------------------------
+// Extraction
+// ---------------------------------------------------------------------------
+
+/** Extract L0 and L1 text from metadata JSON string. */
+export function extractMultiVectorText(metadata?: string): { l0?: string; l1?: string } {
+  if (!metadata) return {};
+  try {
+    const meta = JSON.parse(metadata);
+    return {
+      l0: typeof meta.l0_abstract === "string" && meta.l0_abstract.length > 5 ? meta.l0_abstract : undefined,
+      l1: typeof meta.l1_overview === "string" && meta.l1_overview.length > 5 ? meta.l1_overview : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Embedding
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate L0 and L1 vector embeddings from metadata text.
+ * Returns null vectors when text is not available or multi-vector is disabled.
+ */
+export async function embedMultiVector(
+  embedder: Pick<Embedder, "embedPassage">,
+  metadata?: string,
+): Promise<MultiVectorEmbeddings> {
+  if (!isMultiVectorEnabled()) {
+    return { vector_l0: null, vector_l1: null };
+  }
+
+  const { l0, l1 } = extractMultiVectorText(metadata);
+
+  const [vector_l0, vector_l1] = await Promise.all([
+    l0 ? embedder.embedPassage(l0) : Promise.resolve(null),
+    l1 ? embedder.embedPassage(l1) : Promise.resolve(null),
+  ]);
+
+  return { vector_l0, vector_l1 };
+}
+
+// ---------------------------------------------------------------------------
+// Score Blending
+// ---------------------------------------------------------------------------
+
+/**
+ * Blend multi-vector scores into a single relevance score.
+ *
+ * When L0/L1 scores are available, the main vector score is weighted down
+ * and supplemented by abstract/overview channel scores.
+ * When L0/L1 are unavailable, falls back to main vector score only.
+ */
+export function blendMultiVectorScores(
+  mainScore: number,
+  l0Score: number | null,
+  l1Score: number | null,
+  config: MultiVectorBlendConfig = DEFAULT_BLEND_CONFIG,
+): number {
+  if (l0Score === null && l1Score === null) {
+    return mainScore; // No multi-vector data, use main score as-is
+  }
+
+  // Redistribute weights among available channels
+  let totalWeight = config.vectorWeight;
+  let weightedSum = mainScore * config.vectorWeight;
+
+  if (l0Score !== null) {
+    totalWeight += config.l0Weight;
+    weightedSum += l0Score * config.l0Weight;
+  }
+
+  if (l1Score !== null) {
+    totalWeight += config.l1Weight;
+    weightedSum += l1Score * config.l1Weight;
+  }
+
+  return totalWeight > 0 ? weightedSum / totalWeight : mainScore;
+}
+
+// ---------------------------------------------------------------------------
+// Cosine Similarity (for in-memory multi-vector scoring)
+// ---------------------------------------------------------------------------
+
+/** Compute cosine similarity between two vectors. Returns 0 for mismatched/empty vectors. */
+export function cosineSimilarity(a: number[], b: number[]): number {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+// ---------------------------------------------------------------------------
+// Text-Overlap Scoring (lightweight proxy for L0/L1 vector similarity)
+// ---------------------------------------------------------------------------
+
+const CJK_RANGE = /[\u4e00-\u9fff\u3400-\u4dbf]/;
+const STOP_WORDS_EN = new Set(["a","an","the","is","are","was","were","be","been","being","have","has","had","do","does","did","will","would","shall","should","may","might","can","could","of","in","to","for","with","on","at","by","from","and","or","but","not","no","so","if","as","it","i","my","me","we","our","us","you","your","he","she","they","them","this","that","what","which","who","how","when","where","why"]);
+const STOP_WORDS_ZH = new Set(["的","了","在","是","我","有","和","就","不","人","都","一","一个","上","也","很","到","说","要","去","你","会","着","没有","看","好","自己","这"]);
+
+/** Tokenize text into words, CJK-aware. Returns lowercased tokens with stop words removed. */
+export function tokenize(text: string): string[] {
+  const tokens: string[] = [];
+  const lower = text.toLowerCase();
+
+  // Walk character-by-character: CJK chars → individual tokens, Latin runs → whole-word tokens
+  let currentWord = "";
+  for (const ch of lower) {
+    if (CJK_RANGE.test(ch)) {
+      // Flush any accumulated Latin word
+      if (currentWord.length > 1 && !STOP_WORDS_EN.has(currentWord)) tokens.push(currentWord);
+      currentWord = "";
+      // CJK char as individual token
+      if (!STOP_WORDS_ZH.has(ch)) tokens.push(ch);
+    } else if (/\w/.test(ch)) {
+      currentWord += ch;
+    } else {
+      // Punctuation/whitespace: flush Latin word
+      if (currentWord.length > 1 && !STOP_WORDS_EN.has(currentWord)) tokens.push(currentWord);
+      currentWord = "";
+    }
+  }
+  // Flush trailing Latin word
+  if (currentWord.length > 1 && !STOP_WORDS_EN.has(currentWord)) tokens.push(currentWord);
+
+  return tokens;
+}
+
+/**
+ * Compute term-overlap score between query and candidate text.
+ * Returns [0, 1] blending coverage (query terms found) and density
+ * (query terms / candidate length). Density rewards concise abstracts
+ * over verbose full-text, which is exactly the L0>L1>L2 gradient we want.
+ */
+export function textOverlapScore(query: string, candidateText: string): number {
+  const qTokens = tokenize(query);
+  if (qTokens.length === 0) return 0;
+
+  const cTokens = tokenize(candidateText);
+  if (cTokens.length === 0) return 0;
+
+  const cSet = new Set(cTokens);
+  let hits = 0;
+  for (const t of qTokens) {
+    if (cSet.has(t)) hits++;
+  }
+
+  // Coverage: what fraction of query terms appear in candidate [0, 1]
+  const coverage = hits / qTokens.length;
+
+  // Density: query term hits / candidate token count — rewards concise text [0, 1]
+  const density = hits / cTokens.length;
+
+  // Blend: coverage dominant (70%), density as tiebreaker (30%)
+  return coverage * 0.7 + density * 0.3;
+}
+
+/**
+ * Adaptive blend weights based on query length.
+ * Short/conceptual queries → weight L0/L1 more.
+ * Long/detailed queries → weight L2 (main vector) more.
+ */
+export function adaptiveBlendConfig(queryTokenCount: number): MultiVectorBlendConfig {
+  if (queryTokenCount <= 3) {
+    // Topic-level: boost L0/L1
+    return { vectorWeight: 0.50, l0Weight: 0.25, l1Weight: 0.25 };
+  }
+  if (queryTokenCount <= 10) {
+    // Default balanced
+    return DEFAULT_BLEND_CONFIG;
+  }
+  // Detailed query: rely on L2 main vector
+  return { vectorWeight: 0.80, l0Weight: 0.10, l1Weight: 0.10 };
+}

package/src/noise-filter.ts

@@ -0,0 +1,155 @@
+/**
+ * Noise Filter
+ * Filters out low-quality memories (meta-questions, agent denials, session boilerplate)
+ * Inspired by openclaw-plugin-continuity's noise filtering approach.
+ */
+
+import { logInfo } from "./stderr-log.js";
+
+// Agent-side denial patterns
+const DENIAL_PATTERNS = [
+  /i don'?t have (any )?(information|data|memory|record)/i,
+  /i'?m not sure about/i,
+  /i don'?t recall/i,
+  /i don'?t remember/i,
+  /it looks like i don'?t/i,
+  /i wasn'?t able to find/i,
+  /no (relevant )?memories found/i,
+  /i don'?t have access to/i,
+  // Chinese denial patterns (synced from upstream)
+  /我没有(任何)?(相关)?(信息|数据|记忆|记录)/,
+  /我不(太)?确定/,
+  /我不记得/,
+  /我想不起来/,
+  /我没(有)?找到/,
+  /找不到(相关)?记忆/,
+  /没有(相关)?记忆/,
+  /我无法(访问|获取)/,
+];
+
+// User-side meta-question patterns (about memory itself, not content)
+const META_QUESTION_PATTERNS = [
+  /\bdo you (remember|recall|know about)\b/i,
+  /\bcan you (remember|recall)\b/i,
+  /\bdid i (tell|mention|say|share)\b/i,
+  /\bhave i (told|mentioned|said)\b/i,
+  /\bwhat did i (tell|say|mention)\b/i,
+  // Chinese meta-question patterns (synced from upstream)
+  /你(还)?记得吗/,
+  /你(还)?记不记得/,
+  /你知道我(说过|提过|告诉|提到).*吗/,
+  /我(有没有|是不是)(说过|提过|告诉|提到)/,
+  /我之前(说过|提过|提到|告诉)/,
+  /我(跟你)?说过.*吗/,
+];
+
+// Session boilerplate (anchored to prevent false positives on real content)
+const BOILERPLATE_PATTERNS = [
+  /^(hi|hello|hey|good morning|good evening|greetings)/i,
+  /^fresh session/i,
+  /^new session/i,
+  /^HEARTBEAT/i,
+  /^你好[!！\s,.，。]?$/,
+  /^(早上好|早安|午安|晚上好|晚安)[!！\s,.，。]?$/,
+  /^(嗨|哈[喽啰]|哈[喽啰]呀)[!！\s,.，。]?$/,
+  /^(嗯|哦|噢|呃)[!！\s,.，。]?$/,
+  /^新(会话|对话|聊天)/,
+];
+
+// Short boilerplate: only noise when total text is very short
+// "好的" alone = noise, "好的方案是使用Redis" = real content
+const SHORT_BOILERPLATE_PATTERNS = [
+  /^(好的|好吧|行|可以|没问题|OK|ok|收到|明白|了解|知道了)/i,
+  /^(谢谢|感谢|多谢|谢啦|3Q|thx)/i,
+];
+const BOILERPLATE_MAX_LENGTH = 10;
+
+// OpenClaw v3.2+ injected metadata headers (backport from v1.0.29)
+const METADATA_HEADER_PATTERNS = [
+  /^Conversation info \(untrusted metadata\)/i,
+  /^---\s*\n\s*\{[\s\S]*?\}\s*\n\s*---/m, // YAML-like JSON blocks
+  /^\[?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[^\]]*\]?\s*$/m, // bare timestamps
+];
+
+// Diagnostic artifact patterns (synced from upstream v1.1.0-beta.3)
+// Extractor validation outputs that leak into memory store
+const DIAGNOSTIC_ARTIFACT_PATTERNS = [
+  /^query\s*->\s*none$/i,
+  /^no explicit solution$/i,
+  /^如果你知道.+只回复/i,
+  /^如果不知道.+只回复\s*none/i,
+  /^只回复精确代号/i,
+];
+
+export interface NoiseFilterOptions {
+  /** Filter agent denial responses (default: true) */
+  filterDenials?: boolean;
+  /** Filter meta-questions about memory (default: true) */
+  filterMetaQuestions?: boolean;
+  /** Filter session boilerplate (default: true) */
+  filterBoilerplate?: boolean;
+}
+
+const DEFAULT_OPTIONS: Required<NoiseFilterOptions> = {
+  filterDenials: true,
+  filterMetaQuestions: true,
+  filterBoilerplate: true,
+};
+
+/**
+ * Check if a memory text is noise that should be filtered out.
+ * Returns true if the text is noise.
+ */
+export function isNoise(text: string, options: NoiseFilterOptions = {}): boolean {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const trimmed = text.trim();
+
+  if (trimmed.length < 5) {
+    logInfo(`[INFO] noise-filter: skipped short text (${trimmed.length} chars)`);
+    return true;
+  }
+
+  if (opts.filterDenials && DENIAL_PATTERNS.some(p => p.test(trimmed))) {
+    logInfo(`[INFO] noise-filter: denial pattern matched: "${trimmed.slice(0, 60)}..."`);
+    return true;
+  }
+  if (opts.filterMetaQuestions && META_QUESTION_PATTERNS.some(p => p.test(trimmed))) {
+    logInfo(`[INFO] noise-filter: meta-question filtered: "${trimmed.slice(0, 60)}..."`);
+    return true;
+  }
+  if (opts.filterBoilerplate) {
+    if (BOILERPLATE_PATTERNS.some(p => p.test(trimmed))) {
+      logInfo(`[INFO] noise-filter: boilerplate filtered: "${trimmed.slice(0, 60)}..."`);
+      return true;
+    }
+    if (trimmed.length <= BOILERPLATE_MAX_LENGTH &&
+        SHORT_BOILERPLATE_PATTERNS.some(p => p.test(trimmed))) {
+      logInfo(`[INFO] noise-filter: short boilerplate filtered: "${trimmed}"`);
+      return true;
+    }
+  }
+  // OpenClaw v3.2+ metadata noise (backport from v1.0.29)
+  if (METADATA_HEADER_PATTERNS.some(p => p.test(trimmed))) {
+    logInfo(`[INFO] noise-filter: metadata header filtered`);
+    return true;
+  }
+  // Diagnostic artifact noise (synced from upstream v1.1.0-beta.3)
+  if (DIAGNOSTIC_ARTIFACT_PATTERNS.some(p => p.test(trimmed))) {
+    logInfo(`[INFO] noise-filter: diagnostic artifact filtered: "${trimmed.slice(0, 60)}..."`);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Filter an array of items, removing noise entries.
+ */
+export function filterNoise<T>(
+  items: T[],
+  getText: (item: T) => string,
+  options?: NoiseFilterOptions
+): T[] {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  return items.filter(item => !isNoise(getText(item), opts));
+}

package/src/ppr-traversal.ts

@@ -0,0 +1,279 @@
+/**
+ * Personalized PageRank (PPR) Graph Traversal
+ * Walks the KG from seed entities and scores reachable nodes by relevance.
+ */
+
+import type { KGTriple, NeighborhoodResult } from "./kg-store.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface PPRConfig {
+  /** Teleport probability back to seed nodes (default: 0.85) */
+  dampingFactor: number;
+  /** Max power-iteration rounds (default: 10) */
+  maxIterations: number;
+  /** Early stop when max score delta < threshold (default: 0.001) */
+  convergenceThreshold: number;
+  /** Return top-K scored entities (default: 20) */
+  topK: number;
+  /** Ignore paths longer than this many hops (default: 2) */
+  hopLimit: number;
+}
+
+export interface PPRResult {
+  entity: string;
+  score: number;
+  /** Shortest hop distance from any seed entity */
+  hops: number;
+  /** One shortest path from seed to this entity */
+  path: string[];
+}
+
+export const DEFAULT_PPR_CONFIG: PPRConfig = {
+  dampingFactor: 0.85,
+  maxIterations: 10,
+  convergenceThreshold: 0.001,
+  topK: 20,
+  hopLimit: 2,
+};
+
+// ============================================================================
+// Edge weights by predicate
+// ============================================================================
+
+const PREDICATE_WEIGHTS: Record<string, number> = {
+  created_by: 0.95,
+  depends_on: 0.90,
+  uses: 0.90,
+  works_with: 0.80,
+  works_at: 0.80,
+  friend_of: 0.75,
+  member_of: 0.75,
+  knows: 0.75,
+  manages: 0.75,
+  built: 0.85,
+  wrote: 0.85,
+  prefers: 0.70,
+  discussed: 0.70,
+  lives_in: 0.70,
+  located_in: 0.70,
+  mentioned_in: 0.60,
+  related_to: 0.50,
+  is_a: 0.80,
+  has: 0.75,
+};
+
+const DEFAULT_EDGE_WEIGHT = 0.60;
+
+export function edgeWeight(predicate: string): number {
+  return PREDICATE_WEIGHTS[predicate] ?? DEFAULT_EDGE_WEIGHT;
+}
+
+// ============================================================================
+// Graph builder from NeighborhoodResult
+// ============================================================================
+
+interface AdjEntry {
+  neighbor: string;
+  weight: number;
+  predicate: string;
+}
+
+interface Graph {
+  /** entity -> outgoing adjacency list */
+  adj: Map<string, AdjEntry[]>;
+  /** All nodes in the graph */
+  nodes: Set<string>;
+}
+
+/**
+ * Build an undirected weighted graph from BFS neighborhood results.
+ * Each triple creates edges in both directions.
+ */
+export function buildGraph(neighborhood: NeighborhoodResult[]): Graph {
+  const adj = new Map<string, AdjEntry[]>();
+  const nodes = new Set<string>();
+  const seen = new Set<string>(); // dedup triples by id
+
+  for (const nr of neighborhood) {
+    nodes.add(nr.entity);
+    for (const t of nr.triples) {
+      if (seen.has(t.id)) continue;
+      seen.add(t.id);
+
+      nodes.add(t.subject);
+      nodes.add(t.object);
+
+      const w = edgeWeight(t.predicate) * t.confidence;
+
+      // subject -> object
+      if (!adj.has(t.subject)) adj.set(t.subject, []);
+      adj.get(t.subject)!.push({ neighbor: t.object, weight: w, predicate: t.predicate });
+
+      // object -> subject (undirected)
+      if (!adj.has(t.object)) adj.set(t.object, []);
+      adj.get(t.object)!.push({ neighbor: t.subject, weight: w, predicate: t.predicate });
+    }
+  }
+
+  return { adj, nodes };
+}
+
+// ============================================================================
+// PPR core
+// ============================================================================
+
+/**
+ * Run Personalized PageRank on a pre-built graph.
+ *
+ * Algorithm:
+ *   score(v) = (1-d) * seed(v) + d * Σ_u [ score(u) * w(u→v) / outWeightSum(u) ]
+ *
+ * where d = dampingFactor, seed(v) = 1/|seeds| if v is a seed entity, else 0.
+ */
+export function pprTraverse(
+  graph: Graph,
+  startEntities: string[],
+  config: Partial<PPRConfig> = {},
+): PPRResult[] {
+  const cfg = { ...DEFAULT_PPR_CONFIG, ...config };
+  const { dampingFactor: d, maxIterations, convergenceThreshold, topK } = cfg;
+
+  if (graph.nodes.size === 0 || startEntities.length === 0) {
+    return [];
+  }
+
+  // Filter seeds to only those present in graph
+  const seeds = startEntities.filter(e => graph.nodes.has(e));
+  if (seeds.length === 0) return [];
+
+  const seedSet = new Set(seeds);
+  const seedScore = 1.0 / seeds.length;
+
+  // Initialize scores: uniform over seeds
+  const scores = new Map<string, number>();
+  for (const node of graph.nodes) {
+    scores.set(node, seedSet.has(node) ? seedScore : 0);
+  }
+
+  // Pre-compute out-weight sums
+  const outWeightSum = new Map<string, number>();
+  for (const [node, edges] of graph.adj) {
+    let sum = 0;
+    for (const e of edges) sum += e.weight;
+    outWeightSum.set(node, sum);
+  }
+
+  // Power iteration
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const newScores = new Map<string, number>();
+
+    // Teleport component
+    for (const node of graph.nodes) {
+      newScores.set(node, seedSet.has(node) ? (1 - d) * seedScore : 0);
+    }
+
+    // Diffusion component
+    for (const [node, edges] of graph.adj) {
+      const nodeScore = scores.get(node) ?? 0;
+      if (nodeScore === 0) continue;
+      const totalOut = outWeightSum.get(node) ?? 1;
+
+      for (const edge of edges) {
+        const contribution = d * nodeScore * (edge.weight / totalOut);
+        newScores.set(edge.neighbor, (newScores.get(edge.neighbor) ?? 0) + contribution);
+      }
+    }
+
+    // Check convergence
+    let maxDelta = 0;
+    for (const node of graph.nodes) {
+      const delta = Math.abs((newScores.get(node) ?? 0) - (scores.get(node) ?? 0));
+      if (delta > maxDelta) maxDelta = delta;
+    }
+
+    // Update scores
+    for (const [node, score] of newScores) {
+      scores.set(node, score);
+    }
+
+    if (maxDelta < convergenceThreshold) break;
+  }
+
+  // Compute shortest paths from seeds via BFS
+  const hopsMap = new Map<string, number>();
+  const pathMap = new Map<string, string[]>();
+
+  for (const seed of seeds) {
+    hopsMap.set(seed, 0);
+    pathMap.set(seed, [seed]);
+  }
+
+  const bfsQueue = [...seeds];
+  let qi = 0;
+  while (qi < bfsQueue.length) {
+    const current = bfsQueue[qi++];
+    const currentHops = hopsMap.get(current)!;
+    if (currentHops >= cfg.hopLimit) continue;
+
+    const edges = graph.adj.get(current) ?? [];
+    for (const edge of edges) {
+      if (!hopsMap.has(edge.neighbor)) {
+        hopsMap.set(edge.neighbor, currentHops + 1);
+        pathMap.set(edge.neighbor, [...(pathMap.get(current) ?? []), edge.neighbor]);
+        bfsQueue.push(edge.neighbor);
+      }
+    }
+  }
+
+  // Build results, exclude seed entities themselves, sort by score
+  const results: PPRResult[] = [];
+  for (const [entity, score] of scores) {
+    if (score <= 0) continue;
+    const hops = hopsMap.get(entity) ?? Infinity;
+    if (hops > cfg.hopLimit) continue;
+
+    results.push({
+      entity,
+      score,
+      hops,
+      path: pathMap.get(entity) ?? [entity],
+    });
+  }
+
+  // Sort by score descending, take top-K
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topK);
+}
+
+// ============================================================================
+// Convenience: from triples directly
+// ============================================================================
+
+/**
+ * Build graph from raw triples and run PPR.
+ * Useful when you already have triples without going through KGStore.getNeighborhood.
+ */
+export function pprFromTriples(
+  triples: KGTriple[],
+  startEntities: string[],
+  config?: Partial<PPRConfig>,
+): PPRResult[] {
+  // Convert triples to a NeighborhoodResult-like structure
+  const entities = new Set<string>();
+  for (const t of triples) {
+    entities.add(t.subject);
+    entities.add(t.object);
+  }
+
+  const neighborhood: NeighborhoodResult[] = [...entities].map(e => ({
+    entity: e,
+    triples: triples.filter(t => t.subject === e || t.object === e),
+    hops: 0,
+  }));
+
+  const graph = buildGraph(neighborhood);
+  return pprTraverse(graph, startEntities, config);
+}