@usewhisper/mcp-server 0.3.0 → 0.5.0

package/dist/chunk-TWEIYHI6.js

@@ -1,399 +1,399 @@
-import {
-  calculateTemporalRelevance,
-  parseTemporalQuery
-} from "./chunk-5KBZQHDL.js";
-import {
-  db,
-  embedSingle
-} from "./chunk-MEFLJ4PV.js";
-
-// ../src/engine/cache.ts
-import crypto from "crypto";
-var semanticCache = /* @__PURE__ */ new Map();
-var MAX_SEMANTIC_CACHE_SIZE = 500;
-var SEMANTIC_THRESHOLD = 0.92;
-var DEFAULT_CONFIG = {
-  ttl: 3600,
-  // 1 hour
-  enabled: true,
-  keyPrefix: "whisper:context:"
-};
-var cacheHits = 0;
-var cacheMisses = 0;
-function recordCacheHit() {
-  cacheHits++;
-}
-function recordCacheMiss() {
-  cacheMisses++;
-}
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) return 0;
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-async function getFromSemanticCache(queryEmbedding) {
-  if (!DEFAULT_CONFIG.enabled) return null;
-  const now = Date.now();
-  let bestMatch = null;
-  let bestSimilarity = 0;
-  for (const [key, entry] of semanticCache.entries()) {
-    if (entry.expiry < now) {
-      semanticCache.delete(key);
-      continue;
-    }
-    const similarity = cosineSimilarity(queryEmbedding, entry.embedding);
-    if (similarity > bestSimilarity) {
-      bestSimilarity = similarity;
-      bestMatch = { key, ...entry, similarity };
-    }
-  }
-  if (bestMatch && bestMatch.similarity >= SEMANTIC_THRESHOLD) {
-    recordCacheHit();
-    return { results: bestMatch.results, similarity: bestMatch.similarity };
-  }
-  recordCacheMiss();
-  return null;
-}
-async function setInSemanticCache(queryEmbedding, results) {
-  if (!DEFAULT_CONFIG.enabled) return;
-  const now = Date.now();
-  const key = `sem:${crypto.createHash("md5").update(JSON.stringify(queryEmbedding.slice(0, 10))).digest("hex").substring(0, 8)}`;
-  semanticCache.set(key, {
-    embedding: queryEmbedding,
-    results,
-    expiry: now + DEFAULT_CONFIG.ttl * 1e3
-  });
-  if (semanticCache.size > MAX_SEMANTIC_CACHE_SIZE) {
-    let oldestKey = null;
-    let oldestExpiry = Infinity;
-    for (const [k, v] of semanticCache.entries()) {
-      if (v.expiry < oldestExpiry) {
-        oldestExpiry = v.expiry;
-        oldestKey = k;
-      }
-    }
-    if (oldestKey) {
-      semanticCache.delete(oldestKey);
-    }
-  }
-}
-
-// ../src/engine/memory/search.ts
-var EARLY_EXIT_SIMILARITY = 0.92;
-async function searchMemories(params) {
-  const {
-    query,
-    questionDate,
-    userId,
-    projectId,
-    orgId,
-    sessionId,
-    topK = 10,
-    includeInactive = false,
-    memoryTypes
-  } = params;
-  const queryEmbedding = await embedSingle(query);
-  const cached = await getFromSemanticCache(queryEmbedding);
-  if (cached && cached.similarity >= EARLY_EXIT_SIMILARITY) {
-    console.log(`\u26A1 Semantic cache hit (similarity: ${cached.similarity.toFixed(3)})`);
-    return cached.results.slice(0, topK);
-  }
-  const temporal = params.temporalFilter || await parseTemporalQuery(query, questionDate);
-  const semanticResults = await vectorSearchMemories({
-    embedding: queryEmbedding,
-    userId,
-    projectId,
-    orgId,
-    sessionId,
-    temporal,
-    includeInactive,
-    memoryTypes,
-    limit: topK * 3
-    // Get more for reranking
-  });
-  if (semanticResults.length === 0) {
-    return [];
-  }
-  if (semanticResults.length > 0 && semanticResults[0].similarity >= EARLY_EXIT_SIMILARITY) {
-    console.log(`\u26A1 Early exit at ${semanticResults[0].similarity.toFixed(3)}`);
-    const topMemories2 = semanticResults.slice(0, topK);
-    await setInSemanticCache(queryEmbedding, topMemories2);
-    return topMemories2;
-  }
-  const enriched = await enrichWithRelations(semanticResults, topK * 2);
-  const scored = enriched.map((memory) => ({
-    ...memory,
-    temporalScore: memory.documentDate ? calculateTemporalRelevance(memory.documentDate, questionDate) : 0.5
-  }));
-  const combined = scored.map((m) => ({
-    ...m,
-    finalScore: m.similarity * 0.7 + m.temporalScore * 0.3
-  }));
-  combined.sort((a, b) => b.finalScore - a.finalScore);
-  const topMemories = combined.slice(0, topK);
-  const results = await injectSourceChunks(topMemories);
-  await setInSemanticCache(queryEmbedding, results);
-  return results;
-}
-async function vectorSearchMemories(params) {
-  const {
-    embedding,
-    userId,
-    projectId,
-    orgId,
-    sessionId,
-    temporal,
-    includeInactive,
-    memoryTypes,
-    limit
-  } = params;
-  const whereConditions = [
-    { projectId }
-  ];
-  if (orgId) {
-    whereConditions.push({ orgId });
-  }
-  if (userId) {
-    whereConditions.push({ userId });
-  }
-  if (sessionId) {
-    whereConditions.push({ sessionId });
-  }
-  if (!includeInactive) {
-    whereConditions.push({ isActive: true });
-  }
-  whereConditions.push({
-    OR: [
-      { validUntil: null },
-      { validUntil: { gt: /* @__PURE__ */ new Date() } }
-    ]
-  });
-  if (memoryTypes && memoryTypes.length > 0) {
-    whereConditions.push({
-      memoryType: { in: memoryTypes }
-    });
-  }
-  if (temporal.hasTemporalConstraint && temporal.dateRange) {
-    whereConditions.push({
-      documentDate: {
-        gte: temporal.dateRange.start,
-        lte: temporal.dateRange.end
-      }
-    });
-  }
-  const embeddingStr = `[${embedding.join(",")}]`;
-  let whereClause = `"projectId" = '${projectId}'`;
-  if (orgId) whereClause += ` AND "orgId" = '${orgId}'`;
-  if (userId) whereClause += ` AND "userId" = '${userId}'`;
-  if (sessionId) whereClause += ` AND "sessionId" = '${sessionId}'`;
-  if (!includeInactive) whereClause += ` AND "isActive" = true`;
-  whereClause += ` AND ("validUntil" IS NULL OR "validUntil" > NOW())`;
-  if (memoryTypes && memoryTypes.length > 0) {
-    const typesStr = memoryTypes.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-    whereClause += ` AND "memoryType" IN (${typesStr})`;
-  }
-  if (temporal.hasTemporalConstraint && temporal.dateRange) {
-    whereClause += ` AND "documentDate" >= '${temporal.dateRange.start.toISOString()}' AND "documentDate" <= '${temporal.dateRange.end.toISOString()}'`;
-  }
-  const results = await db.$queryRawUnsafe(`
-    SELECT
-      id,
-      content,
-      "memoryType" as "memoryType",
-      confidence,
-      version,
-      "documentDate" as "documentDate",
-      "eventDate" as "eventDate",
-      "validFrom" as "validFrom",
-      "validUntil" as "validUntil",
-      "sourceChunkId" as "sourceChunkId",
-      metadata,
-      1 - (embedding <=> '${embeddingStr}'::vector) as similarity
-    FROM memories
-    WHERE ${whereClause}
-    ORDER BY embedding <=> '${embeddingStr}'::vector
-    LIMIT ${limit}
-  `);
-  return results;
-}
-async function enrichWithRelations(memories, maxTotal) {
-  if (memories.length === 0) {
-    return [];
-  }
-  const memoryIds = memories.map((m) => m.id);
-  const memoryIdsList = memoryIds.map((id) => `'${id}'`).join(",");
-  const relationsQuery = await db.$queryRawUnsafe(`
-    SELECT 
-      r.id as relation_id,
-      r."fromMemoryId",
-      r."toMemoryId",
-      r."relationType",
-      m.id,
-      m.content,
-      m."memoryType",
-      m.confidence,
-      m.version,
-      m."documentDate",
-      m."eventDate",
-      m."validFrom",
-      m."validUntil",
-      m."sourceChunkId",
-      m.metadata
-    FROM "memory_relations" r
-    LEFT JOIN memories m ON m.id = r."toMemoryId"
-    WHERE r."fromMemoryId" IN (${memoryIdsList})
-      AND m."isActive" = true
-    LIMIT 100
-  `);
-  if (!relationsQuery || relationsQuery.length === 0) {
-    return memories;
-  }
-  const relatedIds = /* @__PURE__ */ new Set();
-  const relationMap = /* @__PURE__ */ new Map();
-  for (const row of relationsQuery) {
-    if (row.toMemoryId && !memoryIds.includes(row.toMemoryId)) {
-      relatedIds.add(row.toMemoryId);
-      if (!relationMap.has(row.fromMemoryId)) {
-        relationMap.set(row.fromMemoryId, []);
-      }
-      relationMap.get(row.fromMemoryId)?.push({
-        memoryId: row.toMemoryId,
-        relationType: row.relationType,
-        content: row.content
-      });
-    }
-  }
-  if (relatedIds.size === 0) {
-    return memories;
-  }
-  const relatedIdsList = Array.from(relatedIds).map((id) => `'${id}'`).join(",");
-  const relatedMemories = await db.$queryRawUnsafe(`
-    SELECT 
-      id,
-      content,
-      "memoryType" as "memoryType",
-      confidence,
-      version,
-      "documentDate" as "documentDate",
-      "eventDate" as "eventDate",
-      "validFrom" as "validFrom",
-      "validUntil" as "validUntil",
-      "sourceChunkId" as "sourceChunkId",
-      metadata
-    FROM memories
-    WHERE id IN (${relatedIdsList})
-      AND "isActive" = true
-    LIMIT ${maxTotal - memories.length}
-  `);
-  const relatedWithScores = relatedMemories.map((m) => ({
-    ...m,
-    similarity: 0.6,
-    isRelated: true,
-    relations: relationMap.get(m.id) || []
-  }));
-  return [...memories, ...relatedWithScores];
-}
-async function injectSourceChunks(memories) {
-  const chunkIds = memories.map((m) => m.sourceChunkId).filter((id) => id !== null);
-  if (chunkIds.length === 0) {
-    return memories.map((m) => ({
-      memory: {
-        id: m.id,
-        content: m.content,
-        memoryType: m.memoryType,
-        entityMentions: m.entityMentions || [],
-        confidence: m.confidence,
-        version: m.version,
-        temporal: {
-          documentDate: m.documentDate,
-          eventDate: m.eventDate,
-          validFrom: m.validFrom,
-          validUntil: m.validUntil
-        }
-      },
-      similarity: m.similarity
-    }));
-  }
-  const chunks = await db.chunk.findMany({
-    where: {
-      id: { in: chunkIds }
-    },
-    select: {
-      id: true,
-      content: true,
-      metadata: true
-    }
-  });
-  const chunkMap = new Map(chunks.map((c) => [c.id, c]));
-  return memories.map((m) => ({
-    memory: {
-      id: m.id,
-      content: m.content,
-      memoryType: m.memoryType,
-      entityMentions: m.entityMentions || [],
-      confidence: m.confidence,
-      version: m.version,
-      temporal: {
-        documentDate: m.documentDate,
-        eventDate: m.eventDate,
-        validFrom: m.validFrom,
-        validUntil: m.validUntil
-      }
-    },
-    chunk: m.sourceChunkId && chunkMap.has(m.sourceChunkId) ? {
-      id: chunkMap.get(m.sourceChunkId).id,
-      content: chunkMap.get(m.sourceChunkId).content,
-      metadata: chunkMap.get(m.sourceChunkId).metadata
-    } : void 0,
-    similarity: m.similarity,
-    relations: m.isRelated ? [] : void 0
-  }));
-}
-async function getSessionMemories(params) {
-  const { sessionId, projectId, limit = 50, sinceDate } = params;
-  const where = {
-    sessionId,
-    projectId,
-    isActive: true
-  };
-  if (sinceDate) {
-    where.createdAt = { gte: sinceDate };
-  }
-  return db.memory.findMany({
-    where,
-    orderBy: {
-      createdAt: "desc"
-    },
-    take: limit
-  });
-}
-async function getUserProfile(params) {
-  const { userId, projectId, memoryTypes, limit = 50 } = params;
-  const where = {
-    userId,
-    projectId,
-    isActive: true,
-    scope: "USER"
-  };
-  if (memoryTypes) {
-    where.memoryType = { in: memoryTypes };
-  }
-  return db.memory.findMany({
-    where,
-    orderBy: { importance: "desc" },
-    take: Math.min(limit, 100)
-  });
-}
-
-export {
-  searchMemories,
-  getSessionMemories,
-  getUserProfile
-};
+import {
+  calculateTemporalRelevance,
+  parseTemporalQuery
+} from "./chunk-5KBZQHDL.js";
+import {
+  db,
+  embedSingle
+} from "./chunk-MEFLJ4PV.js";
+
+// ../src/engine/cache.ts
+import crypto from "crypto";
+var semanticCache = /* @__PURE__ */ new Map();
+var MAX_SEMANTIC_CACHE_SIZE = 500;
+var SEMANTIC_THRESHOLD = 0.92;
+var DEFAULT_CONFIG = {
+  ttl: 3600,
+  // 1 hour
+  enabled: true,
+  keyPrefix: "whisper:context:"
+};
+var cacheHits = 0;
+var cacheMisses = 0;
+function recordCacheHit() {
+  cacheHits++;
+}
+function recordCacheMiss() {
+  cacheMisses++;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function getFromSemanticCache(queryEmbedding) {
+  if (!DEFAULT_CONFIG.enabled) return null;
+  const now = Date.now();
+  let bestMatch = null;
+  let bestSimilarity = 0;
+  for (const [key, entry] of semanticCache.entries()) {
+    if (entry.expiry < now) {
+      semanticCache.delete(key);
+      continue;
+    }
+    const similarity = cosineSimilarity(queryEmbedding, entry.embedding);
+    if (similarity > bestSimilarity) {
+      bestSimilarity = similarity;
+      bestMatch = { key, ...entry, similarity };
+    }
+  }
+  if (bestMatch && bestMatch.similarity >= SEMANTIC_THRESHOLD) {
+    recordCacheHit();
+    return { results: bestMatch.results, similarity: bestMatch.similarity };
+  }
+  recordCacheMiss();
+  return null;
+}
+async function setInSemanticCache(queryEmbedding, results) {
+  if (!DEFAULT_CONFIG.enabled) return;
+  const now = Date.now();
+  const key = `sem:${crypto.createHash("md5").update(JSON.stringify(queryEmbedding.slice(0, 10))).digest("hex").substring(0, 8)}`;
+  semanticCache.set(key, {
+    embedding: queryEmbedding,
+    results,
+    expiry: now + DEFAULT_CONFIG.ttl * 1e3
+  });
+  if (semanticCache.size > MAX_SEMANTIC_CACHE_SIZE) {
+    let oldestKey = null;
+    let oldestExpiry = Infinity;
+    for (const [k, v] of semanticCache.entries()) {
+      if (v.expiry < oldestExpiry) {
+        oldestExpiry = v.expiry;
+        oldestKey = k;
+      }
+    }
+    if (oldestKey) {
+      semanticCache.delete(oldestKey);
+    }
+  }
+}
+
+// ../src/engine/memory/search.ts
+var EARLY_EXIT_SIMILARITY = 0.92;
+async function searchMemories(params) {
+  const {
+    query,
+    questionDate,
+    userId,
+    projectId,
+    orgId,
+    sessionId,
+    topK = 10,
+    includeInactive = false,
+    memoryTypes
+  } = params;
+  const queryEmbedding = await embedSingle(query);
+  const cached = await getFromSemanticCache(queryEmbedding);
+  if (cached && cached.similarity >= EARLY_EXIT_SIMILARITY) {
+    console.log(`\u26A1 Semantic cache hit (similarity: ${cached.similarity.toFixed(3)})`);
+    return cached.results.slice(0, topK);
+  }
+  const temporal = params.temporalFilter || await parseTemporalQuery(query, questionDate);
+  const semanticResults = await vectorSearchMemories({
+    embedding: queryEmbedding,
+    userId,
+    projectId,
+    orgId,
+    sessionId,
+    temporal,
+    includeInactive,
+    memoryTypes,
+    limit: topK * 3
+    // Get more for reranking
+  });
+  if (semanticResults.length === 0) {
+    return [];
+  }
+  if (semanticResults.length > 0 && semanticResults[0].similarity >= EARLY_EXIT_SIMILARITY) {
+    console.log(`\u26A1 Early exit at ${semanticResults[0].similarity.toFixed(3)}`);
+    const topMemories2 = semanticResults.slice(0, topK);
+    await setInSemanticCache(queryEmbedding, topMemories2);
+    return topMemories2;
+  }
+  const enriched = await enrichWithRelations(semanticResults, topK * 2);
+  const scored = enriched.map((memory) => ({
+    ...memory,
+    temporalScore: memory.documentDate ? calculateTemporalRelevance(memory.documentDate, questionDate) : 0.5
+  }));
+  const combined = scored.map((m) => ({
+    ...m,
+    finalScore: m.similarity * 0.7 + m.temporalScore * 0.3
+  }));
+  combined.sort((a, b) => b.finalScore - a.finalScore);
+  const topMemories = combined.slice(0, topK);
+  const results = await injectSourceChunks(topMemories);
+  await setInSemanticCache(queryEmbedding, results);
+  return results;
+}
+async function vectorSearchMemories(params) {
+  const {
+    embedding,
+    userId,
+    projectId,
+    orgId,
+    sessionId,
+    temporal,
+    includeInactive,
+    memoryTypes,
+    limit
+  } = params;
+  const whereConditions = [
+    { projectId }
+  ];
+  if (orgId) {
+    whereConditions.push({ orgId });
+  }
+  if (userId) {
+    whereConditions.push({ userId });
+  }
+  if (sessionId) {
+    whereConditions.push({ sessionId });
+  }
+  if (!includeInactive) {
+    whereConditions.push({ isActive: true });
+  }
+  whereConditions.push({
+    OR: [
+      { validUntil: null },
+      { validUntil: { gt: /* @__PURE__ */ new Date() } }
+    ]
+  });
+  if (memoryTypes && memoryTypes.length > 0) {
+    whereConditions.push({
+      memoryType: { in: memoryTypes }
+    });
+  }
+  if (temporal.hasTemporalConstraint && temporal.dateRange) {
+    whereConditions.push({
+      documentDate: {
+        gte: temporal.dateRange.start,
+        lte: temporal.dateRange.end
+      }
+    });
+  }
+  const embeddingStr = `[${embedding.join(",")}]`;
+  let whereClause = `"projectId" = '${projectId}'`;
+  if (orgId) whereClause += ` AND "orgId" = '${orgId}'`;
+  if (userId) whereClause += ` AND "userId" = '${userId}'`;
+  if (sessionId) whereClause += ` AND "sessionId" = '${sessionId}'`;
+  if (!includeInactive) whereClause += ` AND "isActive" = true`;
+  whereClause += ` AND ("validUntil" IS NULL OR "validUntil" > NOW())`;
+  if (memoryTypes && memoryTypes.length > 0) {
+    const typesStr = memoryTypes.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
+    whereClause += ` AND "memoryType" IN (${typesStr})`;
+  }
+  if (temporal.hasTemporalConstraint && temporal.dateRange) {
+    whereClause += ` AND "documentDate" >= '${temporal.dateRange.start.toISOString()}' AND "documentDate" <= '${temporal.dateRange.end.toISOString()}'`;
+  }
+  const results = await db.$queryRawUnsafe(`
+    SELECT
+      id,
+      content,
+      "memoryType" as "memoryType",
+      confidence,
+      version,
+      "documentDate" as "documentDate",
+      "eventDate" as "eventDate",
+      "validFrom" as "validFrom",
+      "validUntil" as "validUntil",
+      "sourceChunkId" as "sourceChunkId",
+      metadata,
+      1 - (embedding <=> '${embeddingStr}'::vector) as similarity
+    FROM memories
+    WHERE ${whereClause}
+    ORDER BY embedding <=> '${embeddingStr}'::vector
+    LIMIT ${limit}
+  `);
+  return results;
+}
+async function enrichWithRelations(memories, maxTotal) {
+  if (memories.length === 0) {
+    return [];
+  }
+  const memoryIds = memories.map((m) => m.id);
+  const memoryIdsList = memoryIds.map((id) => `'${id}'`).join(",");
+  const relationsQuery = await db.$queryRawUnsafe(`
+    SELECT 
+      r.id as relation_id,
+      r."fromMemoryId",
+      r."toMemoryId",
+      r."relationType",
+      m.id,
+      m.content,
+      m."memoryType",
+      m.confidence,
+      m.version,
+      m."documentDate",
+      m."eventDate",
+      m."validFrom",
+      m."validUntil",
+      m."sourceChunkId",
+      m.metadata
+    FROM "memory_relations" r
+    LEFT JOIN memories m ON m.id = r."toMemoryId"
+    WHERE r."fromMemoryId" IN (${memoryIdsList})
+      AND m."isActive" = true
+    LIMIT 100
+  `);
+  if (!relationsQuery || relationsQuery.length === 0) {
+    return memories;
+  }
+  const relatedIds = /* @__PURE__ */ new Set();
+  const relationMap = /* @__PURE__ */ new Map();
+  for (const row of relationsQuery) {
+    if (row.toMemoryId && !memoryIds.includes(row.toMemoryId)) {
+      relatedIds.add(row.toMemoryId);
+      if (!relationMap.has(row.fromMemoryId)) {
+        relationMap.set(row.fromMemoryId, []);
+      }
+      relationMap.get(row.fromMemoryId)?.push({
+        memoryId: row.toMemoryId,
+        relationType: row.relationType,
+        content: row.content
+      });
+    }
+  }
+  if (relatedIds.size === 0) {
+    return memories;
+  }
+  const relatedIdsList = Array.from(relatedIds).map((id) => `'${id}'`).join(",");
+  const relatedMemories = await db.$queryRawUnsafe(`
+    SELECT 
+      id,
+      content,
+      "memoryType" as "memoryType",
+      confidence,
+      version,
+      "documentDate" as "documentDate",
+      "eventDate" as "eventDate",
+      "validFrom" as "validFrom",
+      "validUntil" as "validUntil",
+      "sourceChunkId" as "sourceChunkId",
+      metadata
+    FROM memories
+    WHERE id IN (${relatedIdsList})
+      AND "isActive" = true
+    LIMIT ${maxTotal - memories.length}
+  `);
+  const relatedWithScores = relatedMemories.map((m) => ({
+    ...m,
+    similarity: 0.6,
+    isRelated: true,
+    relations: relationMap.get(m.id) || []
+  }));
+  return [...memories, ...relatedWithScores];
+}
+async function injectSourceChunks(memories) {
+  const chunkIds = memories.map((m) => m.sourceChunkId).filter((id) => id !== null);
+  if (chunkIds.length === 0) {
+    return memories.map((m) => ({
+      memory: {
+        id: m.id,
+        content: m.content,
+        memoryType: m.memoryType,
+        entityMentions: m.entityMentions || [],
+        confidence: m.confidence,
+        version: m.version,
+        temporal: {
+          documentDate: m.documentDate,
+          eventDate: m.eventDate,
+          validFrom: m.validFrom,
+          validUntil: m.validUntil
+        }
+      },
+      similarity: m.similarity
+    }));
+  }
+  const chunks = await db.chunk.findMany({
+    where: {
+      id: { in: chunkIds }
+    },
+    select: {
+      id: true,
+      content: true,
+      metadata: true
+    }
+  });
+  const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+  return memories.map((m) => ({
+    memory: {
+      id: m.id,
+      content: m.content,
+      memoryType: m.memoryType,
+      entityMentions: m.entityMentions || [],
+      confidence: m.confidence,
+      version: m.version,
+      temporal: {
+        documentDate: m.documentDate,
+        eventDate: m.eventDate,
+        validFrom: m.validFrom,
+        validUntil: m.validUntil
+      }
+    },
+    chunk: m.sourceChunkId && chunkMap.has(m.sourceChunkId) ? {
+      id: chunkMap.get(m.sourceChunkId).id,
+      content: chunkMap.get(m.sourceChunkId).content,
+      metadata: chunkMap.get(m.sourceChunkId).metadata
+    } : void 0,
+    similarity: m.similarity,
+    relations: m.isRelated ? [] : void 0
+  }));
+}
+async function getSessionMemories(params) {
+  const { sessionId, projectId, limit = 50, sinceDate } = params;
+  const where = {
+    sessionId,
+    projectId,
+    isActive: true
+  };
+  if (sinceDate) {
+    where.createdAt = { gte: sinceDate };
+  }
+  return db.memory.findMany({
+    where,
+    orderBy: {
+      createdAt: "desc"
+    },
+    take: limit
+  });
+}
+async function getUserProfile(params) {
+  const { userId, projectId, memoryTypes, limit = 50 } = params;
+  const where = {
+    userId,
+    projectId,
+    isActive: true,
+    scope: "USER"
+  };
+  if (memoryTypes) {
+    where.memoryType = { in: memoryTypes };
+  }
+  return db.memory.findMany({
+    where,
+    orderBy: { importance: "desc" },
+    take: Math.min(limit, 100)
+  });
+}
+
+export {
+  searchMemories,
+  getSessionMemories,
+  getUserProfile
+};