@ai.ntellect/core 0.6.11 → 0.6.13

package/dist/utils/experimental-graph-rag.js

@@ -0,0 +1,152 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.experimentalGraphRag = void 0;
+const meilisearch_1 = require("../memory/adapters/meilisearch");
+const embedding_1 = require("../services/embedding");
+const openai_1 = require("@ai-sdk/openai");
+const ai_1 = require("ai");
+const zod_1 = require("zod");
+const experimentalGraphRag = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    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 meilisearch_1.MeilisearchAdapter({
+        apiKey: process.env.MEILISEARCH_API_KEY,
+        host: process.env.MEILISEARCH_HOST,
+    });
+    yield memoryManager.init("nodes");
+    yield memoryManager.init("edges");
+    const { existingNodes } = yield 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 = yield (0, ai_1.generateObject)({
+        model: (0, openai_1.openai)("gpt-4o"),
+        prompt,
+        schema: zod_1.z.object({
+            nodes: zod_1.z.array(zod_1.z.object({
+                name: zod_1.z.string(), // Nom de l'entité (ex: Adresse, ETH, Transaction ID)
+                metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.any()), // Métadonnées associées
+            })),
+            edges: zod_1.z.array(zod_1.z.object({
+                source: zod_1.z.string(), // ID de l'entité source
+                target: zod_1.z.string(), // ID de l'entité cible
+                relation: zod_1.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 embedding_1.AIEmbeddingService(openai_1.openai.embedding("text-embedding-3-small"));
+    const embedding = yield embeddingManager.embedText(context.prompt);
+    let nodesNameToId = {};
+    for (const node of llmMemory.object.nodes) {
+        // Search for existing memory with same data and query
+        const searchResults = yield 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 = yield memoryManager.createMemory({
+                data: node,
+                embedding,
+                roomId: "nodes",
+            });
+            nodesNameToId[node.name] = (nodesMemory === null || nodesMemory === void 0 ? void 0 : nodesMemory.id) || "";
+        }
+    }
+    for (const edge of llmMemory.object.edges) {
+        // Verify if source and target already exist in memory
+        const searchResults = yield 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 {
+            yield memoryManager.createMemory({
+                data: {
+                    source: nodesNameToId[edge.source],
+                    target: nodesNameToId[edge.target],
+                    relation: edge.relation,
+                },
+                embedding,
+                roomId: "edges",
+            });
+        }
+    }
+});
+exports.experimentalGraphRag = experimentalGraphRag;
+function retrieveExistingRelations(memoryManager, roomId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const existingNodesMemories = yield memoryManager.getAllMemories("nodes");
+        const existingEdgesMemories = yield memoryManager.getAllMemories("edges");
+        let existingNodes = [];
+        let existingEdges = [];
+        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/dist/utils/stringifiy-zod-schema.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyZodSchema = void 0;
+exports.getSchemaString = exports.stringifyZodSchema = void 0;
 const zod_1 = require("zod");
 const stringifyZodSchema = (nodes) => {
     return nodes
         .map((node) => {
-        const schemaStr = node.schema
-            ? getSchemaString(node.schema)
+        const schemaStr = node.parameters
+            ? (0, exports.getSchemaString)(node.parameters)
             : "No parameters";
-        return `Workflow: ${node.name}\nDescription: ${node.description}\nParameters: ${schemaStr}`;
+        return `Workflow: ${node.name}\nParameters: ${schemaStr}`;
     })
         .join("\n\n");
 };
@@ -18,7 +18,7 @@ const getSchemaString = (schema) => {
         const entries = Object.entries(schema.shape);
         const fields = entries.map(([key, value]) => {
             const description = value._def.description;
-            const schemaStr = getSchemaString(value);
+            const schemaStr = (0, exports.getSchemaString)(value);
             return description
                 ? `${key}: ${schemaStr} // ${description}`
                 : `${key}: ${schemaStr}`;
@@ -26,7 +26,7 @@ const getSchemaString = (schema) => {
         return `z.object({${fields.join(", ")}})`;
     }
     if (schema instanceof zod_1.z.ZodArray) {
-        return `z.array(${getSchemaString(schema.element)})`;
+        return `z.array(${(0, exports.getSchemaString)(schema.element)})`;
     }
     if (schema instanceof zod_1.z.ZodString) {
         return "z.string()";
@@ -39,3 +39,4 @@ const getSchemaString = (schema) => {
     }
     return `z.unknown()`;
 };
+exports.getSchemaString = getSchemaString;

package/graph/controller.ts

@@ -1,62 +1,67 @@
-import { GraphDefinition } from "@/types";
-import { GraphEngine } from "./engine";
+import { GraphContext } from "@/types";
+import { ZodSchema } from "zod";
+import { Graph } from "./graph";
 
-/**
- * Controller responsible for executing workflows based on graph definitions.
- * @template T The type representing the graph's state.
- */
-export class GraphController<T> {
-  /**
-   * Executes a sequence of actions using the corresponding graph definitions.
-   * @param {any[]} actions - The list of actions to execute.
-   * @param {GraphDefinition<T>[]} graphs - The available graph definitions.
-   * @returns {Promise<any>} The final state of the executed workflow.
-   * @throws {Error} If no actions are provided or if the graph is not found.
-   */
-  async run(actions: any[], graphs: GraphDefinition<T>[]): Promise<any> {
-    if (actions.length === 0) {
-      throw new Error("No actions provided");
+export class GraphController {
+  static async executeSequential<T extends ZodSchema>(
+    graphs: Graph<T>[],
+    startNodes: string[],
+    inputContexts?: Partial<GraphContext<T>>[]
+  ): Promise<Map<string, GraphContext<T>>> {
+    const results = new Map<string, GraphContext<T>>();
+    for (let i = 0; i < graphs.length; i++) {
+      const result = await graphs[i].execute(startNodes[i], inputContexts?.[i]);
+      results.set(`${graphs[i].name}-${i}`, result);
     }
+    return results;
+  }
 
-    // Create a mapping of graph names to their definitions for quick lookup.
-    const graphMap = new Map(graphs.map((g) => [g.name, g]));
-
-    for (const action of actions) {
-      // Retrieve the graph definition based on the action name.
-      const graphDefinition = graphMap.get(action.name);
-      if (!graphDefinition) {
-        throw new Error(`Graph not found: ${action.name}`);
-      }
-
-      // Initialize the graph engine with the selected graph definition.
-      const graph = new GraphEngine(graphDefinition, {
-        schema: graphDefinition.schema,
-        autoDetectCycles: true,
-      });
-
-      console.log("graph", graph);
+  static async executeParallel<T extends ZodSchema>(
+    graphs: Graph<T>[],
+    startNodes: string[],
+    inputContexts?: Partial<GraphContext<T>>[],
+    inputParams?: any[],
+    concurrencyLimit?: number
+  ): Promise<Map<string, GraphContext<T>>> {
+    const results = new Map<string, GraphContext<T>>();
 
-      // Construct the initial state from action parameters.
-      const initialState = action.parameters.reduce(
-        (acc: Record<string, any>, param: { name: string; value: any }) => {
-          acc[param.name] = param.value;
-          return acc;
-        },
-        {}
-      );
-
-      console.log("initialState", initialState);
+    if (inputContexts) {
+      inputContexts = inputContexts.map((ctx) => ctx || {});
+    }
 
-      // Execute the graph starting from the defined entry node.
-      await graph.execute(initialState, graphDefinition.entryNode);
+    if (inputParams) {
+      inputParams = inputParams.map((params) => params || {});
+    }
 
-      // Retrieve the final state after execution.
-      const result = graph.getState();
-      if (!result) {
-        throw new Error("Workflow execution failed to return a state");
+    if (concurrencyLimit) {
+      for (let i = 0; i < graphs.length; i += concurrencyLimit) {
+        const batchResults = await Promise.all(
+          graphs.slice(i, i + concurrencyLimit).map((graph, index) =>
+            graph.execute(
+              startNodes[i + index],
+              inputContexts?.[i + index] || {},
+              inputParams?.[i + index] || {} // ✅ Passe bien les paramètres
+            )
+          )
+        );
+        batchResults.forEach((result, index) => {
+          results.set(`${graphs[i + index].name}`, result);
+        });
       }
-
-      return result;
+    } else {
+      const allResults = await Promise.all(
+        graphs.map((graph, index) =>
+          graph.execute(
+            startNodes[index],
+            inputContexts?.[index] || {},
+            inputParams?.[index] || {}
+          )
+        )
+      );
+      allResults.forEach((result, index) => {
+        results.set(`${graphs[index].name}`, result);
+      });
     }
+    return results;
   }
 }

package/graph/graph.ts

@@ -0,0 +1,198 @@
+import { GraphConfig, GraphContext, GraphDefinition, Node } from "@/types";
+import { configDotenv } from "dotenv";
+import EventEmitter from "events";
+import { ZodSchema } from "zod";
+configDotenv();
+
+// Classe Graph avec un contexte typé
+export class Graph<T extends ZodSchema> {
+  private nodes: Map<string, Node<T>>;
+  private context: GraphContext<T>;
+  public validator?: T;
+  private eventEmitter: EventEmitter;
+  private globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
+
+  constructor(public name: string, config: GraphConfig<T>) {
+    this.nodes = new Map(config.nodes.map((node) => [node.name, node]));
+    this.context = config.initialContext || ({} as GraphContext<T>);
+    this.validator = config.validator;
+    this.globalErrorHandler = config.globalErrorHandler;
+    this.eventEmitter = new EventEmitter();
+    this.setupEventListeners();
+  }
+
+  private createNewContext(): GraphContext<T> {
+    return structuredClone(this.context);
+  }
+
+  private setupEventListeners(): void {
+    for (const node of this.nodes.values()) {
+      node.events?.forEach((event) => {
+        this.eventEmitter.on(event, async (data?: Partial<GraphContext<T>>) => {
+          const context = this.createNewContext();
+          if (data) Object.assign(context, data);
+          await this.executeNode(node.name, context);
+        });
+      });
+    }
+  }
+  private async executeNode(
+    nodeName: string,
+    context: GraphContext<T>,
+    params?: any
+  ): Promise<void> {
+    const node = this.nodes.get(nodeName);
+    if (!node) throw new Error(`❌ Node ${nodeName} not found`);
+
+    if (node.condition && !node.condition(context)) return;
+
+    let attempts = 0;
+    const maxAttempts = node.retry?.maxAttempts || 1;
+    const delay = node.retry?.delay || 0;
+
+    while (attempts < maxAttempts) {
+      try {
+        let validatedParams;
+
+        // ✅ Si le nœud a un `parameters`, on valide `params` avant exécution
+        if (node.parameters) {
+          if (!params) {
+            throw new Error(
+              `❌ Paramètres requis pour le nœud "${nodeName}" mais reçus: ${params}`
+            );
+          }
+          validatedParams = node.parameters.parse(params);
+        }
+
+        // ✅ Exécuter avec ou sans `params`
+        if (node.execute) {
+          await node.execute(context);
+        } else if (node.executeWithParams) {
+          if (!validatedParams) {
+            throw new Error(
+              `❌ Paramètres invalides pour le nœud "${nodeName}"`
+            );
+          }
+          await node.executeWithParams(context, validatedParams);
+        }
+
+        this.validateContext(context);
+
+        this.eventEmitter.emit("nodeCompleted", { nodeName, context });
+
+        if (node.next) {
+          await Promise.all(
+            node.next.map((nextNode) => this.executeNode(nextNode, context))
+          );
+        }
+        return;
+      } catch (error) {
+        attempts++;
+
+        if (attempts >= maxAttempts) {
+          this.eventEmitter.emit("nodeError", { nodeName, error });
+          node.onError?.(error as Error);
+          this.globalErrorHandler?.(error as Error, context);
+          throw error;
+        }
+
+        console.warn(
+          `[Graph ${this.name}] Retry attempt ${attempts} for node ${nodeName}`,
+          { error }
+        );
+
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  private validateContext(context: GraphContext<T>): void {
+    if (this.validator) {
+      this.validator.parse(context);
+    }
+  }
+
+  async execute(
+    startNode: string,
+    inputContext?: Partial<GraphContext<T>>,
+    inputParams?: any
+  ): Promise<GraphContext<T>> {
+    const context = this.createNewContext();
+    if (inputContext) Object.assign(context, inputContext);
+
+    this.eventEmitter.emit("graphStarted", { name: this.name });
+    try {
+      await this.executeNode(startNode, context, inputParams);
+      this.eventEmitter.emit("graphCompleted", { name: this.name, context });
+      return context;
+    } catch (error) {
+      this.eventEmitter.emit("graphError", { name: this.name, error });
+      this.globalErrorHandler?.(error as Error, context); // Gestionnaire d'erreurs global
+      throw error;
+    }
+  }
+
+  emit(
+    eventName: string,
+    data?: Partial<GraphContext<T>>
+  ): Promise<GraphContext<T>> {
+    return new Promise((resolve, reject) => {
+      if (data) Object.assign(this.context, data); // ✅ Met à jour le contexte global
+
+      this.eventEmitter.emit(eventName, this.context); // Utilise le contexte global
+
+      const eventNodes = Array.from(this.nodes.values()).filter((node) =>
+        node.events?.includes(eventName)
+      );
+      if (eventNodes.length === 0) return resolve(this.context);
+
+      Promise.all(
+        eventNodes.map(
+          (node) =>
+            new Promise<void>((resolve) => {
+              this.eventEmitter.once("nodeCompleted", ({ nodeName }) => {
+                if (nodeName === node.name) resolve();
+              });
+            })
+        )
+      )
+        .then(() => resolve(this.context))
+        .catch(reject);
+    });
+  }
+
+  on(eventName: string, handler: (...args: any[]) => void): void {
+    this.eventEmitter.on(eventName, handler);
+  }
+
+  loadDefinition(definition: GraphDefinition<T>): void {
+    this.nodes.clear();
+    Object.values(definition.nodes).forEach((node) =>
+      this.nodes.set(node.name, node)
+    );
+    this.setupEventListeners();
+  }
+
+  getContext(): GraphContext<T> {
+    return structuredClone(this.context);
+  }
+
+  // Journalisation (logging)
+  log(message: string, data?: any): void {
+    console.log(`[Graph ${this.name}] ${message}`, data);
+  }
+
+  // Modification dynamique du graph
+  addNode(node: Node<T>): void {
+    this.nodes.set(node.name, node);
+    this.setupEventListeners();
+  }
+
+  removeNode(nodeName: string): void {
+    this.nodes.delete(nodeName);
+  }
+
+  getNodes(): Node<T>[] {
+    return Array.from(this.nodes.values());
+  }
+}

package/index.ts

@@ -1,10 +1,11 @@
 export * from "./graph/controller";
-export * from "./graph/engine";
+export * from "./graph/graph";
 export * from "./memory";
 export * from "./memory/adapters/meilisearch";
 export * from "./memory/adapters/redis";
 
 export * from "./interfaces";
+export * from "./services/agenda";
+export * from "./services/embedding";
 export * from "./types";
-export * from "./utils/setup-graphs";
 export * from "./utils/stringifiy-zod-schema";