@ai.ntellect/core 0.0.37 → 0.1.2

package/agent/index.ts

@@ -1,7 +1,8 @@
 import { Evaluator } from "../llm/evaluator";
 import { Orchestrator } from "../llm/orchestrator";
 import { Synthesizer } from "../llm/synthesizer";
-import { MemoryCache } from "../memory";
+import { CacheMemory } from "../memory/cache";
+import { PersistentMemory } from "../memory/persistent";
 import { ActionSchema, AgentEvent, MemoryScope, User } from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
 import { ActionHandler } from "./handlers/ActionHandler";
@@ -12,7 +13,8 @@ export class Agent {
   private readonly actionHandler: ActionHandler;
   private readonly user: User;
   private readonly orchestrator: Orchestrator;
-  private readonly memoryCache: MemoryCache | undefined;
+  private readonly persistentMemory: PersistentMemory;
+  private readonly cacheMemory: CacheMemory | undefined;
   private readonly stream: boolean;
   private readonly maxEvaluatorIteration: number;
   private evaluatorIteration = 0;
@@ -20,19 +22,22 @@ export class Agent {
   constructor({
     user,
     orchestrator,
-    memoryCache,
+    persistentMemory,
+    cacheMemory,
     stream,
     maxEvaluatorIteration = 1,
   }: {
     user: User;
     orchestrator: Orchestrator;
-    memoryCache?: MemoryCache;
+    persistentMemory: PersistentMemory;
+    cacheMemory?: CacheMemory;
     stream: boolean;
     maxEvaluatorIteration: number;
   }) {
     this.user = user;
     this.orchestrator = orchestrator;
-    this.memoryCache = memoryCache;
+    this.cacheMemory = cacheMemory;
+    this.persistentMemory = persistentMemory;
     this.stream = stream;
     this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
@@ -90,7 +95,10 @@ export class Agent {
       return this.handleActionResults({ ...actionsResult, initialPrompt });
     }
 
-    const evaluator = new Evaluator(this.orchestrator.tools);
+    const evaluator = new Evaluator(
+      this.orchestrator.tools,
+      this.persistentMemory
+    );
     const evaluation = await evaluator.process(
       initialPrompt,
       contextualizedPrompt,
@@ -137,11 +145,11 @@ export class Agent {
   }
 
   private async findSimilarActions(prompt: string) {
-    if (!this.memoryCache) {
+    if (!this.cacheMemory) {
       return [];
     }
 
-    return this.memoryCache.findBestMatches(prompt, {
+    return this.cacheMemory.findBestMatches(prompt, {
       similarityThreshold: this.SIMILARITY_THRESHOLD,
       maxResults: this.MAX_RESULTS,
       userId: this.user.id,

package/dist/agent/index.d.ts

@@ -1,5 +1,6 @@
 import { Orchestrator } from "../llm/orchestrator";
-import { MemoryCache } from "../memory";
+import { CacheMemory } from "../memory/cache";
+import { PersistentMemory } from "../memory/persistent";
 import { AgentEvent, User } from "../types";
 export declare class Agent {
     private readonly SIMILARITY_THRESHOLD;
@@ -7,14 +8,16 @@ export declare class Agent {
     private readonly actionHandler;
     private readonly user;
     private readonly orchestrator;
-    private readonly memoryCache;
+    private readonly persistentMemory;
+    private readonly cacheMemory;
     private readonly stream;
     private readonly maxEvaluatorIteration;
     private evaluatorIteration;
-    constructor({ user, orchestrator, memoryCache, stream, maxEvaluatorIteration, }: {
+    constructor({ user, orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration, }: {
         user: User;
         orchestrator: Orchestrator;
-        memoryCache?: MemoryCache;
+        persistentMemory: PersistentMemory;
+        cacheMemory?: CacheMemory;
         stream: boolean;
         maxEvaluatorIteration: number;
     });

package/dist/agent/index.js

@@ -7,13 +7,14 @@ const types_1 = require("../types");
 const queue_item_transformer_1 = require("../utils/queue-item-transformer");
 const ActionHandler_1 = require("./handlers/ActionHandler");
 class Agent {
-    constructor({ user, orchestrator, memoryCache, stream, maxEvaluatorIteration = 1, }) {
+    constructor({ user, orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration = 1, }) {
         this.SIMILARITY_THRESHOLD = 95;
         this.MAX_RESULTS = 1;
         this.evaluatorIteration = 0;
         this.user = user;
         this.orchestrator = orchestrator;
-        this.memoryCache = memoryCache;
+        this.cacheMemory = cacheMemory;
+        this.persistentMemory = persistentMemory;
         this.stream = stream;
         this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
@@ -42,7 +43,7 @@ class Agent {
         if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
             return this.handleActionResults({ ...actionsResult, initialPrompt });
         }
-        const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools);
+        const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.persistentMemory);
         const evaluation = await evaluator.process(initialPrompt, contextualizedPrompt, JSON.stringify(actionsResult.data));
         events.onMessage?.(evaluation);
         if (evaluation.nextActions.length > 0) {
@@ -72,10 +73,10 @@ class Agent {
             : await synthesizer.process(summaryData);
     }
     async findSimilarActions(prompt) {
-        if (!this.memoryCache) {
+        if (!this.cacheMemory) {
             return [];
         }
-        return this.memoryCache.findBestMatches(prompt, {
+        return this.cacheMemory.findBestMatches(prompt, {
             similarityThreshold: this.SIMILARITY_THRESHOLD,
             maxResults: this.MAX_RESULTS,
             userId: this.user.id,

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from "./llm/orchestrator";
 export * from "./llm/synthesizer";
 export * from "./services/queue";
 export * from "./types";
-export * from "./memory";
+export * from "./memory/cache";
+export * from "./memory/persistent";

package/dist/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./llm/orchestrator"), exports);
 __exportStar(require("./llm/synthesizer"), exports);
 __exportStar(require("./services/queue"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./memory"), exports);
+__exportStar(require("./memory/cache"), exports);
+__exportStar(require("./memory/persistent"), exports);

package/dist/llm/evaluator/context.js

@@ -30,6 +30,7 @@ exports.evaluatorContext = {
       1. Success status with explanation (no action needed)
       2. Next actions needed (if any)
       3. Why you are doing the next actions or why you are not doing them
+      4. Extract relevant semantic information to remember (eg. token symbols, token addresses, etc.). No need to remember the actions or the news.
     `;
     },
 };

package/dist/llm/evaluator/index.d.ts

@@ -1,7 +1,9 @@
+import { PersistentMemory } from "../../memory/persistent";
 import { ActionSchema } from "../../types";
 export declare class Evaluator {
     private readonly model;
     tools: ActionSchema[];
-    constructor(tools: ActionSchema[]);
+    private memory;
+    constructor(tools: ActionSchema[], memory: PersistentMemory);
     process(prompt: string, goal: string, results: string): Promise<any>;
 }

package/dist/llm/evaluator/index.js

@@ -4,11 +4,13 @@ exports.Evaluator = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
+const types_1 = require("../../types");
 const context_1 = require("./context");
 class Evaluator {
-    constructor(tools) {
+    constructor(tools, memory) {
         this.model = (0, openai_1.openai)("gpt-4o");
         this.tools = tools;
+        this.memory = memory;
     }
     async process(prompt, goal, results) {
         try {
@@ -23,6 +25,10 @@ class Evaluator {
                         }),
                     })),
                     why: zod_1.z.string(),
+                    importantToRemembers: zod_1.z.array(zod_1.z.object({
+                        hypotheticalQuery: zod_1.z.string(),
+                        result: zod_1.z.string(),
+                    })),
                 }),
                 prompt: prompt,
                 system: context_1.evaluatorContext.compose(goal, results, this.tools),
@@ -34,6 +40,26 @@ class Evaluator {
                     parameters: action.parameters || {},
                 })),
             };
+            if (validatedResponse.importantToRemembers.length > 0) {
+                for (const item of validatedResponse.importantToRemembers) {
+                    // Check if the item is already in the memory
+                    const memories = await this.memory.findBestMatches(item.hypotheticalQuery);
+                    if (memories.length === 0) {
+                        console.log("Adding to memory", {
+                            query: item.hypotheticalQuery,
+                            data: item.result,
+                        });
+                        await this.memory.storeMemory({
+                            id: crypto.randomUUID(),
+                            purpose: "importantToRemember",
+                            query: item.hypotheticalQuery,
+                            data: item.result,
+                            scope: types_1.MemoryScope.USER,
+                            createdAt: new Date(),
+                        });
+                    }
+                }
+            }
             console.log("Evaluator response");
             console.dir(validatedResponse, { depth: null });
             return validatedResponse;
@@ -43,6 +69,26 @@ class Evaluator {
                 console.log("Evaluator error");
                 console.dir(error.value, { depth: null });
                 console.error(error.message);
+                if (error.value.importantToRemembers.length > 0) {
+                    for (const item of error.value.importantToRemembers) {
+                        // Check if the item is already in the memory
+                        const memories = await this.memory.findBestMatches(item.hypotheticalQuery);
+                        if (memories.length === 0) {
+                            console.log("Adding to memory", {
+                                query: item.hypotheticalQuery,
+                                data: item.result,
+                            });
+                            await this.memory.storeMemory({
+                                id: crypto.randomUUID(),
+                                purpose: "importantToRemember",
+                                query: item.hypotheticalQuery,
+                                data: item.result,
+                                scope: types_1.MemoryScope.USER,
+                                createdAt: new Date(),
+                            });
+                        }
+                    }
+                }
                 return {
                     ...error.value,
                 };

package/dist/llm/orchestrator/context.js

@@ -10,10 +10,7 @@ exports.orchestratorContext = {
             "If some parameters are not clear or missing, YOU MUST ask the user for them.",
             "ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
         ],
-        warnings: [
-            "NEVER repeat the same action twice if the user doesn't ask for it.",
-            "NEVER repeat the same action if its not necessary.",
-        ],
+        warnings: ["NEVER repeat same actions if the user doesn't ask for it."],
     },
     compose: (tools) => {
         return `

package/dist/llm/orchestrator/index.d.ts

@@ -1,7 +1,9 @@
+import { PersistentMemory } from "../../memory/persistent";
 import { ActionSchema, BaseLLM } from "../../types";
 export declare class Orchestrator implements BaseLLM {
     private readonly model;
     tools: ActionSchema[];
-    constructor(tools: ActionSchema[]);
+    private memory;
+    constructor(tools: ActionSchema[], memory: PersistentMemory);
     process(prompt: string): Promise<any>;
 }

package/dist/llm/orchestrator/index.js

@@ -6,9 +6,23 @@ const ai_1 = require("ai");
 const zod_1 = require("zod");
 const context_1 = require("./context");
 class Orchestrator {
-    constructor(tools) {
+    constructor(tools, memory) {
         this.model = (0, openai_1.openai)("gpt-4o");
-        this.tools = tools;
+        this.memory = memory;
+        this.tools = [
+            ...tools,
+            {
+                name: "search_memory",
+                description: "Search for relevant information in the internal knowledge base",
+                parameters: zod_1.z.object({
+                    query: zod_1.z.string(),
+                }),
+                execute: async (params) => {
+                    const memories = await this.memory.findBestMatches(params.value);
+                    return memories;
+                },
+            },
+        ];
     }
     async process(prompt) {
         try {

package/dist/memory/{index.d.ts → cache.d.ts}

@@ -1,9 +1,9 @@
-import { CreateMemoryInput, MatchOptions, MemoryCacheOptions, MemoryScope } from "../types";
-export declare class MemoryCache {
+import { CacheMemoryOptions, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
+export declare class CacheMemory {
     private redis;
     private readonly CACHE_PREFIX;
     private readonly CACHE_TTL;
-    constructor(options?: MemoryCacheOptions);
+    constructor(options?: CacheMemoryOptions);
     private initRedis;
     private getMemoryKey;
     private storeMemory;

package/dist/memory/{index.js → cache.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryCache = void 0;
+exports.CacheMemory = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const redis_1 = require("redis");
 const zod_1 = require("zod");
 const types_1 = require("../types");
-class MemoryCache {
+class CacheMemory {
     constructor(options = {}) {
         const ttlInHours = options.cacheTTL ?? 1;
         this.CACHE_TTL = ttlInHours * 60 * 60;
@@ -48,7 +48,7 @@ class MemoryCache {
         });
     }
     async findBestMatches(query, options = {}) {
-        console.log("\n🔍 Searching for query:", query);
+        console.log("\n🔍 Searching in cache for query:", query);
         const { embedding } = await (0, ai_1.embed)({
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: query,
@@ -186,4 +186,4 @@ class MemoryCache {
         return memory;
     }
 }
-exports.MemoryCache = MemoryCache;
+exports.CacheMemory = CacheMemory;

package/dist/test.js

@@ -8,6 +8,7 @@ const rss_parser_1 = __importDefault(require("rss-parser"));
 const zod_1 = require("zod");
 const agent_1 = require("./agent");
 const orchestrator_1 = require("./llm/orchestrator");
+const persistent_1 = require("./memory/persistent");
 exports.getChainsTVL = {
     name: "get_chains_tvl",
     description: "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
@@ -102,16 +103,21 @@ exports.getRssNews = {
     },
 };
 (async () => {
-    const orchestrator = new orchestrator_1.Orchestrator([exports.getRssNews, exports.getChainsTVL]);
+    const memory = new persistent_1.PersistentMemory({
+        host: "http://localhost:7700",
+        apiKey: "aSampleMasterKey",
+    });
+    const orchestrator = new orchestrator_1.Orchestrator([exports.getRssNews, exports.getChainsTVL], memory);
     const agent = new agent_1.Agent({
         user: {
             id: "1",
         },
         orchestrator,
+        persistentMemory: memory,
         stream: false,
         maxEvaluatorIteration: 1,
     });
-    const prompt = "Analyze bitcoin";
+    const prompt = "tu connais avax";
     const context = prompt;
     const result = await agent.process(prompt, context, {
         onMessage: (message) => {

package/dist/types.d.ts

@@ -93,7 +93,7 @@ export interface SummarizerAgent {
     } | StreamTextResult<Record<string, any>>>;
     streamProcess: (results: object, onFinish?: (event: any) => void) => Promise<StreamTextResult<Record<string, any>>>;
 }
-export interface MemoryCacheOptions {
+export interface CacheMemoryOptions {
     cacheTTL?: number;
     redisUrl?: string;
     cachePrefix?: string;
@@ -105,7 +105,7 @@ export interface CreateMemoryInput {
     userId?: string;
     scope?: MemoryScope;
 }
-export interface Memory {
+export interface CacheMemoryType {
     id: string;
     type: MemoryType;
     data: any;
@@ -116,6 +116,26 @@ export interface Memory {
     scope: MemoryScope;
     createdAt: Date;
 }
+export interface PersistentMemoryOptions {
+    host: string;
+    apiKey: string;
+    indexPrefix?: string;
+}
+export interface MemoryChunk {
+    content: string;
+    embedding: number[];
+}
+export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
+export interface Memory {
+    id: string;
+    query: string;
+    purpose: string;
+    data: any;
+    scope: MemoryScopeType;
+    userId?: string;
+    createdAt: Date;
+    chunks?: MemoryChunk[];
+}
 export declare enum MemoryType {
     ACTION = "action",
     CONVERSATION = "conversation",

package/index.ts

@@ -5,4 +5,5 @@ export * from "./llm/synthesizer";
 export * from "./services/queue";
 export * from "./types";
 
-export * from "./memory";
+export * from "./memory/cache";
+export * from "./memory/persistent";

package/llm/evaluator/context.ts

@@ -29,6 +29,7 @@ export const evaluatorContext = {
       1. Success status with explanation (no action needed)
       2. Next actions needed (if any)
       3. Why you are doing the next actions or why you are not doing them
+      4. Extract relevant semantic information to remember (eg. token symbols, token addresses, etc.). No need to remember the actions or the news.
     `;
   },
 };

package/llm/evaluator/index.ts

@@ -1,15 +1,18 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
-import { ActionSchema } from "../../types";
+import { PersistentMemory } from "../../memory/persistent";
+import { ActionSchema, MemoryScope } from "../../types";
 import { evaluatorContext } from "./context";
 
 export class Evaluator {
   private readonly model = openai("gpt-4o");
   public tools: ActionSchema[];
+  private memory: PersistentMemory;
 
-  constructor(tools: ActionSchema[]) {
+  constructor(tools: ActionSchema[], memory: PersistentMemory) {
     this.tools = tools;
+    this.memory = memory;
   }
 
   async process(prompt: string, goal: string, results: string): Promise<any> {
@@ -27,6 +30,12 @@ export class Evaluator {
             })
           ),
           why: z.string(),
+          importantToRemembers: z.array(
+            z.object({
+              hypotheticalQuery: z.string(),
+              result: z.string(),
+            })
+          ),
         }),
         prompt: prompt,
         system: evaluatorContext.compose(goal, results, this.tools),
@@ -40,6 +49,29 @@ export class Evaluator {
         })),
       };
 
+      if (validatedResponse.importantToRemembers.length > 0) {
+        for (const item of validatedResponse.importantToRemembers) {
+          // Check if the item is already in the memory
+          const memories = await this.memory.findBestMatches(
+            item.hypotheticalQuery
+          );
+          if (memories.length === 0) {
+            console.log("Adding to memory", {
+              query: item.hypotheticalQuery,
+              data: item.result,
+            });
+            await this.memory.storeMemory({
+              id: crypto.randomUUID(),
+              purpose: "importantToRemember",
+              query: item.hypotheticalQuery,
+              data: item.result,
+              scope: MemoryScope.USER,
+              createdAt: new Date(),
+            });
+          }
+        }
+      }
+
       console.log("Evaluator response");
       console.dir(validatedResponse, { depth: null });
       return validatedResponse;
@@ -48,6 +80,29 @@ export class Evaluator {
         console.log("Evaluator error");
         console.dir(error.value, { depth: null });
         console.error(error.message);
+        if (error.value.importantToRemembers.length > 0) {
+          for (const item of error.value.importantToRemembers) {
+            // Check if the item is already in the memory
+            const memories = await this.memory.findBestMatches(
+              item.hypotheticalQuery
+            );
+            if (memories.length === 0) {
+              console.log("Adding to memory", {
+                query: item.hypotheticalQuery,
+                data: item.result,
+              });
+              await this.memory.storeMemory({
+                id: crypto.randomUUID(),
+                purpose: "importantToRemember",
+                query: item.hypotheticalQuery,
+                data: item.result,
+                scope: MemoryScope.USER,
+                createdAt: new Date(),
+              });
+            }
+          }
+        }
+
         return {
           ...error.value,
         };

package/llm/orchestrator/context.ts

@@ -9,10 +9,7 @@ export const orchestratorContext = {
       "If some parameters are not clear or missing, YOU MUST ask the user for them.",
       "ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
     ],
-    warnings: [
-      "NEVER repeat the same action twice if the user doesn't ask for it.",
-      "NEVER repeat the same action if its not necessary.",
-    ],
+    warnings: ["NEVER repeat same actions if the user doesn't ask for it."],
   },
   compose: (tools: ActionSchema[]) => {
     return `

package/llm/orchestrator/index.ts

@@ -1,15 +1,32 @@
 import { openai } from "@ai-sdk/openai";
 import { generateObject } from "ai";
 import { z } from "zod";
+import { PersistentMemory } from "../../memory/persistent";
 import { ActionSchema, BaseLLM } from "../../types";
 import { orchestratorContext } from "./context";
 
 export class Orchestrator implements BaseLLM {
   private readonly model = openai("gpt-4o");
   public tools: ActionSchema[];
+  private memory: PersistentMemory;
 
-  constructor(tools: ActionSchema[]) {
-    this.tools = tools;
+  constructor(tools: ActionSchema[], memory: PersistentMemory) {
+    this.memory = memory;
+    this.tools = [
+      ...tools,
+      {
+        name: "search_memory",
+        description:
+          "Search for relevant information in the internal knowledge base",
+        parameters: z.object({
+          query: z.string(),
+        }),
+        execute: async (params) => {
+          const memories = await this.memory.findBestMatches(params.value);
+          return memories;
+        },
+      },
+    ];
   }
 
   async process(prompt: string): Promise<any> {

package/memory/{index.ts → cache.ts}

@@ -3,20 +3,20 @@ import { cosineSimilarity, embed, generateObject } from "ai";
 import { createClient } from "redis";
 import { z } from "zod";
 import {
+  CacheMemoryOptions,
+  CacheMemoryType,
   CreateMemoryInput,
   MatchOptions,
-  Memory,
-  MemoryCacheOptions,
   MemoryScope,
   MemoryType,
 } from "../types";
 
-export class MemoryCache {
+export class CacheMemory {
   private redis;
   private readonly CACHE_PREFIX: string;
   private readonly CACHE_TTL: number;
 
-  constructor(options: MemoryCacheOptions = {}) {
+  constructor(options: CacheMemoryOptions = {}) {
     const ttlInHours = options.cacheTTL ?? 1;
     this.CACHE_TTL = ttlInHours * 60 * 60;
     this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
@@ -53,7 +53,7 @@ export class MemoryCache {
     return `${this.CACHE_PREFIX}user:${userId}:`;
   }
 
-  private async storeMemory(memory: Memory) {
+  private async storeMemory(memory: CacheMemoryType) {
     const prefix = this.getMemoryKey(memory.scope, memory.userId);
     const key = `${prefix}${memory.id}`;
     await this.redis.set(key, JSON.stringify(memory), {
@@ -71,7 +71,7 @@ export class MemoryCache {
       purpose: string;
     }[]
   > {
-    console.log("\n🔍 Searching for query:", query);
+    console.log("\n🔍 Searching in cache for query:", query);
 
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
@@ -126,8 +126,8 @@ export class MemoryCache {
   private async getAllMemories(
     scope?: MemoryScope,
     userId?: string
-  ): Promise<Memory[]> {
-    let patterns: Memory[] = [];
+  ): Promise<CacheMemoryType[]> {
+    let patterns: CacheMemoryType[] = [];
 
     if (!scope || scope === MemoryScope.GLOBAL) {
       const globalPrefix = this.getMemoryKey(MemoryScope.GLOBAL);
@@ -146,8 +146,10 @@ export class MemoryCache {
     return patterns;
   }
 
-  private async getMemoriesFromKeys(keys: string[]): Promise<Memory[]> {
-    const memories: Memory[] = [];
+  private async getMemoriesFromKeys(
+    keys: string[]
+  ): Promise<CacheMemoryType[]> {
+    const memories: CacheMemoryType[] = [];
     for (const key of keys) {
       const data = await this.redis.get(key);
       if (data) {
@@ -230,13 +232,13 @@ export class MemoryCache {
     purpose: string;
     userId?: string;
     scope?: MemoryScope;
-  }): Promise<Memory> {
+  }): Promise<CacheMemoryType> {
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
       value: params.content,
     });
 
-    const memory: Memory = {
+    const memory: CacheMemoryType = {
       id: params.id,
       type: params.type,
       data: params.data,

package/memory/persistent.d.ts

@@ -0,0 +1,28 @@
+import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
+import { Index, MeiliSearch } from "meilisearch";
+import {
+  MatchOptions,
+  MatchResult,
+  Memory,
+  MemoryChunk,
+  MemoryScopeType,
+} from "../types";
+
+export class PersistentMemory {
+  private client: MeiliSearch;
+  private readonly INDEX_PREFIX: string;
+  private textSplitter: RecursiveCharacterTextSplitter;
+
+  constructor(options: PersistentMemoryOptions);
+
+  private _getIndexName(scope: MemoryScopeType, userId?: string): string;
+  private _getOrCreateIndex(indexName: string): Promise<Index>;
+  private _processContent(content: string): Promise<MemoryChunk[]>;
+
+  storeMemory(memory: Memory): Promise<void>;
+  findBestMatches(
+    query: string,
+    options?: MatchOptions
+  ): Promise<MatchResult[]>;
+  deleteMemories(scope: MemoryScopeType, userId?: string): Promise<void>;
+}

package/memory/persistent.js

@@ -0,0 +1,198 @@
+import { openai } from "@ai-sdk/openai";
+import { cosineSimilarity, embed, embedMany } from "ai";
+import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
+import { MeiliSearch } from "meilisearch";
+
+const MemoryScope = {
+  GLOBAL: "global",
+  USER: "user",
+};
+
+export class PersistentMemory {
+  /**
+   * @param {Object} options
+   * @param {string} options.host - MeiliSearch host URL
+   * @param {string} options.apiKey - MeiliSearch API key
+   * @param {string} [options.indexPrefix="memory_"] - Prefix for index names
+   */
+  constructor(options) {
+    this.client = new MeiliSearch({
+      host: options.host,
+      apiKey: options.apiKey,
+    });
+    this.INDEX_PREFIX = options.indexPrefix || "memory_";
+    this.textSplitter = new RecursiveCharacterTextSplitter({
+      chunkSize: 1000,
+    });
+  }
+
+  /**
+   * Get the index name based on scope and userId
+   * @private
+   */
+  _getIndexName(scope, userId) {
+    if (scope === MemoryScope.GLOBAL) {
+      return `${this.INDEX_PREFIX}global`;
+    }
+    return `${this.INDEX_PREFIX}user_${userId}`;
+  }
+
+  /**
+   * Get or create an index with proper settings
+   * @private
+   */
+  async _getOrCreateIndex(indexName) {
+    const index = this.client.index(indexName);
+
+    try {
+      await this.client.createIndex(indexName, { primaryKey: "id" });
+      await index.updateSettings({
+        searchableAttributes: ["query", "purpose", "chunks.content"],
+        sortableAttributes: ["createdAt"],
+      });
+    } catch (error) {
+      // Index might already exist, which is fine
+      if (!error.message.includes("already exists")) {
+        throw error;
+      }
+    }
+
+    return index;
+  }
+
+  /**
+   * Process content into chunks with embeddings
+   * @private
+   */
+  async _processContent(content) {
+    // Split content into chunks
+    const chunks = await this.textSplitter.createDocuments([content]);
+
+    // Generate embeddings for all chunks
+    const { embeddings } = await embedMany({
+      model: openai.embedding("text-embedding-3-small"),
+      values: chunks.map((chunk) => chunk.pageContent),
+    });
+
+    // Create processed chunks with embeddings
+    return chunks.map((chunk, i) => ({
+      content: chunk.pageContent,
+      embedding: embeddings[i],
+    }));
+  }
+
+  /**
+   * Store a memory in the database
+   * @param {Object} memory - Memory object to store
+   */
+  async storeMemory(memory) {
+    const indexName = this._getIndexName(memory.scope, memory.userId);
+    const index = await this._getOrCreateIndex(indexName);
+
+    // Process the query into chunks with embeddings
+    const chunks = await this._processContent(memory.query);
+
+    const result = await index.addDocuments([
+      {
+        ...memory,
+        chunks,
+        createdAt: memory.createdAt.toISOString(),
+      },
+    ]);
+    return result;
+  }
+
+  /**
+   * Find best matching memories using cosine similarity
+   * @param {string} query - Search query
+   * @param {Object} options - Search options
+   */
+  async findBestMatches(query, options = {}) {
+    console.log("\n🔍 Searching in persistent memory:", query);
+
+    // Generate embedding for the query
+    const { embedding: queryEmbedding } = await embed({
+      model: openai.embedding("text-embedding-3-small"),
+      value: query,
+    });
+    const searchResults = [];
+
+    // Search in global memories
+    if (!options.scope || options.scope === MemoryScope.GLOBAL) {
+      const globalIndex = await this._getOrCreateIndex(
+        this._getIndexName(MemoryScope.GLOBAL)
+      );
+      const globalResults = await globalIndex.search(query, {
+        limit: options.maxResults || 10,
+      });
+      searchResults.push(...globalResults.hits);
+    }
+
+    // Search in user memories
+    if (
+      options.userId &&
+      (!options.scope || options.scope === MemoryScope.USER)
+    ) {
+      const userIndex = await this._getOrCreateIndex(
+        this._getIndexName(MemoryScope.USER, options.userId)
+      );
+      const userResults = await userIndex.search(query, {
+        limit: options.maxResults || 10,
+      });
+      searchResults.push(...userResults.hits);
+    }
+
+    // Process and filter results using cosine similarity
+    const results = searchResults
+      .flatMap((hit) => {
+        // Calculate similarities for each chunk
+        console.log(hit);
+        const chunkSimilarities = hit.chunks.map((chunk) => ({
+          data: hit.data,
+          purpose: hit.purpose,
+          chunk: chunk.content,
+          similarityPercentage:
+            (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
+        }));
+        console.log({ chunkSimilarities });
+        // Return the chunk with highest similarity
+        return chunkSimilarities.reduce(
+          (best, current) =>
+            current.similarityPercentage > best.similarityPercentage
+              ? current
+              : best,
+          chunkSimilarities[0]
+        );
+      })
+      .filter(
+        (match) =>
+          match.similarityPercentage >= (options.similarityThreshold || 70)
+      )
+      .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
+
+    // Log results
+    if (results.length > 0) {
+      console.log("\n✨ Best matches found:");
+      results.forEach((match) => {
+        console.log(
+          `- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`
+        );
+        console.log(`  Matching chunk: "${match.chunk}"`);
+      });
+    } else {
+      console.log("No matches found");
+    }
+
+    return results;
+  }
+
+  /**
+   * Delete memories for a given scope and user
+   * @param {string} scope - Memory scope
+   * @param {string} [userId] - User ID for user-specific memories
+   */
+  async deleteMemories(scope, userId) {
+    const indexName = this._getIndexName(scope, userId);
+    await this.client.deleteIndex(indexName);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.0.37",
+  "version": "0.1.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/test.ts

@@ -2,6 +2,7 @@ import Parser from "rss-parser";
 import { z } from "zod";
 import { Agent } from "./agent";
 import { Orchestrator } from "./llm/orchestrator";
+import { PersistentMemory } from "./memory/persistent";
 
 interface ChainTVL {
   name: string;
@@ -122,17 +123,22 @@ export const getRssNews = {
 };
 
 (async () => {
-  const orchestrator = new Orchestrator([getRssNews, getChainsTVL]);
+  const memory = new PersistentMemory({
+    host: "http://localhost:7700",
+    apiKey: "aSampleMasterKey",
+  });
+  const orchestrator = new Orchestrator([getRssNews, getChainsTVL], memory);
   const agent = new Agent({
     user: {
       id: "1",
     },
     orchestrator,
+    persistentMemory: memory,
     stream: false,
     maxEvaluatorIteration: 1,
   });
 
-  const prompt = "Analyze bitcoin";
+  const prompt = "tu connais avax";
   const context = prompt;
 
   const result = await agent.process(prompt, context, {

package/types.ts

@@ -119,7 +119,7 @@ export interface SummarizerAgent {
   ) => Promise<StreamTextResult<Record<string, any>>>;
 }
 
-export interface MemoryCacheOptions {
+export interface CacheMemoryOptions {
   cacheTTL?: number;
   redisUrl?: string;
   cachePrefix?: string;
@@ -133,7 +133,7 @@ export interface CreateMemoryInput {
   scope?: MemoryScope;
 }
 
-export interface Memory {
+export interface CacheMemoryType {
   id: string;
   type: MemoryType;
   data: any;
@@ -145,6 +145,30 @@ export interface Memory {
   createdAt: Date;
 }
 
+export interface PersistentMemoryOptions {
+  host: string;
+  apiKey: string;
+  indexPrefix?: string;
+}
+
+export interface MemoryChunk {
+  content: string;
+  embedding: number[];
+}
+
+export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
+
+export interface Memory {
+  id: string;
+  query: string;
+  purpose: string;
+  data: any;
+  scope: MemoryScopeType;
+  userId?: string;
+  createdAt: Date;
+  chunks?: MemoryChunk[];
+}
+
 export enum MemoryType {
   ACTION = "action",
   CONVERSATION = "conversation",