@launchapp-dev/ao-memory-mcp 1.0.0 → 2.0.0

package/src/tools/knowledge.ts

@@ -0,0 +1,248 @@
+import type Database from "better-sqlite3";
+import { now, jsonResult, errorResult } from "../db.ts";
+
+export const knowledgeTools = [
+  {
+    name: "memory.entity.add",
+    description:
+      "Add an entity to the knowledge graph. Entities represent projects, people, technologies, concepts, files, or any named thing.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        name: { type: "string", description: "Entity name (e.g. 'ao-cli', 'React', 'Sami')" },
+        entity_type: { type: "string", description: "Type (e.g. project, person, technology, concept, file, service)" },
+        namespace: { type: "string", description: "Scope" },
+        description: { type: "string", description: "Brief description" },
+        metadata: { type: "object", description: "Custom metadata" },
+      },
+      required: ["name", "entity_type"],
+    },
+  },
+  {
+    name: "memory.entity.link",
+    description:
+      "Create a relationship between two entities. E.g. 'ao-cli uses Rust', 'invoicer depends_on Drizzle'.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        source: { type: "string", description: "Source entity name" },
+        source_type: { type: "string", description: "Source entity type (for disambiguation)" },
+        relation: { type: "string", description: "Relation type (e.g. uses, depends_on, created_by, part_of, related_to)" },
+        target: { type: "string", description: "Target entity name" },
+        target_type: { type: "string", description: "Target entity type" },
+        weight: { type: "number", description: "Relation strength 0.0-1.0 (default 1.0)" },
+        memory_id: { type: "number", description: "Link to a memory entry as evidence" },
+        namespace: { type: "string", description: "Scope for auto-creating entities" },
+        metadata: { type: "object", description: "Custom metadata" },
+      },
+      required: ["source", "source_type", "relation", "target", "target_type"],
+    },
+  },
+  {
+    name: "memory.entity.query",
+    description:
+      "Query the knowledge graph. Find entities and traverse relationships. Supports multi-hop traversal.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        name: { type: "string", description: "Entity name to start from" },
+        entity_type: { type: "string", description: "Filter by entity type" },
+        relation: { type: "string", description: "Filter by relation type" },
+        direction: { type: "string", enum: ["outgoing", "incoming", "both"], description: "Traversal direction (default: both)" },
+        depth: { type: "number", description: "Max traversal depth (default 1, max 3)" },
+        namespace: { type: "string", description: "Filter by namespace" },
+        limit: { type: "number", description: "Max results (default 50)" },
+      },
+    },
+  },
+  {
+    name: "memory.entity.list",
+    description: "List entities in the knowledge graph.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        entity_type: { type: "string", description: "Filter by type" },
+        namespace: { type: "string", description: "Filter by namespace" },
+        limit: { type: "number", description: "Max results (default 50)" },
+      },
+    },
+  },
+];
+
+export function handleKnowledge(db: Database.Database, name: string, args: any) {
+  if (name === "memory.entity.add") return entityAdd(db, args);
+  if (name === "memory.entity.link") return entityLink(db, args);
+  if (name === "memory.entity.query") return entityQuery(db, args);
+  if (name === "memory.entity.list") return entityList(db, args);
+  return null;
+}
+
+function getOrCreateEntity(db: Database.Database, name: string, entityType: string, namespace?: string): number {
+  const existing = db.prepare(
+    "SELECT id FROM entities WHERE name = ? AND entity_type = ? AND namespace IS ?"
+  ).get(name, entityType, namespace || null) as any;
+
+  if (existing) return existing.id;
+
+  const ts = now();
+  const result = db.prepare(`
+    INSERT INTO entities (name, entity_type, namespace, metadata, created_at, updated_at)
+    VALUES (?, ?, ?, '{}', ?, ?)
+  `).run(name, entityType, namespace || null, ts, ts);
+
+  return Number(result.lastInsertRowid);
+}
+
+function entityAdd(db: Database.Database, args: any) {
+  const ts = now();
+  const existing = db.prepare(
+    "SELECT id FROM entities WHERE name = ? AND entity_type = ? AND namespace IS ?"
+  ).get(args.name, args.entity_type, args.namespace || null) as any;
+
+  if (existing) {
+    // Update existing
+    const sets: string[] = ["updated_at = ?"];
+    const vals: any[] = [ts];
+    if (args.description) { sets.push("description = ?"); vals.push(args.description); }
+    if (args.metadata) { sets.push("metadata = ?"); vals.push(JSON.stringify(args.metadata)); }
+    vals.push(existing.id);
+    db.prepare(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+    return jsonResult({ id: existing.id, updated: true });
+  }
+
+  const result = db.prepare(`
+    INSERT INTO entities (name, entity_type, namespace, description, metadata, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    args.name, args.entity_type, args.namespace || null,
+    args.description || null, JSON.stringify(args.metadata || {}), ts, ts
+  );
+
+  return jsonResult({ id: Number(result.lastInsertRowid), created: true });
+}
+
+function entityLink(db: Database.Database, args: any) {
+  const sourceId = getOrCreateEntity(db, args.source, args.source_type, args.namespace);
+  const targetId = getOrCreateEntity(db, args.target, args.target_type, args.namespace);
+
+  const existing = db.prepare(
+    "SELECT id FROM relations WHERE source_entity_id = ? AND relation_type = ? AND target_entity_id = ?"
+  ).get(sourceId, args.relation, targetId) as any;
+
+  if (existing) {
+    // Update weight/metadata
+    const sets: string[] = [];
+    const vals: any[] = [];
+    if (args.weight !== undefined) { sets.push("weight = ?"); vals.push(args.weight); }
+    if (args.memory_id) { sets.push("memory_id = ?"); vals.push(args.memory_id); }
+    if (args.metadata) { sets.push("metadata = ?"); vals.push(JSON.stringify(args.metadata)); }
+    if (sets.length > 0) {
+      vals.push(existing.id);
+      db.prepare(`UPDATE relations SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+    }
+    return jsonResult({ id: existing.id, updated: true });
+  }
+
+  const ts = now();
+  const result = db.prepare(`
+    INSERT INTO relations (source_entity_id, relation_type, target_entity_id, weight, memory_id, metadata, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(sourceId, args.relation, targetId, args.weight ?? 1.0, args.memory_id || null, JSON.stringify(args.metadata || {}), ts);
+
+  return jsonResult({ id: Number(result.lastInsertRowid), created: true, source_id: sourceId, target_id: targetId });
+}
+
+function entityQuery(db: Database.Database, args: any) {
+  const depth = Math.min(args.depth || 1, 3);
+  const limit = args.limit || 50;
+  const direction = args.direction || "both";
+
+  // Find starting entities
+  const startConditions: string[] = [];
+  const startVals: any[] = [];
+  if (args.name) { startConditions.push("name = ?"); startVals.push(args.name); }
+  if (args.entity_type) { startConditions.push("entity_type = ?"); startVals.push(args.entity_type); }
+  if (args.namespace) { startConditions.push("namespace = ?"); startVals.push(args.namespace); }
+
+  if (startConditions.length === 0) {
+    return errorResult("At least one of: name, entity_type, or namespace required");
+  }
+
+  const startEntities = db.prepare(
+    `SELECT * FROM entities WHERE ${startConditions.join(" AND ")} LIMIT ?`
+  ).all(...startVals, limit) as any[];
+
+  if (startEntities.length === 0) return jsonResult({ entities: [], relations: [] });
+
+  // Traverse relations
+  const visited = new Set<number>();
+  const allEntities: any[] = [...startEntities];
+  const allRelations: any[] = [];
+  let currentIds = startEntities.map(e => e.id);
+  startEntities.forEach(e => visited.add(e.id));
+
+  for (let d = 0; d < depth; d++) {
+    if (currentIds.length === 0) break;
+    const placeholders = currentIds.map(() => "?").join(",");
+
+    const relConditions: string[] = [];
+    if (direction === "outgoing" || direction === "both") {
+      relConditions.push(`source_entity_id IN (${placeholders})`);
+    }
+    if (direction === "incoming" || direction === "both") {
+      relConditions.push(`target_entity_id IN (${placeholders})`);
+    }
+
+    const relFilter = args.relation ? ` AND relation_type = ?` : "";
+    const relVals = args.relation
+      ? [...currentIds, ...(direction === "both" ? currentIds : []), args.relation]
+      : [...currentIds, ...(direction === "both" ? currentIds : [])];
+
+    const rels = db.prepare(`
+      SELECT r.*,
+        se.name as source_name, se.entity_type as source_type,
+        te.name as target_name, te.entity_type as target_type
+      FROM relations r
+      JOIN entities se ON se.id = r.source_entity_id
+      JOIN entities te ON te.id = r.target_entity_id
+      WHERE (${relConditions.join(" OR ")})${relFilter}
+      LIMIT ?
+    `).all(...relVals, limit) as any[];
+
+    allRelations.push(...rels);
+
+    const nextIds: number[] = [];
+    for (const rel of rels) {
+      for (const id of [rel.source_entity_id, rel.target_entity_id]) {
+        if (!visited.has(id)) {
+          visited.add(id);
+          nextIds.push(id);
+        }
+      }
+    }
+
+    if (nextIds.length > 0) {
+      const ents = db.prepare(
+        `SELECT * FROM entities WHERE id IN (${nextIds.map(() => "?").join(",")})`
+      ).all(...nextIds) as any[];
+      allEntities.push(...ents);
+    }
+
+    currentIds = nextIds;
+  }
+
+  return jsonResult({ entities: allEntities, relations: allRelations });
+}
+
+function entityList(db: Database.Database, args: any) {
+  const conditions: string[] = [];
+  const vals: any[] = [];
+  if (args.entity_type) { conditions.push("entity_type = ?"); vals.push(args.entity_type); }
+  if (args.namespace) { conditions.push("namespace = ?"); vals.push(args.namespace); }
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = args.limit || 50;
+
+  const rows = db.prepare(`SELECT * FROM entities ${where} ORDER BY name LIMIT ?`).all(...vals, limit);
+  return jsonResult({ entities: rows, count: rows.length });
+}

package/src/tools/recall.ts

@@ -1,52 +1,55 @@
 import type Database from "better-sqlite3";
-import { jsonResult, errorResult } from "../db.ts";
+import { jsonResult, errorResult, touchAccess } from "../db.ts";
+import { embed, hybridSearch, searchVectors } from "../embeddings.ts";
 
 export const recallTools = [
   {
     name: "memory.recall",
     description:
-      "Query memory entries with structured filters. Returns entries sorted by date. Default: 50 most recent active entries.",
+      "Recall memories with structured filters. Supports filtering by type, scope, namespace, agent role, tags, date range. Returns entries sorted by date.",
     inputSchema: {
       type: "object" as const,
       properties: {
+        memory_type: { type: "string", enum: ["semantic", "episodic", "procedural"], description: "Filter by type" },
+        scope: { type: "string", description: "Filter by scope" },
+        namespace: { type: "string", description: "Filter by namespace (project name, etc.)" },
         agent_role: { type: "string", description: "Filter by agent role" },
-        project: { type: "string", description: "Filter by project" },
-        entry_type: { type: "string", description: "Filter by entry type" },
         task_id: { type: "string", description: "Filter by task ID" },
-        status: { type: "string", enum: ["active", "summarized", "archived"], description: "Filter by status (default: active)" },
-        date_from: { type: "string", description: "Entries from this ISO date" },
-        date_to: { type: "string", description: "Entries up to this ISO date" },
-        tags: { type: "array", items: { type: "string" }, description: "Filter by tags (must have ALL specified)" },
+        status: { type: "string", enum: ["active", "summarized", "archived"], description: "Default: active" },
+        date_from: { type: "string", description: "From ISO date" },
+        date_to: { type: "string", description: "To ISO date" },
+        tags: { type: "array", items: { type: "string" }, description: "Must have ALL specified tags" },
         limit: { type: "number", description: "Max results (default 50)" },
-        offset: { type: "number", description: "Pagination offset (default 0)" },
-        order: { type: "string", enum: ["newest", "oldest"], description: "Sort order (default: newest)" },
+        offset: { type: "number", description: "Pagination offset" },
+        order: { type: "string", enum: ["newest", "oldest", "most_accessed", "highest_confidence"], description: "Sort order" },
       },
     },
   },
   {
     name: "memory.search",
     description:
-      "Full-text search across all memory entries. Uses FTS5 for fast matching.",
+      "Hybrid semantic + keyword search across all memories. Uses vector similarity and FTS5 together for best results.",
     inputSchema: {
       type: "object" as const,
       properties: {
-        query: { type: "string", description: "Search query (supports FTS5 syntax)" },
+        query: { type: "string", description: "Natural language search query" },
+        memory_type: { type: "string", description: "Restrict to type" },
+        namespace: { type: "string", description: "Restrict to namespace" },
         agent_role: { type: "string", description: "Restrict to agent role" },
-        project: { type: "string", description: "Restrict to project" },
-        entry_type: { type: "string", description: "Restrict to entry type" },
         status: { type: "string", description: "Restrict to status" },
-        limit: { type: "number", description: "Max results (default 20)" },
+        limit: { type: "number", description: "Max results (default 10)" },
+        alpha: { type: "number", description: "Semantic vs keyword weight: 0=all keyword, 1=all semantic (default 0.5)" },
       },
       required: ["query"],
     },
   },
   {
     name: "memory.get",
-    description: "Get a single memory entry by ID.",
+    description: "Get a single memory by ID. Updates access tracking.",
     inputSchema: {
       type: "object" as const,
       properties: {
-        id: { type: "number", description: "Memory entry ID" },
+        id: { type: "number", description: "Memory ID" },
       },
       required: ["id"],
     },
@@ -63,16 +66,15 @@ export function handleRecall(db: Database.Database, name: string, args: any) {
 function memoryRecall(db: Database.Database, args: any) {
   const conditions: string[] = [];
   const vals: any[] = [];
-  const status = args.status || "active";
 
-  conditions.push("status = ?"); vals.push(status);
+  conditions.push("status = ?"); vals.push(args.status || "active");
+  if (args.memory_type) { conditions.push("memory_type = ?"); vals.push(args.memory_type); }
+  if (args.scope) { conditions.push("scope = ?"); vals.push(args.scope); }
+  if (args.namespace) { conditions.push("namespace = ?"); vals.push(args.namespace); }
   if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
-  if (args.project) { conditions.push("project = ?"); vals.push(args.project); }
-  if (args.entry_type) { conditions.push("entry_type = ?"); vals.push(args.entry_type); }
   if (args.task_id) { conditions.push("task_id = ?"); vals.push(args.task_id); }
   if (args.date_from) { conditions.push("occurred_at >= ?"); vals.push(args.date_from); }
   if (args.date_to) { conditions.push("occurred_at <= ?"); vals.push(args.date_to); }
-
   if (args.tags?.length) {
     for (const tag of args.tags) {
       conditions.push("EXISTS (SELECT 1 FROM json_each(tags) WHERE json_each.value = ?)");
@@ -80,45 +82,86 @@ function memoryRecall(db: Database.Database, args: any) {
     }
   }
 
-  const order = args.order === "oldest" ? "ASC" : "DESC";
+  const orderMap: Record<string, string> = {
+    newest: "occurred_at DESC",
+    oldest: "occurred_at ASC",
+    most_accessed: "access_count DESC",
+    highest_confidence: "confidence DESC",
+  };
+  const order = orderMap[args.order || "newest"] || "occurred_at DESC";
   const limit = args.limit || 50;
   const offset = args.offset || 0;
 
   const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
   const rows = db.prepare(
-    `SELECT * FROM memory_entries ${where} ORDER BY occurred_at ${order} LIMIT ? OFFSET ?`
+    `SELECT * FROM memories ${where} ORDER BY ${order} LIMIT ? OFFSET ?`
   ).all(...vals, limit, offset);
 
-  return jsonResult({ entries: rows, count: rows.length });
+  return jsonResult({ memories: rows, count: rows.length });
 }
 
-function memorySearch(db: Database.Database, args: any) {
-  const conditions: string[] = [];
-  const vals: any[] = [];
+async function memorySearch(db: Database.Database, args: any) {
+  const limit = args.limit || 10;
+  const alpha = args.alpha ?? 0.5;
+
+  // Get embedding for query
+  let queryEmbedding: Float32Array;
+  try {
+    queryEmbedding = await embed(args.query, true);
+  } catch {
+    // Fallback to FTS-only
+    return ftsOnlySearch(db, args);
+  }
+
+  const results = hybridSearch(db, "memories_fts", "vec_memories", args.query, queryEmbedding, limit * 3, alpha);
+
+  if (results.length === 0) return jsonResult({ memories: [], count: 0 });
+
+  // Fetch full rows and apply filters
+  const ids = results.map(r => r.rowid);
+  const scoreMap = new Map(results.map(r => [r.rowid, r.score]));
 
-  if (args.agent_role) { conditions.push("e.agent_role = ?"); vals.push(args.agent_role); }
-  if (args.project) { conditions.push("e.project = ?"); vals.push(args.project); }
-  if (args.entry_type) { conditions.push("e.entry_type = ?"); vals.push(args.entry_type); }
-  if (args.status) { conditions.push("e.status = ?"); vals.push(args.status); }
+  const conditions: string[] = [`id IN (${ids.map(() => "?").join(",")})`];
+  const vals: any[] = [...ids];
 
-  const extraWhere = conditions.length ? `AND ${conditions.join(" AND ")}` : "";
-  const limit = args.limit || 20;
+  if (args.memory_type) { conditions.push("memory_type = ?"); vals.push(args.memory_type); }
+  if (args.namespace) { conditions.push("namespace = ?"); vals.push(args.namespace); }
+  if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
+  if (args.status) { conditions.push("status = ?"); vals.push(args.status); }
+
+  const rows = db.prepare(
+    `SELECT * FROM memories WHERE ${conditions.join(" AND ")}`
+  ).all(...vals) as any[];
+
+  // Sort by hybrid score and limit
+  const scored = rows
+    .map(r => ({ ...r, _score: scoreMap.get(r.id) || 0 }))
+    .sort((a, b) => b._score - a._score)
+    .slice(0, limit);
 
+  // Touch access for returned results
+  for (const row of scored) touchAccess(db, row.id);
+
+  return jsonResult({ memories: scored, count: scored.length });
+}
+
+function ftsOnlySearch(db: Database.Database, args: any) {
+  const limit = args.limit || 10;
   const rows = db.prepare(`
-    SELECT e.*, snippet(memory_fts, 0, '<mark>', '</mark>', '...', 32) as title_snippet,
-           snippet(memory_fts, 1, '<mark>', '</mark>', '...', 64) as body_snippet
-    FROM memory_fts f
-    JOIN memory_entries e ON e.id = f.rowid
-    WHERE memory_fts MATCH ? ${extraWhere}
-    ORDER BY rank
-    LIMIT ?
-  `).all(args.query, ...vals, limit);
-
-  return jsonResult({ entries: rows, count: rows.length });
+    SELECT m.*, snippet(memories_fts, 0, '<mark>', '</mark>', '...', 32) as title_snippet,
+           snippet(memories_fts, 1, '<mark>', '</mark>', '...', 64) as content_snippet
+    FROM memories_fts f
+    JOIN memories m ON m.id = f.rowid
+    WHERE memories_fts MATCH ?
+    ORDER BY rank LIMIT ?
+  `).all(args.query, limit);
+
+  return jsonResult({ memories: rows, count: rows.length, mode: "keyword_only" });
 }
 
 function memoryGet(db: Database.Database, args: any) {
-  const entry = db.prepare("SELECT * FROM memory_entries WHERE id = ?").get(args.id);
-  if (!entry) return errorResult(`Entry ${args.id} not found`);
+  const entry = db.prepare("SELECT * FROM memories WHERE id = ?").get(args.id) as any;
+  if (!entry) return errorResult(`Memory ${args.id} not found`);
+  touchAccess(db, args.id);
   return jsonResult(entry);
 }

