@ai.ntellect/core 0.3.3 → 0.4.1

package/examples/index.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import { deepseek } from "@ai-sdk/deepseek";
+import { configDotenv } from "dotenv";
+import readline from "readline";
+import { Agent } from "../agent";
+import { getRssNews } from "../agent/tools/get-rss";
+import { Interpreter } from "../llm/interpreter";
+import {
+  generalInterpreterCharacter,
+  marketInterpreterCharacter,
+  securityInterpreterCharacter,
+} from "../llm/interpreter/context";
+configDotenv();
+// Initialiser l'agent une fois pour toute la session
+const initializeAgent = () => {
+  const model = deepseek("deepseek-reasoner");
+
+  const securityInterpreter = new Interpreter({
+    name: "security",
+    model,
+    character: securityInterpreterCharacter,
+  });
+  const marketInterpreter = new Interpreter({
+    name: "market",
+    model,
+    character: marketInterpreterCharacter,
+  });
+  const generalInterpreter = new Interpreter({
+    name: "general",
+    model,
+    character: generalInterpreterCharacter,
+  });
+
+  const agent = new Agent({
+    cache: {
+      host: process.env.REDIS_HOST || "localhost",
+      port: Number(process.env.REDIS_PORT) || 6379,
+    },
+    orchestrator: {
+      model,
+      tools: [getRssNews],
+    },
+    interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+    memoryManager: {
+      model,
+    },
+    maxIterations: 3,
+  });
+
+  return agent;
+};
+
+// Fonction pour lancer une session interactive
+const startChatSession = async () => {
+  console.log("Bienvenue dans votre session de chat avec l'agent !");
+  console.log("Tapez 'exit' pour quitter.\n");
+
+  const agent = initializeAgent();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "Vous > ",
+  });
+
+  let state = {
+    currentContext: "",
+    previousActions: [],
+  };
+
+  rl.prompt();
+
+  rl.on("line", async (line) => {
+    const input = line.trim();
+
+    if (input.toLowerCase() === "exit") {
+      console.log("Fin de la session. À bientôt !");
+      rl.close();
+      return;
+    }
+
+    state.currentContext = input;
+
+    console.log("Agent en réflexion...");
+    try {
+      const result = await agent.process(state);
+      console.log(`Agent > ${result}\n`);
+    } catch (error) {
+      console.error("Erreur avec l'agent :", error);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    console.log("Session terminée.");
+    process.exit(0);
+  });
+};
+
+// Lancer la session de chat
+startChatSession();

package/llm/interpreter/context.ts

