@ai.ntellect/core 0.0.32 → 0.0.33

package/agent/index.ts

@@ -1,4 +1,3 @@
-import EventEmitter from "events";
 import { Evaluator } from "../llm/evaluator";
 import { Orchestrator } from "../llm/orchestrator";
 import { Summarizer } from "../llm/synthesizer";
@@ -11,27 +10,40 @@ export class Agent {
   private readonly SIMILARITY_THRESHOLD = 95;
   private readonly MAX_RESULTS = 1;
   private readonly actionHandler: ActionHandler;
-
-  constructor(
-    private readonly user: User,
-    private readonly dependencies: {
-      orchestrator: Orchestrator;
-      memoryCache: MemoryCache;
-      eventEmitter: EventEmitter;
-    },
-    private readonly stream: boolean = true
-  ) {
+  private readonly user: User;
+  private readonly orchestrator: Orchestrator;
+  private readonly memoryCache: MemoryCache | undefined;
+  private readonly stream: boolean;
+  private readonly maxEvaluatorIteration: number;
+  private readonly evaluatorIteration = 0;
+
+  constructor({
+    user,
+    orchestrator,
+    memoryCache,
+    stream,
+    maxEvaluatorIteration = 1,
+  }: {
+    user: User;
+    orchestrator: Orchestrator;
+    memoryCache?: MemoryCache;
+    stream: boolean;
+    maxEvaluatorIteration: number;
+  }) {
+    this.user = user;
+    this.orchestrator = orchestrator;
+    this.memoryCache = memoryCache;
+    this.stream = stream;
+    this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
   }
 
-  async start(
+  async process(
     prompt: string,
     contextualizedPrompt: string,
     events: AgentEvent
   ): Promise<any> {
-    const request = await this.dependencies.orchestrator.process(
-      contextualizedPrompt
-    );
+    const request = await this.orchestrator.process(contextualizedPrompt);
 
     events.onMessage?.(request);
 
@@ -60,36 +72,39 @@ export class Agent {
     events: AgentEvent
   ): Promise<any> {
     const similarActions = await this.findSimilarActions(initialPrompt);
-    const predefinedActions = this.transformActions(actions, similarActions);
-    const callbacks = {
-      onQueueStart: events.onQueueStart,
-      onActionStart: events.onActionStart,
-      onActionComplete: events.onActionComplete,
-      onQueueComplete: events.onQueueComplete,
-      onConfirmationRequired: events.onConfirmationRequired,
-    };
+    const queueItems = this.transformActions(actions, similarActions);
 
     const actionsResult = await this.actionHandler.executeActions(
-      predefinedActions,
-      this.dependencies.orchestrator.tools,
-      callbacks
+      queueItems,
+      this.orchestrator.tools,
+      {
+        onQueueStart: events.onQueueStart,
+        onActionStart: events.onActionStart,
+        onActionComplete: events.onActionComplete,
+        onQueueComplete: events.onQueueComplete,
+        onConfirmationRequired: events.onConfirmationRequired,
+      }
     );
 
-    const evaluator = new Evaluator(this.dependencies.orchestrator.tools);
+    if (this.evaluatorIteration >= this.maxEvaluatorIteration) {
+      return this.handleActionResults({ ...actionsResult, initialPrompt });
+    }
+
+    const evaluator = new Evaluator(this.orchestrator.tools);
     const evaluation = await evaluator.process(
       initialPrompt,
       contextualizedPrompt,
       JSON.stringify(actionsResult.data)
     );
-    console.log("EVALUATION", evaluation);
+
     events.onMessage?.(evaluation);
 
-    if (evaluation.actions.length > 0) {
+    if (evaluation.nextActions.length > 0) {
       return this.handleActions(
         {
           initialPrompt: contextualizedPrompt,
           contextualizedPrompt: initialPrompt,
-          actions: evaluation.actions,
+          actions: evaluation.nextActions,
         },
         events
       );
@@ -105,8 +120,27 @@ export class Agent {
     return this.handleActionResults({ ...actionsResult, initialPrompt });
   }
 
+  private async handleActionResults(actionsResult: {
+    data: any;
+    initialPrompt: string;
+  }) {
+    const summarizer = new Summarizer();
+    const summaryData = JSON.stringify({
+      result: actionsResult.data,
+      initialPrompt: actionsResult.initialPrompt,
+    });
+
+    return this.stream
+      ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
+      : await summarizer.process(summaryData);
+  }
+
   private async findSimilarActions(prompt: string) {
-    return this.dependencies.memoryCache.findBestMatches(prompt, {
+    if (!this.memoryCache) {
+      return [];
+    }
+
+    return this.memoryCache.findBestMatches(prompt, {
       similarityThreshold: this.SIMILARITY_THRESHOLD,
       maxResults: this.MAX_RESULTS,
       userId: this.user.id,
@@ -125,19 +159,4 @@ export class Agent {
 
     return predefinedActions;
   }
-
-  private async handleActionResults(actionsResult: {
-    data: any;
-    initialPrompt: string;
-  }) {
-    const summarizer = new Summarizer();
-    const summaryData = JSON.stringify({
-      result: actionsResult.data,
-      initialPrompt: actionsResult.initialPrompt,
-    });
-
-    return this.stream
-      ? (await summarizer.streamProcess(summaryData)).toDataStreamResponse()
-      : await summarizer.process(summaryData);
-  }
 }

package/llm/evaluator/context.ts

@@ -8,7 +8,6 @@ export const evaluatorContext = {
       "IMPORTANT: Verify if all required actions were executed successfully",
       "IMPORTANT: Check if the results match the initial goal",
       "IMPORTANT: Identify any missing or incomplete information",
-      "IMPORTANT: Use the same language as the initial request",
     ],
     never: [
       "NEVER modify the results directly",
@@ -22,9 +21,10 @@ export const evaluatorContext = {
 
       ${evaluatorContext.guidelines.important.join("\n")}
       ${evaluatorContext.guidelines.never.join("\n")}
+      
+      ACTIONS COMPLETED: ${results}
 
-      Initial Goal: ${goal}
-      What was done: ${results}
+      Initial Goal: ${goal} (You must use the same language)
 
       The actions available are: ${tools.map((action) => {
         const parameters = action.parameters as z.ZodObject<any>;
@@ -36,6 +36,7 @@ export const evaluatorContext = {
       Evaluate if the goal has been achieved and provide:
       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
     `;
   },
 };

package/llm/evaluator/index.ts

@@ -17,7 +17,7 @@ export class Evaluator {
       const response = await generateObject({
         model: this.model,
         schema: z.object({
-          actions: z.array(
+          nextActions: z.array(
             z.object({
               name: z.string(),
               parameters: z.object({
@@ -26,7 +26,7 @@ export class Evaluator {
               }),
             })
           ),
-          answer: z.string(),
+          why: z.string(),
         }),
         prompt: prompt,
         system: evaluatorContext.compose(goal, results, this.tools),
@@ -34,19 +34,15 @@ export class Evaluator {
 
       const validatedResponse = {
         ...response.object,
-        actions: response.object.actions.map((action) => ({
+        nextActions: response.object.nextActions.map((action) => ({
           ...action,
           parameters: action.parameters || {},
         })),
       };
 
-      console.dir(validatedResponse, { depth: null });
-
       return validatedResponse;
     } catch (error: any) {
       if (error) {
-        console.log("Error in Orchestrator", error.message);
-        console.dir(error.value, { depth: null });
         return {
           ...error.value,
         };

package/llm/orchestrator/context.ts

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { ActionSchema } from "../../types";
 
 export const orchestratorContext = {
-  role: "You are the gateway agent, you are the first agent to be called. You are the one who will decide if the user request is clear and if it's possible to achieve the goal.",
+  role: "You are the first agent to be called. You are the one who will decide if the user request is clear and if it's possible to achieve the goal.",
   guidelines: {
     important: [
       "IMPORTANT: If there is no action to do, you must answer in the 'answer' field.",
-      "IMPORTANT: If user ask for a analysis of the market or a cryptocurrency, use the maximum of useful tools to have a global view of the market (fundamental analysis vs technical analysis).",
+      "IMPORTANT: If user ask for a analysis of the market or a cryptocurrency, use the maximum of useful tools to have for understanding the market.",
       "IMPORTANT: If user ask for an action on chain, use only the necessary tools to do the action.",
       "IMPORTANT: You allow to provide an analysis without providing any financial advice.",
       "IMPORTANT: ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",

package/llm/orchestrator/index.ts

@@ -40,13 +40,9 @@ export class Orchestrator implements BaseLLM {
         })),
       };
 
-      console.dir(validatedResponse, { depth: null });
-
       return validatedResponse;
     } catch (error: any) {
       if (error) {
-        console.log("Error in Orchestrator", error.message);
-        console.dir(error.value, { depth: null });
         return {
           ...error.value,
         };

package/memory/index.ts

@@ -1,8 +1,15 @@
 import { openai } from "@ai-sdk/openai";
-import { cosineSimilarity, embed, embedMany, generateObject } from "ai";
-import { createClient } from 'redis';
+import { cosineSimilarity, embed, generateObject } from "ai";
+import { createClient } from "redis";
 import { z } from "zod";
-import { CreateMemoryInput, MatchOptions, Memory, MemoryCacheOptions, MemoryScope } from "../types";
+import {
+  CreateMemoryInput,
+  MatchOptions,
+  Memory,
+  MemoryCacheOptions,
+  MemoryScope,
+  MemoryType,
+} from "../types";
 
 export class MemoryCache {
   private redis;
@@ -12,29 +19,29 @@ export class MemoryCache {
   constructor(options: MemoryCacheOptions = {}) {
     const ttlInHours = options.cacheTTL ?? 1;
     this.CACHE_TTL = ttlInHours * 60 * 60;
-    this.CACHE_PREFIX = options.cachePrefix ?? 'memory:';
-    
+    this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
+
     this.redis = createClient({
       url: options.redisUrl || process.env.REDIS_URL,
       socket: {
         tls: true,
-        rejectUnauthorized: true
-      }
+        rejectUnauthorized: true,
+      },
     });
     this.initRedis();
   }
 
   private async initRedis() {
-    this.redis.on('error', err => {
-      console.error('Redis Client Error:', err);
+    this.redis.on("error", (err) => {
+      console.error("Redis Client Error:", err);
       // Implement retry logic if needed
     });
-    
+
     try {
       await this.redis.connect();
-      console.log('Successfully connected to Redis');
+      console.log("Successfully connected to Redis");
     } catch (error) {
-      console.error('Failed to connect to Redis:', error);
+      console.error("Failed to connect to Redis:", error);
       // Handle connection failure
     }
   }
@@ -50,66 +57,76 @@ export class MemoryCache {
     const prefix = this.getMemoryKey(memory.scope, memory.userId);
     const key = `${prefix}${memory.id}`;
     await this.redis.set(key, JSON.stringify(memory), {
-      EX: this.CACHE_TTL
+      EX: this.CACHE_TTL,
     });
   }
 
   async findBestMatches(
-    query: string, 
+    query: string,
     options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
-  ): Promise<{
-    data: any;
-    similarityPercentage: number;
-    purpose: string;
-  }[]> {
+  ): Promise<
+    {
+      data: any;
+      similarityPercentage: number;
+      purpose: string;
+    }[]
+  > {
     console.log("\n🔍 Searching for query:", query);
 
     const { embedding } = await embed({
       model: openai.embedding("text-embedding-3-small"),
-      value: query
+      value: query,
     });
 
     const memories = await this.getAllMemories(options.scope, options.userId);
     console.log("\n📚 Found", memories.length, "memories to compare with");
 
     const matches = memories
-      .map(memory => {
-        const similarities = memory.embeddings.map(emb => {
-          const similarity = cosineSimilarity(embedding, emb);
-         
-          return (similarity + 1) * 50; // Convert to percentage
-        });
-
-        const maxSimilarity = Math.max(...similarities);
+      .map((memory) => {
+        const similarity = cosineSimilarity(embedding, memory.embedding);
+        const similarityPercentage = (similarity + 1) * 50; // Conversion en pourcentage
+
         console.log(`\n📊 Memory "${memory.purpose}":
-          - Similarity: ${maxSimilarity.toFixed(2)}%
-          - Original queries: ${memory.queries.join(", ")}`);
+        - Similarity: ${similarityPercentage.toFixed(2)}%
+        - Query: ${memory.query}`);
 
         return {
           data: memory.data,
-          similarityPercentage: maxSimilarity,
+          similarityPercentage,
           purpose: memory.purpose,
+          // Optionnel : ajouter des métadonnées utiles
+          memoryId: memory.id,
         };
       })
-      .filter(match => match.similarityPercentage >= (options.similarityThreshold ?? 70))
+      .filter(
+        (match) =>
+          match.similarityPercentage >= (options.similarityThreshold ?? 70)
+      )
       .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
 
-    const results = options.maxResults ? matches.slice(0, options.maxResults) : matches;
-    
+    const results = options.maxResults
+      ? matches.slice(0, options.maxResults)
+      : matches;
+
     if (results.length > 0) {
-    console.log("\n✨ Best matches found:");
-      results.forEach(match => {
-        console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+      console.log("\n✨ Best matches found:");
+      results.forEach((match) => {
+        console.log(
+          `- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`
+        );
       });
     } else {
       console.log("No matches found");
     }
 
-    console.dir({results});
+    console.dir({ results });
     return results;
   }
 
-  private async getAllMemories(scope?: MemoryScope, userId?: string): Promise<Memory[]> {
+  private async getAllMemories(
+    scope?: MemoryScope,
+    userId?: string
+  ): Promise<Memory[]> {
     let patterns: Memory[] = [];
 
     if (!scope || scope === MemoryScope.GLOBAL) {
@@ -140,34 +157,31 @@ export class MemoryCache {
     return memories;
   }
 
-  public async createMemory(input: CreateMemoryInput): Promise<string | undefined> {
-    const { embedding } = await embed({
-      model: openai.embedding("text-embedding-3-small"),
-      value: input.content
-    });
-
+  public async createMemory(
+    input: CreateMemoryInput
+  ): Promise<string | undefined> {
     const existingPattern = await this.findBestMatches(input.content, {
       similarityThreshold: 95,
       userId: input.userId,
-      scope: input.scope
+      scope: input.scope,
     });
 
     if (existingPattern.length > 0) {
       console.log("\n🔍 Similar memory found:");
-      // Display only the name and similarity percentage
-      existingPattern.forEach(match => {
-        console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+      existingPattern.forEach((match) => {
+        console.log(
+          `- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`
+        );
       });
       return;
     }
 
+    // Générer les variations via GPT-4
     const variations = await generateObject({
       model: openai("gpt-4"),
       schema: z.object({
         request: z.string().describe("The request to be performed"),
-        queries: z.array(z.object({
-              text: z.string()
-        }))
+        queries: z.array(z.object({ text: z.string() })),
       }),
       prompt: `For this input: "${input.content}"
         Generate similar variations that should match the same context.
@@ -175,27 +189,67 @@ export class MemoryCache {
         Data: ${JSON.stringify(input.data)}
         - Keep variations natural and human-like
         - Include the original input
-        - Add 3-5 variations`
-    });
-
-    const embeddingResults = await embedMany({
-      model: openai.embedding("text-embedding-3-small"),
-      values: variations.object.queries.map(q => q.text)
+        - Add 3-5 variations`,
     });
 
-    const memory: Memory = {
+    await this.createSingleMemory({
       id: crypto.randomUUID(),
+      content: input.content,
       type: input.type,
       data: input.data,
       purpose: variations.object.request,
-      queries: [input.content, ...variations.object.queries.map(q => q.text)],
-      embeddings: [embedding, ...embeddingResults.embeddings],
       userId: input.userId,
-      scope: input.scope || (input.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
-      createdAt: new Date()
+      scope: input.scope,
+    });
+
+    const variationPromises = variations.object.queries.map(
+      async (variation) => {
+        if (variation.text !== input.content) {
+          await this.createSingleMemory({
+            id: crypto.randomUUID(),
+            content: variation.text,
+            type: input.type,
+            data: input.data,
+            purpose: variations.object.request,
+            userId: input.userId,
+            scope: input.scope,
+          });
+        }
+      }
+    );
+
+    await Promise.all(variationPromises);
+    return variations.object.request;
+  }
+
+  private async createSingleMemory(params: {
+    id: string;
+    content: string;
+    type: MemoryType;
+    data: any;
+    purpose: string;
+    userId?: string;
+    scope?: MemoryScope;
+  }): Promise<Memory> {
+    const { embedding } = await embed({
+      model: openai.embedding("text-embedding-3-small"),
+      value: params.content,
+    });
+
+    const memory: Memory = {
+      id: params.id,
+      type: params.type,
+      data: params.data,
+      purpose: params.purpose,
+      query: params.content,
+      embedding,
+      userId: params.userId,
+      scope:
+        params.scope || (params.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
+      createdAt: new Date(),
     };
-    
+
     await this.storeMemory(memory);
-    return variations.object.request;
+    return memory;
   }
 }

package/package.json

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

package/test.ts

@@ -0,0 +1,146 @@
+import Parser from "rss-parser";
+import { z } from "zod";
+import { Agent } from "./agent";
+import { Orchestrator } from "./llm/orchestrator";
+import { MemoryCache } from "./memory";
+
+interface ChainTVL {
+  name: string;
+  tvl: number;
+  tokenSymbol: string | null;
+  chainId: number | string | null;
+  gecko_id: string | null;
+  cmcId: string | null;
+}
+
+export const getChainsTVL = {
+  name: "get_chains_tvl",
+  description:
+    "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
+  parameters: z.object({
+    limit: z
+      .number()
+      .optional()
+      .default(10)
+      .describe("Number of top chains to return (default: 10)"),
+  }),
+  execute: async ({ limit }: { limit: number }) => {
+    try {
+      const response = await fetch("https://api.llama.fi/v2/chains", {
+        headers: { accept: "*/*" },
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const chains = (await response.json()) as ChainTVL[];
+
+      // Sort chains by TVL in descending order and take top N
+      const topChains = chains
+        .sort((a, b) => b.tvl - a.tvl)
+        .slice(0, limit)
+        .map((chain) => ({
+          name: chain.name,
+          tvl: chain.tvl,
+          tokenSymbol: chain.tokenSymbol,
+        }));
+
+      const totalTVL = chains.reduce((sum, chain) => sum + chain.tvl, 0);
+
+      return {
+        summary: {
+          totalTVL,
+          numberOfChains: chains.length,
+        },
+        topChains,
+      };
+    } catch (error) {
+      console.error("Error retrieving chains TVL data:", error);
+      throw new Error(
+        `Failed to fetch chains TVL data: ${(error as Error).message}`
+      );
+    }
+  },
+};
+
+const RSS_FEEDS = ["https://www.investing.com/rss/news_301.rss"];
+
+const parser = new Parser();
+
+function stripHtmlTags(content: string): string {
+  if (!content) return "";
+  return content
+    .replace(/<[^>]*>/g, "")
+    .replace(/\n/g, "")
+    .replace(" ", "");
+}
+
+export const getRssNews = {
+  name: "get-news-rss",
+  description: "Get latest news about on website",
+  parameters: z.object({}),
+  execute: async () => {
+    const itemsPerSource = 5;
+
+    try {
+      const feedPromises = RSS_FEEDS.map((url) => parser.parseURL(url));
+      const results = await Promise.allSettled(feedPromises);
+      const successfulFeeds = results
+        .filter(
+          (result): result is PromiseFulfilledResult<Parser.Output<any>> => {
+            return (
+              result.status === "fulfilled" && result.value?.items?.length > 0
+            );
+          }
+        )
+        .map((result) => result.value);
+      const allItems = successfulFeeds
+        .flatMap((feed) => feed.items.slice(0, itemsPerSource))
+        .sort((a, b) => {
+          const dateA = a.pubDate ? new Date(a.pubDate).getTime() : 0;
+          const dateB = b.pubDate ? new Date(b.pubDate).getTime() : 0;
+          return dateB - dateA;
+        })
+        .slice(0, 5)
+        .map((item) => ({
+          title: item.title,
+          content: stripHtmlTags(item.content),
+          link: item.link,
+          date: item.pubDate,
+          source: item.creator || new URL(item.link).hostname,
+        }));
+
+      const result = {
+        status: "success",
+        items: allItems,
+      };
+      return result;
+    } catch (error: any) {
+      throw error;
+    }
+  },
+};
+
+(async () => {
+  const orchestrator = new Orchestrator([getRssNews, getChainsTVL]);
+  const agent = new Agent({
+    user: {
+      id: "1",
+    },
+    orchestrator,
+    memoryCache: new MemoryCache(),
+    stream: false,
+    maxEvaluatorIteration: 1,
+  });
+
+  const prompt = "Analyze le marché des crypto";
+  const context = prompt;
+
+  const result = await agent.process(prompt, context, {
+    onMessage: (message) => {
+      console.log({ message });
+    },
+  });
+  console.log(result.text);
+})();

package/types.ts

@@ -1,4 +1,4 @@
-import { StreamTextResult } from "ai";
+import { Embedding, StreamTextResult } from "ai";
 import { z } from "zod";
 
 export interface BaseLLM {
@@ -138,8 +138,8 @@ export interface Memory {
   type: MemoryType;
   data: any;
   purpose: string;
-  queries: string[];
-  embeddings: number[][];
+  query: string;
+  embedding: Embedding;
   userId?: string;
   scope: MemoryScope;
   createdAt: Date;