package/src/tools/stats.ts

@@ -4,12 +4,11 @@ import { jsonResult } from "../db.ts";
 export const statsTools = [
   {
     name: "memory.stats",
-    description:
-      "Get aggregate statistics about memory entries. Optionally filter by project or agent role.",
+    description: "Get aggregate statistics across all memory types.",
     inputSchema: {
       type: "object" as const,
       properties: {
-        project: { type: "string", description: "Filter by project" },
+        namespace: { type: "string", description: "Filter by namespace" },
         agent_role: { type: "string", description: "Filter by agent role" },
       },
     },
@@ -24,51 +23,29 @@ export function handleStats(db: Database.Database, name: string, args: any) {
 function memoryStats(db: Database.Database, args: any) {
   const conditions: string[] = [];
   const vals: any[] = [];
-
-  if (args.project) { conditions.push("project = ?"); vals.push(args.project); }
+  if (args.namespace) { conditions.push("namespace = ?"); vals.push(args.namespace); }
   if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
-
   const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
 
-  const total = (db.prepare(`SELECT COUNT(*) as count FROM memory_entries ${where}`).get(...vals) as any).count;
-
-  const byType = db.prepare(
-    `SELECT entry_type, COUNT(*) as count FROM memory_entries ${where} GROUP BY entry_type ORDER BY count DESC`
-  ).all(...vals);
-
-  const byStatus = db.prepare(
-    `SELECT status, COUNT(*) as count FROM memory_entries ${where} GROUP BY status ORDER BY count DESC`
-  ).all(...vals);
-
-  const byRole = db.prepare(
-    `SELECT agent_role, COUNT(*) as count FROM memory_entries ${where} GROUP BY agent_role ORDER BY count DESC`
-  ).all(...vals);
-
-  const byProject = db.prepare(
-    `SELECT project, COUNT(*) as count FROM memory_entries ${where} GROUP BY project ORDER BY count DESC`
-  ).all(...vals);
-
-  const dateRange = db.prepare(
-    `SELECT MIN(occurred_at) as oldest, MAX(occurred_at) as newest FROM memory_entries ${where}`
-  ).get(...vals) as any;
+  const totalMemories = (db.prepare(`SELECT COUNT(*) as c FROM memories ${where}`).get(...vals) as any).c;
+  const byType = db.prepare(`SELECT memory_type, COUNT(*) as count FROM memories ${where} GROUP BY memory_type`).all(...vals);
+  const byStatus = db.prepare(`SELECT status, COUNT(*) as count FROM memories ${where} GROUP BY status`).all(...vals);
+  const byScope = db.prepare(`SELECT scope, COUNT(*) as count FROM memories ${where} GROUP BY scope`).all(...vals);
+  const byRole = db.prepare(`SELECT agent_role, COUNT(*) as count FROM memories ${where} GROUP BY agent_role`).all(...vals);
+  const byNamespace = db.prepare(`SELECT namespace, COUNT(*) as count FROM memories ${where} GROUP BY namespace ORDER BY count DESC LIMIT 20`).all(...vals);
 
-  const summaryCount = (db.prepare(
-    `SELECT COUNT(*) as count FROM memory_summaries ${where.replace("entry_type", "entry_type")}`
-  ).get(...vals) as any).count;
+  const dateRange = db.prepare(`SELECT MIN(occurred_at) as oldest, MAX(occurred_at) as newest FROM memories ${where}`).get(...vals) as any;
 
-  const patternCount = (db.prepare(
-    `SELECT COUNT(*) as count FROM memory_patterns WHERE status = 'active'`
-  ).get() as any).count;
+  const totalDocs = (db.prepare("SELECT COUNT(*) as c FROM documents").get() as any).c;
+  const totalChunks = (db.prepare("SELECT COUNT(*) as c FROM chunks").get() as any).c;
+  const totalEntities = (db.prepare("SELECT COUNT(*) as c FROM entities").get() as any).c;
+  const totalRelations = (db.prepare("SELECT COUNT(*) as c FROM relations").get() as any).c;
+  const totalEpisodes = (db.prepare("SELECT COUNT(*) as c FROM episodes").get() as any).c;
 
   return jsonResult({
-    total_entries: total,
-    total_summaries: summaryCount,
-    active_patterns: patternCount,
-    oldest_entry: dateRange?.oldest,
-    newest_entry: dateRange?.newest,
-    by_type: byType,
-    by_status: byStatus,
-    by_role: byRole,
-    by_project: byProject,
+    memories: { total: totalMemories, by_type: byType, by_status: byStatus, by_scope: byScope, by_role: byRole, by_namespace: byNamespace, oldest: dateRange?.oldest, newest: dateRange?.newest },
+    documents: { total: totalDocs, total_chunks: totalChunks },
+    knowledge_graph: { entities: totalEntities, relations: totalRelations },
+    episodes: { total: totalEpisodes },
   });
 }