@ai.ntellect/core 0.2.7 → 0.3.0

package/README.FR.md

@@ -5,8 +5,8 @@
 1. [Composants principaux](#composants-principaux)
    - [Orchestrator](#orchestrator)
    - [Queue Manager](#queue-manager)
-   - [Synthétiseur](#synthétiseur)
    - [Évaluateur](#évaluateur)
+   - [Interpreter](#interpreter)
    - [Mémoire](#architecture-mémoire)
 2. [Création et gestion des actions](#création-et-gestion-des-actions)
 3. [Exécution du Workflow](#exécution-du-workflow)
@@ -39,29 +39,47 @@ Le gestionnaire de la file d'attente (Queue Manager) organise les actions à ex
   - Gérer les priorités des actions.
   - Assurer une exécution correcte et en temps voulu des actions.
 
-### Synthétiseur
+### Évaluateur
 
-Le synthétiseur est responsable de la génération des réponses et de l'analyse des actions en fonction des résultats obtenus dans le workflow. Il peut créer des résumés ou des réponses plus complexes à partir des résultats bruts obtenus lors de l'exécution des actions.
+L'évaluateur collabore maintenant avec les Interpreters :
 
-- **Rôle principal** : Transformer les résultats des actions en une sortie compréhensible et structurée.
-- **Interactions** :
-  - Prend les résultats des actions exécutées.
-  - Crée des résumés ou des réponses adaptées.
+- Analyse les résultats des actions exécutées
+- Détermine si des actions supplémentaires sont nécessaires et renvoie à la Queue Manager
+- Sinon, il sélectionne l'Interpreter approprié selon le type de demande
 
-### Évaluateur
+### Interpreter
 
-L'évaluateur est responsable de l'évaluation des résultats des actions exécutées et de la détermination des actions supplémentaires nécessaires. Il travaille en collaboration avec l'orchestrateur pour s'assurer que toutes les exigences de l'utilisateur sont satisfaites.
+L'Interpreter est le composant spécialisé dans l'interprétation des résultats d'actions et la génération de réponses adaptées. Chaque Interpreter est configuré avec un contexte spécifique et produit des réponses dans un format adapté à son domaine d'expertise.
 
-- **Rôle principal** : Évaluer les résultats des actions et déterminer les prochaines étapes
-- **Fonctions principales** :
-  - Analyse les résultats des actions exécutées
-  - Détermine si des actions supplémentaires sont nécessaires
-  - Suggère les prochaines actions à l'orchestrateur
-  - Assure la réalisation complète des objectifs
-- **Interactions** :
-  - Collabore avec l'orchestrateur pour gérer le workflow
-  - Traite les résultats des actions
-  - Peut déclencher des cycles d'actions supplémentaires
+**Caractéristiques principales** :
+
+- Configuration avec un contexte métier spécifique
+- Format de réponse adapté au domaine
+- Traitement spécialisé des données selon le contexte
+
+**Fonctionnement** :
+
+- Reçoit les résultats des actions via l'Evaluator
+- Analyse les données selon son contexte spécifique
+- Produit une réponse formatée selon les règles de son domaine
+
+Voici quelques exemples d'Interpreters qui peuvent être implémentés :
+
+1. **MarketInterpreter**
+
+   - Spécialisé dans l'analyse des données de marché
+   - Format adapté aux analyses financières
+
+2. **SecurityInterpreter**
+
+   - Dédié aux vérifications de sécurité
+   - Format optimisé pour les rapports de sécurité
+
+3. **GeneralInterpreter**
+   - Traitement des requêtes générales
+   - Format flexible selon le contexte
+
+Ces exemples illustrent la flexibilité du système, qui peut être étendu avec d'autres types d'Interpreters selon les besoins.
 
 [![Sans-titre-2024-11-08-0220.png](https://i.postimg.cc/nryjsx5y/Sans-titre-2024-11-08-0220.png)](https://postimg.cc/rR9FbBqj)
 
@@ -329,3 +347,24 @@ Voici les éléments actuellement en développement ou à améliorer :
 - [ ] Tester l'intégration, la sécurité et la transparence des actions Lit pour garantir leur bon fonctionnement.
 
 **Statut** : En cours d'étude pour déterminer la faisabilité et les implications techniques, notamment en ce qui concerne l'intégration de la décentralisation dans le système existant.
+
+### Exemple d'utilisation
+
+```typescript
+const securityInterpreter = new Interpreter("security", securityContext);
+const marketInterpreter = new Interpreter("market", marketContext);
+const generalInterpreter = new Interpreter("general", generalContext);
+
+const agent = new Agent({
+  interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+  orchestrator,
+  memory: {
+    persistent: memory,
+    cache: cacheMemory,
+  },
+  stream: false,
+  maxEvaluatorIteration: 1,
+});
+
+const result = await agent.process(prompt, context);
+```

package/README.md

@@ -5,8 +5,8 @@
 1. [Main components](#main-components)
    - [Agent](#agent)
    - [Orchestrator](#orchestrator)
-   - [Synthesizer](#synthesizer)
    - [Evaluator](#evaluator)
+   - [Interpreter](#interpreter)
    - [Memory](#memory-architecture)
 2. [Action creation and management](#action-creation-and-management)
 3. [Agent processing](#agent-processing)
@@ -41,31 +41,54 @@ The orchestrator works under the agent's direction to manage the execution of ac
   - Uses memory for context and caching
   - Coordinates with evaluator for result assessment
 
-### Synthesizer
-
-The synthesizer is responsible for generating responses and analyzing actions based on the results obtained in the workflow. It can create summaries or more complex responses from the raw results obtained during the execution of actions.
-
-- **Main role**: Transform the results of actions into a comprehensible and structured output
-- **Interactions**:
-  - Takes the results of executed actions
-  - Creates summaries or tailored responses
-  - Formats final output for user consumption
-  - Can handle streaming responses
-
 ### Evaluator
 
-The evaluator is responsible for assessing the results of executed actions and determining if additional actions are needed. It works in conjunction with the orchestrator to ensure all user requirements are met.
+The evaluator now collaborates with Interpreters to process action results and determine the next steps in the workflow.
 
-- **Main role**: Evaluate action results and determine next steps
+- **Main role**: Evaluate action results and coordinate with appropriate Interpreters
 - **Main functions**:
   - Analyzes results from executed actions
   - Determines if additional actions are needed
-  - Suggests next actions to the orchestrator
+  - Routes results to appropriate Interpreter
   - Ensures completion of user requirements
 - **Interactions**:
   - Works with orchestrator to manage workflow
-  - Processes action results
-  - Can trigger additional action cycles
+  - Coordinates with Interpreters for specialized processing
+  - Can trigger additional action cycles if needed
+
+### Interpreter
+
+The Interpreter is a specialized component responsible for interpreting action results and generating appropriate responses. Each Interpreter is configured with a specific business context and produces responses in a format adapted to its domain of expertise.
+
+**Key characteristics**:
+
+- Business-specific context configuration
+- Domain-adapted response formatting
+- Specialized data processing based on context
+
+**Operation flow**:
+
+- Receives action results via the Evaluator
+- Analyzes data according to its specific context
+- Produces formatted responses following domain rules
+
+Examples of Interpreter implementations:
+
+1. **MarketInterpreter**
+
+   - Specialized in market data analysis
+   - Format adapted for financial analysis
+
+2. **SecurityInterpreter**
+
+   - Dedicated to security verifications
+   - Optimized format for security reports
+
+3. **GeneralInterpreter**
+   - Handles general purpose requests
+   - Flexible formatting based on context
+
+These examples demonstrate the system's flexibility, which can be extended with additional Interpreter types as needed.
 
 [![Sans-titre-2024-11-08-0220.png](https://i.postimg.cc/nryjsx5y/Sans-titre-2024-11-08-0220.png)](https://postimg.cc/rR9FbBqj)
 

package/agent/index.ts

@@ -1,52 +1,67 @@
 import { Evaluator } from "../llm/evaluator";
+import { Interpreter } from "../llm/interpreter";
 import { Orchestrator } from "../llm/orchestrator";
-import { Synthesizer } from "../llm/synthesizer";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { ActionSchema, AgentEvent, QueueResult, User } from "../types";
+import { ActionSchema, AgentEvent, MemoryScope, QueueResult } from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
+import { ResultSanitizer } from "../utils/sanitize-results";
 import { ActionHandler } from "./handlers/ActionHandler";
 
 export class Agent {
   private readonly actionHandler: ActionHandler;
   private readonly orchestrator: Orchestrator;
-  private readonly persistentMemory: PersistentMemory;
-  private readonly cacheMemory: CacheMemory | undefined;
+  private readonly interpreters: Interpreter[];
+  private readonly memory: {
+    persistent: PersistentMemory;
+    cache?: CacheMemory;
+  };
   private readonly stream: boolean;
   private readonly maxEvaluatorIteration: number;
   private evaluatorIteration = 0;
-  private accumulatedResults: QueueResult[] = [];
+  private accumulatedResults: string = "";
 
   constructor({
     orchestrator,
-    persistentMemory,
-    cacheMemory,
+    interpreters,
+    memory,
     stream,
     maxEvaluatorIteration = 1,
   }: {
-    user: User;
     orchestrator: Orchestrator;
-    persistentMemory: PersistentMemory;
-    cacheMemory?: CacheMemory;
+    interpreters: Interpreter[];
+    memory: {
+      persistent: PersistentMemory;
+      cache?: CacheMemory;
+    };
     stream: boolean;
     maxEvaluatorIteration: number;
   }) {
     this.orchestrator = orchestrator;
-    this.cacheMemory = cacheMemory;
-    this.persistentMemory = persistentMemory;
+    this.interpreters = interpreters;
+    this.memory = memory;
     this.stream = stream;
     this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
-    this.accumulatedResults = [];
+    this.accumulatedResults = "";
   }
 
   async process(prompt: string, events: AgentEvent): Promise<any> {
-    this.accumulatedResults = [];
+    this.accumulatedResults = "";
     this.evaluatorIteration = 0;
     console.log("Requesting orchestrator for actions..");
+    const cacheMemories = await this.memory.cache?.findSimilarActions(prompt, {
+      similarityThreshold: 70,
+      maxResults: 5,
+      userId: "1",
+      scope: MemoryScope.GLOBAL,
+    });
+    console.log("✅ RECENT_ACTIONS: ", cacheMemories);
     const request = await this.orchestrator.process(
       prompt,
-      this.accumulatedResults
+      `## RECENT_ACTIONS: ${JSON.stringify(
+        cacheMemories
+      )} ## CURRENT_RESULTS: ${this.accumulatedResults}`
     );
     events.onMessage?.(request);
 
@@ -92,10 +107,7 @@ export class Agent {
       }
     );
 
-    this.accumulatedResults = this.formatResults([
-      ...this.accumulatedResults,
-      ...actionsResult.data,
-    ]);
+    this.accumulatedResults += this.formatResults(actionsResult.data);
 
     const isOnChainAction = actions.some(
       (action) => action.type === "on-chain"
@@ -109,15 +121,17 @@ export class Agent {
     }
 
     if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
-      return this.handleActionResults({
+      return this.interpreterResult({
         data: this.accumulatedResults,
         initialPrompt,
+        interpreter: this.interpreters[0],
       });
     }
 
     const evaluator = new Evaluator(
       this.orchestrator.tools,
-      this.persistentMemory
+      this.memory,
+      this.interpreters
     );
 
     // const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
@@ -138,30 +152,42 @@ export class Agent {
         events
       );
     }
-
-    return this.handleActionResults({
+    const interpreter = this.getInterpreter(
+      this.interpreters,
+      evaluation.interpreter
+    );
+    if (!interpreter) {
+      throw new Error("Interpreter not found");
+    }
+    return this.interpreterResult({
       data: this.accumulatedResults,
       initialPrompt,
+      interpreter,
     });
   }
 
-  private async handleActionResults(actionsResult: {
-    data: QueueResult[];
+  private getInterpreter(interpreters: Interpreter[], name: string) {
+    return interpreters.find((interpreter) => interpreter.name === name);
+  }
+
+  private async interpreterResult(actionsResult: {
+    data: string;
     initialPrompt: string;
+    interpreter: Interpreter;
   }) {
-    const synthesizer = new Synthesizer();
+    const { interpreter, initialPrompt, data } = actionsResult;
 
     return this.stream
       ? (
-          await synthesizer.streamProcess(
-            actionsResult.initialPrompt,
-            actionsResult.data
-          )
+          await interpreter.streamProcess(initialPrompt, {
+            userRequest: initialPrompt,
+            results: data,
+          })
         ).toDataStreamResponse()
-      : await synthesizer.process(
-          actionsResult.initialPrompt,
-          actionsResult.data
-        );
+      : await interpreter.process(initialPrompt, {
+          userRequest: initialPrompt,
+          results: data,
+        });
   }
 
   private transformActions(actions: ActionSchema[]) {
@@ -171,13 +197,15 @@ export class Agent {
     return predefinedActions;
   }
 
-  private formatResults(results: QueueResult[]): QueueResult[] {
-    return results.map((result) => ({
+  private formatResults(results: QueueResult[]): string {
+    const formattedResults = results.map((result) => ({
       ...result,
       result:
         typeof result.result === "object"
           ? JSON.stringify(result.result)
           : result.result,
     }));
+    const sanitizedResults = ResultSanitizer.sanitize(formattedResults);
+    return sanitizedResults;
   }
 }

package/dist/agent/index.d.ts

@@ -1,27 +1,31 @@
+import { Interpreter } from "../llm/interpreter";
 import { Orchestrator } from "../llm/orchestrator";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { AgentEvent, User } from "../types";
+import { AgentEvent } from "../types";
 export declare class Agent {
     private readonly actionHandler;
     private readonly orchestrator;
-    private readonly persistentMemory;
-    private readonly cacheMemory;
+    private readonly interpreters;
+    private readonly memory;
     private readonly stream;
     private readonly maxEvaluatorIteration;
     private evaluatorIteration;
     private accumulatedResults;
-    constructor({ orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration, }: {
-        user: User;
+    constructor({ orchestrator, interpreters, memory, stream, maxEvaluatorIteration, }: {
         orchestrator: Orchestrator;
-        persistentMemory: PersistentMemory;
-        cacheMemory?: CacheMemory;
+        interpreters: Interpreter[];
+        memory: {
+            persistent: PersistentMemory;
+            cache?: CacheMemory;
+        };
         stream: boolean;
         maxEvaluatorIteration: number;
     });
     process(prompt: string, events: AgentEvent): Promise<any>;
     private handleActions;
-    private handleActionResults;
+    private getInterpreter;
+    private interpreterResult;
     private transformActions;
     private formatResults;
 }

package/dist/agent/index.js

@@ -2,26 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 const evaluator_1 = require("../llm/evaluator");
-const synthesizer_1 = require("../llm/synthesizer");
+const types_1 = require("../types");
 const queue_item_transformer_1 = require("../utils/queue-item-transformer");
+const sanitize_results_1 = require("../utils/sanitize-results");
 const ActionHandler_1 = require("./handlers/ActionHandler");
 class Agent {
-    constructor({ orchestrator, persistentMemory, cacheMemory, stream, maxEvaluatorIteration = 1, }) {
+    constructor({ orchestrator, interpreters, memory, stream, maxEvaluatorIteration = 1, }) {
         this.evaluatorIteration = 0;
-        this.accumulatedResults = [];
+        this.accumulatedResults = "";
         this.orchestrator = orchestrator;
-        this.cacheMemory = cacheMemory;
-        this.persistentMemory = persistentMemory;
+        this.interpreters = interpreters;
+        this.memory = memory;
         this.stream = stream;
         this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
-        this.accumulatedResults = [];
+        this.accumulatedResults = "";
     }
     async process(prompt, events) {
-        this.accumulatedResults = [];
+        this.accumulatedResults = "";
         this.evaluatorIteration = 0;
         console.log("Requesting orchestrator for actions..");
-        const request = await this.orchestrator.process(prompt, this.accumulatedResults);
+        const cacheMemories = await this.memory.cache?.findSimilarActions(prompt, {
+            similarityThreshold: 70,
+            maxResults: 5,
+            userId: "1",
+            scope: types_1.MemoryScope.GLOBAL,
+        });
+        console.log("✅ RECENT_ACTIONS: ", cacheMemories);
+        const request = await this.orchestrator.process(prompt, `## RECENT_ACTIONS: ${JSON.stringify(cacheMemories)} ## CURRENT_RESULTS: ${this.accumulatedResults}`);
         events.onMessage?.(request);
         return request.actions.length > 0
             ? this.handleActions({
@@ -39,10 +47,7 @@ class Agent {
             onQueueComplete: events.onQueueComplete,
             onConfirmationRequired: events.onConfirmationRequired,
         });
-        this.accumulatedResults = this.formatResults([
-            ...this.accumulatedResults,
-            ...actionsResult.data,
-        ]);
+        this.accumulatedResults += this.formatResults(actionsResult.data);
         const isOnChainAction = actions.some((action) => action.type === "on-chain");
         if (isOnChainAction) {
             return {
@@ -51,12 +56,13 @@ class Agent {
             };
         }
         if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
-            return this.handleActionResults({
+            return this.interpreterResult({
                 data: this.accumulatedResults,
                 initialPrompt,
+                interpreter: this.interpreters[0],
             });
         }
-        const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.persistentMemory);
+        const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.memory, this.interpreters);
         // const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
         const evaluation = await evaluator.process(initialPrompt, this.accumulatedResults);
         events.onMessage?.(evaluation);
@@ -67,28 +73,44 @@ class Agent {
                 actions: evaluation.nextActionsNeeded,
             }, events);
         }
-        return this.handleActionResults({
+        const interpreter = this.getInterpreter(this.interpreters, evaluation.interpreter);
+        if (!interpreter) {
+            throw new Error("Interpreter not found");
+        }
+        return this.interpreterResult({
             data: this.accumulatedResults,
             initialPrompt,
+            interpreter,
         });
     }
-    async handleActionResults(actionsResult) {
-        const synthesizer = new synthesizer_1.Synthesizer();
+    getInterpreter(interpreters, name) {
+        return interpreters.find((interpreter) => interpreter.name === name);
+    }
+    async interpreterResult(actionsResult) {
+        const { interpreter, initialPrompt, data } = actionsResult;
         return this.stream
-            ? (await synthesizer.streamProcess(actionsResult.initialPrompt, actionsResult.data)).toDataStreamResponse()
-            : await synthesizer.process(actionsResult.initialPrompt, actionsResult.data);
+            ? (await interpreter.streamProcess(initialPrompt, {
+                userRequest: initialPrompt,
+                results: data,
+            })).toDataStreamResponse()
+            : await interpreter.process(initialPrompt, {
+                userRequest: initialPrompt,
+                results: data,
+            });
     }
     transformActions(actions) {
         let predefinedActions = queue_item_transformer_1.QueueItemTransformer.transformActionsToQueueItems(actions) || [];
         return predefinedActions;
     }
     formatResults(results) {
-        return results.map((result) => ({
+        const formattedResults = results.map((result) => ({
             ...result,
             result: typeof result.result === "object"
                 ? JSON.stringify(result.result)
                 : result.result,
         }));
+        const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(formattedResults);
+        return sanitizedResults;
     }
 }
 exports.Agent = Agent;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./agent";
+export * from "./llm/interpreter";
+export * from "./llm/interpreter/context";
 export * from "./llm/orchestrator";
-export * from "./llm/synthesizer";
 export * from "./types";
 export * from "./memory/cache";
 export * from "./memory/persistent";

package/dist/index.js

@@ -15,8 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent"), exports);
+__exportStar(require("./llm/interpreter"), exports);
+__exportStar(require("./llm/interpreter/context"), exports);
 __exportStar(require("./llm/orchestrator"), exports);
-__exportStar(require("./llm/synthesizer"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./memory/cache"), exports);
 __exportStar(require("./memory/persistent"), exports);

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

@@ -5,7 +5,6 @@ export declare const evaluatorContext: {
         guidelines: {
             important: string[];
             warnings: string[];
-            steps: string[];
         };
     };
 };

package/dist/llm/evaluator/context.js

@@ -9,23 +9,14 @@ exports.evaluatorContext = {
             important: [
                 "Verify if all required actions were executed successfully.",
                 "Check if the results align with the initial goal.",
-                "Identify and extract additional relevant information naturally during the process. Examples:",
-                "  - Link a token symbol (e.g., 'USDC') to its address (e.g., '0xA0b8...6EB48').",
-                "  - Associate a wallet address (e.g., '0x1234...abcd') to a user-friendly name (e.g., 'Work Wallet').",
-                "  - Map a token address (e.g., '0x6B17...71d0F') back to its symbol or name (e.g., 'DAI').",
-                "Store these facts in memory with their type (episodic, semantic, or procedural).",
+                "If you retrieved the informations from your internal knowledge base, no need to store them in 'extraInformationsToStore'.",
+                "Store ONLY extra new needed informations in 'extraInformationsToStore' (choose the most relevant informations and memory type: episodic, semantic, or procedural).",
             ],
             warnings: [
-                "NEVER modify the results directly.",
+                "NEVER store an old data you retrieve from your internal knowledge base.",
                 "NEVER make assumptions about missing data.",
                 "NEVER repeat actions already completed unless explicitly required.",
             ],
-            steps: [
-                "Verify success: Confirm if the goal has been fully or partially achieved. If partially, describe what's missing.",
-                "Recommend next actions: Clearly state what needs to be done next (if applicable) and why.",
-                "Store key facts: Store any relevant information in memory with their type (episodic, semantic, or procedural).",
-                "Be clear, concise, and prioritize storing key facts that may help improve future interactions.",
-            ],
         },
     },
 };

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

@@ -1,10 +1,16 @@
+import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, QueueResult, State } from "../../types";
+import { ActionSchema, State } from "../../types";
+import { Interpreter } from "../interpreter";
 export declare class Evaluator {
     private readonly model;
     tools: ActionSchema[];
     private memory;
-    constructor(tools: ActionSchema[], memory: PersistentMemory);
+    private interpreters;
+    constructor(tools: ActionSchema[], memory: {
+        persistent: PersistentMemory;
+        cache?: CacheMemory;
+    }, interpreters: Interpreter[]);
     composeContext(state: State): string;
-    process(prompt: string, results: QueueResult[]): Promise<any>;
+    process(prompt: string, results: string): Promise<any>;
 }