@ai.ntellect/core 0.5.0 → 0.6.0

package/llm/memory-manager/context.ts

@@ -1,19 +0,0 @@
-import { Character } from "../interpreter/context";
-
-export const memoryManagerInstructions: Character = {
-  role: "You are the memory curator. Your role is to extract relevant memories from interactions.",
-  language: "same_as_request",
-  guidelines: {
-    important: [
-      "Generate query for requested data as the user could ask for it later (Eg: 'What is the price of Bitcoin today?')s",
-      "Short-term memories need to be necessary and reusable",
-      "Only store as long-term: User information, User preferences, Important facts that don't change often, Historical milestones",
-      "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

@@ -1,115 +0,0 @@
-import { LanguageModelV1 } from "ai";
-import { z } from "zod";
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-import { MyContext, SharedState } from "../../types";
-import { generateObject } from "../../utils/generate-object";
-import { LLMHeaderBuilder } from "../../utils/header-builder";
-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;
-  public readonly memory?: {
-    cache?: CacheMemory;
-    persistent?: PersistentMemory;
-  };
-
-  constructor(config: {
-    model: LanguageModelV1;
-    memory?: {
-      cache?: CacheMemory;
-      persistent?: PersistentMemory;
-    };
-  }) {
-    this.model = config.model;
-    this.memory = config.memory;
-  }
-
-  buildContext() {
-    const context = LLMHeaderBuilder.create()
-      .addHeader("ROLE", memoryManagerInstructions.role)
-      .addHeader("LANGUAGE", memoryManagerInstructions.language)
-      .addHeader("IMPORTANT", memoryManagerInstructions.guidelines.important)
-      .addHeader("WARNINGS", memoryManagerInstructions.guidelines.warnings);
-    return context.toString();
-  }
-
-  async process(
-    state: SharedState<MyContext>,
-    callbacks?: {
-      onMemoriesGenerated?: (event: any) => void;
-    }
-  ) {
-    const context = this.buildContext();
-    let prompt = LLMHeaderBuilder.create();
-    if (state.messages) {
-      prompt.addHeader(
-        "REQUEST",
-        state.messages[state.messages.length - 2].content.toString()
-      );
-    }
-    if (state.messages && state.messages.length > 0) {
-      prompt.addHeader("RECENT_MESSAGES", JSON.stringify(state.messages));
-    }
-
-    if (state.context.actions) {
-      prompt.addHeader(
-        "PREVIOUS_ACTIONS",
-        JSON.stringify(state.context.actions)
-      );
-    }
-
-    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(),
-          })
-        ),
-      }),
-      system: context.toString(),
-      temperature: 1,
-      prompt: prompt.toString(),
-    });
-
-    if (!this.memory) {
-      return;
-    }
-
-    if (callbacks?.onMemoriesGenerated)
-      callbacks.onMemoriesGenerated(memories.object);
-
-    return memories.object;
-  }
-}

package/llm/orchestrator/context.ts

@@ -1,19 +0,0 @@
-import { Character } from "../interpreter/context";
-
-export const orchestratorInstructions: Character = {
-  role: "Your role is to evaluate the current state and determine next actions.",
-  language: "same_as_request",
-  guidelines: {
-    important: [
-      "If no actions are needed, just answer",
-      "If required, you can schedule actions in cron expression to be executed later",
-      "If required, you choose one interpreter to interpret the results when you have a complete picture of the goal",
-    ],
-    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",
-    ],
-  },
-};

package/llm/orchestrator/index.ts

