memories-lite 0.99.1 → 0.99.3

package/src/memory/index.ts

@@ -40,22 +40,20 @@ import { zodResponseFormat } from "openai/helpers/zod";
 
 export class MemoriesLite {
   private config: MemoryConfig;
-  private customPrompt: string | undefined;
+  private capturePrompt: string | undefined;
   private embedder: Embedder;
   private vectorStoreConfig: VectorStoreConfig;
   private llm: LLM;
   private db: HistoryManager;
   private collectionName: string | undefined;
   private apiVersion: string;
-  private graphMemory?: any;
-  private enableGraph: boolean;
   telemetryId: string;
 
   constructor(config: Partial<MemoryConfig> = {}) {
     // Merge and validate config
     this.config = ConfigManager.mergeConfig(config);
 
-    this.customPrompt = this.config.customPrompt;
+    this.capturePrompt = this.config.capturePrompt;
     this.embedder = EmbedderFactory.create(
       this.config.embedder.provider,
       this.config.embedder.config,
@@ -88,14 +86,8 @@ export class MemoriesLite {
 
     this.collectionName = this.config.vectorStore.config.collectionName;
     this.apiVersion = this.config.version || "v1.0";
-    this.enableGraph = this.config.enableGraph || false;
     this.telemetryId = "anonymous";
 
-    // Initialize graph memory if configured
-    if (this.enableGraph && this.config.graphStore) {
-      // this.graphMemory = new MemoryGraph(this.config);
-    }
-
     // Initialize telemetry if vector store is initialized
     // this._initializeTelemetry();
   }
@@ -109,7 +101,6 @@ export class MemoriesLite {
         api_version: this.apiVersion,
         client_type: "Memory",
         collection_name: this.collectionName,
-        enable_graph: this.enableGraph,
       });
     } catch (error) {}
   }
