memories-lite 0.10.1 → 0.99.2

package/dist/config/defaults.js

@@ -2,16 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_MEMORY_CONFIG = void 0;
 const DEFAULT_SCORING_CONFIG = {
-    // 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 }
 };
 exports.DEFAULT_MEMORY_CONFIG = {
     disableHistory: true,
-    enableGraph: false,
-    version: "v1.1",
+    version: "v2.0",
     embedder: {
         provider: "openai",
         config: {
@@ -26,6 +32,7 @@ exports.DEFAULT_MEMORY_CONFIG = {
             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 @@ exports.DEFAULT_MEMORY_CONFIG = {
             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/dist/config/manager.js

@@ -47,9 +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 },
-                                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
@@ -63,9 +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 },
-                                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
@@ -98,17 +96,12 @@ class ConfigManager {
                 })(),
             },
             historyDbPath: userConfig.historyDbPath || defaults_1.DEFAULT_MEMORY_CONFIG.historyDbPath,
-            customPrompt: userConfig.customPrompt,
-            graphStore: {
-                ...defaults_1.DEFAULT_MEMORY_CONFIG.graphStore,
-                ...userConfig.graphStore,
-            },
+            capturePrompt: userConfig.capturePrompt,
             historyStore: {
                 ...defaults_1.DEFAULT_MEMORY_CONFIG.historyStore,
                 ...userConfig.historyStore,
             },
             disableHistory: userConfig.disableHistory || defaults_1.DEFAULT_MEMORY_CONFIG.disableHistory,
-            enableGraph: userConfig.enableGraph || defaults_1.DEFAULT_MEMORY_CONFIG.enableGraph,
         };
         // Validate the merged config
         return types_1.MemoryConfigSchema.parse(mergedConfig);

package/dist/memory/index.d.ts

@@ -3,24 +3,33 @@ import { VectorStore } from "../vectorstores/base";
 import { AddMemoryOptions, SearchMemoryOptions, DeleteAllMemoryOptions, GetAllMemoryOptions } from "./memory.types";
 export declare class MemoriesLite {
     private config;
-    private customPrompt;
+    private capturePrompt;
     private embedder;
     private vectorStoreConfig;
     private llm;
     private db;
     private collectionName;
     private apiVersion;
-    private graphMemory?;
-    private enableGraph;
     telemetryId: string;
     constructor(config?: Partial<MemoryConfig>);
     private _initializeTelemetry;
     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

@@ -16,7 +16,7 @@ class MemoriesLite {
     constructor(config = {}) {
         // Merge and validate config
         this.config = manager_1.ConfigManager.mergeConfig(config);
-        this.customPrompt = this.config.customPrompt;
+        this.capturePrompt = this.config.capturePrompt;
         this.embedder = factory_1.EmbedderFactory.create(this.config.embedder.provider, this.config.embedder.config);
         //
         // vectorStore.provider is "lite" 
@@ -39,12 +39,7 @@ 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();
     }
@@ -56,7 +51,6 @@ class MemoriesLite {
                 api_version: this.apiVersion,
                 client_type: "Memory",
                 collection_name: this.collectionName,
-                enable_graph: this.enableGraph,
             });
         }
         catch (error) { }
@@ -93,133 +87,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.capturePrompt);
         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) || [];
-        // 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);
-        // console.log("-- DBG updatePrompt:", updatePrompt);
-        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 title seul (TEST COMPARATIF)
+        const embedding = await this.embedder.embed(title);
+        //
+        // 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 {
@@ -234,14 +163,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)
@@ -253,21 +183,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
-        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);
-            }
-        }
+        //
+        // Générer synthèse et stocker
+        const vectorStoreResult = await this.addToVectorStore(final_parsedMessages, metadata, userId, filters, capturePrompt);
         return {
             results: vectorStoreResult,
-            relations: graphResult?.relations,
         };
     }
     async get(memoryId, userId) {
@@ -324,16 +244,6 @@ class MemoriesLite {
         // Search vector store
         const queryEmbedding = await this.embedder.embed(query);
         const memories = await vectorStore.search(queryEmbedding, limit, filters);
-        // 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",
@@ -359,7 +269,6 @@ class MemoriesLite {
         }));
         return {
             results,
-            relations: graphResults,
         };
     }
     async update(memoryId, data, userId) {
@@ -408,9 +317,6 @@ class MemoriesLite {
         await this.db.reset();
         // 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 = factory_1.EmbedderFactory.create(this.config.embedder.provider, this.config.embedder.config);
         this.llm = factory_1.LLMFactory.create(this.config.llm.provider, this.config.llm.config);

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 (10-20 mots) qui capture l'essence de la demande\n2. SUMMARY: Les points cl\u00E9s du chemin de r\u00E9solution en markdown (max 150 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", "todo"]>;
+        type: z.ZodEnum<["assistant_preference"]>;
     }, "strip", z.ZodTypeAny, {
-        type: "todo" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }, {
-        type: "todo" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     facts: {
-        type: "todo" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         fact: string;
         existing: boolean;
     }[];
 }, {
     facts: {
-        type: "todo" | "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", "todo", "assistant_preference"]>;
+        type: z.ZodEnum<["assistant_preference"]>;
     }, "strict", z.ZodTypeAny, {
-        type: "todo" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
         old_memory: string | null;
         reason: string;
     }, {
-        type: "todo" | "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: "todo" | "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: "todo" | "factual" | "assistant_preference";
+        type: "assistant_preference";
         id: string;
         text: string;
         event: "ADD" | "UPDATE" | "DELETE" | "NONE";
@@ -76,16 +112,16 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
         reason: string;
     }[];
 }>;
-/**
- * Practical Application:
- *
- * If the task is "factual" (e.g., "Where do I live?", "What's my job?") → retrieve factual memory.
- * If the task is about assistant behavior (e.g., "How should I respond?") → retrieve assistant_preference 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.";
+/**
+ * @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;