refactor: Optimize memory fetching by moving sorting and slicing to DB

packages/adapter-postgres/src/index.ts

@@ -307,6 +307,7 @@ export class PostgresDatabaseAdapter
         roomIds: UUID[];
         agentId?: UUID;
         tableName: string;
+        limit?: number;
     }): Promise<Memory[]> {
         return this.withDatabase(async () => {
             if (params.roomIds.length === 0) return [];
@@ -322,6 +323,13 @@ export class PostgresDatabaseAdapter
                 queryParams = [...queryParams, params.agentId];
             }
 
+            // Add sorting, and conditionally add LIMIT if provided
+            query += ` ORDER BY "createdAt" DESC`;
+            if (params.limit) {
+                query += ` LIMIT $${queryParams.length + 1}`;
+                queryParams.push(params.limit.toString());
+            }
+
             const { rows } = await this.pool.query(query, queryParams);
             return rows.map((row) => ({
                 ...row,

packages/core/src/database.ts

@@ -94,6 +94,7 @@ export abstract class DatabaseAdapter<DB = any> implements IDatabaseAdapter {
         agentId: UUID;
         roomIds: UUID[];
         tableName: string;
+        limit?: number;
     }): Promise<Memory[]>;
 
     abstract getMemoryById(id: UUID): Promise<Memory | null>;

packages/core/src/memory.ts

@@ -189,11 +189,12 @@ export class MemoryManager implements IMemoryManager {
         );
     }
 
-    async getMemoriesByRoomIds(params: { roomIds: UUID[] }): Promise<Memory[]> {
+    async getMemoriesByRoomIds(params: { roomIds: UUID[], limit?: number; }): Promise<Memory[]> {
         return await this.runtime.databaseAdapter.getMemoriesByRoomIds({
             tableName: this.tableName,
             agentId: this.runtime.agentId,
             roomIds: params.roomIds,
+            limit: params.limit
         });
     }
 

packages/core/src/runtime.ts

@@ -937,18 +937,11 @@ Text: ${attachment.text}
             ]);
 
             // Check the existing memories in the database
-            const existingMemories =
-                await this.messageManager.getMemoriesByRoomIds({
-                    // filter out the current room id from rooms
-                    roomIds: rooms.filter((room) => room !== roomId),
-                });
-
-            // Sort messages by timestamp in descending order
-            existingMemories.sort((a, b) => b.createdAt - a.createdAt);
-
-            // Take the most recent messages
-            const recentInteractionsData = existingMemories.slice(0, 20);
-            return recentInteractionsData;
+            return await this.messageManager.getMemoriesByRoomIds({
+                // filter out the current room id from rooms
+                roomIds: rooms.filter((room) => room !== roomId),
+                limit: 20
+            });
         };
 
         const recentInteractions =

packages/core/src/types.ts

@@ -885,6 +885,7 @@ export interface IDatabaseAdapter {
         tableName: string;
         agentId: UUID;
         roomIds: UUID[];
+        limit?: number;
     }): Promise<Memory[]>;
 
     getCachedEmbeddings(params: {
@@ -1038,7 +1039,7 @@ export interface IMemoryManager {
     ): Promise<{ embedding: number[]; levenshtein_score: number }[]>;
 
     getMemoryById(id: UUID): Promise<Memory | null>;
-    getMemoriesByRoomIds(params: { roomIds: UUID[] }): Promise<Memory[]>;
+    getMemoriesByRoomIds(params: { roomIds: UUID[], limit?: number }): Promise<Memory[]>;
     searchMemoriesByEmbedding(
         embedding: number[],
         opts: {