@@ -176,7 +167,7 @@ export class MemoriesLite {
     // Générer la synthèse via LLM
     const [systemPrompt, userPrompt] = getDiscussionSynthesisMessages(
       parsedMessages, 
-      capturePrompt || this.customPrompt
+      capturePrompt || this.capturePrompt
     );
 
     const response = await this.llm.generateResponse(
@@ -212,8 +203,8 @@ export class MemoriesLite {
     }
 
     //
-    // Créer l'embedding sur le summary (pour recherche sémantique)
-    const embedding = await this.embedder.embed(summary);
+    // Créer l'embedding sur le title seul (TEST COMPARATIF)
+    const embedding = await this.embedder.embed(title);
 
     //
     // Préparer les métadonnées
@@ -237,7 +228,7 @@ export class MemoriesLite {
     console.log(`-- 🧠 Memory created: "${title}" (${memoryType})`);
 
     return [{
-      id: memoryId,
+              id: memoryId,
       memory: summary,
       type: memoryType,
       metadata: { title, event: "ADD" },
@@ -301,25 +292,10 @@ export class MemoriesLite {
       userId,
       filters,
       capturePrompt,
-    );
-
-    //
-    // Graph store (si configuré)
-    let graphResult;
-    if (this.graphMemory) {
-      try {
-        graphResult = await this.graphMemory.add(
-          final_parsedMessages.map((m) => m.content).join("\n"),
-          filters,
         );
-      } catch (error) {
-        console.error("Error adding to graph memory:", error);
-      }
-    }
 
     return {
       results: vectorStoreResult,
-      relations: graphResult?.relations,
     };
   }
 
@@ -398,16 +374,6 @@ export class MemoriesLite {
     );
 
 
-    // Search graph store if available
-    let graphResults =[];
-    if (this.graphMemory) {
-      try {
-        graphResults = await this.graphMemory.search(query, filters);
-      } catch (error) {
-        console.error("Error searching graph memory:", error);
-      }
-    }
-
     const excludedKeys = new Set([
       "userId",
       "agentId",
@@ -434,14 +400,18 @@ export class MemoriesLite {
 
     return {
       results,
-      relations: graphResults,
     };
   }
 
-  async update(memoryId: string, data: string, userId: string): Promise<{ message: string }> {
+  async update(
+    memoryId: string,
+    data: string,
+    userId: string,
+    metadata: Record<string, any> = {},
+  ): Promise<{ message: string }> {
     // await this._captureEvent("update", { memory_id: memoryId });
     const embedding = await this.embedder.embed(data);
-    await this.updateMemory(memoryId, data, { [data]: embedding }, {}, userId);
+    await this.updateMemory(memoryId, data, { [data]: embedding }, metadata, userId);
     return { message: "Memory updated successfully!" };
   }
 
@@ -496,10 +466,6 @@ export class MemoriesLite {
     // Check provider before attempting deleteCol
     await vectorStore.deleteCol();
 
-    if (this.graphMemory) {
-      await this.graphMemory.deleteAll({ userId: "default" }); // Assuming this is okay, or needs similar check?
-    }
-
     // Re-initialize factories/clients based on the original config
     this.embedder = EmbedderFactory.create(
       this.config.embedder.provider,
@@ -603,22 +569,24 @@ export class MemoriesLite {
     }
 
     const prevValue = existingMemory.payload.data;
+    const originalPayload: Record<string, any> = (existingMemory.payload ?? {}) as Record<string, any>;
     const embedding =
       existingEmbeddings[data] || (await this.embedder.embed(data));
 
-    const newMetadata = {
-      ...metadata,
+    //
+    // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
+    // - title: keep original unless explicitly changed
+    // - discussionId, userId, agentId/runId: always keep original
+    const title =
+      (typeof metadata.title === "string" && metadata.title.trim())
+        ? metadata.title.trim()
+        : originalPayload.title;
+    const newMetadata: Record<string, any> = {
+      ...originalPayload,
       data,
       hash: createHash("md5").update(data).digest("hex"),
-      type: existingMemory.payload.type,
-      createdAt: existingMemory.payload.createdAt,
       updatedAt: new Date().toISOString(),
-      ...(existingMemory.payload.agentId && {
-        agentId: existingMemory.payload.agentId,
-      }),
-      ...(existingMemory.payload.runId && {
-        runId: existingMemory.payload.runId,
-      }),
+      title: title,
     };
 
     await vectorStore.update(memoryId, embedding, newMetadata);

package/src/prompts/index.ts

@@ -21,8 +21,8 @@ export const DiscussionSynthesisSchema = z.object({
 export const DEFAULT_DISCUSSION_PROMPT = `Tu es un expert en synthèse opérationnelle.
 
 À partir de cette discussion, génère :
-1. TITRE: Un titre court et descriptif (6-10 mots) qui capture l'essence de la demande
-2. SUMMARY: Les points clés du chemin de résolution (50-100 mots)
+1. TITRE: Un titre court et descriptif (10-20 mots) qui capture l'essence de la demande
+2. SUMMARY: Les points clés du chemin de résolution en markdown (max 150 mots)
 
 Cette synthèse servira à retrouver et réappliquer ce pattern de résolution similaire.
 Utilise la même langue que la discussion.

package/src/types/index.ts

@@ -30,6 +30,7 @@ export interface VectorStoreConfig {
   cacheTtl?: number;
   scoring?: MemoryScoringConfig;
   recencyCleanupThreshold?: number;
+  searchThreshold?: number; // Seuil minimum de score pour retourner un résultat (0-1)
   [key: string]: any;
 }
 
@@ -51,19 +52,6 @@ export interface LLMConfig {
   modelProperties?: Record<string, any>;
 }
 
-export interface Neo4jConfig {
-  url: string;
-  username: string;
-  password: string;
-}
-
-export interface GraphStoreConfig {
-  provider: string;
-  config: Neo4jConfig;
-  llm?: LLMConfig;
-  customPrompt?: string;
-}
-
 export interface MemoryTypeConfig {
   alpha: number; // Weight for cosine similarity
   beta: number;  // Weight for recency
@@ -95,9 +83,7 @@ export interface MemoryConfig {
   historyStore?: HistoryStoreConfig;
   disableHistory?: boolean;
   historyDbPath?: string;
-  customPrompt?: string;
-  graphStore?: GraphStoreConfig;
-  enableGraph?: boolean;
+  capturePrompt?: string; // Prompt par défaut pour la synthèse de discussion
 }
 
 export type MemoryType = 'assistant_preference' | 'discussion';
@@ -181,6 +167,7 @@ export const MemoryConfigSchema = z.object({
           }),
         }).optional(),
         recencyCleanupThreshold: z.number().min(0).max(1).optional(),
+        searchThreshold: z.number().min(0).max(1).optional(),
       })
       .passthrough(),
   }),
@@ -193,25 +180,7 @@ export const MemoryConfigSchema = z.object({
     }),
   }),
   historyDbPath: z.string().optional(),
-  customPrompt: z.string().optional(),
-  enableGraph: z.boolean().optional(),
-  graphStore: z
-    .object({
-      provider: z.string(),
-      config: z.object({
-        url: z.string(),
-        username: z.string(),
-        password: z.string(),
-      }),
-      llm: z
-        .object({
-          provider: z.string(),
-          config: z.record(z.string(), z.any()),
-        })
-        .optional(),
-      customPrompt: z.string().optional(),
-    })
-    .optional(),
+  capturePrompt: z.string().optional(),
   historyStore: z
     .object({
       provider: z.string(),

package/src/vectorstores/lite.ts

@@ -31,7 +31,8 @@ export class LiteVectorStore implements VectorStore {
   private dimension: number;
   private currentUserId: string;
   private scoringConfig: MemoryScoringConfig;
-  private cleanupThreshold?: number; // Store the threshold
+  private cleanupThreshold?: number; // Seuil de recency pour cleanup
+  private searchThreshold: number; // Seuil minimum de score pour retourner un résultat
   private static cache: Map<string, LiteVectorStore>;
   constructor(config: VectorStoreConfig, currentUserId: string) {
     if (!config.scoring) {
@@ -41,7 +42,8 @@ export class LiteVectorStore implements VectorStore {
     this.currentUserId = currentUserId;
     this.isSecure = config.secure || false;
     this.scoringConfig = config.scoring;
-    this.cleanupThreshold = config.recencyCleanupThreshold || 0.25; // (default 0.25 means 2 times the half-life  )
+    this.cleanupThreshold = config.recencyCleanupThreshold || 0.25; // (default 0.25 means 2 times the half-life)
+    this.searchThreshold = config.searchThreshold ?? 0; // Seuil de score (default 0 = pas de filtrage)
     config.rootPath = config.rootPath || process.cwd();
     const filename = this.isSecure ? `memories-lite-${currentUserId}.db` : `memories-lite-global.db`;
     this.dbPath = (config.rootPath == ':memory:') ? ':memory:' : path.join(config.rootPath, filename);
@@ -246,11 +248,15 @@ export class LiteVectorStore implements VectorStore {
         const cosineScore = this.cosineSimilarity(query, vector);
         const hybridScore = this.calculateHybridScore(cosineScore, payload);
 
-        results.push({
-          id: memoryVector.id,
-          payload: memoryVector.payload,
-          score: hybridScore,
-        });
+        //
+        // Filtrer par searchThreshold - ne retourner que les résultats au-dessus du seuil
+        if (hybridScore >= this.searchThreshold) {
+          results.push({
+            id: memoryVector.id,
+            payload: memoryVector.payload,
+            score: hybridScore,
+          });
+        }
       }
     }
 

package/tests/init.mem.ts

@@ -6,9 +6,10 @@ dotenv.config();
 
 /**
  * Helper to initialize MemoriesLite instance and generate a random userId.
- * @param customPrompt Optional prompt to inject into the memory config.
+ * @param capturePrompt Optional prompt to inject into the memory config.
+ * @param searchThreshold Optional minimum score threshold for search results (0-1)
  */
-export function createTestMemory({customPrompt, dimension, rootPath, secure}:any) {
+export function createTestMemory({capturePrompt, dimension, rootPath, secure, searchThreshold}:any) {
   dimension = dimension || 768;
   const userId =
     Math.random().toString(36).substring(2, 15) +
@@ -17,7 +18,7 @@ export function createTestMemory({customPrompt, dimension, rootPath, secure}:any
   const memory = new MemoriesLite({
     version: "v1.1",
     disableHistory: true,
-    ...(customPrompt ? { customPrompt } : {}),
+    ...(capturePrompt ? { capturePrompt } : {}),
     embedder: {
       provider: "openai",
       config: { dimension, apiKey: process.env.OPENAI_API_KEY!, model: "text-embedding-3-small" }
@@ -27,7 +28,9 @@ export function createTestMemory({customPrompt, dimension, rootPath, secure}:any
       config: { 
         dimension, 
         rootPath: (rootPath || ":memory:"), 
-        secure: secure || false }
+        secure: secure || false,
+        searchThreshold: searchThreshold ?? 0 // Par défaut 0 (pas de filtrage) pour les tests existants
+      }
     },
     llm: {
       provider: "openai",

package/tests/lite.spec.ts

@@ -132,35 +132,35 @@ describe('LiteVectorStore Private Methods', () => {
       //
       // discussion with Infinity halfLife → old memories have same score as new
       const payload: MemoryPayload = { memoryId: 'mem-d2', userId: userId, type: 'discussion', createdAt: veryOldDate };
-      const cosineScore = 0.9;
+        const cosineScore = 0.9;
       const expectedRecency = 1.0; // Infinity halfLife → recency = 1 even for old dates
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
       expect(hybridScore).toBe(1); // Score constant = 1
     });
 
     it('should handle assistant_preference with no decay (Infinity half-life)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-a1', userId: userId, type: 'assistant_preference', createdAt: veryOldDate };
-      const cosineScore = 0.7;
-      const expectedRecency = 1.0;
-      const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeCloseTo(expectedScore, 5);
+        const payload: MemoryPayload = { memoryId: 'mem-a1', userId: userId, type: 'assistant_preference', createdAt: veryOldDate };
+        const cosineScore = 0.7;
+        const expectedRecency = 1.0;
+        const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeCloseTo(expectedScore, 5);
     });
 
     it('should use default scoring if type is missing', () => {
       const payload: MemoryPayload = { memoryId: 'mem-def1', userId: userId, createdAt: sevenDaysAgo }; // No type specified
-      const cosineScore = 0.8;
-      const expectedRecency = (store as any).calculateRecencyScore(sevenDaysAgo, scoring.default.halfLifeDays);
-      const expectedScore = scoring.default.alpha * cosineScore + scoring.default.beta * expectedRecency + scoring.default.gamma;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeCloseTo(expectedScore, 5);
+        const cosineScore = 0.8;
+        const expectedRecency = (store as any).calculateRecencyScore(sevenDaysAgo, scoring.default.halfLifeDays);
+        const expectedScore = scoring.default.alpha * cosineScore + scoring.default.beta * expectedRecency + scoring.default.gamma;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeCloseTo(expectedScore, 5);
     });
 
     it('should return score >= 0 even with negative cosine similarity', () => {
       const payload: MemoryPayload = { memoryId: 'mem-neg1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
-      const cosineScore = -0.5;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeGreaterThanOrEqual(0);
+        const cosineScore = -0.5;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeGreaterThanOrEqual(0);
     });
 
   });