@ai.ntellect/core 0.3.3 → 0.4.1

package/memory/persistent.ts

@@ -1,7 +1,6 @@
-import { openai } from "@ai-sdk/openai";
-import { cosineSimilarity, embed, embedMany } from "ai";
+import { cosineSimilarity, embed, EmbeddingModel, embedMany } from "ai";
 import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
-import { Memory, MemoryScope } from "../types";
+import { LongTermMemory, MemoryScope } from "../types";
 
 interface SearchOptions {
   scope?: MemoryScope;
@@ -40,19 +39,31 @@ export class PersistentMemory {
   private readonly host: string;
   private readonly apiKey: string;
   private readonly INDEX_PREFIX: string;
-
-  constructor(options: { host: string; apiKey: string; indexPrefix?: string }) {
+  private readonly embeddingModel: EmbeddingModel<string>;
+  constructor(options: {
+    host: string;
+    apiKey: string;
+    indexPrefix?: string;
+    embeddingModel: EmbeddingModel<string>;
+  }) {
     this.host = options.host;
     this.apiKey = options.apiKey;
     this.INDEX_PREFIX = options.indexPrefix || "memory";
+    this.embeddingModel = options.embeddingModel;
   }
 
   /**
    * Initialize indexes
    */
   async init() {
-    // Create global index
-    await this._getOrCreateIndex(this.INDEX_PREFIX);
+    try {
+      // Create or get main index
+      await this._getOrCreateIndex(this.INDEX_PREFIX);
+      console.log(`✅ Index '${this.INDEX_PREFIX}' initialized successfully`);
+    } catch (error) {
+      console.error(`❌ Failed to initialize index: ${error}`);
+      throw error;
+    }
   }
 
   /**
@@ -63,6 +74,7 @@ export class PersistentMemory {
     options: RequestInit = {}
   ): Promise<T> {
     const url = `${this.host}${path}`;
+    console.log("🔍 Making request to Meilisearch:", url);
     const response = await fetch(url, {
       ...options,
       headers: {
@@ -79,19 +91,27 @@ export class PersistentMemory {
 
     return response.json() as Promise<T>;
   }
+
   /**
    * Get or create an index with proper settings
    */
   private async _getOrCreateIndex(indexName: string) {
     try {
-      // Try to create index
-      await this._makeRequest("/indexes", {
-        method: "POST",
-        body: JSON.stringify({
-          uid: indexName,
-          primaryKey: "id",
-        }),
-      });
+      // Check if index exists first
+      const indexExists = await this._makeRequest(`/indexes/${indexName}`, {
+        method: "GET",
+      }).catch(() => false);
+
+      if (!indexExists) {
+        console.log(`Creating new index: ${indexName}`);
+        await this._makeRequest("/indexes", {
+          method: "POST",
+          body: JSON.stringify({
+            uid: indexName,
+            primaryKey: "id",
+          }),
+        });
+      }
 
       // Update index settings
       const settings: MeilisearchSettings = {
@@ -103,11 +123,11 @@ export class PersistentMemory {
         method: "PATCH",
         body: JSON.stringify(settings),
       });
+
+      console.log(`Index ${indexName} configured successfully`);
     } catch (error: any) {
-      // Index might already exist, which is fine
-      if (!error.message.includes("already exists")) {
-        throw error;
-      }
+      console.error(`Failed to configure index ${indexName}:`, error);
+      throw error;
     }
   }
 
@@ -120,7 +140,7 @@ export class PersistentMemory {
 
     // Generate embeddings for all chunks
     const { embeddings } = await embedMany({
-      model: openai.embedding("text-embedding-3-small"),
+      model: this.embeddingModel,
       values: chunks.map((chunk) => chunk.pageContent),
     });
 
@@ -134,102 +154,104 @@ export class PersistentMemory {
   /**
    * Store a memory in the database
    */
-  async createMemory(memory: Memory) {
-    await this._getOrCreateIndex(memory.roomId);
-
-    const chunks = await this.processContent(memory.data);
-
-    const document = {
-      ...memory,
-      chunks,
-      createdAt: memory.createdAt.toISOString(),
-    };
-
-    const response = await this._makeRequest(
-      `/indexes/${this.INDEX_PREFIX}/documents`,
-      {
-        method: "POST",
-        body: JSON.stringify([document]),
-      }
-    );
-    console.log("Stored persistent memory response:", response);
-    return response;
+  async createMemory(memory: LongTermMemory) {
+    try {
+      console.log(`📝 Creating memory in index: ${this.INDEX_PREFIX}`);
+
+      // Process content into chunks with embeddings
+      const chunks = await this.processContent(memory.data);
+
+      // Generate unique ID if not provided
+      const id = memory.id || crypto.randomUUID();
+
+      const document = {
+        ...memory,
+        chunks,
+        createdAt: memory.createdAt.toISOString(),
+      };
+
+      const response = await this._makeRequest(
+        `/indexes/${this.INDEX_PREFIX}/documents`,
+        {
+          method: "POST",
+          body: JSON.stringify([document]),
+        }
+      );
+
+      console.log("✅ Memory created successfully", { id });
+      return response;
+    } catch (error) {
+      console.error("❌ Failed to create memory:", error);
+      throw error;
+    }
   }
 
   /**
    * Find best matching memories
    */
   async findRelevantDocuments(query: string, options: SearchOptions = {}) {
-    console.log("\n🔍 Searching in persistent memory");
+    console.log(`\n🔍 Searching in index: ${this.INDEX_PREFIX}`);
     console.log("Query:", query);
-    console.log("Options:", JSON.stringify(options, null, 2));
-
-    // Generate embedding for the query
-    const { embedding: queryEmbedding } = await embed({
-      model: openai.embedding("text-embedding-3-small"),
-      value: query,
-    });
 
-    const searchResults = [];
-
-    console.log("\n📚 Searching in global index:", this.INDEX_PREFIX);
     try {
-      const globalResults = await this._makeRequest<MeilisearchResponse>(
+      // Generate embedding for the query
+      const { embedding: queryEmbedding } = await embed({
+        model: this.embeddingModel,
+        value: query,
+      });
+
+      // Search in the index
+      const searchResults = await this._makeRequest<MeilisearchResponse>(
         `/indexes/${this.INDEX_PREFIX}/search`,
         {
           method: "POST",
-          body: JSON.stringify({ q: query }),
+          body: JSON.stringify({
+            q: query,
+            limit: options.maxResults || 10,
+          }),
         }
       );
-      if (globalResults?.hits) {
-        searchResults.push(...globalResults.hits);
+
+      if (!searchResults?.hits?.length) {
+        console.log("❌ No matches found");
+        return [];
       }
-    } catch (error) {
-      console.error("❌ Error searching global index:", error);
-    }
 
-    const totalResults = searchResults.length;
-    console.log(`\n📊 Found ${totalResults} total matches`);
-
-    // Process and filter results using cosine similarity
-    const results = searchResults
-      .flatMap((hit) => {
-        const chunkSimilarities = hit.chunks.map((chunk) => ({
-          query: hit.query,
-          data: hit.data,
-          similarityPercentage:
-            (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
-          createdAt: hit.createdAt,
-        }));
-
-        return chunkSimilarities.reduce(
-          (best, current) =>
-            current.similarityPercentage > best.similarityPercentage
-              ? current
-              : best,
-          chunkSimilarities[0]
-        );
-      })
-      .filter(
-        (match) =>
-          match.similarityPercentage >= (options.similarityThreshold || 70)
-      )
-      .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-
-    // Log filtered results in a more structured way
-    if (results.length > 0) {
-      console.log("\n✨ Relevant matches found:");
-      console.log("─".repeat(50));
-
-      results.forEach((match, index) => {
-        console.log(`\n${index + 1}. Match Details:`);
-        console.log(`   Query: ${match.query}`);
-      });
-    } else {
-      console.log("\n❌ No relevant matches found");
-    }
+      // Process and filter results using cosine similarity
+      const results = searchResults.hits
+        .flatMap((hit) => {
+          const chunkSimilarities = hit.chunks.map((chunk) => ({
+            query: hit.query,
+            data: hit.data,
+            similarityPercentage:
+              (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
+            createdAt: hit.createdAt,
+          }));
+
+          return chunkSimilarities.reduce(
+            (best, current) =>
+              current.similarityPercentage > best.similarityPercentage
+                ? current
+                : best,
+            chunkSimilarities[0]
+          );
+        })
+        .filter(
+          (match) =>
+            match.similarityPercentage >= (options.similarityThreshold || 70)
+        )
+        .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
 
-    return results;
+      console.log(`✨ Found ${results.length} relevant matches`);
+      return results.map((result) => ({
+        query: result.query,
+        data: result.data,
+        createdAt: result.createdAt,
+      }));
+    } catch (error) {
+      console.error("❌ Search failed:", error);
+      return [];
+    }
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -12,18 +12,24 @@
   "author": "Lorcann Rauzduel",
   "license": "ISC",
   "dependencies": {
+    "@ai-sdk/deepseek": "^0.1.0",
     "@ai-sdk/openai": "1.0.6",
+    "@types/node-cron": "^3.0.11",
     "ai": "^3.0.0",
     "ethers": "^6.13.5",
     "langchain": "^0.3.11",
+    "node-cron": "^3.0.3",
+    "readline": "^1.3.0",
     "redis": "^4.7.0",
     "rss-parser": "^3.13.0",
+    "ws": "^8.18.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.0",
+    "@types/ws": "^8.5.14",
     "chai": "^4.5.0",
     "mocha": "^10.0.0",
     "ts-node": "^10.9.0",
@@ -37,5 +43,8 @@
   "bugs": {
     "url": "https://github.com/ai-ntellect/core/issues"
   },
-  "homepage": "https://github.com/ai-ntellect/core#readme"
+  "homepage": "https://github.com/ai-ntellect/core#readme",
+  "bin": {
+    "wallet-assistant": "./dist/examples/index.js"
+  }
 }

package/services/redis-cache.ts

@@ -0,0 +1,128 @@
+import Redis from "ioredis";
+import cron from "node-cron";
+
+export interface CacheConfig {
+  host: string;
+  port: number;
+  password?: string;
+  ttl?: number; // Time to live in seconds (default 30 minutes)
+  cleanupInterval?: string; // Cron expression (default every 30 minutes)
+}
+
+export class RedisCache {
+  private redis: Redis;
+  private readonly defaultTTL: number;
+  private readonly cleanupJob: cron.ScheduledTask;
+
+  constructor(config: CacheConfig) {
+    this.redis = new Redis({
+      host: config.host,
+      port: config.port,
+      password: config.password,
+    });
+
+    this.defaultTTL = config.ttl || 1800; // 30 minutes in seconds
+
+    // Setup cleanup job (default: every 30 minutes)
+    this.cleanupJob = cron.schedule(
+      config.cleanupInterval || "*/30 * * * *",
+      () => this.cleanup()
+    );
+  }
+
+  /**
+   * Store previous actions for a specific request
+   */
+  async storePreviousActions(requestId: string, actions: any[]): Promise<void> {
+    const key = `previous_actions:${requestId}`;
+    await this.redis.setex(
+      key,
+      this.defaultTTL,
+      JSON.stringify({
+        timestamp: new Date().toISOString(),
+        actions,
+      })
+    );
+  }
+
+  /**
+   * Get previous actions for a specific request
+   */
+  async getPreviousActions(requestId: string): Promise<any[]> {
+    const key = `previous_actions:${requestId}`;
+    const data = await this.redis.get(key);
+    if (!data) return [];
+
+    const parsed = JSON.parse(data);
+    return parsed.actions;
+  }
+
+  /**
+   * Store a recent message
+   */
+  async storeRecentMessage(
+    message: string,
+    metadata?: Record<string, any>
+  ): Promise<void> {
+    const id = crypto.randomUUID();
+    const key = `recent_messages:${id}`;
+    await this.redis.setex(
+      key,
+      this.defaultTTL,
+      JSON.stringify({
+        timestamp: new Date().toISOString(),
+        message,
+        metadata,
+      })
+    );
+  }
+
+  /**
+   * Get recent messages
+   */
+  async getRecentMessages(limit: number = 10): Promise<any[]> {
+    const keys = await this.redis.keys("recent_messages:*");
+    if (!keys.length) return [];
+
+    const messages = await Promise.all(
+      keys.map(async (key) => {
+        const data = await this.redis.get(key);
+        return data ? JSON.parse(data) : null;
+      })
+    );
+
+    return messages
+      .filter(Boolean)
+      .sort(
+        (a, b) =>
+          new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+      )
+      .slice(0, limit);
+  }
+
+  /**
+   * Cleanup expired keys
+   */
+  private async cleanup(): Promise<void> {
+    console.log("🧹 Starting cache cleanup...");
+    try {
+      // Redis automatically removes expired keys
+      // This is just for logging purposes
+      const actionKeys = await this.redis.keys("previous_actions:*");
+      const messageKeys = await this.redis.keys("recent_messages:*");
+      console.log(
+        `Cache status: ${actionKeys.length} actions, ${messageKeys.length} messages`
+      );
+    } catch (error) {
+      console.error("❌ Cache cleanup error:", error);
+    }
+  }
+
+  /**
+   * Stop the cleanup job and close Redis connection
+   */
+  async close(): Promise<void> {
+    this.cleanupJob.stop();
+    await this.redis.quit();
+  }
+}