@@ -1,192 +0,0 @@
-import { generateObject, LanguageModelV1 } from "ai";
-import { z } from "zod";
-import { CacheMemory } from "../../memory/cache";
-import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope, MyContext, SharedState } from "../../types";
-import { LLMHeaderBuilder } from "../../utils/header-builder";
-import { injectActions } from "../../utils/inject-actions";
-import { Interpreter } from "../interpreter";
-import { orchestratorInstructions } from "./context";
-
-export class Orchestrator {
-  private readonly model: LanguageModelV1;
-  private readonly tools: ActionSchema[];
-  private readonly interpreters: Interpreter[];
-  private memory?: {
-    persistent?: PersistentMemory;
-    cache?: CacheMemory;
-  };
-
-  constructor(
-    model: LanguageModelV1,
-    tools: ActionSchema[],
-    interpreters: Interpreter[],
-    memory?: {
-      persistent?: PersistentMemory;
-      cache?: CacheMemory;
-    }
-  ) {
-    this.model = model;
-    this.tools = tools;
-    this.interpreters = interpreters;
-    this.memory = memory;
-  }
-
-  private async buildContext(state: SharedState<MyContext>): Promise<string> {
-    console.log("🧠 Building context with RAG and CAG...");
-    const context = LLMHeaderBuilder.create();
-
-    // Add orchestrator instructions
-    context.addHeader("ROLE", orchestratorInstructions.role);
-    context.addHeader("LANGUAGE", orchestratorInstructions.language);
-    context.addHeader(
-      "IMPORTANT",
-      orchestratorInstructions.guidelines.important
-    );
-    context.addHeader("WARNINGS", orchestratorInstructions.guidelines.warnings);
-    // Add tools to context
-    context.addHeader("TOOLS", injectActions(this.tools));
-
-    // Get recent similar actions (CAG)
-    if (this.memory?.cache && state.messages) {
-      const cacheMemories = await this.memory.cache.findSimilarActions(
-        state.messages[state.messages.length - 1].content.toString(),
-        {
-          similarityThreshold: 80,
-          maxResults: 3,
-          scope: MemoryScope.GLOBAL,
-        }
-      );
-
-      if (cacheMemories.length > 0) {
-        context.addHeader("RECENT_ACTIONS", JSON.stringify(cacheMemories));
-      }
-    }
-
-    // Get relevant knowledge (RAG)
-    if (this.memory?.persistent && state.messages) {
-      const persistentMemory =
-        await this.memory.persistent.findRelevantDocuments(
-          state.messages[state.messages.length - 1].content.toString(),
-          {
-            similarityThreshold: 80,
-          }
-        );
-
-      if (persistentMemory.length > 0) {
-        context.addHeader(
-          "RELEVANT_KNOWLEDGE",
-          JSON.stringify(persistentMemory)
-        );
-      }
-    }
-
-    // Add available interpreters
-    context.addHeader(
-      "INTERPRETERS (choose one)",
-      JSON.stringify(this.interpreters.map((i) => i.name))
-        .replace("[", "")
-        .replace("]", "")
-    );
-    return context.toString();
-  }
-
-  async process(
-    state: SharedState<MyContext>,
-    callbacks?: {
-      onStart?: () => void;
-      onFinish?: (event: any) => void;
-    }
-  ): Promise<{
-    processing: {
-      stop: boolean;
-      stopReason?: string;
-    };
-    actions: Array<{
-      name: string;
-      parameters: Array<{
-        name: string;
-        value: any;
-      }>;
-      scheduler?: {
-        isScheduled: boolean;
-        cronExpression?: string;
-        reason?: string;
-      };
-    }>;
-    response: string;
-    interpreter?: string | null;
-    results?: string;
-  }> {
-    if (callbacks?.onStart) callbacks.onStart();
-
-    const context = await this.buildContext(state);
-    let prompt = LLMHeaderBuilder.create();
-    if (state.messages) {
-      prompt.addHeader(
-        "REQUEST",
-        state.messages[state.messages.length - 1].content.toString()
-      );
-
-      if (state.messages.length > 1) {
-        prompt.addHeader("RECENT_MESSAGES", JSON.stringify(state.messages));
-      }
-    }
-    if (state.context.results) {
-      prompt.addHeader("ACTIONS_DONE", JSON.stringify(state.context.results));
-    }
-
-    console.log("\n🧠 Generating response from Orchestrator...");
-    const response = await generateObject({
-      model: this.model,
-      schema: z.object({
-        processing: z.object({
-          stop: z.boolean(),
-          reason: z.string(),
-        }),
-        actions: z.array(
-          z.object({
-            name: z.string(),
-            parameters: z.array(
-              z.object({
-                name: z.string(),
-                value: z.any(),
-              })
-            ),
-            scheduler: z.object({
-              isScheduled: z.boolean(),
-              cronExpression: z.string(),
-              reason: z.string(),
-            }),
-          })
-        ),
-        response: z.string(),
-        interpreter: z.string().or(z.null()),
-      }),
-      system: context.toString(),
-      temperature: 0,
-      prompt: prompt.toString(),
-    });
-    console.log("🔄 Orchestrator response:");
-    console.dir(response.object, { depth: null });
-
-    // Force shouldContinue to false if no actions are planned
-    if (response.object.actions.length === 0) {
-      response.object.processing.stop = true;
-      console.log("⚠️ No actions planned, forcing isProcessing to false");
-    }
-
-    // Handle social interactions and actions in a single block
-    if (response.object.response) {
-      console.log("\n💬 Processing social response");
-      if (response.object.response) {
-        console.log("📢 Response:", response.object.response);
-        // Ensure all parameters have a value property
-      }
-    }
-
-    if (callbacks?.onFinish) callbacks.onFinish(response.object);
-
-    return response.object as any;
-  }
-}

