memories-lite 0.10.1 → 0.99.2

package/dist/types/index.js

@@ -21,19 +21,13 @@ exports.MemoryConfigSchema = zod_1.z.object({
             dimension: zod_1.z.number().optional(),
             client: zod_1.z.any().optional(),
             scoring: zod_1.z.object({
-                todo: zod_1.z.object({
-                    alpha: zod_1.z.number(),
-                    beta: zod_1.z.number(),
-                    gamma: zod_1.z.number(),
-                    halfLifeDays: zod_1.z.number(),
-                }),
-                factual: zod_1.z.object({
+                assistant_preference: zod_1.z.object({
                     alpha: zod_1.z.number(),
                     beta: zod_1.z.number(),
                     gamma: zod_1.z.number(),
                     halfLifeDays: zod_1.z.number(),
                 }),
-                assistant_preference: zod_1.z.object({
+                discussion: zod_1.z.object({
                     alpha: zod_1.z.number(),
                     beta: zod_1.z.number(),
                     gamma: zod_1.z.number(),
@@ -47,6 +41,7 @@ exports.MemoryConfigSchema = zod_1.z.object({
                 }),
             }).optional(),
             recencyCleanupThreshold: zod_1.z.number().min(0).max(1).optional(),
+            searchThreshold: zod_1.z.number().min(0).max(1).optional(),
         })
             .passthrough(),
     }),
@@ -59,25 +54,7 @@ exports.MemoryConfigSchema = zod_1.z.object({
         }),
     }),
     historyDbPath: zod_1.z.string().optional(),
-    customPrompt: zod_1.z.string().optional(),
-    enableGraph: zod_1.z.boolean().optional(),
-    graphStore: zod_1.z
-        .object({
-        provider: zod_1.z.string(),
-        config: zod_1.z.object({
-            url: zod_1.z.string(),
-            username: zod_1.z.string(),
-            password: zod_1.z.string(),
-        }),
-        llm: zod_1.z
-            .object({
-            provider: zod_1.z.string(),
-            config: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
-        })
-            .optional(),
-        customPrompt: zod_1.z.string().optional(),
-    })
-        .optional(),
+    capturePrompt: zod_1.z.string().optional(),
     historyStore: zod_1.z
         .object({
         provider: zod_1.z.string(),

package/dist/vectorstores/lite.d.ts

@@ -18,6 +18,7 @@ export declare class LiteVectorStore implements VectorStore {
     private currentUserId;
     private scoringConfig;
     private cleanupThreshold?;
+    private searchThreshold;
     private static cache;
     constructor(config: VectorStoreConfig, currentUserId: string);
     private init;

package/dist/vectorstores/lite.js

@@ -28,7 +28,8 @@ class LiteVectorStore {
         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_1.default.join(config.rootPath, filename);
@@ -195,11 +196,15 @@ class LiteVectorStore {
             if (this.filterVector(memoryVector, filters)) {
                 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,
+                    });
+                }
             }
         }
         results.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memories-lite",
-  "version": "0.10.1",
+  "version": "0.99.2",
   "description": "A lightweight memory system for LLM agents",
   "author": "olivier@evaletolab.ch",
   "main": "dist/index.js",

package/src/config/defaults.ts

@@ -1,17 +1,23 @@
 import { MemoryConfig, MemoryScoringConfig } from "../types";
 
 const DEFAULT_SCORING_CONFIG: MemoryScoringConfig = {
-  // Focused on user preferences with AI - removed episodic and procedural memories
-  todo: { alpha: 0.40, beta: 0.50, gamma: 0.10, halfLifeDays: 40 }, // ~40 days 
-  factual: { alpha: 0.70, beta: 0.20, gamma: 0.10, halfLifeDays: 150 }, // ~150 days 
+  //
+  // assistant_preference: préférences utilisateur avec l'assistant (style, langue, etc.)
   assistant_preference: { alpha: 0.60, beta: 0.05, gamma: 0.35, halfLifeDays: Infinity },
-  default: { alpha: 0.5, beta: 0.3, gamma: 0.1, halfLifeDays: 30 } // Fallback default
+  //
+  // discussion: mémoires de discussions (synthèses opérationnelles)
+  // - alpha=1: score basé uniquement sur la similarité cosinus
+  // - beta=0: pas de recency
+  // - gamma=0: pas d'importance base
+  discussion: { alpha: 1, beta: 0, gamma: 0, halfLifeDays: Infinity },
+  //
+  // default: fallback si type manquant ou inconnu
+  default: { alpha: 0.5, beta: 0.3, gamma: 0.1, halfLifeDays: 30 }
 };
 
 export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {
   disableHistory: true,
-  enableGraph: false,
-  version: "v1.1",
+  version: "v2.0",
   embedder: {
     provider: "openai",
     config: {
@@ -26,6 +32,7 @@ export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {
       collectionName: "memories",
       dimension: 768,
       scoring: DEFAULT_SCORING_CONFIG,
+      searchThreshold: 0.50, // Seuil minimum de score pour retourner un résultat
     },
   },
   llm: {
@@ -36,20 +43,6 @@ export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {
       modelProperties: undefined,
     },
   },
-  graphStore: {
-    provider: "neo4j",
-    config: {
-      url: process.env.NEO4J_URL || "neo4j://localhost:7687",
-      username: process.env.NEO4J_USERNAME || "neo4j",
-      password: process.env.NEO4J_PASSWORD || "password",
-    },
-    llm: {
-      provider: "openai",
-      config: {
-        model: "gpt-5-mini",
-      },
-    },
-  },
   historyStore: {
     provider: "dummy",
     config: {

package/src/config/manager.ts

@@ -51,9 +51,8 @@ export class ConfigManager {
               dimension: userConf.dimension || defaultConf.dimension,
               // Merge scoring deeply if present in userConf, otherwise use default
               scoring: userConf.scoring ? {
-                todo: { ...defaultConf.scoring?.todo, ...userConf.scoring.todo },
-                factual: { ...defaultConf.scoring?.factual, ...userConf.scoring.factual },
                 assistant_preference: { ...defaultConf.scoring?.assistant_preference, ...userConf.scoring.assistant_preference },
+                discussion: { ...defaultConf.scoring?.discussion, ...userConf.scoring.discussion },
                 default: { ...defaultConf.scoring?.default, ...userConf.scoring.default },
               } : defaultConf.scoring,
               ...userConf, // Include any other passthrough fields from user
@@ -67,9 +66,8 @@ export class ConfigManager {
               client: undefined,
               // Merge scoring deeply if present in userConf, otherwise use default
               scoring: userConf?.scoring ? {
-                todo: { ...defaultConf.scoring?.todo, ...userConf.scoring.todo },
-                factual: { ...defaultConf.scoring?.factual, ...userConf.scoring.factual },
                 assistant_preference: { ...defaultConf.scoring?.assistant_preference, ...userConf.scoring.assistant_preference },
+                discussion: { ...defaultConf.scoring?.discussion, ...userConf.scoring.discussion },
                 default: { ...defaultConf.scoring?.default, ...userConf.scoring.default },
               } : defaultConf.scoring,
               recencyCleanupThreshold:
@@ -108,18 +106,13 @@ export class ConfigManager {
       },
       historyDbPath:
         userConfig.historyDbPath || DEFAULT_MEMORY_CONFIG.historyDbPath,
-      customPrompt: userConfig.customPrompt,
-      graphStore: {
-        ...DEFAULT_MEMORY_CONFIG.graphStore,
-        ...userConfig.graphStore,
-      },
+      capturePrompt: userConfig.capturePrompt,
       historyStore: {
         ...DEFAULT_MEMORY_CONFIG.historyStore,
         ...userConfig.historyStore,
       },
       disableHistory:
         userConfig.disableHistory || DEFAULT_MEMORY_CONFIG.disableHistory,
-      enableGraph: userConfig.enableGraph || DEFAULT_MEMORY_CONFIG.enableGraph,
     };
 
     // Validate the merged config

package/src/memory/index.ts

@@ -16,10 +16,8 @@ import {
   HistoryManagerFactory,
 } from "../utils/factory";
 import {
-  FactRetrievalSchema_extended,
-  getFactRetrievalMessages,
-  getUpdateMemoryMessages,
-  MemoryUpdateSchema,
+  DiscussionSynthesisSchema,
+  getDiscussionSynthesisMessages,
   removeCodeBlocks,
 } from "../prompts";
 import { DummyHistoryManager } from "../storage/DummyHistoryManager";
@@ -42,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,
@@ -90,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();
   }
@@ -111,7 +101,6 @@ export class MemoriesLite {
         api_version: this.apiVersion,
         client_type: "Memory",
         collection_name: this.collectionName,
-        enable_graph: this.enableGraph,
       });
     } catch (error) {}
   }
@@ -152,180 +141,98 @@ export class MemoriesLite {
   }
 
 
+  /**
+   * Capture une discussion et génère une synthèse (title + summary)
+   * Utilise getDiscussionSynthesisMessages pour produire la synthèse
+   */
   private async addToVectorStore(
     messages: Message[],
     metadata: Record<string, any>,
     userId: string,
     filters: SearchFilters,
-    customFacts?: string,
+    capturePrompt?: string,
   ): Promise<MemoryItem[]> {
 
     const $t = this.$t;
     const vectorStore = await this.getVectorStore(userId);
-    const parsedMessages = messages.filter((m) => typeof m.content === 'string' && m.role=='user').map((m) => `${m.role=='user' ? '**USER**: ' : '**ASSISTANT**: '}${$t(m.content as string)}\n`).join("\n");
-
-    // Disinterest handling is delegated to the LLM via prompt guidelines
+    
+    //
+    // Formater les messages pour la synthèse
+    const parsedMessages = messages
+      .filter((m) => typeof m.content === 'string')
+      .map((m) => `**${m.role.toUpperCase()}**: ${$t(m.content as string)}`)
+      .join("\n\n");
 
-    const [systemPrompt, userPrompt] = getFactRetrievalMessages(parsedMessages, customFacts||this.customPrompt);
+    //
+    // Générer la synthèse via LLM
+    const [systemPrompt, userPrompt] = getDiscussionSynthesisMessages(
+      parsedMessages, 
+      capturePrompt || this.capturePrompt
+    );
 
     const response = await this.llm.generateResponse(
       [
         { role: "system", content: systemPrompt },
         { role: "user", content: userPrompt },
       ],
-      {...zodResponseFormat(FactRetrievalSchema_extended,"FactRetrieval")},[],false
+      { ...zodResponseFormat(DiscussionSynthesisSchema, "DiscussionSynthesis") },
+      [],
+      false
     );
-    const parsedResponse = (response:any) => {
+
+    //
+    // Parser la réponse
+    const parsedResponse = (res: any) => {
       try {
-        // structured output
-        if(typeof response === 'object') {
-          return response;
+        if (typeof res === 'object') {
+          return res;
         }
-        const cleanResponse = removeCodeBlocks(response as string);
+        const cleanResponse = removeCodeBlocks(res as string);
         return JSON.parse(cleanResponse);
       } catch (e) {
-        console.error(
-          "Failed to parse facts from LLM response:",
-          response,
-          e,
-          response
-        );
-        return [];
+        console.error("Failed to parse synthesis from LLM response:", res, e);
+        return { title: "Sans titre", summary: "" };
       }
-    }
-    // 
-    // can use native structured output
-    // Drop factual facts at capture level (do not store factual memories)
-    // FIXME Drop factual should be done at prompt level
-    const facts = parsedResponse(response).facts?.filter((f:any) => !f.existing )||[];
+    };
 
-    // console.log("-- DBG extract:", userPrompt);
-    // console.log("-- DBG facts:", facts);
+    const { title, summary } = parsedResponse(response);
 
-    // Get embeddings for new facts
-    const newMessageEmbeddings: Record<string, number[]> = {};
-    const retrievedOldMemory: Array<{ id: string; text: string; type: string }> = [];
+    if (!summary) {
+      console.warn("-- ⚠️ Empty summary from LLM, skipping memory creation");
+      return [];
+    }
 
     //
-    // add the userId to the filters
-    filters.userId = userId;
-    // Create embeddings and search for similar memories
-    for (const elem of facts) {
-      const fact = elem.fact;
-      const embedding = await this.embedder.embed(fact);
-      newMessageEmbeddings[fact] = embedding;
-
-      const existingMemories = await vectorStore.search(
-        embedding,
-        5,
-        filters,
-      );
-      for (const mem of existingMemories) {
-        retrievedOldMemory.push({ id: mem.id, text: mem.payload.data,type: mem.payload.type });
-      }
-    }
+    // Créer l'embedding sur le title seul (TEST COMPARATIF)
+    const embedding = await this.embedder.embed(title);
 
-    // console.log("-- DBG old memories:", retrievedOldMemory);
-    // Remove duplicates from old memories
-    const uniqueOldMemories = retrievedOldMemory.filter(
-      (mem, index) =>
-        retrievedOldMemory.findIndex((m) => m.id === mem.id) === index,
-    );
+    //
+    // Préparer les métadonnées
+    const memoryType: MemoryType = metadata.type || 'discussion';
+    const memoryMetadata = {
+      ...metadata,
+      title,
+      type: memoryType,
+      userId,
+    };
 
-    // Create UUID mapping for handling UUID hallucinations
-    const tempUuidMapping: Record<string, string> = {};
-    uniqueOldMemories.forEach((item, idx) => {
-      tempUuidMapping[String(idx)] = item.id;
-      uniqueOldMemories[idx].id = String(idx);
-    });
-
-    // Get memory update decisions
-    const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
-    const userInstruction = typeof lastUserMessage?.content === 'string' ? lastUserMessage?.content as string : '';
-    const updatePrompt = getUpdateMemoryMessages(uniqueOldMemories, facts, 'French', userInstruction);
-
-    // console.log("-- DBG updatePrompt:", updatePrompt);
-    const updateResponse = await this.llm.generateResponse(
-      [{ role: "user", content: updatePrompt }],
-      {...zodResponseFormat(MemoryUpdateSchema,"Memory")},[],false,
+    //
+    // Stocker la mémoire
+    const memoryId = await this.createMemory(
+      summary,
+      { [summary]: embedding },
+      memoryMetadata,
+      userId,
     );
-    // console.log("-- DBG merge:", updatePrompt);
 
-    const memoryActions: any[] = parsedResponse(updateResponse).memory || [];
+    console.log(`-- 🧠 Memory created: "${title}" (${memoryType})`);
 
-    // Process memory actions
-    const results: MemoryItem[] = [];
-    for (const action of memoryActions) {
-      // Ignore any factual memory actions (ADD/UPDATE/DELETE) → void
-      if(action.type === 'factual') {
-        continue;
-      }
-      if(action.reason === "undefined") {
-        console.log(`-- ⛔ LLM Error: ${action.event}, ${action.type}, "${action.text}"`);
-        continue;
-      }
-      console.log(`-- DBG memory "${userId}": ${action.event}, ${action.type}, "${action.text}", why: "${action.reason}"`);
-      try {
-        switch (action.event) {
-          case "ADD": {
-            if(!action.type) {
-              // log error
-              console.error("Type is mandatory to manage memories:", action);
-              continue;
-            }
-            metadata.type = action.type;
-            const memoryId = await this.createMemory(
-              action.text,
-              newMessageEmbeddings,
-              metadata,
-              userId,
-            );
-            results.push({
-              id: memoryId,
-              memory: action.text,
-              type: action.type,
-              metadata: { event: action.event },
-            });
-            break;
-          }
-          case "UPDATE": {
-            const realMemoryId = tempUuidMapping[action.id];
-            const type = metadata.type = uniqueOldMemories[action.id].type || action.type;
-            await this.updateMemory(
-              realMemoryId,
-              action.text,
-              newMessageEmbeddings,
-              metadata,
-              userId,
-            );
-            results.push({
-              id: realMemoryId,
-              memory: action.text,
-              type,
-              metadata: {
-                event: action.event,
-                previousMemory: action.old_memory,
-              },
-            });
-            break;
-          }
-          case "DELETE": {
-            const realMemoryId = tempUuidMapping[action.id];
-            await this.deleteMemory(realMemoryId, userId);
-            results.push({
-              id: realMemoryId,
-              memory: action.text,
-              type: action.type,
-              metadata: { event: action.event },
-            });
-            break;
-          }
-        }
-      } catch (error) {
-        console.error(`Error processing memory action: ${error}`);
-      }
-    }
-    return results;
+    return [{
+      id: memoryId,
+      memory: summary,
+      type: memoryType,
+      metadata: { title, event: "ADD" },
+    }];
   }  
 
   static fromConfig(configDict: Record<string, any>): MemoriesLite {
@@ -342,24 +249,24 @@ export class MemoriesLite {
     return LiteVectorStore.from(userId, this.vectorStoreConfig);
   }
 
+  /**
+   * Capture une discussion et génère une mémoire (title + summary)
+   * 
+   * @param messages - Messages de la discussion ou texte brut
+   * @param userId - ID utilisateur
+   * @param config - Options incluant capturePrompt pour personnaliser la synthèse
+   */
   async capture(
     messages: string | Message[],
     userId: string,
     config: AddMemoryOptions,
   ): Promise<SearchResult> {
-    // await this._captureEvent("add", {
-    //   message_count: Array.isArray(messages) ? messages.length : 1,
-    //   has_metadata: !!config.metadata,
-    //   has_filters: !!config.filters,
-    //   infer: config.infer,
-    // });
     const {
       agentId,
       runId,
       metadata = {},
       filters = {},
-      infer = true,
-      customFacts
+      capturePrompt
     } = config;
 
     if (agentId) filters.agentId = metadata.agentId = agentId;
@@ -377,31 +284,18 @@ export class MemoriesLite {
 
     const final_parsedMessages = await parse_vision_messages(parsedMessages);
 
-    // Add to vector store
+    //
+    // Générer synthèse et stocker
     const vectorStoreResult = await this.addToVectorStore(
       final_parsedMessages,
       metadata,
       userId,
       filters,
-      customFacts,
+      capturePrompt,
     );
 
-    // Add to graph store if available
-    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,
     };
   }
 
@@ -480,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",
@@ -516,7 +400,6 @@ export class MemoriesLite {
 
     return {
       results,
-      relations: graphResults,
     };
   }
 
@@ -578,10 +461,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,

package/src/memory/memory.types.ts

@@ -10,8 +10,7 @@ export interface Entity {
 export interface AddMemoryOptions extends Entity {
   metadata?: Record<string, any>;
   filters?: SearchFilters;
-  customFacts?: string;
-  infer?: boolean;
+  capturePrompt?: string;
 }
 
 export interface SearchMemoryOptions extends Entity {