@ai.ntellect/core 0.6.11 → 0.6.13

package/memory/adapters/meilisearch/index.ts

@@ -1,14 +1,7 @@
-import { BaseMemoryService } from "@/interfaces";
-import { BaseMemory } from "@/memory";
 import { BaseMemoryType, CreateMemoryInput, MeilisearchConfig } from "@/types";
 
-export class MeilisearchAdapter extends BaseMemory {
-  constructor(
-    private readonly config: MeilisearchConfig,
-    baseMemoryService: BaseMemoryService
-  ) {
-    super(baseMemoryService);
-  }
+export class MeilisearchAdapter {
+  constructor(private readonly config: MeilisearchConfig) {}
 
   private async makeRequest(path: string, options?: RequestInit) {
     try {
@@ -45,31 +38,23 @@ export class MeilisearchAdapter extends BaseMemory {
       let indexExists = false;
 
       try {
-        // Check if index exists
         await this.makeRequest(`/indexes/${roomId}`);
         indexExists = true;
       } catch (error) {
-        // Only continue if the error is "Not found"
-        if (!(error instanceof Error && error.message.includes("Not found"))) {
-          throw error;
+        if (!indexExists) {
+          const createResponse = await this.makeRequest("/indexes", {
+            method: "POST",
+            body: JSON.stringify({
+              uid: roomId,
+              primaryKey: "id",
+            }),
+          });
+
+          console.log("✅ Index creation response:", createResponse);
         }
       }
 
-      if (!indexExists) {
-        // Create new index
-        await this.makeRequest("/indexes", {
-          method: "POST",
-          body: JSON.stringify({
-            uid: roomId,
-            primaryKey: "id",
-          }),
-        });
-
-        // Wait for index creation
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-
-      // Update settings
+      // Appliquer les settings seulement si l'index existe bien
       await this.makeRequest(`/indexes/${roomId}/settings`, {
         method: "PATCH",
         body: JSON.stringify({
@@ -84,7 +69,7 @@ export class MeilisearchAdapter extends BaseMemory {
       const errorMessage =
         error instanceof Error ? error.message : "Unknown error";
       console.error(
-        `Error initializing storage for index ${roomId}:`,
+        `❌ Error initializing storage for index ${roomId}:`,
         errorMessage
       );
       throw new Error(
@@ -102,6 +87,24 @@ export class MeilisearchAdapter extends BaseMemory {
       body: JSON.stringify(documents),
     });
   }
+  async deleteStorage(roomId: string): Promise<void> {
+    await this.makeRequest(`/indexes/${roomId}`, {
+      method: "DELETE",
+    });
+  }
+
+  // Required BaseMemory implementations
+  async init(roomId: string): Promise<void> {
+    try {
+      // Initialize the default "memories" index
+      await this.initializeStorage(roomId);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : "Unknown error";
+      console.error("Failed to initialize default index:", errorMessage);
+      throw new Error(`Failed to initialize default index: ${errorMessage}`);
+    }
+  }
 
   async search(
     query: string,
@@ -120,7 +123,6 @@ export class MeilisearchAdapter extends BaseMemory {
       document: {
         id: hit.id,
         data: hit.data,
-        query: hit.query,
         embedding: hit.embedding,
         roomId: hit.roomId,
         createdAt: hit.createdAt,
@@ -129,52 +131,16 @@ export class MeilisearchAdapter extends BaseMemory {
     }));
   }
 
-  async deleteStorage(roomId: string): Promise<void> {
-    await this.makeRequest(`/indexes/${roomId}`, {
-      method: "DELETE",
-    });
-  }
-
-  // Required BaseMemory implementations
-  async init(): Promise<void> {
-    try {
-      // Initialize the default "memories" index
-      await this.initializeStorage("memories");
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : "Unknown error";
-      console.error("Failed to initialize default index:", errorMessage);
-      throw new Error(`Failed to initialize default index: ${errorMessage}`);
-    }
-  }
-
   async createMemory(
     input: CreateMemoryInput & { embedding?: number[] }
   ): Promise<BaseMemoryType | undefined> {
     // Initialize storage for this roomId if needed
     await this.initializeStorage(input.roomId);
 
-    // Search for existing memory with same data and query
-    const searchResults = await this.search(input.data, input.roomId, {
-      limit: 1,
-    });
-    const existingMemory = searchResults.find(
-      (result) =>
-        result.document.data === input.data &&
-        result.document.query === input.query &&
-        result.document.roomId === input.roomId
-    );
-
-    // If found, return existing memory
-    if (existingMemory) {
-      return existingMemory.document;
-    }
-
     // If not found, create new memory
     const memory: BaseMemoryType = {
-      id: crypto.randomUUID(),
+      id: input.id || crypto.randomUUID(),
       data: input.data,
-      query: input.query,
       embedding: input.embedding || null,
       roomId: input.roomId,
       createdAt: new Date(),
@@ -196,7 +162,6 @@ export class MeilisearchAdapter extends BaseMemory {
         ? {
             id: result.id,
             data: result.data,
-            query: result.query,
             embedding: result.embedding,
             roomId: result.roomId,
             createdAt: result.createdAt,
@@ -219,7 +184,6 @@ export class MeilisearchAdapter extends BaseMemory {
       .map((result) => ({
         id: result.document.id,
         data: result.document.data,
-        query: result.document.query,
         embedding: result.document.embedding,
         roomId: result.document.roomId,
         createdAt: result.document.createdAt,
@@ -228,10 +192,13 @@ export class MeilisearchAdapter extends BaseMemory {
 
   async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
     const results = await this.makeRequest(`/indexes/${roomId}/documents`);
-    return results.map((doc: any) => ({
+    if (results.total === 0) {
+      return [];
+    }
+
+    return results.results.map((doc: any) => ({
       id: doc.id,
       data: doc.data,
-      query: doc.query,
       embedding: doc.embedding,
       roomId: doc.roomId,
       createdAt: doc.createdAt,
@@ -269,9 +236,6 @@ export class MeilisearchAdapter extends BaseMemory {
       for (const index of indexes) {
         await this.deleteStorage(index.uid);
       }
-
-      // Reinitialize the default index
-      await this.init();
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : "Unknown error";
@@ -281,6 +245,7 @@ export class MeilisearchAdapter extends BaseMemory {
 }
 
 interface SearchResult {
-  document: BaseMemoryType;
-  score: number;
+  document?: any;
+  score?: number;
+  results?: any[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -35,7 +35,7 @@
     "@types/sinon": "^17.0.3",
     "@types/ws": "^8.5.14",
     "chai": "^4.5.0",
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.4.7",
     "meilisearch": "^0.37.0",
     "mocha": "^10.0.0",
     "redis": "^4.6.13",

package/tsconfig.json

@@ -12,5 +12,5 @@
     },
     "outDir": "./dist"
   },
-  "exclude": ["node_modules", "examples", "test"]
+  "exclude": ["node_modules", "examples", "test", "app"]
 }

package/types/index.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z, ZodSchema } from "zod";
 
 /* ======================== MEMORY ======================== */
 
@@ -11,8 +11,9 @@ import { z } from "zod";
  * @property {number} [ttl] - Time-to-live in seconds (optional).
  */
 export type CreateMemoryInput = {
-  query: string;
+  id?: string;
   data: any;
+  embedding?: number[];
   roomId: string;
   ttl?: number;
 };
@@ -29,8 +30,7 @@ export type CreateMemoryInput = {
  */
 export type BaseMemoryType = {
   id: string;
-  data: string;
-  query: string;
+  data: any;
   embedding: number[] | null;
   roomId: string;
   createdAt: Date;
@@ -172,19 +172,39 @@ export type ScheduledRequest = {
 
 /* ======================== GRAPH ======================== */
 
-/**
- * Defines a graph definition.
- * @typedef {Object} GraphDefinition
- * @property {string} name - The graph name.
- * @property {string} entryNode - The entry node name.
- * @property {Record<string, Node<T>>} nodes - The nodes in the graph.
- * @property {z.ZodSchema<T>} [schema] - Optional schema for input validation.
- */
-export type GraphDefinition<T> = {
+export type GraphContext<T extends ZodSchema> = z.infer<T>;
+
+export type Node<T extends ZodSchema, P extends ZodSchema = ZodSchema> = {
+  name: string;
+  execute?: (context: GraphContext<T>) => Promise<void>;
+  executeWithParams?: (
+    context: GraphContext<T>,
+    params: z.infer<P>
+  ) => Promise<void>; // ✅ Nouvelle méthode
+  next?: string[];
+  condition?: (context: GraphContext<T>) => boolean;
+  onError?: (error: Error) => void;
+  events?: string[];
+  schema?: T;
+  parameters?: P; // ✅ Ajout d'un schéma spécifique aux paramètres du nœud
+  retry?: {
+    maxAttempts: number;
+    delay: number;
+  };
+};
+
+export type GraphConfig<T extends ZodSchema> = {
+  name: string;
+  nodes: Node<T>[];
+  initialContext?: GraphContext<T>;
+  validator?: T;
+  globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
+};
+
+export type GraphDefinition<T extends ZodSchema> = {
   name: string;
-  entryNode: string;
   nodes: Record<string, Node<T>>;
-  schema?: z.ZodSchema<T>;
+  entryNode: string;
 };
 
 /**
@@ -194,29 +214,6 @@ export type GraphDefinition<T> = {
  */
 export type SharedState<T> = T;
 
-/**
- * Defines a graph node within a graph execution structure.
- * @typedef {Object} Node
- * @property {string} name - The node name.
- * @property {string} [description] - Optional description.
- * @property {(params: P, state: SharedState<T>) => Promise<SharedState<T> | void>} execute - Execution function.
- * @property {(state: SharedState<T>) => boolean} [condition] - Optional condition for execution.
- * @property {NodeRelationship[]} [relationships] - Possible node transitions.
- * @property {z.ZodSchema<P>} [schema] - Optional schema for input validation.
- * @property {any} [state] - Internal node state.
- * @property {string[]} [events] - Events triggered by the node.
- */
-export type Node<T, P = any> = {
-  name: string;
-  description?: string;
-  execute: (state: SharedState<T>) => Promise<SharedState<T> | void>;
-  condition?: (state: SharedState<T>) => boolean;
-  relationships?: NodeRelationship[];
-  schema?: z.ZodSchema<P>;
-  state?: any;
-  events?: string[];
-};
-
 /**
  * Defines a node relationship in an execution graph.
  * @typedef {Object} NodeRelationship

package/utils/experimental-graph-rag.ts

@@ -0,0 +1,170 @@
+import { MeilisearchAdapter } from "@/memory/adapters/meilisearch";
+import { AIEmbeddingService } from "@/services/embedding";
+import { openai } from "@ai-sdk/openai";
+import { generateObject } from "ai";
+import { z } from "zod";
+
+export const experimentalGraphRag = async (context: {
+  prompt: string;
+  results: any;
+}) => {
+  if (!process.env.MEILISEARCH_API_KEY)
+    throw new Error("MEILISEARCH_API_KEY is not set");
+  if (!process.env.MEILISEARCH_HOST)
+    throw new Error("MEILISEARCH_HOST is not set");
+
+  const memoryManager = new MeilisearchAdapter({
+    apiKey: process.env.MEILISEARCH_API_KEY,
+    host: process.env.MEILISEARCH_HOST,
+  });
+  await memoryManager.init("nodes");
+  await memoryManager.init("edges");
+  const { existingNodes } = await retrieveExistingRelations(
+    memoryManager,
+    "nodes"
+  );
+  const prompt = `
+      User asked: ${context.prompt}
+      Results: ${JSON.stringify(context.results, null, 2)}
+      Existing nodes: ${JSON.stringify(existingNodes, null, 2)}
+      `;
+  console.log("🔍 Prompt:", prompt);
+  const llmMemory = await generateObject({
+    model: openai("gpt-4o"),
+    prompt,
+    schema: z.object({
+      nodes: z.array(
+        z.object({
+          name: z.string(), // Nom de l'entité (ex: Adresse, ETH, Transaction ID)
+          metadata: z.record(z.string(), z.any()), // Métadonnées associées
+        })
+      ),
+      edges: z.array(
+        z.object({
+          source: z.string(), // ID de l'entité source
+          target: z.string(), // ID de l'entité cible
+          relation: z.string(), // Type de relation (ex: "sent", "received", "on_chain")
+        })
+      ),
+    }),
+    system: `
+       You are an **AI memory manager** for a crypto wallet assistant.
+  
+  ## Rules:
+  - Nodes are entities like user, networks, tokens...etc
+  - Relations are edges like sent, uses, supported_on, loves, has_website...etc
+  - Ensure NO DUPLICATE RELATIONS.
+  - Standardize all relations using Cypher language.
+
+  Return the structured memory in JSON format, ensuring it follows the schema.
+
+        Generate structured graph data accordingly.
+
+        Format the output as a JSON object :
+        {
+          nodes: [
+            {
+              name: string,
+              metadata: Record<string, any>,
+            },
+          ],
+          edges: [
+            {
+              source: string,
+              target: string,
+              relation: string,
+            },
+          ],
+        }
+        `,
+  });
+
+  console.log("🔍 LLM memory (graph-based):");
+  console.log("Nodes:");
+  console.dir(llmMemory.object.nodes, { depth: null, colors: true });
+  console.log("Edges:");
+  console.dir(llmMemory.object.edges, { depth: null, colors: true });
+
+  const embeddingManager = new AIEmbeddingService(
+    openai.embedding("text-embedding-3-small")
+  );
+  const embedding = await embeddingManager.embedText(context.prompt);
+  let nodesNameToId: Record<string, string> = {};
+  for (const node of llmMemory.object.nodes) {
+    // Search for existing memory with same data and query
+    const searchResults = await memoryManager.search(node.name, "nodes", {
+      limit: 1,
+    });
+    const existingMemory = searchResults.find(
+      (result) =>
+        result.document.data.name === node.name &&
+        result.document.roomId === "nodes"
+    );
+
+    // If found, return existing memory
+    if (existingMemory) {
+      nodesNameToId[node.name] = existingMemory.document.id;
+    } else {
+      const nodesMemory = await memoryManager.createMemory({
+        data: node,
+        embedding,
+        roomId: "nodes",
+      });
+      nodesNameToId[node.name] = nodesMemory?.id || "";
+    }
+  }
+  for (const edge of llmMemory.object.edges) {
+    // Verify if source and target already exist in memory
+    const searchResults = await memoryManager.search(
+      nodesNameToId[edge.source],
+      "edges",
+      {
+        limit: 100,
+      }
+    );
+    const existingEdge = searchResults.find(
+      (result) =>
+        result.document.data.source === nodesNameToId[edge.source] &&
+        result.document.data.target === nodesNameToId[edge.target] &&
+        result.document.data.relation === edge.relation
+    );
+    if (existingEdge) {
+    } else {
+      await memoryManager.createMemory({
+        data: {
+          source: nodesNameToId[edge.source],
+          target: nodesNameToId[edge.target],
+          relation: edge.relation,
+        },
+        embedding,
+        roomId: "edges",
+      });
+    }
+  }
+};
+
+async function retrieveExistingRelations(
+  memoryManager: MeilisearchAdapter,
+  roomId: string
+) {
+  const existingNodesMemories = await memoryManager.getAllMemories("nodes");
+  const existingEdgesMemories = await memoryManager.getAllMemories("edges");
+  let existingNodes: any[] = [];
+  let existingEdges: any[] = [];
+
+  if (existingNodesMemories.length > 0) {
+    existingNodes = existingNodesMemories.flatMap((memory) => {
+      return {
+        id: memory.id,
+        data: memory.data,
+      };
+    });
+  }
+  if (existingEdgesMemories.length > 0) {
+    existingEdges = existingEdgesMemories.flatMap(
+      (memory) => memory.data || []
+    );
+  }
+
+  return { existingNodes, existingEdges };
+}

package/utils/stringifiy-zod-schema.ts

@@ -1,18 +1,18 @@
-import { Node } from "@/types";
 import { z } from "zod";
+import { Node } from "../types";
 
-export const stringifyZodSchema = <T>(nodes: Node<T>[]) => {
+export const stringifyZodSchema = (nodes: Node<any>[]) => {
   return nodes
     .map((node) => {
-      const schemaStr = node.schema
-        ? getSchemaString(node.schema)
+      const schemaStr = node.parameters
+        ? getSchemaString(node.parameters)
         : "No parameters";
-      return `Workflow: ${node.name}\nDescription: ${node.description}\nParameters: ${schemaStr}`;
+      return `Workflow: ${node.name}\nParameters: ${schemaStr}`;
     })
     .join("\n\n");
 };
 
-const getSchemaString = (schema: z.ZodType): string => {
+export const getSchemaString = (schema: z.ZodType): string => {
   if (schema instanceof z.ZodObject) {
     const entries = Object.entries(schema.shape);
     const fields = entries.map(([key, value]) => {