memories-lite 0.9.5 → 0.99.1

package/dist/config/defaults.js

@@ -2,13 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_MEMORY_CONFIG = void 0;
 const DEFAULT_SCORING_CONFIG = {
-    // Values from memories-lite rule & user request
-    procedural: { alpha: 0.30, beta: 0.40, gamma: 0.05, halfLifeDays: 1 / 24 }, // ~1 hour
-    episodic: { alpha: 0.40, beta: 0.50, gamma: 0.10, halfLifeDays: 2 }, // ~2 days (user request 'temporary')
-    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=0: pas de cosine dans le score final
+    // - beta=1: score basé sur recency (constant car halfLife=∞)
+    // - gamma=0: pas d'importance base
+    discussion: { alpha: 0, beta: 1, gamma: 0, halfLifeDays: Infinity },
+    //
+    // default: fallback si type manquant ou inconnu
+    default: { alpha: 0.5, beta: 0.3, gamma: 0.1, halfLifeDays: 30 }
 };
 exports.DEFAULT_MEMORY_CONFIG = {
     disableHistory: true,
@@ -34,7 +39,7 @@ exports.DEFAULT_MEMORY_CONFIG = {
         provider: "openai",
         config: {
             apiKey: process.env.OPENAI_API_KEY || "",
-            model: "gpt-5-nano",
+            model: "gpt-5-mini",
             modelProperties: undefined,
         },
     },
@@ -48,7 +53,7 @@ exports.DEFAULT_MEMORY_CONFIG = {
         llm: {
             provider: "openai",
             config: {
-                model: "gpt-5-nano",
+                model: "gpt-5-mini",
             },
         },
     },

package/dist/config/manager.js

@@ -47,11 +47,8 @@ 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 },
-                                procedural: { ...defaultConf.scoring?.procedural, ...userConf.scoring.procedural },
-                                episodic: { ...defaultConf.scoring?.episodic, ...userConf.scoring.episodic },
-                                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
@@ -65,11 +62,8 @@ class ConfigManager {
                             client: undefined,
                             // Merge scoring deeply if present in userConf, otherwise use default
                             scoring: userConf?.scoring ? {
-                                todo: { ...defaultConf.scoring?.todo, ...userConf.scoring.todo },
-                                procedural: { ...defaultConf.scoring?.procedural, ...userConf.scoring.procedural },
-                                episodic: { ...defaultConf.scoring?.episodic, ...userConf.scoring.episodic },
-                                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: userConf?.recencyCleanupThreshold ?? defaultConf.recencyCleanupThreshold, // Merge cleanup threshold

package/dist/memory/index.d.ts

@@ -18,9 +18,20 @@ export declare class MemoriesLite {
     private _getTelemetryId;
     private _captureEvent;
     private $t;
+    /**
+     * Capture une discussion et génère une synthèse (title + summary)
+     * Utilise getDiscussionSynthesisMessages pour produire la synthèse
+     */
     private addToVectorStore;
     static fromConfig(configDict: Record<string, any>): MemoriesLite;
     getVectorStore(userId: string): Promise<VectorStore>;
+    /**
+     * 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
+     */
     capture(messages: string | Message[], userId: string, config: AddMemoryOptions): Promise<SearchResult>;
     get(memoryId: string, userId: string): Promise<MemoryItem | null>;
     retrieve(query: string, userId: string, config: SearchMemoryOptions): Promise<SearchResult>;

package/dist/memory/index.js

@@ -93,132 +93,68 @@ class MemoriesLite {
         // return text.replace(/<thinking>[\s\S]*?(?:<\/thinking>)/g,'').replace(/^<step.*$/g,'');
         return text.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').replace(/^<step.*$/gm, '').replace(/<memories>[\s\S]*?<\/memories>/g, '');
     }
-    async addToVectorStore(messages, metadata, userId, filters, customFacts) {
+    /**
+     * Capture une discussion et génère une synthèse (title + summary)
+     * Utilise getDiscussionSynthesisMessages pour produire la synthèse
+     */
+    async addToVectorStore(messages, metadata, userId, filters, capturePrompt) {
         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)}\n`).join("\n");
-        // Disinterest handling is delegated to the LLM via prompt guidelines
-        const [systemPrompt, userPrompt] = (0, prompts_1.getFactRetrievalMessages)(parsedMessages, customFacts || this.customPrompt);
+        //
+        // Formater les messages pour la synthèse
+        const parsedMessages = messages
+            .filter((m) => typeof m.content === 'string')
+            .map((m) => `**${m.role.toUpperCase()}**: ${$t(m.content)}`)
+            .join("\n\n");
+        //
+        // Générer la synthèse via LLM
+        const [systemPrompt, userPrompt] = (0, prompts_1.getDiscussionSynthesisMessages)(parsedMessages, capturePrompt || this.customPrompt);
         const response = await this.llm.generateResponse([
             { role: "system", content: systemPrompt },
             { role: "user", content: userPrompt },
-        ], { ...(0, zod_1.zodResponseFormat)(prompts_1.FactRetrievalSchema_extended, "FactRetrieval") }, [], false);
-        const parsedResponse = (response) => {
+        ], { ...(0, zod_1.zodResponseFormat)(prompts_1.DiscussionSynthesisSchema, "DiscussionSynthesis") }, [], false);
+        //
+        // Parser la réponse
+        const parsedResponse = (res) => {
             try {
-                // structured output
-                if (typeof response === 'object') {
-                    return response;
+                if (typeof res === 'object') {
+                    return res;
                 }
-                const cleanResponse = (0, prompts_1.removeCodeBlocks)(response);
+                const cleanResponse = (0, prompts_1.removeCodeBlocks)(res);
                 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) => !f.existing && f.type !== 'factual') || [];
-        // console.log("-- DBG extract:", userPrompt);
-        // console.log("-- DBG facts:", facts);
-        // Get embeddings for new facts
-        const newMessageEmbeddings = {};
-        const retrievedOldMemory = [];
-        //
-        // 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 });
-            }
+        const { title, summary } = parsedResponse(response);
+        if (!summary) {
+            console.warn("-- ⚠️ Empty summary from LLM, skipping memory creation");
+            return [];
         }
-        // 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);
-        // Create UUID mapping for handling UUID hallucinations
-        const tempUuidMapping = {};
-        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 : '';
-        const updatePrompt = (0, prompts_1.getUpdateMemoryMessages)(uniqueOldMemories, facts, 'French', userInstruction);
-        const updateResponse = await this.llm.generateResponse([{ role: "user", content: updatePrompt }], { ...(0, zod_1.zodResponseFormat)(prompts_1.MemoryUpdateSchema, "Memory") }, [], false);
-        // console.log("-- DBG merge:", updatePrompt);
-        const memoryActions = parsedResponse(updateResponse).memory || [];
-        // Process memory actions
-        const results = [];
-        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;
+        //
+        // Créer l'embedding sur le summary (pour recherche sémantique)
+        const embedding = await this.embedder.embed(summary);
+        //
+        // Préparer les métadonnées
+        const memoryType = metadata.type || 'discussion';
+        const memoryMetadata = {
+            ...metadata,
+            title,
+            type: memoryType,
+            userId,
+        };
+        //
+        // Stocker la mémoire
+        const memoryId = await this.createMemory(summary, { [summary]: embedding }, memoryMetadata, userId);
+        console.log(`-- 🧠 Memory created: "${title}" (${memoryType})`);
+        return [{
+                id: memoryId,
+                memory: summary,
+                type: memoryType,
+                metadata: { title, event: "ADD" },
+            }];
     }
     static fromConfig(configDict) {
         try {
@@ -233,14 +169,15 @@ class MemoriesLite {
     async getVectorStore(userId) {
         return lite_1.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, userId, config) {
-        // 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 } = config;
+        const { agentId, runId, metadata = {}, filters = {}, capturePrompt } = config;
         if (agentId)
             filters.agentId = metadata.agentId = agentId;
         if (runId)
@@ -252,9 +189,11 @@ class MemoriesLite {
             ? messages
             : [{ role: "user", content: messages }];
         const final_parsedMessages = await (0, memory_1.parse_vision_messages)(parsedMessages);
-        // Add to vector store
-        const vectorStoreResult = await this.addToVectorStore(final_parsedMessages, metadata, userId, filters, customFacts);
-        // Add to graph store if available
+        //
+        // Générer synthèse et stocker
+        const vectorStoreResult = await this.addToVectorStore(final_parsedMessages, metadata, userId, filters, capturePrompt);
+        //
+        // Graph store (si configuré)
         let graphResult;
         if (this.graphMemory) {
             try {

package/dist/memory/memory.types.d.ts

@@ -8,8 +8,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 {
     limit?: number;

package/dist/prompts/index.d.ts

@@ -1,5 +1,34 @@
 import { z } from "zod";
 import { MemoryItem } from "../types";
+/**
+ * Schema pour la synthèse de discussion
+ * Produit un titre court et une synthèse opérationnelle
+ */
+export declare const DiscussionSynthesisSchema: z.ZodObject<{
+    title: z.ZodString;
+    summary: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    summary: string;
+}, {
+    title: string;
+    summary: string;
+}>;
+/**
+ * Prompt par défaut pour la synthèse de discussion
+ * Peut être remplacé via capturePrompt dans AddMemoryOptions
+ */
+export declare const DEFAULT_DISCUSSION_PROMPT = "Tu es un expert en synth\u00E8se op\u00E9rationnelle.\n\n\u00C0 partir de cette discussion, g\u00E9n\u00E8re :\n1. TITRE: Un titre court et descriptif (6-10 mots) qui capture l'essence de la demande\n2. SUMMARY: Les points cl\u00E9s du chemin de r\u00E9solution (50-100 mots)\n\nCette synth\u00E8se servira \u00E0 retrouver et r\u00E9appliquer ce pattern de r\u00E9solution similaire.\nUtilise la m\u00EAme langue que la discussion.\n\nDiscussion \u00E0 synth\u00E9tiser:\n";
+/**
+ * Génère les messages pour la synthèse de discussion
+ * @param discussion - Contenu de la discussion formatée
+ * @param capturePrompt - Prompt custom optionnel (remplace DEFAULT_DISCUSSION_PROMPT)
+ * @returns [systemPrompt, userPrompt]
+ */
+export declare function getDiscussionSynthesisMessages(discussion: string, capturePrompt?: string): [string, string];
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ */
 export declare const FactRetrievalSchema_simple: z.ZodObject<{
     facts: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
@@ -7,33 +36,40 @@ export declare const FactRetrievalSchema_simple: z.ZodObject<{
 }, {
     facts: string[];
 }>;
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ * Types todo et factual supprimés - seul assistant_preference reste pour compatibilité
+ */
 export declare const FactRetrievalSchema_extended: z.ZodObject<{
     facts: z.ZodArray<z.ZodObject<{
         fact: z.ZodString;
         existing: z.ZodBoolean;
-        type: z.ZodEnum<["assistant_preference", "factual", "episodic", "procedural", "todo"]>;
+        type: z.ZodEnum<["assistant_preference"]>;
     }, "strip", z.ZodTypeAny, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     facts: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }[];
 }, {
     facts: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }[];
 }>;
+/**
+ * @deprecated Memory updates are disabled - use capture() for new memories
+ */
 export declare const MemoryUpdateSchema: z.ZodObject<{
     memory: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -41,16 +77,16 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
         event: z.ZodEnum<["ADD", "UPDATE", "DELETE", "NONE"]>;
         old_memory: z.ZodNullable<z.ZodString>;
         reason: z.ZodString;
-        type: z.ZodEnum<["factual", "episodic", "todo", "procedural", "assistant_preference"]>;
+        type: z.ZodEnum<["assistant_preference"]>;
     }, "strict", z.ZodTypeAny, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
         old_memory: string | null;
         reason: string;
     }, {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -59,7 +95,7 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     memory: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -68,7 +104,7 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
     }[];
 }, {
     memory: {
-        type: "procedural" | "todo" | "episodic" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -76,17 +112,16 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
         reason: string;
     }[];
 }>;
-/**
- * Practical Application:
- *
- * If the task is "factual" (e.g., "Where do I live?") → retrieve factual memory.
- * If the task is temporal or event-based ("What was I doing yesterday?") → retrieve episodic memory.
- * If the task is a user task/reminder (e.g., "Add a reminder to call the bank tomorrow") → retrieve todo memory.
- */
 export declare const MEMORY_STRING_SYSTEM = "# DIRECTIVES FOR MEMORIES\n- Information stored in memory is always enclosed within the <memories> tag.\n- Prioritize the latest user message over memories (the user's current question is authoritative).\n- Select at most the top-5 relevant memories using cosine similarity and recency; ignore the rest.\n- Adapt your answer based strictly on the <memories> section when relevant.\n- If the memories are irrelevant to the user's query, ignore them.\n- By default, do not reference this section or the memories in your response.\n- Use memories only to guide reasoning; do not respond to the memories themselves.";
 export declare const MEMORY_STRING_PREFIX = "Use these contextual memories to guide your response. Prioritize the user's question. Ignore irrelevant memories.";
-export declare const MEMORY_STRING_SYSTEM_OLD = "# USER AND MEMORIES PREFERENCES:\n- Utilize the provided memories to guide your responses.\n- Disregard any memories that are not relevant.\n- By default, do not reference this section or the memories in your response.\n";
+/**
+ * @deprecated Use getDiscussionSynthesisMessages instead
+ * Cette fonction est conservée pour compatibilité avec l'ancien système
+ */
 export declare function getFactRetrievalMessages(parsedMessages: string, customRules?: string, defaultLanguage?: string): [string, string];
+/**
+ * @deprecated Memory updates are disabled by config
+ */
 export declare function getUpdateMemoryMessages(retrievedOldMemory: Array<{
     id: string;
     text: string;