package/llm/orchestrator/types.ts

@@ -1,14 +0,0 @@
-import { CoreMessage } from "ai";
-import { QueueResult } from "../../types";
-
-export interface State {
-  currentContext: string;
-  previousActions: (string | QueueResult)[];
-  results?: string;
-  recentMessages: CoreMessage[];
-}
-
-export interface Action {
-  name: string;
-  parameters: Record<string, any>;
-}

package/memory/cache.ts

@@ -1,221 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { cosineSimilarity, embed, EmbeddingModel } from "ai";
-import { createClient } from "redis";
-import {
-  CacheMemoryOptions,
-  CacheMemoryType,
-  CreateMemoryInput,
-  MatchOptions,
-  MemoryScope,
-} from "../types";
-
-export class CacheMemory {
-  private redis;
-  private readonly CACHE_PREFIX: string;
-  private readonly CACHE_TTL: number;
-  private readonly embeddingModel: EmbeddingModel<string>;
-
-  constructor(options: CacheMemoryOptions) {
-    this.embeddingModel = options.embeddingModel;
-    const ttlInHours = options.cacheTTL ?? 1;
-    this.CACHE_TTL = ttlInHours * 60 * 60;
-    this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
-
-    this.redis = createClient({
-      url: options.redisUrl || process.env.REDIS_URL,
-      socket: {
-        tls: true,
-        rejectUnauthorized: true,
-      },
-    });
-    this.initRedis();
-  }
-
-  private async initRedis() {
-    this.redis.on("error", (err) => {
-      console.error("❌ Redis Client Error:", err);
-    });
-
-    try {
-      await this.redis.connect();
-      console.log("✅ Successfully connected to Redis");
-    } catch (error) {
-      console.error("❌ Failed to connect to Redis:", error);
-    }
-  }
-
-  private async storeMemory(memory: CacheMemoryType, ttl?: number) {
-    const prefix = this.CACHE_PREFIX;
-    const key = `${prefix}${memory.id}`;
-    const result = await this.redis.set(key, JSON.stringify(memory), {
-      EX: ttl || this.CACHE_TTL,
-    });
-    console.log("💾 Cache memory created:", result);
-  }
-
-  async findSimilarActions(
-    query: string,
-    options: MatchOptions & { userId?: string; scope?: MemoryScope } = {}
-  ): Promise<
-    {
-      data: any;
-      query: string;
-      createdAt: Date;
-    }[]
-  > {
-    console.log("\n🔍 Searching in cache");
-    console.log("Query:", query);
-    console.log("Options:", JSON.stringify(options, null, 2));
-
-    const { embedding } = await embed({
-      model: openai.embedding("text-embedding-3-small"),
-      value: query,
-    });
-
-    const memories = await this.getAllMemories();
-    console.log(`\n📚 Found ${memories.length} cached queries to compare`);
-
-    const matches = memories
-      .map((memory) => {
-        const similarity = cosineSimilarity(embedding, memory.embedding);
-        const similarityPercentage = (similarity + 1) * 50;
-        return {
-          data: memory.data,
-          query: memory.query,
-          similarityPercentage,
-          createdAt: memory.createdAt,
-        };
-      })
-      .filter(
-        (match) =>
-          match.similarityPercentage >= (options.similarityThreshold ?? 70)
-      )
-      .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-
-    const results = options.maxResults
-      ? matches.slice(0, options.maxResults)
-      : matches;
-
-    if (results.length > 0) {
-      console.log("\n✨ Similar queries found:");
-      console.log("─".repeat(50));
-
-      results.forEach((match, index) => {
-        console.log(`\n${index + 1}. Match Details:`);
-        console.log(`   Query: ${match.query}`);
-        console.log(`   Data: ${JSON.stringify(match.data)}`);
-        console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
-        console.log("─".repeat(50));
-      });
-    } else {
-      console.log("\n❌ No similar queries found in cache");
-    }
-
-    return results.map((match) => {
-      return {
-        data: match.data,
-        query: match.query,
-        createdAt: match.createdAt,
-      };
-    });
-  }
-
-  async getAllMemories(): Promise<CacheMemoryType[]> {
-    const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
-    const memories = await this.getMemoriesFromKeys(keys);
-
-    return memories;
-  }
-
-  private async getMemoriesFromKeys(
-    keys: string[]
-  ): Promise<CacheMemoryType[]> {
-    const memories: CacheMemoryType[] = [];
-    for (const key of keys) {
-      const data = await this.redis.get(key);
-      if (data) {
-        memories.push(JSON.parse(data));
-      }
-    }
-    return memories;
-  }
-
-  public async createMemory(
-    input: CreateMemoryInput
-  ): Promise<CacheMemoryType | undefined> {
-    console.log("\n📝 Processing new memory creation");
-    console.log("Content:", input.query);
-    console.log("TTL:", input.ttl ? `${input.ttl} seconds` : "default");
-
-    const existingPattern = await this.findSimilarActions(input.query, {
-      similarityThreshold: 95,
-      userId: input.userId,
-      scope: input.scope,
-    });
-
-    if (existingPattern.length > 0) {
-      console.log("\n🔄 Similar cache memory already exists");
-      console.log("─".repeat(50));
-      existingPattern.forEach((match, index) => {
-        console.log(`\n${index + 1}. Existing Match:`);
-        console.log(`   Query: ${match.query}`);
-        console.log(`   Data: ${JSON.stringify(match.data)}`);
-        console.log(`   Created At: ${match.createdAt}`);
-      });
-      console.log("\n⏭️  Skipping creation of new memory");
-      return;
-    }
-
-    console.log("\n🆕 No similar memory found - creating new one");
-
-    const memory = await this.createSingleMemory({
-      id: crypto.randomUUID(),
-      query: input.query,
-      data: input.data,
-      userId: input.userId,
-      scope: input.scope,
-      ttl: input.ttl,
-    });
-
-    return memory;
-  }
-
-  private async createSingleMemory(params: {
-    id: string;
-    query: string;
-    data: any;
-    userId?: string;
-    scope?: MemoryScope;
-    ttl?: number;
-  }): Promise<CacheMemoryType> {
-    console.log("\n🏗️  Creating new cache memory");
-    console.log("ID:", params.id);
-    console.log("Content:", params.query);
-
-    console.log("\n🧮 Generating embedding...");
-    const { embedding } = await embed({
-      model: this.embeddingModel,
-      value: params.query,
-    });
-    console.log("✅ Embedding generated successfully");
-
-    const memory: CacheMemoryType = {
-      id: params.id,
-      data: params.data,
-      query: params.query,
-      embedding,
-      userId: params.userId,
-      scope:
-        params.scope || (params.userId ? MemoryScope.USER : MemoryScope.GLOBAL),
-      createdAt: new Date(),
-    };
-
-    await this.storeMemory(memory, params.ttl);
-    console.log("✅ Short-term memory created and stored successfully", {
-      ...memory,
-      ttl: params.ttl || this.CACHE_TTL,
-    });
-
-    return memory;
-  }
-}