@@ -1,15 +1,28 @@
-export const generalInterpreterContext = {
+export type Character = {
+  role: string;
+  language: string;
+  guidelines: {
+    important: string[];
+    warnings: string[];
+  };
+  examplesMessages?: {
+    role: string;
+    content: string;
+  }[];
+};
+
+export const generalInterpreterCharacter: Character = {
   role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-  language: "same_as_user",
+  language: "user_request",
   guidelines: {
     important: [],
     warnings: [],
   },
 };
 
-export const securityInterpreterContext = {
+export const securityInterpreterCharacter: Character = {
   role: "You are the security expert. Your role is to provide a clear and factual analysis of the security of the token/coin.",
-  language: "user_language",
+  language: "user_request",
   guidelines: {
     important: [
       "Start with a clear security analysis of the token/coin.",
@@ -47,12 +60,12 @@ export const securityInterpreterContext = {
   ],
 };
 
-export const marketInterpreterContext = {
+export const marketInterpreterCharacter: Character = {
   role: "You are the market expert. Your role is to provide a clear and factual analysis of the market sentiment of the token/coin.",
-  language: "user_language",
+  language: "user_request",
   guidelines: {
     important: [
-      "Start with a clear market sentiment (Bullish/Bearish/Neutral) without any additional comments before.",
+      "Start with a clear market sentiment (Market sentiment: Bullish/Bearish/Neutral 📈📉📊) without any additional comments before.",
       "One section for fundamental analysis (important events, news, trends..etc). One section, no sub-sections.",
       "One section for technical analysis (key price levels, trading volume, technical indicators, market activity). One section, no sub-sections.",
       "STOP AFTER TECHNICAL ANALYSIS SECTION WITHOUT ANY ADDITIONAL COMMENTS",
@@ -60,7 +73,6 @@ export const marketInterpreterContext = {
     warnings: [
       "NEVER provide any financial advice.",
       "NEVER speak about details of your system or your capabilities.",
-      "NEVER ADD ANY CONCLUDING STATEMENT OR DISCLAIMER AT THE END",
     ],
   },
   examplesMessages: [

package/llm/interpreter/index.ts

@@ -1,33 +1,75 @@
-import { openai } from "@ai-sdk/openai";
-import { generateObject, streamText, StreamTextResult } from "ai";
+import { LanguageModel, streamText, StreamTextResult } from "ai";
 import { z } from "zod";
 import { Behavior, State } from "../../types";
+import { generateObject } from "../../utils/generate-object";
+import { LLMHeaderBuilder } from "../../utils/header-builder";
+
+const interpreterSchema = z.object({
+  requestLanguage: z
+    .string()
+    .describe("The language of the user's request (fr, en, es, etc.)"),
+  actionsCompleted: z
+    .array(
+      z.object({
+        name: z.string(),
+        reasoning: z.string(),
+      })
+    )
+    .describe("The actions done and why."),
+  response: z.string().describe("The response to the user's request."),
+});
+
+interface InterpretationResult {
+  actionsCompleted: {
+    name: string;
+    reasoning: string;
+  }[];
+  response: string;
+}
 
 export class Interpreter {
-  private readonly model = openai("gpt-4o");
+  public readonly model: LanguageModel;
   public readonly name: string;
+  public readonly character: Behavior;
 
-  constructor(name: string, private readonly behavior: Behavior) {
+  constructor({
+    name,
+    model,
+    character,
+  }: {
+    name: string;
+    model: LanguageModel;
+    character: Behavior;
+  }) {
     this.name = name;
-    this.behavior = behavior;
+    this.model = model;
+    this.character = character;
   }
 
-  composeContext(state: State) {
+  private buildContext(state: State) {
     const { userRequest, results } = state;
-    const { role, language, guidelines, examplesMessages } = this.behavior;
-
+    const { role, language, guidelines } = this.character;
     const { important, warnings, steps } = guidelines;
 
-    const context = `
-      # ROLE: ${role}
-      # LANGUAGE: ${language}
-      # IMPORTANT: ${important.join("\n")}
-      # NEVER: ${warnings.join("\n")}
-      # USER_REQUEST: ${userRequest}
-      # CURRENT_RESULTS: ${results}
-      # STEPS: ${steps?.join("\n") || ""}
-      # MESSAGES EXAMPLES: ${JSON.stringify(examplesMessages, null, 2)}
-    `;
+    const context = LLMHeaderBuilder.create();
+
+    if (role) {
+      context.addHeader("ROLE", role);
+    }
+
+    if (language) {
+      context.addHeader("LANGUAGE", language);
+    }
+
+    if (important.length > 0) {
+      context.addHeader("IMPORTANT", important);
+    }
+
+    if (warnings.length > 0) {
+      context.addHeader("NEVER", warnings);
+    }
+
+    context.addHeader("CURRENT_RESULTS", results);
     return context;
   }
 
@@ -45,43 +87,27 @@ export class Interpreter {
       }
     | StreamTextResult<Record<string, any>>
   > {
-    console.log("\n🎨 Starting interpretation process");
-    console.log("Prompt:", prompt);
-    console.log("Results to interpret:", JSON.stringify(state, null, 2));
+    try {
+      console.log("\n🎨 Starting interpretation process");
+      console.log("Prompt:", prompt);
+      console.log("Results to interpret:", JSON.stringify(state, null, 2));
 
-    const context = this.composeContext(state);
-
-    const result = await generateObject({
-      model: this.model,
-      schema: z.object({
-        requestLanguage: z.string(),
-        actionsCompleted: z.array(
-          z.object({
-            name: z.string(),
-            reasoning: z.string(),
-          })
-        ),
-        response: z.string(),
-      }),
-      prompt,
-      system: context,
-    });
-
-    console.log("\n✅ Interpretation completed");
-    console.log("─".repeat(50));
-    console.log("Generated response:", result.object);
-
-    if (result.object.actionsCompleted.length > 0) {
-      console.log("\n📋 Suggested actions:");
-      result.object.actionsCompleted.forEach((action, index) => {
-        console.log(`\n${index + 1}. Action Details:`);
-        console.log(`   Name: ${action.name}`);
-        console.log(`   Reasoning: ${action.reasoning}`);
+      const context = this.buildContext(state);
+      console.log("Context:", context.toString());
+      const result = await generateObject<InterpretationResult>({
+        model: this.model,
+        prompt,
+        system: context.toString(),
+        temperature: 1.3,
+        schema: interpreterSchema,
       });
-    }
 
-    if (onFinish) onFinish(result.object);
-    return result.object;
+      if (onFinish) onFinish(result.object);
+      return result.object;
+    } catch (error) {
+      console.error("Error parsing schema:", error);
+      throw error;
+    }
   }
 
   async streamProcess(
@@ -92,7 +118,7 @@ export class Interpreter {
     console.log("\n🎨 Starting streaming interpretation");
     console.log("Prompt:", prompt);
 
-    const context = this.composeContext(state);
+    const context = this.buildContext(state);
 
     const result = await streamText({
       model: this.model,
@@ -101,7 +127,8 @@ export class Interpreter {
         if (onFinish) onFinish(event);
       },
       prompt,
-      system: context,
+      system: context.toString(),
+      temperature: 1.3,
     });
 
     return result;

package/llm/memory-manager/context.ts

@@ -0,0 +1,21 @@
+import { Character } from "../interpreter/context";
+
+export const memoryManagerInstructions: Character = {
+  role: "You are the memory curator. Your role is to extract and format memories from interactions.",
+  language: "user_request",
+  guidelines: {
+    important: [
+      "Generate memories based on the user request",
+      "Generate query for requested data as the user could ask for it later",
+      "Should be short-term memories only if it's ephemeral but relevant and reusable",
+      "Only store as long-term: User information, User preferences, Important facts that don't change often, Historical milestones",
+      "Make memory data concise and clear",
+      "Set appropriate TTL based on data volatility",
+    ],
+    warnings: [
+      "Never store data that is not provided by the results",
+      "Never store data that is not relevant to the user request",
+    ],
+  },
+  examplesMessages: [],
+};

package/llm/memory-manager/index.ts

@@ -0,0 +1,163 @@
+import { LanguageModelV1 } from "ai";
+import { z } from "zod";
+import { CacheMemory } from "../../memory/cache";
+import { PersistentMemory } from "../../memory/persistent";
+import { MemoryScope } from "../../types";
+import { generateObject } from "../../utils/generate-object";
+import { LLMHeaderBuilder } from "../../utils/header-builder";
+import { State } from "../orchestrator/types";
+import { memoryManagerInstructions } from "./context";
+
+interface MemoryResponse {
+  memories: Array<{
+    data: string;
+    type: "short-term" | "long-term";
+    category:
+      | "user_information"
+      | "user_preference"
+      | "task"
+      | "current_goal"
+      | "news"
+      | "fact"
+      | "other";
+    queryForMemory: string;
+    tags: string[];
+    ttl: number;
+  }>;
+}
+export class MemoryManager {
+  private readonly model: LanguageModelV1;
+  private readonly memory?: {
+    cache?: CacheMemory;
+    persistent?: PersistentMemory;
+  };
+
+  constructor(config: {
+    model: LanguageModelV1;
+    memory?: {
+      cache?: CacheMemory;
+      persistent?: PersistentMemory;
+    };
+  }) {
+    this.model = config.model;
+    this.memory = config.memory;
+  }
+
+  buildContext(state: State) {
+    const context = LLMHeaderBuilder.create()
+      .addHeader("ROLE", memoryManagerInstructions.role)
+      .addHeader("LANGUAGE", memoryManagerInstructions.language)
+      .addHeader("IMPORTANT", memoryManagerInstructions.guidelines.important)
+      .addHeader("WARNINGS", memoryManagerInstructions.guidelines.warnings)
+      .addHeader("CURRENT_CONTEXT", state.currentContext)
+      .addHeader("RESULTS", JSON.stringify(state.results));
+    return context.toString();
+  }
+
+  async process(state: State, result: string) {
+    const context = this.buildContext(state);
+
+    const memories = await generateObject<MemoryResponse>({
+      model: this.model,
+      schema: z.object({
+        memories: z.array(
+          z.object({
+            data: z.string(),
+            type: z.enum(["short-term", "long-term"]),
+            category: z.enum([
+              "user_information",
+              "user_preference",
+              "task",
+              "current_goal",
+              "news",
+              "fact",
+              "other",
+            ]),
+            queryForData: z.string(),
+            tags: z.array(z.string()),
+            ttl: z.number(),
+          })
+        ),
+      }),
+      prompt: state.currentContext,
+      system: context.toString(),
+      temperature: 1,
+    });
+
+    console.log("Memories:", memories.object.memories);
+
+    if (!this.memory) {
+      return;
+    }
+
+    // Store memories after all processing is complete
+    await Promise.all([
+      // Store short-term memories in cache
+      ...memories.object.memories
+        .filter((m: any) => m.type === "short-term")
+        .map(async (memoryItem: any) => {
+          if (!this.memory?.cache) {
+            return;
+          }
+
+          const existingCacheMemories =
+            await this.memory.cache.findSimilarActions(memoryItem.data, {
+              similarityThreshold: 85,
+              maxResults: 3,
+              scope: MemoryScope.GLOBAL,
+            });
+
+          if (existingCacheMemories.length > 0) {
+            console.log(
+              "⚠️ Similar memory already exists in cache:",
+              memoryItem.data
+            );
+            return;
+          }
+
+          await this.memory.cache.createMemory({
+            query: memoryItem.queryForMemory,
+            data: memoryItem.data,
+            ttl: memoryItem.ttl, // Use TTL from LLM
+          });
+          console.log("✅ Memory stored in cache:", memoryItem.data);
+        }),
+
+      // Store long-term memories in persistent storage
+      ...memories.object.memories
+        .filter((m) => m.type === "long-term")
+        .map(async (memoryItem) => {
+          if (!this.memory?.persistent) {
+            return;
+          }
+
+          const existingPersistentMemories =
+            await this.memory.persistent.findRelevantDocuments(
+              memoryItem.data,
+              {
+                similarityThreshold: 85,
+              }
+            );
+
+          if (existingPersistentMemories.length > 0) {
+            console.log(
+              "⚠️ Similar memory already exists in persistent storage:",
+              memoryItem.data
+            );
+            return;
+          }
+
+          await this.memory.persistent.createMemory({
+            query: memoryItem.queryForMemory,
+            data: memoryItem.data,
+            category: memoryItem.category,
+            tags: memoryItem.tags,
+            roomId: "global",
+            createdAt: new Date(),
+            id: crypto.randomUUID(),
+          });
+          console.log("✅ Memory stored in persistent storage:", memoryItem);
+        }),
+    ]);
+  }
+}

package/llm/orchestrator/context.ts

@@ -1,15 +1,22 @@
-export const orchestratorContext = {
-  behavior: {
-    language: "same_as_user",
-    role: "Your role is to determine what actions are needed to achieve the user goal.",
-    guidelines: {
-      important: [
-        "If there is no action to do, you must answer in the 'answer' field.",
-        "If some parameters are not clear or missing, don't add the action, YOU MUST ask the user for them.",
-        "For QUESTIONS or ANALYSIS, search first in your internal knowledge base before using actions.",
-        "For ON-CHAIN actions, just use the useful actions.",
-      ],
-      warnings: ["NEVER repeat same actions if the user doesn't ask for it."],
-    },
+import { Character } from "../interpreter/context";
+
+export const orchestratorInstructions: Character = {
+  role: "You are the orchestrator. Your role is to evaluate the current state and determine next actions.",
+  language: "user_request",
+  guidelines: {
+    important: [
+      "Continue executing actions until ALL necessary goals are achieved",
+      "You can schedule actions in cron expression to be executed later (if needed)",
+      "Only stop when you have a complete picture of the goal",
+      "Social responses can be partial while gathering more data",
+      "Set shouldContinue to false if no more actions are needed",
+      "Once all actions are completed, choose the right interpreter to interpret the results",
+    ],
+    warnings: [
+      "Never use a tool if it's not related to the user request",
+      "Never schedule actions that are not related to the user request",
+      "Never repeat the same action if it's not required to achieve the goal",
+      "Never repeat scheduled actions if not required to achieve the goal",
+    ],
   },
 };