memories-lite 0.10.1 → 0.99.2

package/src/prompts/index.ts

@@ -1,36 +1,83 @@
 import { z } from "zod";
 import { MemoryItem } from "../types";
 
-// Define Zod schema for fact retrieval output
+// ══════════════════════════════════════════════════════════════════════════════
+// DISCUSSION SYNTHESIS - Nouveau système de mémoire
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Schema pour la synthèse de discussion
+ * Produit un titre court et une synthèse opérationnelle
+ */
+export const DiscussionSynthesisSchema = z.object({
+  title: z.string().describe("Titre court et descriptif (6-10 mots)"),
+  summary: z.string().describe("Synthèse opérationnelle des points clés (50-100 mots)")
+});
+
+/**
+ * Prompt par défaut pour la synthèse de discussion
+ * Peut être remplacé via capturePrompt dans AddMemoryOptions
+ */
+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 (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.
+
+Discussion à synthétiser:
+`;
+
+/**
+ * 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 function getDiscussionSynthesisMessages(
+  discussion: string,
+  capturePrompt?: string
+): [string, string] {
+  const systemPrompt = capturePrompt || DEFAULT_DISCUSSION_PROMPT;
+  return [systemPrompt, discussion];
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// @deprecated - Ancien système de capture (todo, factual)
+// Ces exports sont conservés pour compatibilité mais ne doivent plus être utilisés
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ */
 export const FactRetrievalSchema_simple = z.object({
   facts: z
     .array(z.string())
     .describe("An array of distinct facts extracted from the conversation."),
 });
 
-
-//1. **Factual memory** – stable facts & preferences about the user
-//2. **Todo memory** – explicit user tasks to remember
-//3. **Assistant preference memory** – how the user wants the AI to behave
-//
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ * Types todo et factual supprimés - seul assistant_preference reste pour compatibilité
+ */
 export const FactRetrievalSchema_extended = z.object({
   facts: z
   .array(
     z.object({
       fact: z.string().describe("The fact extracted from the conversation."),
       existing: z.boolean().describe("Whether the fact is already present"),
-      type: z.enum(["assistant_preference","factual","todo"])
-      .describe(`The type of the fact.
-        Use 'assistant_preference' for Assistant behavior preferences (style/language/constraints/commands).
-        Use 'factual' for stable user facts (identity, preferences, beliefs, work context).
-        Use 'todo' ONLY if the user explicitly asks to save/keep as a todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Do not infer todos.
-        `),
+      type: z.enum(["assistant_preference"])
+      .describe(`The type of the fact. Only 'assistant_preference' is supported.`),
     })
   )
 });
 
 
-// Define Zod schema for memory update output
+/**
+ * @deprecated Memory updates are disabled - use capture() for new memories
+ */
 export const MemoryUpdateSchema = z.object({
   memory: z
     .array(
@@ -54,21 +101,14 @@ export const MemoryUpdateSchema = z.object({
             "The reason why you selected this event.",
           ),
         type: z
-          .enum(["factual", "todo", "assistant_preference"])
-          .describe("Type of the memory. Use 'assistant_preference' for Assistant behavior preferences, 'factual' for user facts, 'todo' for explicit tasks."),
+          .enum(["assistant_preference"])
+          .describe("Type of the memory. Only 'assistant_preference' is supported."),
       }),
     )
     .describe(
       "An array representing the state of memory items after processing new facts.",
     ),
 });
-/**
- * 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 const MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 - Information stored in memory is always enclosed within the <memories> tag.
 - Prioritize the latest user message over memories (the user's current question is authoritative).
@@ -80,10 +120,10 @@ export const MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 
 export const MEMORY_STRING_PREFIX = "Use these contextual memories to guide your response. Prioritize the user's question. Ignore irrelevant memories."
 
-
-// Deprecated: getFactRetrievalMessages_O removed in favor of getFactRetrievalMessages
-
-
+/**
+ * @deprecated Use getDiscussionSynthesisMessages instead
+ * Cette fonction est conservée pour compatibilité avec l'ancien système
+ */
 export function getFactRetrievalMessages(
   parsedMessages: string, 
   customRules: string = "",
@@ -132,6 +172,9 @@ Remember the following:
   return [systemPrompt, userPrompt];
 }
 
+/**
+ * @deprecated Memory updates are disabled by config
+ */
 export function getUpdateMemoryMessages(
   retrievedOldMemory: Array<{ id: string; text: string }>,
   newRetrievedFacts: any[],

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
@@ -72,9 +60,8 @@ export interface MemoryTypeConfig {
 }
 
 export interface MemoryScoringConfig {
-  todo: MemoryTypeConfig;
-  factual: MemoryTypeConfig;
   assistant_preference: MemoryTypeConfig;
+  discussion: MemoryTypeConfig;
   default: MemoryTypeConfig; // Fallback if type is missing or unknown
 }
 
@@ -96,12 +83,10 @@ 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 = 'todo' | 'factual' | 'assistant_preference';
+export type MemoryType = 'assistant_preference' | 'discussion';
 
 export interface MemoryItem {
   id: string;
@@ -162,19 +147,13 @@ export const MemoryConfigSchema = z.object({
         dimension: z.number().optional(),
         client: z.any().optional(),
         scoring: z.object({
-          todo: z.object({
-            alpha: z.number(),
-            beta: z.number(),
-            gamma: z.number(),
-            halfLifeDays: z.number(),
-          }),
-          factual: z.object({
+          assistant_preference: z.object({
             alpha: z.number(),
             beta: z.number(),
             gamma: z.number(),
             halfLifeDays: z.number(),
           }),
-          assistant_preference: z.object({
+          discussion: z.object({
             alpha: z.number(),
             beta: z.number(),
             gamma: z.number(),
@@ -188,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(),
   }),
@@ -200,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

@@ -25,6 +25,10 @@ jest.mock('sqlite3', () => {
 });
 
 
+/**
+ * Tests for LiteVectorStore private methods
+ * Updated to use new memory types: assistant_preference and discussion
+ */
 describe('LiteVectorStore Private Methods', () => {
   let store: LiteVectorStore;
   const userId = 'test-user';
@@ -98,59 +102,65 @@ describe('LiteVectorStore Private Methods', () => {
     const veryOldDate = new Date(now.getTime() - 400 * 24 * 60 * 60 * 1000).toISOString();
     const scoring = DEFAULT_MEMORY_CONFIG.vectorStore.config.scoring!;
 
-    it('should prioritize cosine similarity for factual memory (high alpha)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-f1', userId: userId, type: 'factual', createdAt: twoDaysAgo };
+    it('should prioritize cosine similarity for assistant_preference (high alpha)', () => {
+      //
+      // assistant_preference: { alpha: 0.60, beta: 0.05, gamma: 0.35, halfLifeDays: Infinity }
+      const payload: MemoryPayload = { memoryId: 'mem-ap1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
       const cosineScore = 0.9;
-      const expectedRecency = (store as any).calculateRecencyScore(twoDaysAgo, scoring.factual.halfLifeDays);
-      const expectedScore = scoring.factual.alpha * cosineScore + scoring.factual.beta * expectedRecency + scoring.factual.gamma;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1
+      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);
-      expect(scoring.factual.alpha * cosineScore).toBeGreaterThan(scoring.factual.beta * expectedRecency);
+      // alpha * cosine (0.54) > beta * recency (0.05)
+      expect(scoring.assistant_preference.alpha * cosineScore).toBeGreaterThan(scoring.assistant_preference.beta * expectedRecency);
     });
 
-    it('should prioritize recency for episodic memory (high beta, short half-life)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-e1', userId: userId, type: 'episodic', createdAt: twoDaysAgo };
+    it('should return constant score for discussion (beta=1, alpha=0, gamma=0)', () => {
+      //
+      // discussion: { alpha: 0, beta: 1, gamma: 0, halfLifeDays: Infinity }
+      // Score = 0 * cosine + 1 * recency + 0 = 1 (constant)
+      const payload: MemoryPayload = { memoryId: 'mem-d1', userId: userId, type: 'discussion', createdAt: twoDaysAgo };
       const cosineScore = 0.5;
-      const expectedRecency = (store as any).calculateRecencyScore(twoDaysAgo, scoring.episodic.halfLifeDays);
-      const expectedScore = scoring.episodic.alpha * cosineScore + scoring.episodic.beta * expectedRecency + scoring.episodic.gamma;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1
+      const expectedScore = scoring.discussion.alpha * cosineScore + scoring.discussion.beta * expectedRecency + scoring.discussion.gamma;
       const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
       expect(hybridScore).toBeCloseTo(expectedScore, 5);
-      expect(scoring.episodic.beta * expectedRecency).toBeGreaterThan(0.2);
+      expect(hybridScore).toBe(1); // Score constant = 1
     });
 
-    it('should have low score for old episodic memory', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-e2', userId: userId, type: 'episodic', createdAt: veryOldDate };
-        const cosineScore = 0.9;
-        const expectedRecency = (store as any).calculateRecencyScore(veryOldDate, scoring.episodic.halfLifeDays);
-        const expectedScore = scoring.episodic.alpha * cosineScore + scoring.episodic.beta * expectedRecency + scoring.episodic.gamma;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(expectedRecency).toBeLessThan(0.01);
-        expect(hybridScore).toBeCloseTo(scoring.episodic.alpha * cosineScore + scoring.episodic.gamma, 5);
+    it('should have constant score for old discussion memory (no decay)', () => {
+      //
+      // 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 expectedRecency = 1.0; // Infinity halfLife → recency = 1 even for old dates
+      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-d1', 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 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);
     });
 
     it('should return score >= 0 even with negative cosine similarity', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-s1', userId: userId, type: 'factual', createdAt: twoDaysAgo };
-        const cosineScore = -0.5;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(hybridScore).toBeGreaterThanOrEqual(0);
+      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);
     });
 
   });